Wie initialisiere ich ein leeres Array in C #?

Ist es möglich, ein leeres Array ohne Angabe der Größe zu erstellen?

Zum Beispiel habe ich erstellt:

String[] a = new String[5];

Können wir das obige String-Array ohne die Größe erstellen?

Wenn Sie eine Sammlung verwenden, deren Größe Sie nicht im Voraus kennen, gibt es bessere Optionen als Arrays.

Verwenden Sie List<string>stattdessen ein - Sie können so viele Elemente hinzufügen, wie Sie benötigen. Wenn Sie ein Array zurückgeben müssen, rufen Sie ToArray()die Variable auf.

var listOfStrings = new List<string>();

// do stuff...

string[] arrayOfStrings = listOfStrings.ToArray();

Wenn Sie ein leeres Array erstellen müssen , können Sie dies tun:

string[] emptyStringArray = new string[0]; 

Versuche dies:

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

In .NET 4.6 wird bevorzugt eine neue Methode verwendet Array.Empty:

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

Die Implementierung ist prägnant und verwendet das Verhalten statischer Elemente in generischen Klassen 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];
}

^{(Code vertragsbezogener Code aus Gründen der Übersichtlichkeit entfernt)}

Siehe auch:

• Array.Empty Quellcode auf Referenzquelle
• Einführung zu Array.Empty<T>()
• Marc Gravell - Allokation, Allokation, Allokation - mein Lieblingsbeitrag zu winzigen versteckten Allokationen.

Sie können es mit einer Größe von 0 initialisieren, müssen es jedoch neu initialisieren, wenn Sie die Größe kennen, da Sie es nicht an das Array anhängen können.

string[] a = new string[0];

Es macht nicht viel Sinn, ein Array ohne Größe zu deklarieren. Ein Array hat ungefähr die Größe . Wenn Sie ein Array mit einer bestimmten Größe deklarieren, geben Sie die feste Anzahl von Slots an, die in einer Sammlung verfügbar sind, die Dinge aufnehmen können, und dementsprechend wird Speicher zugewiesen. Um etwas hinzuzufügen, müssen Sie das vorhandene Array trotzdem neu initialisieren (auch wenn Sie die Größe des Arrays ändern, siehe diesen Thread ). Einer der seltenen Fälle, in denen Sie ein leeres Array initialisieren möchten, besteht darin, das Array als Argument zu übergeben.

Wenn Sie eine Sammlung definieren möchten, wenn Sie nicht wissen, welche Größe sie möglicherweise haben könnte, ist das Array nicht Ihre Wahl, sondern so etwas wie ein List<T>oder ähnliches.

Die einzige Möglichkeit, ein Array ohne Angabe der Größe zu deklarieren, besteht darin, ein leeres Array der Größe 0 zu haben . Hemant und Alex Dn bieten zwei Möglichkeiten. Eine andere einfachere Alternative ist einfach :

string[] a = { };

[ Die Elemente in der Klammer sollten implizit in den definierten Typ konvertierbar sein, z. B.string[] a = { "a", "b" }; ]

Oder noch eine andere:

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

Hier ist ein deklarativerer Weg :

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

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

Jetzt können Sie anrufen:

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

//or

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

Einfach und elegant!

string[] array = {}

string[] a = new string[0];

oder kurze Notation:

string[] a = { };

Der bevorzugte Weg ist jetzt:

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

Ich habe einen kurzen regulären Ausdruck geschrieben, den Sie in Visual Studio verwenden können, wenn Sie Zuordnungen mit der Länge Null ersetzen möchten, z new string[0]. Verwenden Sie Suchen (Suchen) in Visual Studio mit aktivierter Option für reguläre Ausdrücke:

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

Jetzt Find All oder F3 (Find Next) und ersetze alle durch Array.Empty <…> ()!

Sie können die Arraygröße zur Laufzeit definieren .

Auf diese Weise können Sie alles tun, um die Größe des Arrays dynamisch zu berechnen. Einmal definiert, ist die Größe jedoch unveränderlich.

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

Ich hatte versucht:

string[] sample = new string[0];

Aber ich konnte nur eine Zeichenfolge einfügen, und dann bekam ich einen exceptionOutOfBound-Fehler, also habe ich einfach eine Größe dafür eingefügt, wie z

string[] sample = new string[100];

Oder eine andere Art und Weise, die für mich funktioniert:

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

Wert für Liste zuweisen:

sample.Add(your input);

Wie ich weiß, können Sie kein Array ohne Größe erstellen, aber Sie können es verwenden

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

und dann l.ToArray().

Kombinieren von @ nawfal & @ Kobi-Vorschlägen:

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];
    }
}

Anwendungsbeispiel:

Array<string>.Empty

UPDATE 2019-05-14

(Dank an @Jaider ty)

Bessere Verwendung der .Net-API:

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

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

Gilt für:

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

...

HTH

Du kannst tun:

string[] a = { String.Empty };

Hinweis: OP bedeutete, keine Größe angeben zu müssen und ein Array nicht größenlos zu machen

Hier ist ein Beispiel aus der Praxis. In diesem Fall muss das Array foundFileszuerst auf die Länge Null initialisiert werden .

(Wie in anderen Antworten hervorgehoben: Dies initialisiert kein Element und insbesondere kein Element mit dem Index Null, da dies bedeuten würde, dass das Array die Länge 1 hat. Das Array hat nach dieser Zeile die Länge Null!).

Wenn das Teil = string[0]weggelassen wird, liegt ein Compilerfehler vor!

Dies liegt am Fangblock ohne erneutes Werfen. Der C # -Compiler erkennt den Codepfad, dass die Funktion Directory.GetFiles()eine Ausnahme auslösen kann, sodass das Array nicht initialisiert werden kann.

Bevor jemand sagt, die Ausnahme nicht erneut auszulösen, wäre eine schlechte Fehlerbehandlung: Dies ist nicht wahr. Die Fehlerbehandlung muss den Anforderungen entsprechen.

In diesem Fall wird davon ausgegangen, dass das Programm im Falle eines nicht lesbaren Verzeichnisses fortgesetzt und nicht unterbrochen werden soll. Das beste Beispiel ist eine Funktion, die eine Verzeichnisstruktur durchläuft. Hier protokolliert die Fehlerbehandlung sie nur. Dies könnte natürlich besser gemacht werden, z. B. das Sammeln aller Verzeichnisse mit fehlgeschlagenen GetFiles(Dir)Aufrufen in einer Liste, aber dies wird hier zu weit führen.

Es genügt zu sagen, dass das Vermeiden throwein gültiges Szenario ist, und daher muss das Array auf die Länge Null initialisiert werden. Es würde ausreichen, dies im Catch-Block zu tun, aber das wäre ein schlechter Stil.

Der Aufruf zum GetFiles(Dir)Ändern der Größe des Arrays.

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