Wszystkie możliwe składnie inicjalizacji tablicy

Jakie są wszystkie składnie inicjalizacji tablicy, które są możliwe w języku C #?

Są to bieżące metody deklaracji i inicjalizacji prostej tablicy.

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

Zauważ, że istnieją inne techniki uzyskiwania tablic, takie jak ToArray()rozszerzenia Linq na IEnumerable<T>.

Zauważ również, że w powyższych deklaracjach pierwsze dwa mogą zastąpić string[]lewe z var(C # 3+), ponieważ informacje z prawej strony są wystarczające, aby wywnioskować właściwy typ. Trzeci wiersz musi być zapisany jako wyświetlony, ponieważ sama składnia inicjalizacji tablicy nie wystarcza, aby spełnić wymagania kompilatora. Czwarty mógłby również użyć wnioskowania. Więc jeśli interesuje Cię cała zwięzłość, powyższe można zapisać jako

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 

Składnie tworzenia tablic w języku C #, które są wyrażeniami, to:

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

W pierwszym przypadku rozmiar może być dowolną nieujemną wartością całkowitą, a elementy tablicy są inicjowane do wartości domyślnych.

W drugim rozmiar musi być stały, a liczba podanych elementów musi być zgodna. Musi nastąpić niejawna konwersja z podanych elementów na podany typ elementu tablicy.

W trzecim z nich elementy muszą być domyślnie konwertowane na typ elementu, a rozmiar określa się na podstawie podanej liczby elementów.

W czwartym typ elementu tablicy jest wyprowadzany na podstawie obliczenia najlepszego typu, jeśli taki istnieje, ze wszystkich podanych elementów, które mają typy. Wszystkie elementy muszą być domyślnie konwertowalne na ten typ. Rozmiar określa się na podstawie liczby podanych elementów. Ta składnia została wprowadzona w C # 3.0.

Istnieje również składnia, której można używać tylko w deklaracji:

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

Elementy muszą być domyślnie konwertowane na typ elementu. Rozmiar określa się na podstawie liczby podanych elementów.

nie ma przewodnika „wszystko w jednym”

Odsyłam do specyfikacji C # 4.0, sekcja 7.6.10.4 „Wyrażenia tworzenia macierzy”.

Niepuste tablice

• 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 }nie jest kompatybilny. Użyj int[] data5 = { 1, 2, 3 }zamiast tego.

Puste tablice

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

• var data8 = new [] { } i int[] data9 = new [] { }nie są kompatybilne.

• var data10 = { }nie jest kompatybilny. Użyj int[] data11 = { } zamiast tego.

Jako argument metody

Tylko wyrażenia, które można przypisać za pomocą varsłowa kluczowego, można przekazywać jako argumenty.

• Foo(new int[2])
• Foo(new int[2] { 1, 2 })
• Foo(new int[] { 1, 2 })
• Foo(new[] { 1, 2 })
• Foo({ 1, 2 }) nie jest kompatybilny
• Foo(new int[0])
• Foo(new int[] { })
• Foo({}) nie jest kompatybilny

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

Utworzy tablicę pustych ciągów powtórzonych „zliczeń” razy. W przypadku, gdy chcesz zainicjować tablicę z tą samą, ale specjalną wartością domyślną elementu. Ostrożnie z typami referencji, wszystkie elementy będą odnosić się do tego samego obiektu.

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

Jeśli chcesz zainicjować stałą tablicę wstępnie zainicjalizowanych równych ( nullinnych niż default) elementów, użyj tego:

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

Proszę również wziąć udział w tej dyskusji.

Przykład tworzenia tablicy niestandardowej klasy

Poniżej znajduje się definicja klasy.

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

Oto jak zainicjować tablicę:

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

Powtórz bez 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;

lub

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

lub

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

oraz w układzie wielowymiarowym

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

Kolejny sposób tworzenia i inicjowania tablicy obiektów. Jest to podobne do przykładu opublikowanego powyżej przez @Amol , z tym wyjątkiem, że ten używa konstruktorów. Zaskoczyła go odrobina polimorfizmu, nie mogłem się oprzeć.

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

Klasy kontekstu:

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

Dla klasy poniżej:

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

możesz zainicjalizować tablicę powyższego obiektu jak poniżej.

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

Mam nadzieję że to pomoże.

Możesz także tworzyć tablice dynamiczne, tzn. Możesz najpierw zapytać użytkownika o rozmiar tablicy przed jej utworzeniem.

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

Trywialne rozwiązanie z wyrażeniami. Zauważ, że dzięki NewArrayInit możesz stworzyć tylko jednowymiarową tablicę.

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

Tylko uwaga

Następujące tablice:

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

Zostanie skompilowany do:

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