Implémentation de la collection d'une classe générique

Question

J'essaie de créer une classe personnalisée comme suit.

public MyClass<T> 
{
    public string Value1 { get; set; }
    public T Value2 { get; set; }
    public string Value3 { get; set; }
}

La valeur de T peut être soit une chaîne de caractères, soit un nombre entier, soit une date. Je suppose que je peux créer une nouvelle instance de cette classe comme suit

MyClass<int> intclass = new MyClass<int>();
MyClass<String> stringclass=new MyClass<String>();

et ainsi de suite.

Est-il possible de créer une collection des classes ci-dessus où je peux mettre intclass et stringclass dans une collection personnalisée.

Answer 1

Si vous souhaitez mélanger différents types génériques (par exemple, avoir une collection contenant à la fois des MyClass<int> y MyClass<string> ) vous devez définir un type de base commun ou utiliser une collection qui n'est pas fortement typée :

public class MyClass<T> : MyClass
{
    public T Value2 { get; set; }
}

public class MyClass
{
    public string Value1 { get; set; }
    public string Value3 { get; set; }
}

Ensuite, vous pouvez définir une collection comme :

List<MyClass> list = new List<MyClass>();
list.Add(new MyClass<int>());
list.Add(new MyClass<string>());

Vous devrez couler les résultats lors de la récupération des entrées afin d'accéder à leur Value2 propriété cependant.

Une autre option pour éviter la classe de base est simplement d'utiliser un fichier de type List<object> :

List<object> list = new List<object>();
list.Add(new MyClass<int>());
list.Add(new MyClass<string>());

Mais c'est le même problème que ci-dessus, mais il est plausible qu'il soit pire (parce qu'alors vous pouvez enregistrer tout ce qui est là-dedans)

EDIT : Il y a plusieurs façons de permettre un accès non typographié à Value2 dans la base non-générique MyClass . Une façon de procéder est de définir une version "non typée" de la classe de base et de la surcharger sur la sous-classe qui effectuerait la vérification du type :

public abstract class MyClass
{
    public string Value1 { get; set; }
    public abstract object Value2Untyped { get; set; }
    public string Value3 { get; set; }
}

public class MyClass<T> : MyClass
{
    public T Value2 { get; set; }

    public override object Value2Untyped
    {
        get
        {
            return Value2;
        }
        set
        {
            Value2 = (T)value;
        }
    }
}

Ensuite, pour tous vos objets ou collections qui sont typés par rapport à la base non-générique MyClass vous pouvez toujours accéder aux valeurs, et même définir des valeurs au moment de l'exécution. (le set est bien sûr facultatif)

Answer 2

Vous voulez dire quelque chose comme ça ?

List<MyClass<int>> intClassList = new List<MyClass<int>>();
intClassList.Add(new MyClass<int>());