¿Cómo inicializar una List <T> a un tamaño determinado (en oposición a la capacidad)?

.NET ofrece un contenedor de lista genérico cuyo rendimiento es casi idéntico (consulte la pregunta Rendimiento de matrices frente a listas). Sin embargo, son bastante diferentes en la inicialización.

Las matrices son muy fáciles de inicializar con un valor predeterminado y, por definición, ya tienen cierto tamaño:

string[] Ar = new string[10];

Lo que permite a uno asignar de forma segura elementos aleatorios, digamos:

Ar[5]="hello";

con la lista, las cosas son más complicadas. Puedo ver dos formas de hacer la misma inicialización, ninguna de las cuales es lo que llamarías elegante:

List<string> L = new List<string>(10);
for (int i=0;i<10;i++) L.Add(null);

o

string[] Ar = new string[10];
List<string> L = new List<string>(Ar);

¿Cuál sería una forma más limpia?

EDITAR: Las respuestas hasta ahora se refieren a la capacidad, que es algo más que rellenar previamente una lista. Por ejemplo, en una lista recién creada con una capacidad de 10, no se puede hacerL[2]="somevalue"

EDICIÓN 2: La gente se pregunta por qué quiero usar las listas de esta manera, ya que no es la forma en que deben usarse. Puedo ver dos razones:

1. Se podría argumentar de manera bastante convincente que las listas son los arreglos de la "próxima generación", lo que agrega flexibilidad sin casi ninguna penalización. Por lo tanto, uno debería usarlos por defecto. Estoy señalando que es posible que no sean tan fáciles de inicializar.

2. Lo que estoy escribiendo actualmente es una clase base que ofrece una funcionalidad predeterminada como parte de un marco más grande. En la funcionalidad predeterminada que ofrezco, el tamaño de la Lista se conoce de manera avanzada y, por lo tanto, podría haber usado una matriz. Sin embargo, quiero ofrecer a cualquier clase base la posibilidad de ampliarla dinámicamente y, por tanto, opto por una lista.

No puedo decir que necesite esto muy a menudo, ¿podría dar más detalles sobre por qué quiere esto? Probablemente lo pondría como un método estático en una clase auxiliar:

public static class Lists
{
    public static List<T> RepeatedDefault<T>(int count)
    {
        return Repeated(default(T), count);
    }

    public static List<T> Repeated<T>(T value, int count)
    {
        List<T> ret = new List<T>(count);
        ret.AddRange(Enumerable.Repeat(value, count));
        return ret;
    }
}

Usted podría utilizar Enumerable.Repeat(default(T), count).ToList(), pero que podría ser debido ineficaz para amortiguar el cambio de tamaño.

Tenga en cuenta que si Tes un tipo de referencia, almacenará countcopias de la referencia pasada para el valueparámetro, por lo que todas harán referencia al mismo objeto. Eso puede ser o no lo que desea, dependiendo de su caso de uso.

EDITAR: Como se señaló en los comentarios, puede Repeatedusar un bucle para completar la lista si lo desea. Eso también sería un poco más rápido. Personalmente, el código me parece Repeatmás descriptivo y sospecho que en el mundo real la diferencia de rendimiento sería irrelevante, pero su kilometraje puede variar.

List<string> L = new List<string> ( new string[10] );

Utilice el constructor que toma un int ("capacidad") como argumento:

List<string> = new List<string>(10);

EDITAR: Debo agregar que estoy de acuerdo con Frederik. Está usando la Lista de una manera que va en contra de todo el razonamiento detrás de su uso en primer lugar.

EDIT2:

EDITAR 2: Lo que estoy escribiendo actualmente es una clase base que ofrece una funcionalidad predeterminada como parte de un marco más grande. En la funcionalidad predeterminada que ofrezco, el tamaño de la Lista se conoce de manera avanzada y, por lo tanto, podría haber usado una matriz. Sin embargo, quiero ofrecer a cualquier clase base la posibilidad de ampliarla dinámicamente y, por tanto, opto por una lista.

¿Por qué alguien necesitaría saber el tamaño de una lista con todos los valores nulos? Si no hay valores reales en la lista, esperaría que la longitud sea 0. De todos modos, el hecho de que esto sea complicado demuestra que va en contra del uso previsto de la clase.

Cree una matriz con la cantidad de elementos que desee primero y luego convierta la matriz en una Lista.

int[] fakeArray = new int[10];

List<int> list = fakeArray.ToList();

