Tableau versus Liste<T>: Quand utiliser?

MyClass[] array;
List<MyClass> list;

Quels sont les scénarios quand l'un est préférable à l'autre? Et pourquoi?

  • Les tableaux sont plutôt obsolète, comme on le voit dans un populaire de discussion ici. Aussi souligné ici, et par notre hôte le blog.
  • Si je ne me trompe pas, la Liste<> a un tableau en tant que structure interne. Chaque fois que le tableau interne est rempli, il suffit de copier le contenu d'un tableau qui est le double de la taille (ou une autre constante de temps de la taille actuelle). en.wikipedia.org/wiki/Dynamic_array
  • Ykok: Ce que vous dites semble à propos de droite, j'ai trouvé le code source de List<> ici.
  • Faisant valoir que les tableaux sont obsolètes est peut-être un peu gras
InformationsquelleAutor Frederick The Fool | 2009-01-12
  1. 551

    Il est rare, en réalité, que vous ne souhaitez pas utiliser un tableau. Certainement utiliser un List<T> tout moment vous souhaitez ajouter/supprimer des données, depuis le redimensionnement des tableaux est cher. Si vous connaissez les données de longueur fixe, et que vous souhaitez micro-optimiser pour certains très spécifiques raison (après évaluation), puis un tableau peut être utile.

    List<T> offre un beaucoup plus de fonctionnalités qu'un tableau (bien que LINQ evens un peu), et est presque toujours le bon choix. Sauf pour params arguments, bien sûr. ;-p

    Comme un contre - List<T> est unidimensionnel; où-comme vous avez rectangulaire (etc) des tableaux comme int[,] ou string[,,] - mais il existe d'autres moyens de modélisation de ces données (si vous en avez besoin) dans un modèle objet.

    Voir aussi:

    Cela dit, je fais une beaucoup de l'utilisation de tableaux dans mon protobuf-net projet; entièrement pour la performance:

    • il fait beaucoup de décalage de bits, donc un byte[] est à peu près indispensable pour l'encodage;
    • - Je utiliser un local de roulement byte[] tampon que je remplis avant de les envoyer vers le flux sous-jacent (et v. v.); plus rapide que BufferedStream etc;
    • il utilise en interne un tableau basée sur le modèle d'objets (Foo[] plutôt que List<Foo>), puisque la taille est fixe une fois construit, et doit être très rapide.

    Mais c'est certainement une exception; pour la ligne générale de traitement des affaires, un List<T> gagne à chaque fois.

    • L'argument sur le redimensionnement est totalement valide. Toutefois, les gens préfèrent les Listes, même lorsqu'il n'redimensionnement est nécessaire. Pour ce dernier cas, est-il un solide, d'un argument logique ou est-il rien de plus que des "tableaux sont en dehors de la mode"?
    • difficile de répondre sans entendre le "pourquoi". En fait, dans de nombreux cas, je préfère IList<T> ou IEnumerable<T> - il permet à l'appelant de décider ce qu'ils veulent utiliser (T[] ou List<T> etc). LINQ largement soldes beaucoup de supplémentaire List<T> fonctions (plus de IList<T>).
    • En fait, je travaille avec un héritage, C# 1.0 base de code. Certaines des fonctions y prendre et retourner les tableaux. Pas de redimensionnement ou de tout ce qui se passe....
    • ...Maintenant, dans mes fonctions wrapper, je suis enclin à utiliser la Liste<T>'s au lieu des tableaux. Mais je n'ai pas de raisonnement solide pour justifier cela. Juste une ambiance chaleureuse et douillette. J'ai besoin d'un bon argument en faveur de ma décision.
    • Eh bien, les choses sont légèrement différentes sans les génériques... la Boxe et le casting ne sont pas les pire choses dans le monde, mais il ajoute. Je dirais que les tableaux ont un peu plus de place dans .NET 1.x que maintenant, mais il ya encore de la liste de tableaux, etc si vous pouvez vivre avec la boîte/cast/pas-au moment de la compilation de vérification de la douleur.
    • sérieusement: considérer IList<T> (si vous avez besoin d'ajouter/supprimer/indexeur) ou IEnumerable<T> (si vous avez juste besoin foreach).
    • Je ne comprends pas tout cela: le fait de travailler avec un éventail besoin boxing/unboxing? Même si le type d'un tableau est un type de référence? Et le casting est nécessaire de trop? Mais n'est-ce pas un tableau fortement typé? PS: je suis juste curieux de savoir si il y a juste quelques dogme contre les tableaux. PPS: Encore à lire Jon Skeet du lien.
    • Ouais. J'apprécie et d'accord avec l'utilisation IList<T>, et IEnumerable<T>. Ils font de votre classe utilisateur de moins de contraintes en termes de ce qui à l'alimentation et attendre de retour à partir de votre classe.
    • mon boxe/cast observations ont été adressées à la liste de tableaux, etc, étant donné qu'ils sont l'option la plus proche à la Liste des<T> dans .NET 1.x
    • "Certainement utiliser une List<T> toutes les fois que vous souhaitez ajouter/supprimer des données, depuis le redimensionnement des tableaux est cher". Liste<T> utilise un tableau à l'interne. Pensiez-vous de LinkedList<T>?
    • Une Liste<T> maintient le tableau plus grand qu'il doit être, si pas tous les ajouter/supprimer des besoins de l'opération pour redimensionner le tableau, car il y a encore de l'espace libre à la fin du tableau, la plupart du temps.
    • mais que faire si vous supprimer un élément à partir du milieu du tableau? Tous les éléments ci-dessus, il devra être mélangées long pour combler le trou.
    • Except for params arguments, of course ;-p Pourquoi, sauf pour les params arguments? Pourriez-vous expliquer un peu?
    • parce que params uniquement il existe pour les vecteurs; c'est donc l'un des endroits où il est plus naturel d'utiliser un tableau nu. Bien sûr, personnellement, je suis très anti-invisible-allocation, donc j'essaie d'éviter params en premier lieu.
    • Vous avez écrit "il y a d'autres façons de la modélisation, [n-dimensionnelle] données (si vous en avez besoin) dans un modèle d'objet." Eh bien, je ne ont besoin, depuis l'application, j'ai fait de la forte utilisation de la n-dimensions données, et je suis heureux à l'aide de double[,], Point3D[,], et la comme. Vous avez toutes les ressources sur le point concernant les modèles d'objet pour cette utilisation, qui sont mieux que la plaine des tableaux? Mes tableaux sont généralement dense et ne pas les redimensionner ou les transformer. Merci!
    • Plus de fonctionnalités == plus complexe == pas bon, sauf si vous avez besoin de ces fonctionnalités. Cette réponse essentiellement des listes de raisons pour lesquelles la matrice sont mieux, mais en tire la conclusion inverse.
    • Oui. Il n'y a rien qui vous empêche de doubler la taille de la matrice lors qu'il remplit de vous-même, de sorte que la charge de redimensionner un tableau n'est pas pertinent.
    • Je n'ai pas vraiment d'accord avec ça. La plupart des "caractéristiques" dont vous parlez (comme la mise en œuvre de tableaux dynamiques) ne sont pas comme, newfangled indésirable que vous avez à peine jamais allons utiliser.
    • Il n'importe pas s'ils sont newfangled, c'est extra complexité, vous n'avez pas besoin. Êtes-vous réellement à l'aide de ces fonctionnalités? Non? N'utilisez pas de List<>. Puisque les structures de données qui changent au fil du temps, de rendre le code difficile à comprendre, j'avais activement vous recommandons de ne pas utiliser List<>.Add, sauf si vous avez donné un examen attentif; du tableau il suffit de retirer un plus source de bugs dans le code qui n'a pas besoin d'un redimensionnement dynamique (c'est à dire la plupart du code).
    • si vous n'utilisez pas ces fonctionnalités, je peux très bien la garantie qu'ils ne vont pas faire de mal... mais: le nombre de collections que jamais besoin de mutation est beaucoup petit, dans mon expérience, que ceux qui sont mutés
    • cela dépend de votre style de codage. Dans mon expérience, pratiquement pas de collections sont jamais muté. C'est-à-collections sont extraites de la base de données ou construit à partir d'une source quelconque, mais plus loin traitement est toujours fait en recréant une nouvelle collection (par exemple map/filter, etc). Même lorsque conceptuel mutation est nécessaire, elle tend à être de plus simple il vous suffit de créer une nouvelle collection. Je n'ai muter une collection comme une optimisation des performances, et de telles optimisations ont tendance à être très locale et de ne pas exposer la mutation de l'API de consommateurs.
    • Pour en contexte, la non-mutation des collections est clairement ce que LINQ est le mieux, et ce n'est pas rare qu'une API de nos jours. C'est à la fois étrange de "muter" le résultat d'une requête linq (pourquoi ne pas vous sélectionnez+projet correctement en premier lieu?), et c'est conceptuellement difficile à muter la source d'une requête linq en raison du mélange de hâte et d'évaluation différée. Si vous êtes à la construction d'une base de données sauvegardées de site web, je serais curieux de savoir si il y en a (commun) cas d'utilisation à tout pour mutable collections - en dehors de la base de données elle-même, bien sûr.
    • Je ne pouvais pas être plus en désaccord que "la plupart de code" n'a pas besoin de la matrice de redimensionnement et il y a beaucoup d'autres choses que vous avez à vous soucier de se tromper si vous travaillez avec des tableaux.
    • Certains code traite, avec des collections de manuellement en boucle, la transformation des structures de données comme il va. Ce code aime foreach et List<>.Add. Autres code traite avec des collections de valeurs, et calcule les nouvelles collections de vieux. Ce code aime LINQ, et est de peu d'usage pour mutable collections. Cette réponse implicitement préfère les boucles de+de mutation au cours de constructions fonctionnelles, et je ne pense pas qu'une telle préférence devrait être implicite que fait la façon dont il est. La plupart des code je vois tend vers le fonctionnel, le calcul de nouvelles collections (ou les itérateurs) à partir de l'existant, des données inchangées.
    • la mutabilité fait mal, dans la pratique, précisément parce que certains de code de façon conventionnelle s'attend à des modifications effectuées par la mutation. En évitant les Add méthode immédiatement évite la source n ° 1 d'une mauvaise utilisation accidentelle, et de l'expérience dans un grand projet, je peux dire que les bugs sont désagréables car (tout comme null-deref bugs) le code qui plante ou calcule la valeur faux est souvent éloignés de la source de l'erreur (le code qui a changé interne discbased qui était censé être immuable). TL;DR: Si vous allez le LINQ route, ce qui est le cas d'utilisation pour List<>?
    • Si vous voulez immuable collections, en fait, vous devez utiliser un immuable de la collection. Les tableaux sont mutables; elles sont seulement de longueur fixe.
    • Les tableaux sont le meilleur choix dans la plutôt rares circonstances que vous besoin une mutable collection, mais celui qui est de longueur fixe. Ce n'est pas de la programmation fonctionnelle à tous.
    • Les tableaux ne sont pas parfaits, mais ils sont mieux que List<> si vous n'avez pas besoin de la mutabilité: ils sont plus rapides, utiliser moins de mémoire et éviter le plus commun mutable opération. Malheureusement, .NET ne fournit pas de comparable immuable array (il y a un package nuget pour le Système.Les Collections.Immuable, mais la matrice de mise en œuvre est encore préliminaire uniquement), et encore une fois il ne, pas tout le monde peut mettre à jour à la dernière .NET immédiatement et l'immutabilité wrapper ont des frais généraux. Dans l'ensemble: pour l'instant, l'ensemble est assez bon (et certainement mieux que List<> non-mutation de cas d'utilisation.
    • pensez-y de cette façon: c'est précisément parce que List<> est donc approprié pour la mutation de collections, il est inapproprié pour les non-mutation des collections parce que le type de véhicule le mauvais message.
    • Eh bien, à l'aide de ReadOnlyCollection<T> serait d'envoyer ce message encore plus fortement.
    • beaucoup plus détaillé, et terrifiant lent. Pour une API publique - sûr. Mais la plupart du code n'est pas dans l'API publique, et des conventions de codage que l'état "ne salissez pas avec le contenu du tableau après la construction", beau travail. Applique immutabilité n'est pas naturel ou facile en C#, et je ne pense pas que le supplémentaires mentale et de gestion d'exécution en vaut la peine, surtout quand de simples conventions sont presque tout aussi bon, et beaucoup plus simple et plus rapide.
    • pourquoi dites-vous "List<T> est unidimensionnel; où-comme vous avez rectangulaire (etc) des tableaux" <--- en Effet, vous pouvez avoir recangular ou les tableaux irréguliers, mais de la même manière, vous pouvez avoir List<List<string>> Alors pourquoi suggèrent que la Liste est 1D quand il n'est pas plus ou moins que les tableaux 1D?
    • k; int[,] est explicitement un tableau 2D. int[,,] est explicitement un tableau 3d. int[][] n'est cependant pas un "tableau 2d" - c'est un tableau 1D de tableaux 1D, aka un tableau en escalier. De même List<List<int>> n'est pas un 2D liste: c'est une liste de listes. Le point est que, dans le cas de int[,] il y a un array, nous pouvons ainsi décrire les propriétés de l'1 tableau. Dans le cas de List<List<int>> il y a n+1 listes; l'un est un 1D liste de listes, quand est-1D listes d'entiers. Oui, vous pouvez utiliser un List<List<int>> pour exprimer les données en 2D, mais ce n'est pas la même chose. La sémantique de la matière.
    • Ce sujet de la commutation entre les Listes et les Tableaux lorsque le cas l'exige. j'.e, une fois que la liste est de taille fixe, commutateur de mise en réseau et d'effectuer des trucs sur le tableau, et peut-être que si nous avons besoin de beaucoup de ajout/suppression de nouveau revenir de nouveau à la liste (à l'aide de LINQ)
    • vous ne pouvez pas tout simplement de basculer entre les tableaux et les listes sans avoir à payer de l'allocation+frais de copie qui permettrait de rendre l'approche d'un coût prohibitif
    • ouais, j'ai pensé que. La chose est, si la liste est moins cher à ajouter/supprimer des éléments, puis un tableau est moins cher à lire et à utiliser, peut-être un droit de conversion, après que nous aurons terminé l'ajout de n'' être à ce point. Mais je suis d'accord que l'approche semble être un gaspillage de ressources. Je ne sais pas comment les conversions dans LINQ sont mis en œuvre à l'interne, par contre...
    • Les tableaux pour les variadic params ou de garantie de taille fixe. Liste de traiter avec les redimensionner.
    • Aussi, certaines API est juste naturellement return Array comme par exemple Regex.split

    InformationsquelleAutor Marc Gravell
  2. 117

    Vraiment juste de répondre à ajouter un lien sur lequel je suis surpris n'a pas encore été mentionnés: Eric Lippert l'entrée de blog sur Des "tableaux considéré comme un peu dangereux."

    Vous pouvez en juger par le titre qu'il suggère à l'aide de collections dans la mesure du possible - mais comme Marc souligne à juste titre, il y a beaucoup d'endroits où un tableau est vraiment la seule solution pratique.

    • Enfin eu le temps de la lecture de ce plus de 3 ans plus tard, haha. Bon article, bonne article. 🙂
    InformationsquelleAutor Jon Skeet
  3. 20

    Nonobstant les autres réponses recommander List<T>, vous aurez envie d'utiliser des tableaux lors de la manipulation:

    • image bitmap de données
    • d'autres données de bas niveau-structures (c'est à dire les protocoles réseau)
    • Pourquoi pour les protocoles réseau? Ne serait-il pas plutôt d'utiliser des structures et de leur donner une spéciale sérialiseur ou explicite d'une disposition de la mémoire? En outre, ce qui parle contre l'utilisation d'un List<T> ici plutôt que d'un tableau d'octets?
    • eh bien, pour commencer, Stream.Lire et diffuser.Écrire travailler avec byte[], comme le fait d'Encodage etc...
    InformationsquelleAutor Alnitak
  4. 11

    Sauf si vous êtes vraiment intéressé à la performance, et par cela je veux dire, "Pourquoi êtes-vous à l'aide .Net au lieu de C++?" vous devriez coller avec la Liste des<>. C'est plus facile à maintenir et à faire tout le sale travail de redimensionnement d'un tableau derrière les coulisses pour vous. (Si nécessaire, une Liste<> est assez intelligent pour choisir la taille des matrices de sorte qu'il n'a pas besoin de d'habitude.)

    • "Pourquoi êtes-vous à l'aide .Net au lieu de C++?" XNA
    InformationsquelleAutor Spencer Ruport
  5. 6

    Tableaux devrait être utilisée de préférence à la Liste lors de l'immutabilité de la collection elle-même est une partie du contrat entre le client & fournisseur de code (pas nécessairement l'immuabilité des éléments au sein de la collection) ET quand IEnumerable n'est pas adapté.

    Par exemple,

    var str = "This is a string";
