Les meilleures pratiques lors du retour d'un tableau de valeurs (.NET)

Question

Habituellement mes méthodes sont comme suit:

public List<int> Method1(int input) 
{ 
    var output = new List<int>(); 
    //add some items to output 
    return output; 
} 

Mais une autre mise en œuvre FxCop conseille IList au lieu de la liste, mais je ne sais plus. Les alternatives comprennent le retour comme un IList, ICollection ou IEnumerable pour plus de flexibilité ou d'une toute autre façon que le code ci-dessous .:

public int[] Method2(int input) 
{ 
    var output = new List<int>(); 
    //add some items to output 
    return output.ToArray(); 
} 

de toutes les alternatives, tous fournis et toutes les possibilités, ce qui est considéré comme la meilleure pratique?

Answer 1

"Framework Design Guidelines" (2e éd) dans §8.3.1 a beaucoup de choses à dire au sujet de collections comme valeurs de retour, résumé:

• NE PAS possèdent des propriétés de collecte définissables.
• DO d'utiliser Collection<T> ou une sous-classe de Collection<T> pour les propriétés ou les valeurs de retour représentant des collections de lecture/écriture.
• DO utilisation ReadOnlyCollection<T>, une sous-classe de ReadOnlyCollection<T>, ou dans de rares cas IEnumerable<T> pour les propriétés ou renvoient des valeurs représentant en lecture seule collections.

(et plus, mais ces trois capturent le noyau). Le premier de ceux ci-dessus: ne renvoie pas de référence à la collection interne à moins que vous vouliez que l'utilisateur puisse le changer (et alors probablement vous devriez avoir un type personnalisé ainsi vous avez un degré de contrôle).

Je retournerais IList<T> et je m'assurerais de ne pas définir le type réel que je retourne, sauf si je retournais un itérateur (quand j'utiliserais IEnumerable<T>).

Answer 2

IEnumerable/IEnumerable < T> sauf si vous avez besoin spécifiquement une liste, vous devez retourner IList < T>

Answer 3

Retour à l'interface que vous avez besoin dans le code appelant cette méthode.

Si vous devez effectuer des actions de liste sur le résultat, renvoyez IList<T>. Si vous avez juste besoin d'énumérer les résultats, retournez IEnumerable<T>.

Ce sont ceux que j'utilise le plus, en fait. Je ne renvoie jamais de tableaux à partir d'interfaces publiques à moins d'une très bonne raison.

Answer 4

ReadOnlyCollection<T> est une autre option.

Answer 5

Cela dépend.

Voulez-vous que l'appelant puisse modifier les éléments et que vous voyiez ces changements? Les tableaux peuvent être modifiés. L'interface IList définit les méthodes de modification (mais l'implémentation peut ne pas l'autoriser).

Pouvez-vous élaborer sur l'avertissement FxCop?

Kent

Answer 6

Cela dépend de vos besoins. Tout compte fait, l'itération à travers des tableaux fortement typés est la plus rapide parmi tous les types de collection. Si vous n'avez pas besoin de redimensionner/ajouter/rechercher à travers eux, les tableaux sont assez bien.

Answer 7

Je vais presque toujours avec List parce qu'il me donne des méthodes que je trouve souvent les plus utiles. Une conséquence négative potentielle du renvoi d'un IEnumerable est que toutes les exceptions qui sont levées lors de l'énumération proviendraient d'une zone de code qui pourrait être assez éloignée du code qui a réellement construit l'objet, rendant le suivi des bogues plus difficile.

Answer 8

Eric Lippert a un bon post sur pourquoi returning an array is usually a bad idea. En règle générale, vous devriez être aussi général que vous pouvez être sans causer de chagrin indu à celui qui va appeler votre méthode. Préférez les interfaces aux classes concrètes et choisissez l'interface la plus générique avec laquelle vous pouvez vous en sortir. Les interfaces de retour encapsulent mieux votre implémentation et faciliteront les choses à l'avenir. Si vous commencez avec un type concret, vous êtes engagé à toujours renvoyant ce type.

IEnumerable<T> est le meilleur endroit pour commencer. Avec l'avènement de LINQ, il y a très peu de choses qu'un appelant ne peut pas faire facilement juste donné une énumération. Si un appelant a parfois besoin d'une liste, il est assez facile d'appeler le .ToList().

Si les appelants sont susceptibles d'avoir un besoin spécifique d'indexer dans la collection retournée, ou s'ils vont probablement vouloir modifier eux-mêmes la collection (insertion/suppression/réorganisation d'éléments), utilisez un IList<T>.