L'ajout d'objet générique pour générique liste en C#

J'ai la classe où la partie pertinente de l'ressemble

class C {
    void Method<T>(SomeClass<T> obj) {
        list.Add(obj);
    }
    List<?> list = new List<?>();
}

Comment dois-je définir la liste de sorte que la classe compile?

Je veux une liste de type List<SomeClass<?>>, qui est une liste d'objets de SomeClass où chaque objet peut avoir n'importe quel type de paramètre. La Java ? construire le permet; qu'est-ce que le C# équivalent? Si une telle chose existe, est-il adapté à la solution de contournement? (Un List<object> le ferait, mais est terriblement laid.)

pouvez-vous donner des précisions sur la nature des éléments que vous attendez pour ajouter via la "Méthode" de la fonction?
ah tant pis, je le vois dans un commentaire.
En c# 4.0, vous pouvez déclarer SomeClass dynamique et ne pas utiliser les médicaments génériques. La liste devient alors une Liste<SomeClass>.

OriginalL'auteur errcw | 2009-04-16

c#generics list

13

Je ne pense pas que vous pouvez le faire en C#... vous devez ajouter le paramètre de type de la classe:
```
class C<T> {
    void Method(SomeClass<T> obj) {
        list.Add(obj);
    }
    List<SomeClass<T>> list = new List<SomeClass<T>>();
}
```
L'autre option serait d'utiliser une interface:
```
class C {

    void Method<T>(T obj)
         where T : ISomeClass {
        list.Add(obj);
    }
    List<ISomeClass> list = new List<ISomeClass>();
}
```
Je pense que cela devient de plus en plus à l'esprit de ce que je comprends de la question à se poser (la version de l'interface). Fondamentalement, de son une liste de "partiellement connue" éléments, mais plus qu'un simple "Liste<object>"
Merci pour l'aide. Donc, stackoverflow me permet de monter ma question...mais est-il possible de combiner votre réponse avec ceux d'en bas que d'ajouter des informations supplémentaires à propos de l'impossibilité de ce que je veux en C#?
Je peux le modifier, ou de anytone d'autre avec 2k+ rep... quelles infos avez-vous envie?
Simplement la note technique sur la C# 3/4 de Mehrdad: "Malheureusement, il n'y a pas d'équivalent direct dans C# 3.0 génériques sont invariantes. Vous serez en mesure de faire quelque chose comme cela dans une gracieuse manière à l'aide de C# 4.0 sécurité co/contra-variance de la fonction."

OriginalL'auteur
4

À faire ce que vous voulez, vous avez deux options.

Vous pouvez utiliser une Liste<object>, et de manipuler les objets. Ce ne sera pas typesafe, et aura boxing/unboxing questions pour les types de valeur, mais il faudra travailler.

Votre autre option est d'utiliser une contrainte générique de limiter à une base de classe ou d'interface, et d'utiliser une Liste<Interface>.

OriginalL'auteur
2

Malheureusement, il n'y a pas d'équivalent direct dans C# 3.0 génériques sont invariantes.
Vous serez en mesure de faire quelque chose comme cela dans une gracieuse manière à l'aide de C# 4.0 sécurité co/contra-variance de la fonction.
Pour contourner cela, vous pourriez hériter SomeClass<T> à partir d'un nongeneric de base et créer un List<BaseClass> à la place.
Si chaque instance de la classe doit contenir qu'un seul type, vous pouvez faire la classe elle-même générique et définissez le type de paramètre.

Merci pour le BaseClass astuce, vraiment utile, en effet, lorsque vous souhaitez émuler Java des caractères génériques.

OriginalL'auteur

Je ne sais rien à propos de Java ? de construire, mais je pense que le suivant préserve au mieux votre syntaxe tout en correspondant à votre description.

    class SomeClass<T>
    {
    }

    class C
    {
        void Add<T>(SomeClass<T> item)
        {
            Type type = typeof(SomeClass<T>);
            if (!list.ContainsKey(type))
                list[type] = new List<SomeClass<T>>();
            var l = (List<SomeClass<T>>)list[type];
            l.Add(item);
        }

        public void Method<T>(SomeClass<T> obj)
        {
            Add(obj);
        }
        readonly Dictionary<Type, object> list = new Dictionary<Type, object>();
    }

test avec les éléments suivants:

    class Program
    {
        static void Main(string[] args)
        {
            var c = new C();
            var sc1 = new SomeClass<int>();
            var sc2 = new SomeClass<String>();
            c.Method(sc1);
            c.Method(sc2);
            c.Method(sc1);
            c.Method(sc2);
        }
    }

OriginalL'auteur

0

Personnellement, je le ferai, si possible, de déplacer le paramètre générique de la méthode, à la classe.
```
class C<T> {
    void Method(SomeClass<T> obj) {
        list.Add(obj);
    }
    List<?> list = new List<?>();
}
```
Si votre liste générique est un membre, il va de soi que la classe devrait être construit avec cela à l'esprit. Il est difficile pour nous de vous suggérer les meilleurs motif, sans plus de contexte d'utilisation de la classe.

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.