C# appelle un const en utilisant une variable qui correspond au nom const

Question

J'ai un groupe de consts, puis je crée dynamiquement une variable qui est égale à l'un des noms consts. Je dois appeler ce const, je sais que je peux utiliser d'autres déclarations, mais je voulais savoir si theres un meilleur moyen Merci!

public const int LifeBand1Standard = 78; 
    public const int LifeBand1Multi = 61; 
    public const int LifeBand2Standard = 71; 
    public const int LifeBand2Multi = 56; 
    public const int LifeBand3Standard = 62; 
    public const int LifeBand3Multi = 48; 
    public const int LifeBand4Standard = 56; 
    public const int LifeBand4Multi = 44; 
    public const int LifeBand5Standard = 45; 
    public const int LifeBand5Multi = 35; 

    // Band discounts/loads for trauma cover 
    public const int TraumaBand1Standard = 140; 
    public const int TraumaBand1Multi = 126; 
    public const int TraumaBand2Standard = 135; 
    public const int TraumaBand2Multi = 121; 
    public const int TraumaBand3Standard = 121; 
    public const int TraumaBand3Multi = 109; 
    public const int TraumaBand4Standard = 110; 
    public const int TraumaBand4Multi = 99; 
    public const int TraumaBand5Standard = 100; 
    public const int TraumaBand5Multi = 90; 

    protected float GetPercentageFromBand(int band) 
    { 
     var constantName = "Life"; 

     if (IsTraumaCover == true) 
     { 
      constantName = "Trauma"; 
     } 

     constantName += "Band" + band; 

     if (IsMultiLife == true) 
     { 
      constantName += "Multi"; 
     } 
     else 
     { 
      constantName += "Standard"; 
     } 

     // Constant should look something like LifeBand3Standard and will return the value of the const LifeBand3Standard 
     BandPercentage = InsuranceBandFetcher.constantName; 

    } 

Answer 1

Utilisez un enum couplé à un Dictionary quelque chose comme ci-dessous (juste un exemple de code)

public enum MyConstant 
{ 
    LifeBand1Standard = 78, 
    LifeBand1Multi = 61, 
    LifeBand2Standard = 71, 
    LifeBand2Multi = 56, 
    LifeBand3Standard = 62, 
    LifeBand3Multi = 48 
} 

Conserver les données dans le dictionnaire

 Dictionary<string, MyConstant> dict = new Dictionary<string, MyConstant> 
     { 
      { "TraumaCover ", MyConstant.LifeBand3Multi}, 
      { "MultiLife ", MyConstant.LifeBand2Standard} 
     }; 

     Console.WriteLine(dict["MultiLife "]); 

par votre commentaire, un autre exemple de code. Vous pouvez utiliser Enum.Parse() à cet effet comme

namespace Test 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      string key = PrepareConstant(1, false); 
      MyConstant val = (MyConstant)Enum.Parse(typeof(MyConstant), key, true); 

      Dictionary<string, MyConstant> dict = new Dictionary<string, MyConstant> 
      { 
       { key, val}, 
      }; 

      Console.WriteLine(dict[key]); // output: LifeBand1Standard 

      Console.ReadKey(); 
     } 

     static string PrepareConstant(int band, bool isMultiLife) 
     { 
      var constantName = "Life"; 
      constantName += "Band" + band; 
      constantName += (isMultiLife) ? "Multi" : "Standard"; 

      return constantName; 
     } 
    } 

    public enum MyConstant 
    { 
     LifeBand1Standard = 78, 
     LifeBand1Multi = 61, 
     LifeBand2Standard = 71, 
     LifeBand3Standard = 62, 
     TrumaBand2Multi = 56, 
     TrumaBand3Multi = 48 
    } 
} 

Answer 2

Utilisez un dictionnaire, au lieu de cordes magiques (en particulier ceux créés par programme).

Je ne comprends pas votre domaine d'affaires, de sorte que mes noms ENUM/valeurs peuvent être tout à fait bizarre, mais voici comment j'aborder le problème:

public enum Cover 
{ 
    Life, 
    Trauma 
} 

public enum MultiLife 
{ 
    Multi, 
    Standard 
} 

public readonly Dictionary<Tuple<Cover, int, MultiLife>, int> Values 
= new Dictionary<System.Tuple<UserQuery.Cover, int, UserQuery.MultiLife>, int> 
{ 
    [Tuple.Create(Cover.Life, 1, MultiLife.Standard)] = 78, 
    [Tuple.Create(Cover.Life, 1, MultiLife.Multi)] = 61, 
    [Tuple.Create(Cover.Life, 2, MultiLife.Standard)] = 71, 
    // [...] 
}; 

Ensuite, l'utilisation serait:

var bandPercentage 
= Values[Tuple.Create(IsTraumaCover ? Cover.Trauma : Cover.Life, 
         band, 
         IsMultiLife ? MultiLife.Multi : MultiLife.Standard)]; 

Answer 3

Ce que vous essayez de faire n'est pas possible sans réflexion. Même avec la réflexion, ce n'est pas un design recommandé. Ce que vous semblez vouloir, c'est une fonction qui mappe de trois valeurs: 1. multi ou standard (booléen ou enum). 2. vie ou traumatisme (booléen ou enum). 3. Nombre (int) (ou octet, ou structure personnalisée) et renvoie un certain nombre de sorte (un pourcentage?).

enum BandKind { 
Multi, 
Standard, 
} 

enum BandType { 
Life, 
Trauma 
} 

int GetBandValue(BandKind kind, BandType type, int num) { 

/// impl here 
} 

Bon, alors comment implémenter GetBandValue? Vous pouvez utiliser des instructions switch imbriquées et renvoyer des valeurs littérales, ce qui serait une option, mais les commutateurs imbriqués finissent par devenir plutôt moche. Vous pouvez créer un tableau multidimensionnel et l'indexer en utilisant les valeurs.

int[][][] BandData = {{{78, 61},{71, 56},...}}}; // build this array with your real values. 

Ensuite, votre mise en œuvre peut être:

int GetBandValue(BandKind kind, BandType type, int num) { 

    return BandData[(int)kind][(int)type][num]; 
}