La manière de voter, Générique Listes de façon dynamique en C#?

Je suis en train de jeter List<object> à List<string> de façon dynamique. J'ai essayé de plusieurs façons, mais je ne peux pas trouver une solution. C'est un petit exemple qui montre le problème:

List<object> listObject = new List<object>();
listObject.Add("ITEM 1");
listObject.Add("ITEM 2");
listObject.Add("ITEM 3");

List<string> listString = ¿¿listObject??;

Merci d'avance!

Ce ne sera pas possible dans la version 4, car il n'est pas typesafe soit de "sortie" ou "abattu" un List<T> - c'est invariant, pas covariant et contravariant. En passant, je suis fatigué de cette désinformation est affecté à chaque question à propos de la collecte co/contravariance.

OriginalL'auteur | 2009-08-21

.net c#casting generics list

18

Si vous pouvez utiliser LINQ puis le Cast méthode de faire ce que vous avez besoin de:
```
List<string> listString = listObject.Cast<string>().ToList();
```
Vous pouvez également utiliser le ConvertAll méthode, comme Stan le souligne dans sa réponse:
```
List<string> listString = listObject.ConvertAll(x => (string)x);
```
Si vous n'êtes pas à l'aide de C#3, alors vous aurez besoin d'utiliser le "vieux" délégué syntaxe plutôt qu'un lambda:
```
List<string> listString =
    listObject.ConvertAll(delegate(object x) { return (string)x; });
```
+1 pour une utilisation correcte de délégué sytnax 🙂
J'essaie toujours de se rappeler que lorsque LINQ n'est pas disponible, alors il n'est ni lambda de la syntaxe.
+1 bon point Luke
Et juste pour devancer tout nitpickers... je suis conscient que VS2008 pouvez cibler les versions antérieures de l' .NET framework, ce qui permettrait l'utilisation de lambda de la syntaxe, mais pas LINQ. Mais, comme une règle-de-pouce, pas de LINQ signifie généralement pas lambdas trop.

OriginalL'auteur LukeH
4

Si vous êtes en utilisant .NET 3.5, vous pouvez utiliser, de cette façon, vous n'avez pas à faire un extra ToList(). Vous pouvez également fournir votre propre convertisseur si vous avez besoin de convertir advanced objets.
```
 List<string> listString = listObject.ConvertAll(x=> x as String);
```
Si vous ne pouvez pas utiliser LINQ, vous pouvez le faire
```
foreach(object item in listObject)
{
  string convertedItem = item as String;
  if(convertedItem != null)
       listString.Add(convertedItem);
}
```
C'est également en charge .NET 2.0 (sans LINQ, bien que la delgate syntaxe n'est pas aussi beau). Une remarque cependant, je ne crois pas que l' .Cast<string>.ToList() permet de créer un "extra" de la liste que vous voulez dire. Il va créer une nouvelle liste, pour le résultat, qu'est-ce que votre approche
Je pense que tu veux dire C# 3.0 et .Net 3.5.
c'est ce que je voulais dire. merci.
J'ai été ce qui implique que ToList() est un supplément de l'énumération.
Êtes-vous sûr? ToList() permet de faire une énumération, mais c'est tout. Cast<string>() ne sera pas réellement d'énumérer la collection.

OriginalL'auteur Stan R.

Comment combat ce:

public static List<T> ConvertToGenericList<T>(IList listOfObjects)
{
    List<T> items = new List<T>();

    for (int i = 0; i < listOfObjects.Count; i++)
    {
        items.Add((T)listOfObjects[i]);
    }
     return items;
}

Utilisation:

List<object> listObject = new List<object>();
listObject.Add("ITEM 1");
listObject.Add("ITEM 2");
listObject.Add("ITEM 3");
List<string> listString = Converter.ConvertToGenericList<string>(listObject);

OriginalL'auteur Jon

0

Je ne pense pas que vous pouvez le faire en une seule étape. Au lieu de cela, essayez quelque chose comme ceci:
```
        List<object> listObject = new List<object>();
        listObject.Add( "ITEM 1" );
        listObject.Add( "ITEM 2" );
        listObject.Add( "ITEM 3" );

        List<string> lstStr = new List<string>( listObject.Count );

        foreach ( object obj in listObject )
        {
            lstStr.Add( obj.ToString() );
        }
```
c'est faux, il ne veut pas de table des matières tous les ToString() sur cet objet, il veut le convertir en un objet de type string. Techniquement, votre exemple de travail cette fois, mais seulement pour les chaînes. Mais s'il lui arrive de tomber sur une version plus avancée de l'objet, il ne sera pas en mesure d'utiliser cette méthode.
Il peut être fait en une seule étape, voir les autres réponses...

OriginalL'auteur TLiebe

List<string> listString = (from o in listObject select (string)o).ToList();

Voir Enumerable.Cast<T>().

OriginalL'auteur svinto

-2

Mon premier post... j'Espère utile semble travailler dans mon projet...

        public  dynamic ConvertList(Type CallingType)
    {

        dynamic DynamicList;

        if (CallingType == TypeOfValue)
        {
            Type d1 = typeof(List<>);

            Type[] typeArgs = { TypeOfValue };

            Type DynamicListType = d1.MakeGenericType(typeArgs);


            object DynamicListObj = Activator.CreateInstance(DynamicListType);


            DynamicList = Convert.ChangeType(DynamicListObj, DynamicListType);


            foreach (object ValueElement in ValueRange)
            {
                    dynamic el = Convert.ChangeType(ValueElement, TypeOfValue);
                    DynamicList.Add(el);
            }

        }
        else //retrun empty List but with right type
        {
            Type d1 = typeof(List<>);

            Type[] typeArgs = { CallingType };

            Type DynamicListType = d1.MakeGenericType(typeArgs);

            object DynamicListObj = Activator.CreateInstance(DynamicListType);

            DynamicList = Convert.ChangeType(DynamicListObj, DynamicListType);
        }

        return DynamicList;
    }

Je pense que je vais aussi ajouter un essayez d'attraper quelque part.

comment tester

                if (PropertyType == typeof(UInt32))
                {
                    List<UInt32> UInt32_test = NewProperty.ConvertList(PropertyType);
                }
                if (PropertyType == typeof(string))
                {

                    List<string> string_test = NewProperty.ConvertList(PropertyType);
                }

OriginalL'auteur Riccardo G

Vous devez vous connecter pour publier un commentaire.