C# Conversion de List<int> Liste<double>

J'ai un List<int> et je veux le convertir en un List<double>. Est-il possible de faire d'autres que de simplement en parcourant les List<int> et l'ajout d'un nouveau List<double> comme suit:

List<int> lstInt = new List<int>(new int[] {1,2,3});
List<double> lstDouble = new List<double>(lstInt.Count);//Either Count or Length, I don't remember

for (int i = 0; i < lstInt.Count; i++)
{
    lstDouble.Add(Convert.ToDouble(lstInt[0]));
}

Est-il une façon élégante de faire cela? Je suis à l'aide de C# 4.0, donc la réponse peut prendre avantage des nouvelles fonctionnalités de langage.

(pour la petite histoire, notez que le C# 4.0 variance ne fonctionne pas sur le béton-types (List<T>), ne fonctionne pas sur les listes en général (IList<T>), et ne fonctionne pas entre int et double)

InformationsquelleAutor Ames | 2010-01-18

c#generics

32

Vous pouvez utiliser LINQ méthodes:
```
List<double> doubles = integers.Select<int, double>(i => i).ToList();
```
ou:
```
List<double> doubles = integers.Select(i => (double)i).ToList();
```
Aussi, la liste de la classe a une méthode ForEach:
```
List<double> doubles = new List<double>(integers.Count);
integers.ForEach(i => doubles.Add(i));
```
- Ce doit être Select<int,double>(i => j').ToList(); Est-il un moyen d'utiliser le <,> la syntaxe avec un "Type" variable de type int?
- Il serait effectivement normalement juste être integers.Select(i => (double)i) être idiomatiques. Mais non, les génériques sont une compilation de fonction - si vous souhaitez utiliser un type connu au moment de l'exécution, vous aurez besoin d'utiliser la réflexion. Typage dynamique en C# 4 peut être en mesure de vous aider, mais vous auriez à donner un exemple plus concret avant que l'on puisse dire.
- À l'aide de la deuxième démo, je peux créer un effet de reflet liste de type double, puis utilisez le foreach des trucs à ajouter des éléments à partir de l'int en fonction de la liste. La Promotion se fera et tout heureux va se passer. Cette réponse effectivement résolu mon problème, mais ceux ci-dessus sont plus concise à la question que j'avais posée.
InformationsquelleAutor Guffa
51

Vous peut utilisation Select comme suggéré par d'autres, mais vous pouvez également utiliser ConvertAll:
```
List<double> doubleList = intList.ConvertAll(x => (double)x);
```
Cela a deux avantages:
- Il ne nécessite pas de LINQ, donc si vous êtes en utilisant .NET 2.0 et ne souhaitez pas utiliser LINQBridge, vous pouvez toujours l'utiliser.
- Il est plus efficace: la ToList méthode ne sais pas la taille de la suite de Select, il peut donc nécessité de réaffecter les tampons, comme il va. ConvertAll connaît la source et la destination de la taille, de sorte qu'il peut le faire en une seule fois. Il peut aussi le faire sans l'abstraction des itérateurs.
Les inconvénients:
- Il ne fonctionne qu'avec List<T> et les tableaux. Si vous obtenez une plaine IEnumerable<T> vous aurez à utiliser Select et ToList.
- Si vous êtes à l'aide de LINQ lourdement dans votre projet, il peut être plus cohérent de continuer à l'utiliser ici.
- et disponible en .NET 3.5 ainsi
- N'est-ce pas ConvertAll juste un wrapper pour l'expression LINQ?
- Est-il une différence pour Sélectionner sauf que c'est en montrant clairement votre intention?
- Voir le deuxième point dans "avantages". Imaginez une liste avec un million d'entrées - ConvertAll pouvez créer une nouvelle liste avec un million d'entrées pour commencer, mais Sélectionnez(...).ToList(...) ne peut - il devra garder un redimensionnable tampon.
- disponible en .NET 2.0...
- en effet. L'affiche mentionnée .NET 4.0, donc j'ai un peu cru qu'il n'était pas intéressé .NET 2.0.
InformationsquelleAutor Jon Skeet
8

Vous pouvez le faire à l'aide de la Sélectionnez méthode d'extension:
```
List<double> doubleList = intList.Select(x => (double)x).ToList();
```
- mais encore juste une boucle sous le couvre, droite?
- Le blé, qui est correct.
- Donc, il y a tout point pas seulement à l'aide d'une boucle? Performance sage?
- À l'aide de Select et ToList ne sera pas plus efficace. ConvertAll à faites - vous perdez la surcharge des contrôles au sein de l'Ajouter, mais il y a les frais généraux de l'appel à un délégué de nombreuses fois. Avez-vous des preuves que ce code est un goulot d'étranglement pour vous?
- Aucune preuve. Dans mon application "en double" par exemple va être dynamique afin que le casting est difficile de le faire sans réflexion. Je me demandais juste si il y avait bien des lamba fonction ou quelque chose que je ne connaissais pas qui a pris soin de casting pour ainsi dire.
- Vous pourriez construire une arborescence d'expression pour effectuer la conversion, très probablement. Toutefois, à ce stade, vous avez un peu différente de la question.
- Je peux juste utiliser la réflexion. J'ai obtenu mon problème est résolu. J'ai fini juste à faire un foreach et en ajoutant à une réflexion dynamique générée liste des <ce>. Merci pour l'aide.
InformationsquelleAutor Darin Dimitrov

Vous pouvez utiliser ConvertAll méthode à l'intérieur de .Net Framework 2.0 voici un exemple

        List<int> lstInt = new List<int>(new int[] { 1, 2, 3 });
        List<double> lstDouble = lstInt.ConvertAll<double>(delegate(int p)
        {
            return (double)p;
        });

InformationsquelleAutor fyasar

1

Vous pouvez utiliser une méthode de groupe:
```
lstDouble = lstInt.Select(Convert.ToDouble)
```
InformationsquelleAutor Tom
0

Vous pouvez utiliser Select ou ConvertAll. Gardez à l'esprit que ConvertAll est disponible dans .Net 2.0 trop

InformationsquelleAutor Giorgi

Vous devez vous connecter pour publier un commentaire.