¿Es malo devolver matrices en C#? ¿Debo devolver la lista <T>?

Question

Tengo una función que devuelve una cantidad variable de elementos, ¿debo devolver una matriz o una lista? El tamaño de "colección" no cambia una vez devuelto, es decir, para todos los fines, la colección es inmutable. Pensaría simplemente devolver una matriz, pero algunas personas han dicho que no devuelvan matrices de tamaño variable de una función, ya que es "de mala calidad". No estoy seguro por qué?

¿Importa que esto tenga que ser compatible con .NET 2.0?

Answer 1

No es correcto devolver matrices si no es necesario, y especialmente para devolver List<T>.

Generalmente, querrá devolver IEnumerable<T> o IList<T>.

Si su usuario solo va a necesitar pasar por cada elemento, IEnumerable<T> proporcionará esta capacidad. También le permite implementar potencialmente la rutina (ahora o más tarde) utilizando la ejecución diferida.

Si su usuario necesita acceder a los elementos por índice, devuelva IList<T>. Esto proporciona todos los beneficios de las matrices, pero le brinda más flexibilidad en su implementación. Puede implementarlo como una matriz, una lista o alguna otra colección que implemente IList<T>, y no tiene que convertir/copiar a una matriz.

Answer 2

Una opinión Veo muy a menudo una sugerencia para devolver IList<T> o ReadOnlyCollection<T>. Está bien devolverlos si tiene uno de estos disponibles; ambos se pueden asignar directamente a IEnumerable<T> (trabajan directamente con cualquier método LINQ). Una cosa a tener en cuenta es ReadOnlyCollection<T> es un tipo muy ligero que puede envolver cualquier IList<T>.

Answer 3

Si el tamaño de la colección no cambia después de su devolución IEnumerable<T> sería mi elección, ya que la persona que llama podría utilizar los métodos de extensión LINQ con la lista inmediatamente.

Answer 4

Expandiendo la respuesta de Reed.

Eric Lippert hizo una gran publicación de blog sobre este mismo tema. Tiene probablemente la respuesta más detallada disponible

• http://blogs.msdn.com/ericlippert/archive/2008/09/22/arrays-considered-somewhat-harmful.aspx

Answer 5

Es fácil conseguir una matriz desde un IList si una matriz es lo que necesita, pero lo contrario no es cierto. Entonces, es preferible devolver un IList.

Answer 6

Como indudablemente ha visto en las respuestas de este hilo, las opiniones sobre este tema son amplias.

En general, mis pensamientos son los siguientes:

Si yo estoy devolviendo una lista cuyo tamaño es constante y no quiero que la persona que llama a poder modificar mis datos (que es el 99% de las veces), Devolveré un ReadOnlyCollection<T>. Esto me da inmutabilidad en el lado del cliente sin tener que doblar (o triplicar, o lo que sea) la huella de memoria de mis datos al crear una nueva lista o una matriz.

Vacilo en decir que "siempre debe devolver IEnumerable o IEnumerable<T>".Si bien esto es ciertamente apropiado en algunos casos (y estos casos no son pocos), la naturaleza liviana de la interfaz IEnumerable limita en gran medida su funcionalidad (ninguna recuperación basada en índices es la más grande), y en muchos casos la fuente subyacente de datos es va a ser una matriz de todos modos, incluso si es un List<T>.

Un peligro adicional de devolver IEnumerable proviene de la práctica perezosa de simplemente devolver la lista interna en el contexto de esa interfaz. Hacer eso lo expone al método de llamada abusando de este atajo volviéndolo al tipo de colección más robusto. Un buen programador defensivo no hará esto.

La huella de memoria más baja proviene de utilizar un ReadOnlyCollection construido a partir de List. A ReadOnlyCollection sigue exponiéndolo al peligro a través del abuso basado en la reflexión y la captura de una referencia a la lista mutable, pero eso es un poco marginal.

Answer 7

Volver a menos que deba IEnumerable:

1. acceso Conde - luego regresar IReadOnlyCollection.
2. modificar elementos y Count es menor ArrayList.Capacity - luego devolver matriz.
3. agregar nuevos elementos - luego lista de devolución.
4. algunas microoptimizaciones: hacer referencia. P.ej. foreach sobre matriz es más rápido entonces sobre la lista

BenchmarkDotNet = v0.10.8, OS = Windows 10 Redstone 1 (10.0.14393) Procesador = Intel Core i5-2500K CPU 3.30GHz (Sandy Bridge), ProcessorCount = 4 Frecuencia = 3233538 Hz, Resolución = 309.2588 ns, Timer = TSC [Host]: Clr 4.0.30319.42000, 64 bits RyuJIT-v4.6.1648.0 Clr: Clr 4.0.30319.42000, 64 bits RyuJIT-v4.6.1648.0 núcleo: núcleo .NET 4.6.25211.01, 64 bits RyuJIT

Method | Job | Runtime |  Mean |  Error | StdDev |  Min |  Max |  Median | Rank | Allocated | 
---------- |----- |-------- |-----------:|-----------:|----------:|-----------:|-----------:|-----------:|-----:|----------:| 
    TestList | Clr |  Clr | 5,153.3 ns | 34.002 ns | 31.806 ns | 5,119.2 ns | 5,213.4 ns | 5,135.9 ns | 3 |  0 B | 
TestArray | Clr |  Clr | 730.1 ns | 6.962 ns | 6.512 ns | 722.4 ns | 743.9 ns | 729.5 ns | 2 |  0 B | 
    TestList | Core | Core | 5,188.4 ns | 102.816 ns | 96.174 ns | 5,070.3 ns | 5,342.6 ns | 5,185.6 ns | 3 |  0 B | 
TestArray | Core | Core | 709.0 ns | 6.126 ns | 5.730 ns | 700.8 ns | 718.6 ns | 708.1 ns | 1 |  0 B | 

Código:

[RankColumn, MinColumn, MaxColumn, StdDevColumn, MedianColumn] 
[ClrJob, CoreJob] 
[HtmlExporter, MarkdownExporter] 
[MemoryDiagnoser] 
public class BenchmarkForEach 
{ 
    List<string> testData = new List<string>(); 
    string[] testArray; 
    public BenchmarkForEach() 
    { 
     for(int i=0;i<1000;i++) 
     { 
      testData.Add(i.ToString()); 
     } 
     testArray = testData.ToArray(); 
    } 
    [Benchmark] 
    public int TestList() 
    { 
     var x = 0; 
     foreach(var i in testData) 
     { 
      x += i.Length; 
     } 
     return x; 
    } 
    [Benchmark] 
    public int TestArray() 
    { 
     var x = 0; 
     foreach (var i in testArray) 
     { 
      x += i.Length; 
     } 
     return x; 
    } 

}