¿Por qué utiliza una lista si desea inicializarla con un valor fijo? Puedo entender que, por el bien del rendimiento, desea darle una capacidad inicial, pero ¿no es una de las ventajas de una lista sobre una matriz regular que puede crecer cuando sea necesario?

Cuando haces esto:

List<int> = new List<int>(100);

Creas una lista cuya capacidad es de 100 enteros. Esto significa que su Lista no necesitará "crecer" hasta que agregue el elemento 101. La matriz subyacente de la lista se inicializará con una longitud de 100.

Inicializar el contenido de una lista como esa no es realmente para lo que sirven las listas. Las listas están diseñadas para contener objetos. Si desea asignar números particulares a objetos particulares, considere usar una estructura de par clave-valor como una tabla hash o un diccionario en lugar de una lista.

Parece estar enfatizando la necesidad de una asociación posicional con sus datos, entonces, ¿no sería más apropiado un arreglo asociativo?

Dictionary<int, string> foo = new Dictionary<int, string>();
foo[2] = "string";

Si desea inicializar la lista con N elementos de algún valor fijo:

public List<T> InitList<T>(int count, T initValue)
{
  return Enumerable.Repeat(initValue, count).ToList();
}

Puede usar Linq para inicializar inteligentemente su lista con un valor predeterminado. (Similar a la respuesta de David B. )

var defaultStrings = (new int[10]).Select(x => "my value").ToList();

Vaya un paso más allá e inicialice cada cadena con valores distintos "cadena 1", "cadena 2", "cadena 3", etc.

int x = 1;
var numberedStrings = (new int[10]).Select(x => "string " + x++).ToList();

string [] temp = new string[] {"1","2","3"};
List<string> temp2 = temp.ToList();

La respuesta aceptada (la que tiene la marca de verificación verde) tiene un problema.

El problema:

var result = Lists.Repeated(new MyType(), sizeOfList);
// each item in the list references the same MyType() object
// if you edit item 1 in the list, you are also editing item 2 in the list

Recomiendo cambiar la línea de arriba para realizar una copia del objeto. Hay muchos artículos diferentes sobre eso:

• El método String.MemberwiseClone () llamado a través de la reflexión no funciona, ¿por qué?
• https://code.msdn.microsoft.com/windowsdesktop/CSDeepCloneObject-8a53311e

Si desea inicializar todos los elementos de su lista con el constructor predeterminado, en lugar de NULL, agregue el siguiente método:

public static List<T> RepeatedDefaultInstance<T>(int count)
    {
        List<T> ret = new List<T>(count);
        for (var i = 0; i < count; i++)
        {
            ret.Add((T)Activator.CreateInstance(typeof(T)));
        }
        return ret;
    }

Un aviso sobre IList: MSDN IList Comentarios : "Las implementaciones de IList se dividen en tres categorías: solo lectura, tamaño fijo y tamaño variable. (...). Para obtener la versión genérica de esta interfaz, consulte System.Collections.Generic.IList<T>."

IList<T>NO hereda de IList(pero List<T>implementa ambos IList<T>y IList), pero siempre es de tamaño variable . Desde .NET 4.5, también tenemos, IReadOnlyList<T>pero AFAIK, no hay una Lista genérica de tamaño fijo que sea lo que está buscando.

Esta es una muestra que utilicé para mi prueba unitaria. Creé una lista de objetos de clase. Luego usé forloop para agregar una cantidad 'X' de objetos que espero del servicio. De esta forma, puede agregar / inicializar una lista para cualquier tamaño dado.

public void TestMethod1()
    {
        var expected = new List<DotaViewer.Interface.DotaHero>();
        for (int i = 0; i < 22; i++)//You add empty initialization here
        {
            var temp = new DotaViewer.Interface.DotaHero();
            expected.Add(temp);
        }
        var nw = new DotaHeroCsvService();
        var items = nw.GetHero();

        CollectionAssert.AreEqual(expected,items);


    }

Espero haber sido de ayuda para ustedes.

Un poco tarde, pero la primera solución que propuso me parece mucho más limpia: no asigna memoria dos veces. Incluso el constrcutor de List necesita recorrer la matriz para copiarla; ni siquiera sabe de antemano que solo hay elementos nulos en su interior.

1. - asignar N - loop N Costo: 1 * asignar (N) + N * loop_iteration

2. - asignar N - asignar N + bucle () Costo: 2 * asignar (N) + N * loop_iteration

Sin embargo, la asignación de bucles de List puede ser más rápida ya que List es una clase incorporada, pero C # está compilado con jit tan ...