Conversion de Système.Tableau pour la Liste

La nuit dernière, j'ai eu de rêve que le suivant était impossible. Mais dans le même rêve, quelqu'un de la SORTE m'a dit le contraire. Donc je voudrais savoir si il est possible de convertir System.Array à List

Array ints = Array.CreateInstance(typeof(int), 5);
ints.SetValue(10, 0);
ints.SetValue(20, 1);
ints.SetValue(10, 2);
ints.SetValue(34, 3);
ints.SetValue(113, 4);

List<int> lst = ints.OfType<int>(); //not working

Ci-dessous lien à montrer comment il le fait en c# codegateway.com/2011/12/...
Vous devez lancer le Array pour ce qu'elle est réellement, un int[], alors vous pouvez utiliser ToList: ((int[])ints).ToList();

InformationsquelleAutor user193276 | 2009-10-21

378

Vous épargner un peu de douleur...
```
using System.Linq;

int[] ints = new [] { 10, 20, 10, 34, 113 };

List<int> lst = ints.OfType<int>().ToList(); //this isn't going to be fast.
```
Pouvez aussi simplement...
```
List<int> lst = new List<int> { 10, 20, 10, 34, 113 };
```
ou...
```
List<int> lst = new List<int>();
lst.Add(10);
lst.Add(20);
lst.Add(10);
lst.Add(34);
lst.Add(113);
```
ou...
```
List<int> lst = new List<int>(new int[] { 10, 20, 10, 34, 113 });
```
ou...
```
var lst = new List<int>();
lst.AddRange(new int[] { 10, 20, 10, 34, 113 });
```
- Note pour l'exhaustivité: la 2e méthode est disponible uniquement en C# 3.0+.
- Depuis le tableau int implémente déjà IEnumerable<int>, le OfType<int>() n'est pas nécessaire. ints.ToList(); suffit.
- Pour OfType, vous devez utiliser le Système.Linq
- J'ai essayé et ça a ralenti mon programme immensly par rapport à il suffit de le mettre manuellement dans une liste avec une boucle for
- fait quelques ajustements, la première méthode ici, n'est certainement pas le moyen le plus rapide pour ce faire.
- Aucun de ces exemples n'en fait répondre à la question. Mais je suppose qu'il a accepté de répondre tellement il était heureux. Pourtant, pas un seul de ces en fait de convertir un Tableau à une Liste. "La Conversion de Système.Tableau pour la Liste". Faut ajouter que l'exemple de l'exhaustivité de l'OMI. (En haut de réponse et tout et tout)
- Le premier exemple est exactement ce que fait.
- Il est vrai que OfType de travail pour la classe Array, c'est juste pas à l'aide de la classe Array dans l'exemple. Et à en juger par le deuxième commentaire que je ne suis pas le seul à avoir eu confus à ce sujet.
- Système.Linq dans .Net 4.0 est dans le Système.Base: stackoverflow.com/questions/2893601/...
- Ne pas répondre à la question.
- Enum.GetValues(typeof(Enumtype)).Cast<itemtype>().ToList()
InformationsquelleAutor Dave
70

