C# empêche la conversion en int

Question

J'ai une énumération qui énumère les valeurs entières renvoyées par une API externe pour une utilisation plus facile dans mon code. Mais je ne connais pas nécessairement les valeurs entières au moment de la compilation, donc j'ai du code qui les relie au démarrage du programme et les stocke dans un dictionnaire.

J'ai défini des méthodes d'extension pour la conversion vers/depuis les codes entiers, mais ces codes entiers ne sont pas les mêmes que ceux qui seraient renvoyés d'un cast vers int. Si un autre programmeur devait programmer avec mon énumération, j'ai peur qu'ils essaieraient d'aller et de sortir des entiers hors de l'habitude. Et le programme accepterait simplement le mauvais code.

Existe-t-il un moyen d'empêcher la conversion explicite de mon énumération en/de int? Sinon, existe-t-il un moyen de provoquer une exception si quelqu'un tente? Ou connecter mes propres fonctions de conversion? Ou changer la valeur sous-jacente d'une énumération au moment de l'exécution?

Answer 1

Ce que vous essayez est très "sale".

Utilisez une classe statique avec des valeurs readonly au lieu des enums. Vous pouvez ensuite initialiser les valeurs du type initialiseur (ou via une méthode statique):

public static class Foos 
{ 
    public static readonly int First; 
    public static readonly int Second; 

    //... 

    static Foos() 
    { 
     //For Example: 
     First = DateTime.Now.Day; 
     First = DateTime.Now.Month; 
    } 
} 

Answer 2

Une autre façon de faire ce qui pourrait donner un sens: définir le Enum dans votre programme et la carte des valeurs de l'API externe au Enum dans des méthodes privées. En d'autres termes, n'exposez le type de l'API externe nulle part dans votre modèle objet. Par exemple:

public enum MyEnum { First, Second, Third }; 

public class MyApiWrapper 
{ 
    private Dictionary<int, int> ExternalToInternal = new Dictionary<int, int>(); 
    private Dictionary<int, int> InternalToExternal = new Dictionary<int, int>(); 

    public MyApiWrapper(List<int> externalApiEnumValues) 
    { 
     foreach (int i = 0; i < externalApiEnumValues.Count; i++) 
     { 
     ExternalToInternal[externalApiEnumValues[i]] = i; 
     InternalToExternal[i] = externalApiEnumValues[i]; 
     } 
    } 

    // obviously, your real method for calling the external API 
    // will do more than this. 
    public void CallApi() 
    { 
     CallExternalApi(_EnumValue); 
    } 

    private MyEnum _ExternalEnumValue; 
    public MyEnum EnumValue 
    { 
     get { return ExternalToInternal[_ExternalEnumValue]; } 
     set { _ExternalEnumValue = InternalToExternal[value]; } 
    } 
} 

Tant que tous les accès à l'API est fait par cette classe (on espère que vous avez déjà accès API encapsulé externe dans une classe), vous pouvez utiliser librement MyEnum partout dans votre application sans être préoccupé par ce que les autres programmeurs font avec les valeurs.