Comment puis-je faire une énumération "abstraite" dans une bibliothèque de classes .NET?

Pourquoi tout le monde pense que les Énumérations ne peut être abstraite?

Le Système de classe.Enum EST l'abstraction d'une énumération.

Vous pouvez assigner n'importe quelle valeur de l'énumération à un Enum, et vous pouvez la lancer en arrière à l'original de l'énumération ou l'utilisation du nom ou de la valeur.

par exemple:

Ce petit bout de code est à partir d'une propriété dynamique de collecte utilisé dans une de mes bibliothèques de contrôle. Je propriétés à être créé et accessible par une valeur de l'énumération pour le rendre un peu plus rapide, et moins d'une erreur humaine

    ///<summary>
    ///creates a new trigger property.
    ///</summary>
    ///<typeparam name="T"></typeparam>
    ///<param name="value"></param>
    ///<param name="name"></param>
    ///<returns></returns>
    protected virtual TriggerProperty<T> Create<T>(T value, Enum name)
    {
        var pt = new TriggerProperty<T>(value, OnPropertyChanged, Enum.GetName(name.GetType(), name));
        _properties[name.GetHashCode()] = pt;
        return pt;
    }

- Je utiliser Enum.GetName(Type, object) pour obtenir le nom de la valeur de l'énumération (à fournir un nom pour la propriété), et pour la vitesse et des raisons de cohérence-je utiliser GetHashCode() pour retourner la valeur de l'entier de l'énumération des membres (le code de hachage pour un int, c'est toujours juste l'int valeur)

Ceci est un exemple de la méthode appelée:

    public enum Props
    {
        A, B, C, Color, Type, Region, Centre, Angle
    }

    public SpecularProperties()
        :base("SpecularProperties", null)
    {
        Create<double>(1, Props.A);
        Create<double>(1, Props.B);
        Create<double>(1, Props.C);
        Create<Color>(Color.Gray, Props.Color);
        Create<GradientType>(GradientType.Linear, Props.Type);
        Create<RectangleF>(RectangleF.Empty, Props.Region);
        Create<PointF>(PointF.Empty, Props.Centre);
        Create<float>(0f, Props.Angle);
    }

1. Créer un Enum pour LoginResponse, SelectionResponse, etc., mais ne pas spécifier les valeurs.

2. Ont ServerOperationCode et ClientOperationCode mettre en œuvre une fonction qui, étant donné un entier pseudo-code binaire, renvoie la valeur appropriée à partir de votre Enum.

Exemple:

public enum OperationCode
{
 LoginResponse,
 SelectionResponse,
 BlahBlahResponse
}

public interface IOperationCodeTranslator {
 public OperationCode GetOperationCode(byte inputcode);
 }

public class ServerOperationCode : IOperationCodeTranslator
{
  public OperationCode GetOperationCode(byte inputcode) {
    switch(inputcode) {
       case 0x00: return OperationCode.LoginResponse;
      [...]
    } 
}

Mise en garde: depuis les interfaces ne pouvez pas définir des fonctions statiques, ServerOperationCode et ClientOperationCode ne serait en mesure de mettre en œuvre une interface commune si cette fonction est une instance de la fonction. Si ils n'ont pas besoin d'implémenter une interface commune, GetOperationCode peut être une fonction statique.

(Excuses pour les C# gags, ce n'est pas ma langue maternelle...)

J'ai écrit un message de commutation de la bibliothèque avec un scénario similaire a un moment déjà, et j'ai décidé d'utiliser des génériques de passe défini par l'utilisateur enum. Le principal problème avec cela est que vous ne pouvez pas imposer votre générique pour seulement les types enum, mais ne peut dire tout T: struct. Quelqu'un peut instancier votre type avec un autre type primitif (bien que, en utilisant ints pourrait encore être fonctionnel, à condition qu'elles soient toutes les valeurs uniques. Le dictionnaire va lever une exception si elles ne le sont pas. Vous pourriez peut-être ajouter un peu supplémentaire de vérifier à l'aide de la réflexion pour vous assurer de passer un enum.

public abstract class DefaultMessageHandler<T> : IMessageHandler<T> where T : struct {
    public delegate void MessageHandlerDelegate(IMessage<T> message, IConnection connnection);

    private readonly IDictionary<T, MessageHandlerDelegate> messageHandlerDictionary = 
        new Dictionary<T, MessageHandlerDelegate>();

    protected void RegisterMessageHandler(T messageType, MessageHandlerDelegate handler) {
        if (this.messageHandlerDictionary.ContainsKey(messageType)) 
            return;
        else this.messageHandlerDictionary.Add(messageType, handler);
    }

    protected void UnregisterMessageHandler(T messageType) {
        if (this.messageHandlerDictionary.ContainsKey(messageType))
            this.messageHandlerDictionary.Remove(messageType);
    }

    protected virtual void HandleUnregisteredMessage(IMessage<T> message, IConnection connection) {
    }

    void IMessageHandler<T>.HandleMessage(IMessage<T> message, IConnection connection) {
        if (this.messageHandlerDictionary.ContainsKey(message.MessageType))
            this.messageHandlerDictionary[message.MessageType].Invoke(message, connection);
        else HandleUnregisteredMessage(message, connection);
    }
}

Donné votre scénario d'exemple, vous devriez juste sous-classe comme ça.

public sealed class ServerOperationHandler : DefaultMessageHandler<ServerOperationCode> {
    public ServerOperationHandler() {
        this.RegisterMessageHandler(ServerOperationCode.LoginResponse, this.HandleLoginResponse);
        this.RegisterMessageHandler(ServerOperationCode.SelectionResponse, this.HandleSelectionResponse);
    }

    private void HandleLoginResponse(IMessage<ServerOperationCode> message, IConnection connection) {
        //TODO
    }

    private void HandleSelectionResponse(IMessage<ServerOperationCode> message, IConnection connection) {
        //TODO
    }
}