Inicjowanie listę z tablicami

Question

Chcę zapełnić listę tablic ciągów w czasie kompilacji

coś takiego:

 List<string[]> synonyms = new List<string[]> 
     { 
      { "enabled", "enable", "enabling" }, 
      { "disabled", "disable", "disabling" }, 
      { "s0", "s0 state" }, 
      { "s5", "s5 state" } 
     }; 

ale pojawia się błąd kompilacji: No overloaded method 'Add' takes 2 arguments

dlaczego to? To działa, jeśli nie były one tablice ciąg z List<string>

Answer 1

Powodem, że kod ma nie praca jest opisana w How to: Initialize a Dictionary with a Collection Initializer (C# Programming Guide):

A Dictionary contains a collection of key/value pairs. Its Add method takes two parameters, one for the key and one for the value. To initialize a Dictionary, or any collection whose Add method takes multiple parameters, enclose each set of parameters in braces...

Zatem w składni

{ 
     { "enabled", "enable", "enabling" }, 
    } 

Kompilator spodziewa swoją kolekcję mieć metoda Add(string, string, string). Ponieważ nie ma takiej metody na List<string []>, kompilacja nie powiedzie się.

Tak naprawdę można utworzyć taką kolekcję i zainicjować ją za pomocą tej składni.Jeśli utworzyć następujący zbiór:

public class TripleCollection<T> : IEnumerable<Tuple<T, T, T>> 
{ 
    readonly List<Tuple<T, T, T>> list = new List<Tuple<T, T, T>>(); 

    public void Add(T first, T second, T third) 
    { 
     list.Add(Tuple.Create(first, second, third)); 
    } 

    public IEnumerator<Tuple<T, T, T>> GetEnumerator() 
    { 
     return list.GetEnumerator(); 
    } 

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() 
    { 
     return GetEnumerator(); 
    } 
} 

Następujące będzie skompilować pomyślnie i utworzyć kolekcję z jedną 3-krotki:

 var tuples = new TripleCollection<string> 
     { 
      { "1", "2", "3" }, 
     }; 

Można również wprowadzić następujące List podklasy:

public class ListOfArray<T> : List<T[]> 
{ 
    public new void Add(params T[] args) 
    { 
     base.Add(args); 
    } 
} 

I zainicjuj go przy użyciu wymaganej składni:

 var synonyms = new ListOfArray<string> 
     { 
      { "enabled", "enable", "enabling" }, 
      { "disabled", "disable", "disabling" }, 
      { "s0", "s0 state" }, 
      { "s5", "s5 state" } 
     }; 

Ale List<string []>, jak inni to zauważyli, trzeba zainicjować listy synonimy wyraźnie przydzielając każdy wpis string [], zamiast niejawnego gromadzenia intializer dla każdego wpisu:

 var synonyms = new List<string[]> 
     { 
      new [] { "enabled", "enable", "enabling" }, 
      new [] { "disabled", "disable", "disabling" }, 
      new [] { "s0", "s0 state" }, 
      new [] { "s5", "s5 state" } 
     }; 

Answer 2

Trzeba dodać tablicę ciągów

List<string[]> synonyms = new List<string[]> 
    { 
     new string[] { "enabled", "enable", "enabling" }, 
     new string[] { "disabled", "disable", "disabling" }, 
     new string[] { "s0", "s0 state" }, 
     new string[] { "s5", "s5 state" } 
    }; 

Answer 3

Tworzenie niejawnie wpisywanych tablice dla List inicjatora:

List<string[]> synonyms = new List<string[]> 
{ 
    new [] { "enabled", "enable", "enabling" }, 
    new [] { "disabled", "disable", "disabling" }, 
    new [] { "s0", "s0 state" }, 
    new [] { "s5", "s5 state" } 
}; 

new [] { ... } jest równoważne temu new string[] { ... }, gdy typy obiektów w tablicy są wszystkie string. Otrzymasz błąd przy użyciu niejawnej składni, jeśli typy obiektów w tablicy są różne.

Answer 4

Nie tworzymy tablice w przykładzie, spróbuj wykonać następujące czynności:

List<string[]> synonyms = new List<string[]> 
    { 
     new[] { "enabled", "enable", "enabling" }, 
     new[] { "disabled", "disable", "disabling" }, 
     new[] { "s0", "s0 state" }, 
     new[] { "s5", "s5 state" } 
    }; 

Answer 5

musisz określić, że wewnętrzne obiekty są tablice tak, że nie wygląda na Wieloparametrowa Dodaj metod.

List<string[]> synonyms = new List<string[]> 
    { 
     new[] { "enabled", "enable", "enabling" }, 
     new[] { "disabled", "disable", "disabling" }, 
     new[] { "s0", "s0 state" }, 
     new[] { "s5", "s5 state" } 
    }; 

Answer 6

Myślę, że może to być, że nie robisz żadnych wystąpień tablic.

 List<string[]> synonyms = new List<string[]> 
    { 
     {new string[] { "enabled", "enable", "enabling" }}, 
     {new string[] { "disabled", "disable", "disabling" }}, 
     {new string[] { "s0", "s0 state" }}, 
     {new string[] { "s5", "s5 state" }} 
    };