En C#, pourquoi pas une Liste<string> object être stockés dans une Liste<object> variable

Pensez-y de cette façon, si vous décidez de faire un tel casting, puis ajouter un objet de type Foo à la liste, la liste des chaînes est plus cohérent. Si vous deviez effectuer une itération de la première référence, vous obtenez une classe cast exception, car une fois que vous frappez les Foo exemple, les Foo n'a pas pu être converti en string!

Comme une note de côté, je pense qu'il serait plus important de savoir si vous pouvez ou non faire l'inverse cast:

List<object> ol = new List<object>();
List<string> sl;
sl = (List<string>)ol;

Je n'ai pas utilisé le langage C# dans un certain temps, donc je ne sais pas si c'est légal, mais ce genre de cast est en fait (peut-être) utile. Dans ce cas, vous allez partir d'une classe plus générale (objet) à une classe plus spécifique (string) qui s'étend à partir de la générale. De cette façon, si vous ajouter à la liste de chaînes, vous ne violez pas la liste d'objets.

Quelqu'un sait ou peut tester si un tel casting est légal en C#?

Vous ne pouvez pas convertir entre les types génériques avec différents paramètres de type. Spécialisé types génériques ne font pas partie de la même arborescence d'héritage et sont donc sans rapport avec les types.

Pour ce faire pré-NET 3.5:

List<string> sl = new List<string>();
//Add strings to sl

List<object> ol = new List<object>();

foreach(string s in sl)
{
    ol.Add((object)s);  //The cast is performed implicitly even if omitted
}

À L'Aide De Linq:

var sl = new List<string>();
//Add strings to sl

var ol = new List<object>(sl.Cast<object>());

//OR
var ol = sl.Cast<object>().ToList();

//OR (note that the cast to object here is required)
var ol = sl.Select(s => (object)s).ToList();

Cela a beaucoup à voir avec la covariance, par exemple, les types génériques sont considérés comme des paramètres, et si les paramètres ne permettent pas de résoudre correctement un plus spécifique alors que l'opération échoue. L'implication est que vous avez vraiment ne peut pas lancer d'un type plus général comme objet. Et comme l'a déclaré Rex, l'objet de la Liste ne sera pas converti chaque objet pour vous.

Vous pourriez vouloir essayer le ff code à la place:

List<string> sl = new List<string>();
//populate sl
List<object> ol = new List<object>(sl);

ou:

List<object> ol = new List<object>();
ol.AddRange(sl);

ol sera (théoriquement) copie de tout le contenu de sl sans problèmes.

Mike - je crois que la contravariance n'est pas autorisé en C# soit

Voir Paramètre de type générique de la variance dans le CLR pour plus d'info.

C'est fait de sorte que vous n'essayez pas de mettre n'importe quel étrange "objet" dans votre "ol" variante de liste (comme List<object> semble permettre) - parce que votre code crash alors (parce que la liste est vraiment List<string> et n'acceptera que les objets de type String). C'est pourquoi vous ne pouvez pas lancer votre variable d'une spécification plus générale.

Sur Java c'est l'inverse, vous n'avez pas les génériques, et, au lieu de tout ce qui est de la Liste de l'objet au moment de l'exécution, et vous ne pouvez vraiment des trucs tout objet étrange dans votre soi-disant-strictement Liste tapée. Recherche pour "Réifiée génériques" pour voir une discussion plus large de java problème...

Voici un autre pre-.NET 3.5 solution pour tout IList dont le contenu peut être exprimés de façon implicite.

public IList<B> ConvertIList<D, B>(IList<D> list) where D : B
{
    List<B> newList = new List<B>();

    foreach (D item in list)
    {
        newList.Add(item);
    }

    return newList;
}

(Basé sur Zooba exemple)

Mm, grâce à des commentaires précédents, j'ai trouvé deux façons de le découvrir. Le premier est l'obtention de la chaîne de liste d'éléments, puis un moulage IEnumerable liste d'objets:

IEnumerable<object> ob;
List<string> st = new List<string>();
ob = st.Cast<object>();

Et la seconde est d'éviter la IEnumerable type d'objet, juste un moulage de la chaîne de type d'objet, puis en utilisant la fonction "toList()" dans la même phrase:

List<string> st = new List<string>();
List<object> ob = st.Cast<object>().ToList();

J'aime plus la seconde. J'espère que cette aide.