Il y a aussi une surcharge du constructeur pour la Liste de travail... Mais je suppose que ce serait une forte tableau typé.
```
//public List(IEnumerable<T> collection)
var intArray = new[] { 1, 2, 3, 4, 5 };
var list = new List<int>(intArray);
```
... pour la classe Array
```
var intArray = Array.CreateInstance(typeof(int), 5);
for (int i = 0; i < 5; i++)
    intArray.SetValue(i, i);
var list = new List<int>((int[])intArray);
```
- Entre cette approche et celle à l'aide de ToList(), qui est plus efficace? Ou est-il une différence?
- Difficile à dire sans connaître la véritable taille du jeu de données (Liste interne utilise des tableaux qui doivent être en mesure de se développer. Les tableaux sont immuables.) Si vous savez la Liste de la taille de l'avance de cette façon pourrait améliorer légèrement les performances... mais le gain va être tellement petit que vous pouvez aussi bien utiliser la version que vous préférez à maintenir.
- Avez-vous remarqué ce thread est de 6 ans? (Et ma deuxième réponse directement occupe de son exemple d'utilisation de Array au lieu de int[].)
InformationsquelleAutor Matthew Whited
51

Curieusement personne ne répond à la question, OP n'est pas à l'aide d'un fortement typé int[] mais un Array.

Vous devez lancer le Array pour ce qu'elle est réellement, un int[], alors vous pouvez utiliser ToList:
```
List<int> intList = ((int[])ints).ToList();
```
Noter que Énumérable.ToList appelle la liste constructeur qui vérifie d'abord si l'argument peut être utilisé pour ICollection<T>(dont un tableau met en œuvre), alors il utilisera le plus efficace ICollection<T>.CopyTo méthode au lieu d'énumérer la séquence.
- Merci, Enum.GetValues retourne un Tableau et cela m'a aidé à faire une liste de il.
- Je sais que c'est vieux, mais vous avez raison, la question est de répondre par la présente. Dans ma situation, une dynamique deserializer renvoie une matrice du système, car il doit être prêt à accepter n'importe quel type de données de sorte que vous ne pouvez pas précharger la liste jusqu'à l'exécution. Merci
- C'est la réponse correcte à la question.
InformationsquelleAutor Tim Schmelter

La méthode la plus simple est:

int[] ints = new [] { 10, 20, 10, 34, 113 };

List<int> lst = ints.ToList();

List<int> lst = new List<int>();
lst.AddRange(ints);

On a besoin using System.Linq; pour ToList() de travail.

InformationsquelleAutor Danny

Dans le cas où vous voulez retourner un tableau d'énumérations comme une liste, vous pouvez effectuer les opérations suivantes.

using System.Linq;

public List<DayOfWeek> DaysOfWeek
{
  get
  {
    return Enum.GetValues(typeof(DayOfWeek))
               .OfType<DayOfWeek>()
               .ToList();
  }
}

InformationsquelleAutor Rahbek

4

dans vb.net viens de le faire
```
mylist.addrange(intsArray)
```
ou
```
Dim mylist As New List(Of Integer)(intsArray)
```
- beaucoup mieux que d'utiliser OfType<> (mon VS2010 n'accepteraient rien de OfType...)
InformationsquelleAutor Smith
4

Vous pouvez le faire comme ceci en gros:
```
int[] ints = new[] { 10, 20, 10, 34, 113 };
```
c'est votre tableau, et que vous pouvez appeler votre nouvelle liste comme ceci:
```
 var newList = new List<int>(ints);
```
Vous pouvez faire cela pour objet complexe aussi.

InformationsquelleAutor nzrytmn

Vous pouvez juste essayer de votre code:

Array ints = Array.CreateInstance(typeof(int), 5);
ints.SetValue(10, 0);

ints.SetValue(20, 1);
ints.SetValue(10, 2);
ints.SetValue(34, 3);
ints.SetValue(113, 4);

int[] anyVariable=(int[])ints;

Vous pouvez simplement utiliser le anyVariable que votre code.

InformationsquelleAutor 13kudo

2

Suffit d'utiliser la méthode existante.. .ToList();
```
   List<int> listArray = array.ToList();
```
KISS(KEEP IT SIMPLE SIR)

InformationsquelleAutor Drew Aguirre

J'espère que cela est utile.

enum TESTENUM
    {
        T1 = 0,
        T2 = 1,
        T3 = 2,
        T4 = 3
    }

obtenir de la chaîne de valeur

string enumValueString = "T1";

        List<string> stringValueList =  typeof(TESTENUM).GetEnumValues().Cast<object>().Select(m => 
            Convert.ToString(m)
            ).ToList();

        if(!stringValueList.Exists(m => m == enumValueString))
        {
            throw new Exception("cannot find type");
        }

        TESTENUM testEnumValueConvertString;
        Enum.TryParse<TESTENUM>(enumValueString, out testEnumValueConvertString);

obtenir la valeur entière

        int enumValueInt = 1;

        List<int> enumValueIntList =  typeof(TESTENUM).GetEnumValues().Cast<object>().Select(m =>
            Convert.ToInt32(m)
            ).ToList();

        if(!enumValueIntList.Exists(m => m == enumValueInt))
        {
            throw new Exception("cannot find type");
        }

        TESTENUM testEnumValueConvertInt;
        Enum.TryParse<TESTENUM>(enumValueString, out testEnumValueConvertInt);

InformationsquelleAutor Арсений Савин

Vous devez vous connecter pour publier un commentaire.