Wszystkie możliwe składnie inicjalizacji tablicy


Odpowiedzi:


777

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 

1
Z ciekawości ktoś mógłby wyjaśnić, dlaczego wyrażenie inicjujące w 3. linii nie może być użyte samo (np. Przekazane do metody) lub przypisane do varzmiennej?
Ruben9922,

1
@ Ruben9922: Interesujące pytanie. Byłoby sensowne, że var x = {}to nie działa, jeśli inicjator tablic mógłby dać cokolwiek innego niż tablice, ale nie wiedziałbym, co to jest. Sądzę więc, że inicjalizator tablicy jest funkcją języka. Jeśli użyjesz go razem z new List<string> {"A", "B"}nim, otrzymasz również coś innego.
TvdH,

441

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”.


8
@BoltClock: Pierwsza wspomniana składnia to „niejawnie wpisane wyrażenie tworzenia tablicy”. Drugi to „anonimowe wyrażenie tworzenia obiektu”. Nie wymieniasz dwóch pozostałych podobnych składni; są to „inicjalizator obiektów” i „inicjator kolekcji”.
Eric Lippert,

11
Nie do końca „składnia” C #, ale nie zapominajmy (mój ulubiony) Array.CreateInstance(typeof(int), 3)!
Jeffrey L. Whitledge

17
@Jeffrey: Jeśli idziemy tą drogą, zaczyna się robić głupio. Np "1,2,3,4".split(',').
Brian

11
Następnie dla tablic wielowymiarowych, istnieją „zagnieżdżone” notacje podoba new int[,] { { 3, 7 }, { 103, 107 }, { 10003, 10007 }, };, i tak dalej int[,,], int[,,,]...
Jeppe Stig Nielsen

6
@ Learning-Overthinker-Confused: Masz dwa konie. Chcesz wiedzieć, który jest szybszy. Czy (1) ścigasz się z końmi, czy (2) pytasz nieznajomego w Internecie, który nigdy nie widział koni, który według niego jest szybszy? Ścigaj się z końmi . Chcesz wiedzieć, który jest bardziej „wydajny”? Najpierw stwórz wymierny standard wydajności; pamiętaj, że wydajność to wytwarzana wartość na koszt jednostkowy , więc dokładnie określ swoją wartość i koszt. Następnie napisz kod w obie strony i zmierz jego wydajność. Użyj nauki, aby odpowiedzieć na pytania naukowe, nie pytając przypadkowych nieznajomych o domysły.
Eric Lippert,

111

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

14
Dobrze byłoby wyraźniej oddzielić nieprawidłowe składnie od poprawnych.
jpmc26,

Czy podane przykłady są kompletne? Czy jest jakiś inny przypadek?
Programista zorientowany na pieniądze

49
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.


5
Tak, var arr1 = Enumerable.Repeat(new object(), 10).ToArray();otrzymasz 10 referencji do tego samego obiektu. Aby utworzyć 10 różnych obiektów, możesz użyć var arr2 = Enumerable.Repeat(/* dummy: */ false, 10).Select(x => new object()).ToArray();lub podobnego.
Jeppe Stig Nielsen

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

Jak powinieneś używać tej struktury? Czy to jest jak słownik?
R. Navega,

1
@ R.Navega to zwykła tablica :)
grooveplex

17

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.


13

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 = "abc.xyz@email.com",
       language = "English"
    },
    new DummyUser{
       email = "def@email.com",
       language = "Spanish"
    }
};


6
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)"

5
Cześć, ostatnim blokiem przykładów wydaje się być Visual Basic, pytanie dotyczy przykładów c #.
Alex KeySmith,

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

2

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("abc@cde.edu", "Gibberish"),
    new SmartyUser("pga@lna.it", "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;
}

1

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.


0

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

0

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

0

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"
};
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.