C#: Enum dans les Interfaces

comme Jon Skeet l'a mentionné, la base IL supporte la contrainte des génériques pour être enums, cependant C# ne vous permet pas d'en profiter.

F# permet ce genre de contrainte, cependant. De plus, si l'interface est définie en F#, la contrainte sera appliquée en C# code qui implémente l'interface. Si vous êtes prêt à mélanger les langues dans votre solution, quelque chose comme ceci devrait fonctionner très bien:

type IError<'T when 'T :> System.Enum and 'T : struct> =
    abstract member Error : 'T
    abstract member Description : string

si vous mettez ceci un projet F# et le référencer à partir de votre projet C#, votre code C# qui implémente l'interface causera une erreur de C# compilateur sur toute tentative de l'utiliser avec un type non-enum.

vous pouvez suivre votre approche d'une manière légèrement différente:

public interface IError
{
    Enum ErrorCode;
    string Description;
}

System.Enum est la classe de base de tous vos énums, donc qui devrait le gérer, mais est loin d'être expressif.

la bonne approche ici est de construire vos propres classes d'enum et une classe de base d'enum pour cela. Pour eg.,

public class ErrorFlag // base enum class
{
    int value;

    ErrorFlag() 
    {

    }

    public static implicit operator ErrorFlag(int i)
    {
        return new ErrorFlag { value = i };
    }

    public bool Equals(ErrorFlag other)
    {
        if (ReferenceEquals(this, other))
            return true;

        if (ReferenceEquals(null, other))
            return false;

        return value == other.value;
    }

    public override bool Equals(object obj)
    {
        return Equals(obj as ErrorFlag);
    }

    public static bool operator ==(ErrorFlag lhs, ErrorFlag rhs)
    {
        if (ReferenceEquals(lhs, null))
            return ReferenceEquals(rhs, null);

        return lhs.Equals(rhs);
    }

    public static bool operator !=(ErrorFlag lhs, ErrorFlag rhs)
    {
        return !(lhs == rhs);
    }

    public override int GetHashCode()
    {
        return value;
    }

    public override string ToString()
    {
        return value.ToString();
    }
}

public interface IError
{
    ErrorFlag ErrorCode;
    string Description;
}

maintenant au lieu d'avoir vos propres erreurs, écrivez vos propres ErrorFlag classe.

public sealed class ReportErrorFlag : ErrorFlag
{
    //basically your enum values
    public static readonly ErrorFlag Report1 = 1;
    public static readonly ErrorFlag Report2 = 2;
    public static readonly ErrorFlag Report3 = 3;

    ReportErrorFlag() 
    {

    }
}

public sealed class DataErrorFlag : ErrorFlag
{
    //basically your enum values
    public static readonly ErrorFlag Data1 = 1;
    public static readonly ErrorFlag Data2 = 2;
    public static readonly ErrorFlag Data3 = 3;

    DataErrorFlag() 
    {

    }
}

// etc

Maintenant, vos principales classes:

public class ReportError : IError
{
    // implementation
}

public class DataError : IError
{
    // implementation
}

ou autrement,

public class ErrorFlag // base enum class
{
    internal int value { get; set; }

    public bool Equals(ErrorFlag other)
    {
        if (ReferenceEquals(this, other))
            return true;

        if (ReferenceEquals(null, other))
            return false;

        return value == other.value;
    }

    public override bool Equals(object obj)
    {
        return Equals(obj as ErrorFlag);
    }

    public static bool operator ==(ErrorFlag lhs, ErrorFlag rhs)
    {
        if (ReferenceEquals(lhs, null))
            return ReferenceEquals(rhs, null);

        return lhs.Equals(rhs);
    }

    public static bool operator !=(ErrorFlag lhs, ErrorFlag rhs)
    {
        return !(lhs == rhs);
    }

    public override int GetHashCode()
    {
        return value;
    }

    public override string ToString()
    {
        return value.ToString();
    }
}

public interface IError<T> where T : ErrorFlag
{
    T ErrorCode { get; set; }
    string Description { get; set; }
}

//enum classes
public sealed class ReportErrorFlag : ErrorFlag
{
    //basically your enum values
    public static readonly ReportErrorFlag Report1 = new ReportErrorFlag { value = 1 };
    public static readonly ReportErrorFlag Report2 = new ReportErrorFlag { value = 2 };
    public static readonly ReportErrorFlag Report3 = new ReportErrorFlag { value = 3 };

    ReportErrorFlag()
    {

    }
}

public sealed class DataErrorFlag : ErrorFlag
{
    //basically your enum values
    public static readonly DataErrorFlag Data1 = new DataErrorFlag { value = 1 };
    public static readonly DataErrorFlag Data2 = new DataErrorFlag { value = 2 };
    public static readonly DataErrorFlag Data3 = new DataErrorFlag { value = 3 };

    DataErrorFlag()
    {

    }
}

//implement the rest

avoir laid d'avoir enum contraintes, voir quelqu'un connais une bonne solution de contournement pour le manque d'un enum contrainte générique?

l'incapacité d'écrire public interface IError<T> where T: enum est quelque chose dont nous nous plaignons tous depuis des années. Jusqu'à présent il n'y a pas eu de progrès sur ce point.

je finis habituellement par écrire public interface IError<T> et en laissant une note pour l'exécuteur que T doit être un enum.

si je comprends ce que vous voulez faire, alors oui, il n'y a aucun moyen de définir une interface qui contient comme l'un de ses membres un enum non spécifique. Votre second exemple est proche, mais vous êtes limité à limiter le type de T à un struct , ce qui permettrait n'importe quel type de valeur. À ce moment-là, vous avez juste à compter sur la connaissance de l'utilisation correcte des interfaces pour faire savoir aux gens le type attendu de T devrait être un enum. Vous pourriez potentiellement faire il est un peu plus clair en définissant T comme TEnum ou TErrorValue :

public interface IError<TEnum> where T: struct
{
    T ErrorCode;
    string Description;
}