Alle möglichen Syntaxen für die Array-Initialisierung

Welche Syntaxen für die Array-Initialisierung sind mit C # möglich?

Dies sind die aktuellen Deklarations- und Initialisierungsmethoden für ein einfaches Array.

string[] array = new string[2]; // creates array of length 2, default values
string[] array = new string[] { "A", "B" }; // creates populated array of length 2
string[] array = { "A" , "B" }; // creates populated array of length 2
string[] array = new[] { "A", "B" }; // created populated array of length 2

Beachten Sie, dass andere Techniken zum Abrufen von Arrays vorhanden sind, z. B. die Linq- ToArray()Erweiterungen für IEnumerable<T>.

Beachten Sie auch, dass in den obigen Erklärungen die ersten beiden string[]die links durch var(C # 3+) ersetzen könnten , da die Informationen auf der rechten Seite ausreichen, um auf den richtigen Typ zu schließen. Die dritte Zeile muss wie angezeigt geschrieben werden, da die Syntax der Array-Initialisierung allein nicht ausreicht, um die Anforderungen des Compilers zu erfüllen. Der vierte könnte auch Inferenz verwenden. Wenn Sie sich also für die ganze Kürze interessieren, könnte das Obige wie folgt geschrieben werden

var array = new string[2]; // creates array of length 2, default values
var array = new string[] { "A", "B" }; // creates populated array of length 2
string[] array = { "A" , "B" }; // creates populated array of length 2
var array = new[] { "A", "B" }; // created populated array of length 2 

Die Syntaxen zur Array-Erstellung in C #, die Ausdrücke sind, sind:

new int[3]
new int[3] { 10, 20, 30 }
new int[] { 10, 20, 30 }
new[] { 10, 20, 30 }

Im ersten Fall kann die Größe ein beliebiger nicht negativer Integralwert sein, und die Array-Elemente werden auf die Standardwerte initialisiert.

Im zweiten Fall muss die Größe konstant sein und die Anzahl der angegebenen Elemente muss übereinstimmen. Es muss eine implizite Konvertierung von den angegebenen Elementen in den angegebenen Array-Elementtyp erfolgen.

Im dritten Fall müssen die Elemente implizit in den Elementtyp konvertierbar sein, und die Größe wird aus der Anzahl der angegebenen Elemente bestimmt.

Im vierten wird der Typ des Array-Elements abgeleitet, indem der beste Typ aller gegebenen Elemente mit Typen berechnet wird, falls es einen gibt. Alle Elemente müssen implizit in diesen Typ konvertierbar sein. Die Größe wird aus der Anzahl der angegebenen Elemente bestimmt. Diese Syntax wurde in C # 3.0 eingeführt.

Es gibt auch eine Syntax, die nur in einer Deklaration verwendet werden darf:

int[] x = { 10, 20, 30 };

Die Elemente müssen implizit in den Elementtyp konvertierbar sein. Die Größe wird aus der Anzahl der angegebenen Elemente bestimmt.

Es gibt keinen All-in-One-Leitfaden

Ich verweise Sie auf die C # 4.0-Spezifikation, Abschnitt 7.6.10.4 "Ausdrücke zur Array-Erstellung".

Nicht leere Arrays

• var data0 = new int[3]

• var data1 = new int[3] { 1, 2, 3 }

• var data2 = new int[] { 1, 2, 3 }

• var data3 = new[] { 1, 2, 3 }

• var data4 = { 1, 2, 3 }ist nicht kompilierbar. Verwenden Sie int[] data5 = { 1, 2, 3 }stattdessen.

Leere Arrays

• var data6 = new int[0]
• var data7 = new int[] { }

• var data8 = new [] { } und int[] data9 = new [] { }sind nicht kompilierbar.

• var data10 = { }ist nicht kompilierbar. Verwenden Sie int[] data11 = { } stattdessen.

Als Argument einer Methode

Nur Ausdrücke, die mit dem varSchlüsselwort zugewiesen werden können, können als Argumente übergeben werden.

• Foo(new int[2])
• Foo(new int[2] { 1, 2 })
• Foo(new int[] { 1, 2 })
• Foo(new[] { 1, 2 })
• Foo({ 1, 2 }) ist nicht kompilierbar
• Foo(new int[0])
• Foo(new int[] { })
• Foo({}) ist nicht kompilierbar

Enumerable.Repeat(String.Empty, count).ToArray()

Erstellt ein Array von leeren Zeichenfolgen, die wiederholt gezählt werden. Für den Fall, dass Sie ein Array mit demselben, jedoch speziellen Standardelementwert initialisieren möchten. Vorsichtig mit Referenztypen verweisen alle Elemente auf dasselbe Objekt.

var contacts = new[]
{
    new 
    {
        Name = " Eugene Zabokritski",
        PhoneNumbers = new[] { "206-555-0108", "425-555-0001" }
    },
    new 
    {
        Name = " Hanying Feng",
        PhoneNumbers = new[] { "650-555-0199" }
    }
};

Wenn Sie ein festes Array von vorinitialisierten gleichen (nicht nulloder nicht als default) Elementen initialisieren möchten, verwenden Sie Folgendes :

var array = Enumerable.Repeat(string.Empty, 37).ToArray();

Bitte nehmen Sie auch an dieser Diskussion teil.

Beispiel zum Erstellen eines Arrays einer benutzerdefinierten Klasse

Unten ist die Klassendefinition.

public class DummyUser
{
    public string email { get; set; }
    public string language { get; set; }
}

So können Sie das Array initialisieren:

private DummyUser[] arrDummyUser = new DummyUser[]
{
    new DummyUser{
       email = "[email protected]",
       language = "English"
    },
    new DummyUser{
       email = "[email protected]",
       language = "Spanish"
    }
};

Wiederholen Sie ohne LINQ :

float[] floats = System.Array.ConvertAll(new float[16], v => 1.0f);

int[] array = new int[4]; 
array[0] = 10;
array[1] = 20;
array[2] = 30;

oder

string[] week = new string[] {"Sunday","Monday","Tuesday"};

oder

string[] array = { "Sunday" , "Monday" };

und in mehrdimensionaler Anordnung

    Dim i, j As Integer
    Dim strArr(1, 2) As String

    strArr(0, 0) = "First (0,0)"
    strArr(0, 1) = "Second (0,1)"

    strArr(1, 0) = "Third (1,0)"
    strArr(1, 1) = "Fourth (1,1)"

For Class initialization:
var page1 = new Class1();
var page2 = new Class2();
var pages = new UIViewController[] { page1, page2 };

Eine andere Möglichkeit, ein Array von Objekten zu erstellen und zu initialisieren. Dies ähnelt dem Beispiel, das @Amol oben veröffentlicht hat , außer dass dieses Konstruktoren verwendet. Ein Schuss Polymorphismus breitete sich aus, ich konnte nicht widerstehen.

IUser[] userArray = new IUser[]
{
    new DummyUser("[email protected]", "Gibberish"),
    new SmartyUser("[email protected]", "Italian", "Engineer")
};

Klassen für den Kontext:

interface IUser
{
    string EMail { get; }       // immutable, so get only an no set
    string Language { get; }
}

public class DummyUser : IUser
{
    public DummyUser(string email, string language)
    {
        m_email = email;
        m_language = language;
    }

    private string m_email;
    public string EMail
    {
        get { return m_email; }
    }

    private string m_language;
    public string Language
    {
        get { return m_language; }
    }
}

public class SmartyUser : IUser
{
    public SmartyUser(string email, string language, string occupation)
    {
        m_email = email;
        m_language = language;
        m_occupation = occupation;
    }

    private string m_email;
    public string EMail
    {
        get { return m_email; }
    }

    private string m_language;
    public string Language
    {
        get { return m_language; }
    }

    private string m_occupation;
}

Für die folgende Klasse:

public class Page
{

    private string data;

    public Page()
    {
    }

    public Page(string data)
    {
        this.Data = data;
    }

    public string Data
    {
        get
        {
            return this.data;
        }
        set
        {
            this.data = value;
        }
    }
}

Sie können das Array des obigen Objekts wie folgt initialisieren.

Pages = new Page[] { new Page("a string") };

Hoffe das hilft.

Sie können auch dynamische Arrays erstellen, dh Sie können zuerst die Größe des Arrays vom Benutzer erfragen, bevor Sie es erstellen.

Console.Write("Enter size of array");
int n = Convert.ToInt16(Console.ReadLine());

int[] dynamicSizedArray= new int[n]; // Here we have created an array of size n
Console.WriteLine("Input Elements");
for(int i=0;i<n;i++)
{
     dynamicSizedArray[i] = Convert.ToInt32(Console.ReadLine());
}

Console.WriteLine("Elements of array are :");
foreach (int i in dynamicSizedArray)
{
    Console.WriteLine(i);
}
Console.ReadKey();

Triviale Lösung mit Ausdrücken. Beachten Sie, dass Sie mit NewArrayInit nur ein eindimensionales Array erstellen können.

NewArrayExpression expr = Expression.NewArrayInit(typeof(int), new[] { Expression.Constant(2), Expression.Constant(3) });
int[] array = Expression.Lambda<Func<int[]>>(expr).Compile()(); // compile and call callback

Nur eine Notiz

Die folgenden Arrays:

string[] array = new string[2];
string[] array2 = new string[] { "A", "B" };
string[] array3 = { "A" , "B" };
string[] array4 = new[] { "A", "B" };

Wird zusammengestellt zu:

string[] array = new string[2];
string[] array2 = new string[]
{
   "A",
   "B"
};
string[] array3 = new string[]
{
   "A",
   "B"
};
string[] array4 = new string[]
{
   "A",
   "B"
};