var strChars = str.ToCharArray();  //returns array

    Il est clair que la modification de la "strChars" ne sera pas la mutation de l'original "str" objet, indépendamment de la mise en œuvre des connaissances de niveau de "str"de type sous-jacent.

    Mais supposons que

    var str = "This is a string";
var strChars = str.ToCharList();  //returns List<char>
strChars.Insert(0, 'X');

    Dans ce cas, il n'est pas clair à partir de ce code-extrait de seul si la méthode d'insertion permettra ou non de la mutation de l'original "str" objet. Il nécessite la mise en place du niveau de connaissance de la Chaîne pour faire cette détermination, qui casse la Conception par Contrat approche. Dans le cas de la Chaîne, c'est pas une grosse affaire, mais il peut être un gros problème dans presque tous les autres cas. Réglage de la Liste de lecture seule aide, mais les résultats dans les erreurs d'exécution, et non pas au moment de la compilation.

    • Je suis relativement novice en C#, mais il n'est pas clair pour moi pourquoi revenir une liste suggère la mutabilité des données d'origine dans la façon de retourner un tableau ne serait pas. J'aurais bien qu'une méthode dont le nom commence par To va créer un objet qui n'a pas la possibilité de modifier l'instance d'origine, par opposition à strChars as char[] qui, si elle valide suggère que vous êtes maintenant en mesure de modifier l'objet original.
    InformationsquelleAutor Herman Schoenfeld
  6. 3

    Si je sais exactement comment beaucoup d'éléments que je vais avoir besoin d', dire que j'ai besoin de 5 éléments et seulement jamais 5 éléments, puis-je utiliser un tableau. Sinon je viens d'utiliser une Liste<T>.

    • Pourquoi ne pas utiliser une Liste<T> dans le cas où vous connaissez le nombre d'éléments?
    InformationsquelleAutor smack0007
  7. 3

    La plupart du temps, à l'aide d'un List suffirait. Un List utilise un tableau interne pour gérer ses données, et redimensionne automatiquement la matrice lors de l'ajout d'autres éléments à l' List que sa capacité actuelle, ce qui rend plus facile à utiliser qu'un tableau, où vous avez besoin de connaître les capacités de l'avance.

    Voir http://msdn.microsoft.com/en-us/library/ms379570(v=vs. 80).aspx#datastructures20_1_topic5 pour plus d'informations sur les Listes en C# ou tout simplement décompiler System.Collections.Generic.List<T>.

    Si vous avez besoin de données multidimensionnelles (par exemple à l'aide d'une matrice ou dans les graphiques de programmation), vous devriez probablement aller avec un array à la place.

    Comme toujours, si la mémoire ou de la performance est un problème, de le mesurer! Sinon, vous pourriez faire de fausses hypothèses sur le code.

    • Bonjour, pourriez-vous expliquer pourquoi "de la liste de recherche de temps serait O(n)" est vrai? Autant que je sache, List<T> utilise la matrice de derrière les coulisses.
    • vous avez tout à fait raison. Source. À l'époque, je suppose que la mise en œuvre utilisé des pointeurs, mais depuis j'ai appris le contraire. À partir du lien ci-dessus: 'Récupération de la valeur de cette propriété est un O(1) opération; la définition de la propriété est aussi un O(1) opération".
    InformationsquelleAutor Sune Rievers
  8. 1

    Une autre situation qui n'est pas encore mentionné, c'est que quand on va avoir un grand nombre d'éléments, dont chacun se compose d'un fixe tas de mais-variables indépendantes collés ensemble (par exemple, les coordonnées d'un point, ou les sommets d'un 3d triangle). Un tableau de l'exposé-structures sur le terrain permettra à l'un de ses éléments pour être efficace modifié "en place"--quelque chose qui n'est pas possible avec n'importe quel autre type de collection. Car un tableau de structures tient ses éléments de manière consécutive dans la mémoire RAM, séquentielle accède aux éléments d'un tableau peuvent être très rapides. Dans les situations où le code a besoin de faire de nombreux séquentielle passe à travers un tableau, un tableau de structures peuvent produire un tableau ou d'un autre groupe de la classe des références d'objet par un facteur de 2:1; de plus, la possibilité de mettre à jour les éléments en place peut permettre à un tableau de structures à surpasser tout autre type de collection de structures.

    Bien que les tableaux ne sont pas redimensionnables, il n'est pas difficile d'avoir le code de stocker une référence de tableau avec le nombre d'éléments qui sont en cours d'utilisation, et de remplacer le tableau avec un plus grand un seul en tant que de besoin. Alternativement, on pourrait facilement écrire du code pour un type qui s'est comporté comme un List<T> mais exposé son magasin de sauvegarde, permettant ainsi à dire soit MyPoints.Add(nextPoint); ou MyPoints.Items[23].X += 5;. A noter que ce dernier ne serait pas nécessairement lever une exception si le code a tenté d'accéder au-delà de la fin de la liste, mais l'utilisation serait contraire être conceptuellement assez similaire à List<T>.

    • Ce que vous décrivez est une Liste<>. Il y a un indexeur de sorte que vous pouvez accéder à la sous-jacentes tableau directement, et la Liste des<>, permettra de maintenir la taille pour vous.
    • Compte tenu par exemple Point[] arr;, il est possible pour le code-à-dire, par exemple,arr[3].x+=q;. En utilisant par exemple List<Point> list, il faudrait plutôt dire Point temp=list[3]; temp.x+=q; list[3]=temp;. Il serait utile si List<T> avait une méthode Update<TP>(int index, ActionByRefRef<T,TP> proc, ref TP params). et les compilateurs pourrait se transformer list[3].x+=q; en {list.Update(3, (ref int value, ref int param)=>value+=param, ref q);, mais pas une telle fonction existe.
    • De bonnes nouvelles. Elle fonctionne. list[0].X += 3; va ajouter 3 à la propriété X de le premier élément de la liste. Et list est un List<Point> et Point est une classe avec des propriétés X et Y
    InformationsquelleAutor supercat
  9. 1

    Listes .NET sont des wrappers sur des tableaux, et l'utilisation d'un tableau à l'interne. Le temps de la complexité des opérations sur les listes est le même que ce serait avec les tableaux, mais il est un peu plus frais avec toutes les fonctionnalités ajoutées /facilité d'utilisation des listes (comme le redimensionnement automatique et les méthodes de la classe list). Très bien, je recommande l'utilisation de listes dans tous les cas, sauf s'il existe une raison impérieuse pas de le faire, comme si vous avez besoin d'écrire très optimisé le code, ou de travailler avec un autre code qui est construit autour des tableaux.

    InformationsquelleAutor iliketocode
  10. 0

    Plutôt que de passer par une comparaison des caractéristiques de chaque type de données, je pense que le plus pragmatique réponse est "les différences ne sont probablement pas si important que cela pour ce que vous devez accomplir, surtout depuis qu'ils mettent en œuvre IEnumerable, afin de suivre la convention populaire et l'utilisation d'un List jusqu'à ce que vous avez une raison de ne pas, à quel point vous aurez probablement la raison de votre utilisation d'un tableau sur une List."

    La plupart du temps dans la gestion de code que vous allez vouloir faveur des collections étant aussi facile à travailler que possible plus de se soucier de micro-optimisations.

    InformationsquelleAutor moarboilerplate
  11. 0

    Ils peuvent être impopulaires, mais je suis un fan de Tableaux dans des projets de jeux.
    - Itération de la vitesse peut être important dans certains cas, foreach sur un Tableau a nettement moins de frais généraux si vous ne faites pas beaucoup par élément
    - L'ajout et la suppression n'est pas difficile avec des fonctions d'assistance
    - Son plus lent, mais dans le cas où vous ne construisez une fois qu'il ne peut pas d'importance
    - Dans la plupart des cas, moins de la mémoire supplémentaire est perdue (le seul vraiment important avec des Tableaux de structures)
    - Un peu moins de déchets et des pointeurs de pointeurs et de chasser

    Cela étant dit, j'ai utiliser la Liste beaucoup plus souvent que les Matrices dans la pratique, mais ils ont chacun leur place.

    Ce serait bien si la Liste où construit dans le type, afin qu'ils puissent optimiser l'emballage et l'énumération de frais généraux.

    InformationsquelleAutor
  12. 0

    Remplissage d'une liste est plus facile que d'un tableau. Pour les tableaux, vous avez besoin de connaître la longueur exacte des données, mais pour les listes, la taille des données peut être tout. Et, vous pouvez convertir une liste dans un tableau.

    List<URLDTO> urls = new List<URLDTO>();

urls.Add(new URLDTO() {
    key = "wiki",
    url = "https://...",
});

urls.Add(new URLDTO()
{
    key = "url",
    url = "http://...",
});

urls.Add(new URLDTO()
{
    key = "dir",
    url = "https://...",
});

//convert a list into an array: URLDTO[]
return urls.ToArray();
    InformationsquelleAutor Bimal Poudel
  13. 0

    Tableaux De Vs. Listes est un classique de la maintenabilité et de performances de problème. La règle de base que presque tous les développeurs suivent, c'est que vous pouvez tirer pour les deux, mais quand ils entrent en conflit, choisissez la facilité de maintenance sur les performances. L'exception à cette règle est lorsque la performance est déjà avéré être un problème. Si vous portez ce principe dans les Tableaux de Vs. Les listes, puis vous obtenez ceci:

    Utilisation fortement typé des listes jusqu'à ce que vous frappez les problèmes de performance. Si vous rencontrez un problème de performance, de prendre une décision quant à savoir si le décrochage des tableaux seront bénéfiques pour votre solution avec des performances plus que ce sera au détriment de votre solution en termes de maintenance.

    InformationsquelleAutor Melbourne Developer
  14. 0

    Car on ne mentionner: En C#, un tableau est une liste de. Maclasse[] et List<Maclasse> à la fois de mettre en œuvre IList<Maclasse>. (par exemple, void Foo(IList<int> foo) peut être appelée comme Foo(new[] { 1, 2, 3 }) ou Foo(new List<int> { 1, 2, 3 }) )

    Donc, si vous écrivez une méthode qui accepte un List<MyClass> comme un argument, mais utilise seulement sous-ensemble de fonctionnalités, vous pouvez déclarer en tant que IList<MyClass> la place pour les appelants confort.

    Détails:

    • "En C#, un tableau est une liste" ce n'est pas vrai; un tableau n'est pas un List, il n'implémente que la IList interface.
    InformationsquelleAutor snipsnipsnip
  15. -1

    Il dépend entièrement du contexte dans lequel la structure de données est nécessaire. Par exemple, si vous créez des éléments qui seront utilisés par d'autres fonctions ou services à l'aide de la Liste est la meilleure façon de l'accomplir.

    Maintenant, si vous avez une liste d'éléments et vous voulez juste pour les afficher, par exemple sur une page web tableau est le conteneur, vous devez utiliser.

    • Si vous avez une liste d'éléments et vous voulez juste pour les afficher, alors quel est le problème avec juste l'aide de la liste que vous avez déjà? Ce serait un tableau de l'offre ici?
    • Et pour "la création d'éléments pour être utilisée par d'autres fonctions ou de services", en fait, je préfère un itérateur bloc avec IEnumerable<T> - alors je peux les objets de flux plutôt que de les protéger.
    InformationsquelleAutor sajidnizami