Come posso inizializzare un array vuoto in C #?

È possibile creare un array vuoto senza specificare la dimensione?

Ad esempio, ho creato:

String[] a = new String[5];

Possiamo creare l'array di stringhe sopra senza le dimensioni?

Se si intende utilizzare una raccolta di cui non si conosce in anticipo la dimensione, esistono opzioni migliori rispetto alle matrici.

Usa List<string>invece un - ti permetterà di aggiungere tutti gli elementi di cui hai bisogno e se devi restituire un array, chiama ToArray()la variabile.

var listOfStrings = new List<string>();

// do stuff...

string[] arrayOfStrings = listOfStrings.ToArray();

Se è necessario creare un array vuoto, è possibile farlo:

string[] emptyStringArray = new string[0]; 

Prova questo:

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

In .NET 4.6 il modo preferito è utilizzare un nuovo metodo Array.Empty:

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

L' implementazione è sintetica, usando come si comportano i membri statici nelle classi generiche in .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];
}

^{(codice relativo al contratto di codice rimosso per chiarezza)}

Guarda anche:

• Array.Empty codice sorgente su Fonte di riferimento
• Introduzione a Array.Empty<T>()
• Marc Gravell - Allocazione, Allocazione, Allocazione - il mio post preferito su piccole allocazioni nascoste.

È possibile inizializzarlo con una dimensione pari a 0, ma sarà necessario inizializzarlo nuovamente quando si conosce la dimensione, poiché non è possibile accodarla all'array.

string[] a = new string[0];

Non ha molto senso dichiarare un array senza dimensioni. Un array ha dimensioni . Quando si dichiara un array di dimensioni specifiche, si specifica il numero fisso di slot disponibili in una raccolta che può contenere oggetti e di conseguenza viene allocata la memoria. Per aggiungere qualcosa ad esso, dovrai comunque reinizializzare l'array esistente (anche se stai ridimensionando l'array, vedi questo thread ). Uno dei rari casi in cui si desidera inizializzare un array vuoto sarebbe passare l'array come argomento.

Se vuoi definire una raccolta quando non sai di quale dimensione potrebbe essere, l'array non è la tua scelta, ma qualcosa di simile List<T>o simile.

Detto questo, l'unico modo per dichiarare un array senza specificare la dimensione è avere un array vuoto di dimensione 0 . Hemant e Alex Dn offrono due modi. Un'altra alternativa più semplice è semplicemente :

string[] a = { };

[ Gli elementi all'interno della parentesi devono essere implicitamente convertibili in un tipo definito, ad esempio,string[] a = { "a", "b" }; ]

O ancora un altro:

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

Ecco un modo più dichiarativo :

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

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

Ora puoi chiamare:

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

//or

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

Semplice ed elegante!

string[] array = {}

string[] a = new string[0];

o notazione breve:

string[] a = { };

Il modo preferito ora è:

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

Ho scritto una breve espressione regolare che puoi usare in Visual Studio se vuoi sostituire allocazioni di lunghezza zero, ad es new string[0]. Utilizzare l'opzione Trova (ricerca) in Visual Studio con l'opzione Espressione regolare attivata:

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

Ora Trova tutto o F3 (Trova successivo) e sostituisci tutto con Array.Empty <…> ()!

È possibile definire le dimensioni dell'array in fase di esecuzione .

Ciò ti consentirà di fare qualsiasi cosa per calcolare dinamicamente le dimensioni dell'array. Ma, una volta definita, la dimensione è immutabile.

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

Avevo provato:

string[] sample = new string[0];

Ma ho potuto inserire solo una stringa in esso, e quindi ho ricevuto un errore exceptionOutOfBound, quindi ho semplicemente messo una dimensione per esso, come

string[] sample = new string[100];

O un altro modo che funziona per me:

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

Assegnazione valore per elenco:

sample.Add(your input);

Come so non è possibile creare array senza dimensioni, ma è possibile utilizzare

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

e poi l.ToArray().

Combinazione dei suggerimenti di @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];
    }
}

Esempio di utilizzo:

Array<string>.Empty

AGGIORNAMENTO 2019-05-14

(crediti a @Jaider ty)

Migliore utilizzo dell'API .Net:

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

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

Si applica a:

.NET Core: 3.0 Preview 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 Preview 2.0 1.6 1.5 1.4 1.3

...

HTH

Tu puoi fare:

string[] a = { String.Empty };

Nota: OP significava non dover specificare una dimensione, non rendere un array privo di dimensioni

Ecco un esempio del mondo reale. In questo è necessario inizializzare l'array foundFilesprima a zero lunghezza.

(Come sottolineato in altre risposte: questo inizializza non un elemento e soprattutto non un elemento con indice zero perché ciò significherebbe che l'array aveva lunghezza 1. L'array ha lunghezza zero dopo questa linea!).

Se la parte = string[0]viene omessa, si verifica un errore del compilatore!

Ciò è dovuto al blocco di cattura senza riprogrammazione. Il compilatore C # riconosce il percorso del codice, che la funzione Directory.GetFiles()può generare un'eccezione, in modo che l'array possa essere non inizializzato.

Prima che qualcuno dica, non riproporre l'eccezione sarebbe una cattiva gestione degli errori: questo non è vero. La gestione degli errori deve soddisfare i requisiti.

In questo caso, si presume che il programma debba continuare nel caso di una directory che non può essere letta e non interrotta: l'esempio migliore è una funzione che attraversa una struttura di directory. Qui la gestione degli errori lo sta semplicemente registrando. Naturalmente questo potrebbe essere fatto meglio, ad esempio raccogliendo tutte le directory con GetFiles(Dir)chiamate fallite in un elenco, ma questo porterà troppo lontano qui.

È sufficiente affermare che evitare throwè uno scenario valido e quindi l'array deve essere inizializzato su lunghezza zero. Basterebbe farlo nel blocco catch, ma questo sarebbe uno stile cattivo.

La chiamata per GetFiles(Dir)ridimensionare l'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);