C# - Dictionnaire, Puis-je définir le type de valeur dans le constructeur? .NET 2.0

Question

Existe-t-il un moyen de réaliser quelque chose comme ça? J'ai trouvé cette dynamique peut être une solution mais son de .NET 4.0+:/

public class Message 
     { 
      public int ID; 
      Dictionary<dynamic, dynamic> dict 

      public Message(int ID, Dictionary<dynamic, dynamic> Data) 
      { 
       this.ID = ID; 
       dict = Data 
      } 
     } 

La raison est parce que je veux parfois dictionnaire avec chaîne: string et parfois avec la chaîne: int donc je voudrais avoir cette classe un peu dynamique et pas 2 classes.

Answer 1

Si votre dictionnaire peut contenir celui-là en même temps et celui-ci à un autre moment, ce devrait être en fait deux dictionnaires différents. Cela va avec le principe SOLID, ce qui signifie que n'importe quelle classe et même n'importe quel membre d'une classe sert un seul but. Avoir un objet faisant l'un dans le scénario 1 et quelque chose de différent dans le scénario 2 est généralement une conception brisée et vous devriez envisager de créer deux choses différentes.

Alternativly aller avec les génériques, c'est Dictionary<T, U> où vous devez passer T et U à votre Message -class:

public class Message<T, U> 
{ 
    public int ID; 
    private readonly Dictionary<T, U> dict; 

    public Message(int ID, Dictionary<T, U> Data) 
    { 
     this.ID = ID; 
     dict = Data; 
    } 
} 

Maintenant, vous pouvez faire des cas comme celui-ci:

var myDict = new Dictionary<string, string>(); 
var m = new Message<string, string>(0, myDict); 

qui sera automatiquement déduire les bons types pour T et U en fonction de votre définition de myDict.

Answer 2

Vous devez utiliser les médicaments génériques

public class MyClass<T> 
    { 
     private readonly Dictionary<string, T> _data; 

     public MyClass(Dictionary<string, T> newData) 
     { 
      _data = newData; 
     } 

     public Dictionary<string, T> Data 
     { 
      get { return _data;} 
     } 

    } 

Answer 3

La meilleure façon est de créer une méthode de fabrication générique, et de cette façon vous n'avez même pas à la charge de l'utilisateur avec les types:

public static class MessageFactory 
{ 
    public static Message<TKey, TValue> Create<TKey, TValue>(int ID, IDictionary<TKey, TValue> data) 
     => new Message<TKey, TValue>(ID, data); 

    public class Message<TKey, TValue> 
    { 
     public Message(int ID, IDictionary<TKey, TValue> data) { ... } 
    } 
} 

et maintenant, l'utilisation est presque le même que votre solution dynamic, mais beaucoup plus sûr:

var message = MessageFactory.Create(1, someDictionary); 

L'inférence de type prendra en charge l'élaboration des types TKey et TValue.

P.S. Rendre Message<,> imbriqué ou non est entièrement facultatif. Je l'aime de cette façon afin de désencombrer autant que possible l'espace de noms.