¿Cómo inicializo un array vacío en C#?

Prueba esto:

string[] a= new string[] { };

En. Net 4.6 la forma preferida es usar un nuevo método, Array.Empty:

String[] a = Array.Empty<string>();

La implementación es sucinta, usando cómo se comportan los miembros estáticos en las clases genéricas en. Net :

public static T[] Empty<T>()
{
    return EmptyArray<T>.Value;
}

// Useful in number of places that return an empty byte array to avoid
// unnecessary memory allocation.
internal static class EmptyArray<T>
{
    public static readonly T[] Value = new T[0];
}

^{(código código relacionado con el contrato eliminado para mayor claridad)}

Véase también:

• Array.Empty código fuente en la Fuente de referencia
• Introducción a Array.Empty<T>()
• Marc Gravell-Allocaction, Allocation, Allocation - mi post favorito sobre pequeñas asignaciones ocultas.

Podría inicializarlo con un tamaño de 0, pero tendrá que reiniciarlo, cuando sepa cuál es el tamaño, ya que no puede anexar al array.

string[] a = new string[0];

No tiene mucho sentido declarar un array sin tamaño. Un array tiene aproximadamente el tamaño. Cuando se declara una matriz de tamaño específico, se especifica el número fijo de ranuras disponibles en una colección que puede contener cosas y, en consecuencia, se asigna memoria. Para agregarle algo, necesitará reiniciar el array existente (incluso si está redimensionando el array, vea este hilo). Uno de los raros casos en los que querría inicializar una matriz vacía sería: pase array como argumento.

Si desea definir una colección cuando no sabe de qué tamaño podría ser posiblemente, array no es su elección, sino algo como un List<T> o similar.

Dicho esto, la única manera de declarar un array sin especificar tamaño es tener un array vacío de tamaño 0. hemant y Alex Dn proporciona dos maneras. Otra alternativa más simple es simplemente :

string[] a = { };

[Los elementos dentro del soporte debe ser implícitamente convertible a tipo definido, por ejemplo, string[] a = { "a", "b" };]

O aún otro:

var a = Enumerable.Empty<string>().ToArray();

Aquí hay una forma más declarativa :

public static class Array<T>
{
    public static T[] Empty()
    {
        return Empty(0);
    }

    public static T[] Empty(int size)
    {
        return new T[size];
    }
}

Ahora puedes llamar:

var a = Array<string>.Empty();

//or

var a = Array<string>.Empty(5);

Puedes hacer:

string[] a = { String.Empty };

Nota: OP significaba no tener que especificar un tamaño, no hacer un array sizeless

Puede definir el tamaño del array en tiempo de ejecución .

Esto le permitirá hacer lo que sea para calcular dinámicamente el tamaño de la matriz. Pero, una vez definido el tamaño es inmutable.

Array a = Array.CreateInstance(typeof(string), 5);

Lo había intentado:

string[] sample = new string[0];

Pero solo pude insertar una cadena en ella, y luego obtuve un error exceptionOutOfBound, así que simplemente puse un tamaño para ella, como

string[] sample = new string[100];

U otra forma que funcione para mí:

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

Asignando valor para la lista:

sample.Add(your input);

Como sé que no se puede hacer matriz sin tamaño, pero se puede utilizar

List<string> l = new List<string>() 

Y luego l.ToArray().

Simple y elegante!

string[] array = {}

Combinando las sugerencias de @nawfal y @Kobi:

namespace Extensions
{
    /// <summary> Useful in number of places that return an empty byte array to avoid unnecessary memory allocation. </summary>
    public static class Array<T>
    {
        public static readonly T[] Empty = new T[0];
    }
}

Ejemplo de uso:

Array<string>.Empty

HTH

Aquí hay un ejemplo del mundo real. En esto es necesario inicializar el array foundFiles primero a longitud cero.

(Como se enfatiza en otras respuestas: Esto no inicializa un elemento y especialmente no un elemento con índice cero porque eso significaría que la matriz tiene una longitud 1. La matriz tiene longitud cero después de esta línea!).

Si la parte = string[0] se omite, hay un error de compilador!

Esto se debe al bloque catch sin rethrow. El compilador de C# reconoce el código path, que la función Directory.GetFiles() puede lanzar una excepción, por lo que la matriz podría no inicializarse.

Antes de que alguien diga, no repensar la excepción sería un mal manejo de errores: Esto no es cierto. El manejo de errores tiene que ajustarse a los requisitos.

En este caso se asume que el programa debe continuar en caso de un directorio que no se puede leer, y no romper - el mejor ejemplo es una función que atraviesa una estructura de directorios. Aquí el manejo de errores es solo registrarlo. De por supuesto, esto podría hacerse mejor, por ejemplo, recopilando todos los directorios con llamadas fallidas GetFiles(Dir) en una lista, pero esto conducirá demasiado lejos aquí.

Es suficiente indicar que evitar throw es un escenario válido, por lo que la matriz debe inicializarse a una longitud cero. Sería suficiente hacer esto en el bloque catch, pero esto sería un mal estilo.

La llamada a GetFiles(Dir) redimensiona el array.

string[] foundFiles= new string[0];
string dir = @"c:\";
try
{
    foundFiles = Directory.GetFiles(dir);  // Remark; Array is resized from length zero
}
// Please add appropriate Exception handling yourself
catch (IOException)
{
  Console.WriteLine("Log: Warning! IOException while reading directory: " + dir);
  // throw; // This would throw Exception to caller and avoid compiler error
}

foreach (string filename in foundFiles)
    Console.WriteLine("Filename: " + filename);