Como inicializar uma matriz vazia em c #?

É possível criar uma matriz vazia sem especificar o tamanho?

Por exemplo, eu criei:

String[] a = new String[5];

Podemos criar a matriz de strings acima sem o tamanho?

Se você vai usar uma coleção que você não conhece antecipadamente o tamanho, há opções melhores do que matrizes.

Use um List<string>- em vez disso, você poderá adicionar quantos itens precisar e, se precisar retornar uma matriz, chame ToArray()a variável.

var listOfStrings = new List<string>();

// do stuff...

string[] arrayOfStrings = listOfStrings.ToArray();

Se você deve criar uma matriz vazia, você pode fazer isso:

string[] emptyStringArray = new string[0]; 

Tente o seguinte:

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

No .NET 4.6, a maneira preferida é usar um novo método Array.Empty:

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

A implementação é sucinta, usando como os membros estáticos em classes genéricas se comportam em .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 relacionado ao contrato de código removido para maior clareza)}

Veja também:

• Array.Empty código fonte na fonte de referência
• Introdução a Array.Empty<T>()
• Marc Gravell - Alocação, Alocação, Alocação - meu post favorito em pequenas alocações ocultas.

Você pode inicializá-lo com um tamanho de 0, mas precisará reinicializá-lo quando souber qual é o tamanho, pois não poderá anexá-lo à matriz.

string[] a = new string[0];

Não há muito sentido em declarar uma matriz sem tamanho. Uma matriz é sobre o tamanho . Ao declarar uma matriz de tamanho específico, você especifica o número fixo de slots disponíveis em uma coleção que pode conter itens e, portanto, a memória é alocada. Para adicionar algo a ele, você precisará reinicializar de qualquer maneira a matriz existente (mesmo que você esteja redimensionando a matriz, consulte este tópico ). Um dos raros casos em que você desejaria inicializar uma matriz vazia seria passar a matriz como argumento.

Se você deseja definir uma coleção quando não sabe qual o tamanho possível, a matriz não é sua escolha, mas algo como um List<T>ou semelhante.

Dito isto, a única maneira de declarar uma matriz sem especificar o tamanho é ter uma matriz vazia do tamanho 0 . hemant e Alex Dn fornecem duas maneiras. Outra alternativa mais simples é apenas :

string[] a = { };

[ Os elementos dentro do colchete devem ser implicitamente conversíveis no tipo definido, por exemplo,string[] a = { "a", "b" }; ]

Ou ainda outro:

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

Aqui está uma maneira mais declarativa :

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

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

Agora você pode ligar para:

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

//or

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

Simples e elegante!

string[] array = {}

string[] a = new string[0];

ou notação curta:

string[] a = { };

A maneira preferida agora é:

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

Eu escrevi uma expressão regular curta que você pode usar no Visual Studio se quiser substituir alocações de tamanho zero, por exemplo new string[0]. Use a opção Localizar (pesquisa) no Visual Studio com a Expressão regular ativada:

new[ ][a-zA-Z0-9]+\[0\]

Agora Encontre Tudo ou F3 (Localizar Próximo) e substitua tudo por Array.Empty <…> ()!

Você pode definir o tamanho da matriz em tempo de execução .

Isso permitirá que você faça o que for necessário para calcular dinamicamente o tamanho da matriz. Mas, uma vez definido, o tamanho é imutável.

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

Eu tentei:

string[] sample = new string[0];

Mas eu só consegui inserir uma string e, em seguida, recebi um erro exceptionOutOfBound, então simplesmente coloquei um tamanho para ela, como

string[] sample = new string[100];

Ou de outra maneira que funcione para mim:

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

Atribuindo valor à lista:

sample.Add(your input);

Como eu sei, você não pode fazer array sem tamanho, mas pode usar

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

e depois l.ToArray().

Combinando as sugestões @nawfal e @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];
    }
}

Exemplo de uso:

Array<string>.Empty

ATUALIZAÇÃO 14-05-2019

(créditos para @Jaider ty)

Melhor uso da API .Net:

public static T[] Empty<T> ();

https://docs.microsoft.com/en-us/dotnet/api/system.array.empty?view=netframework-4.8

Aplica-se a:

.NET Core: 3.0 Pré-visualização 5 2.2 2.1 2.0 1.1 1.0

.NET Framework: 4.8 4.7.2 4.7.1 4.7 4.6.2 4.6.1 4.6

.NET Standard: 2.1 Visualização 2.0 1.6 1.5 1.4 1.3

...

HTH

Você pode fazer:

string[] a = { String.Empty };

Nota: OP significava não ter que especificar um tamanho, não tornar uma matriz sem tamanho

Aqui está um exemplo do mundo real. Nesse sentido, é necessário inicializar a matriz foundFilesprimeiro com comprimento zero.

(Como enfatizado em outras respostas: Isso inicializa não um elemento e, especialmente, um elemento com índice zero, porque isso significaria que a matriz tinha comprimento 1. A matriz tem comprimento zero após esta linha!).

Se a peça = string[0]for omitida, há um erro do compilador!

Isso ocorre por causa do bloco de captura sem religação. O compilador C # reconhece o caminho do código, que a função Directory.GetFiles()pode lançar uma exceção, para que a matriz possa ser não inicializada.

Antes que alguém diga, não reler a exceção seria um tratamento incorreto de erros: isso não é verdade. O tratamento de erros deve atender aos requisitos.

Nesse caso, supõe-se que o programa continue no caso de um diretório que não possa ser lido e não quebre - o melhor exemplo é uma função que atravessa uma estrutura de diretórios. Aqui, a manipulação de erros está apenas registrando-a. É claro que isso poderia ser feito melhor, por exemplo, coletando todos os diretórios com GetFiles(Dir)chamadas com falha em uma lista, mas isso levará muito longe aqui.

É suficiente afirmar que evitar throwé um cenário válido e, portanto, a matriz deve ser inicializada com o comprimento zero. Seria o suficiente para fazer isso no bloco catch, mas seria um estilo ruim.

A chamada para GetFiles(Dir)redimensionar a matriz.

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);