2015-12-03 10 views
8

voglio compilare un elenco di array di stringhe al momento della compilazioneinizializzazione di un elenco con gli array

qualcosa di simile:

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

ma ottengo un errore di compilazione: No overloaded method 'Add' takes 2 arguments

Perché Questo? Funziona se non fossero gli array di stringhe con List<string>

+0

state trattando la vostra collezione come un dizionario invece di una lista. –

+0

I dizionari possono contenere solo una coppia, voglio essere in grado di contenere più di un paio se necessario – dukevin

+0

In tal caso potrebbe essere necessaria una classe di modello personalizzata che assuma il valore di sinistra, ad es. s0 o s5, e in quel modello personalizzato aggiungi sinonimi che sono una lista di stringhe. Quello che hai al momento non funzionerà. –

risposta

6

La ragione per cui il codice fa non lavoro è scritto in 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...

Così, nella sintassi

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

Il compilatore si aspetta la vostra collezione di avere un metodo Add(string, string, string). Poiché non esiste un tale metodo su List<string []>, la compilazione non riesce.

In effetti, è possibile creare una raccolta di questo tipo e inizializzarla con questa sintassi.Se si crea la seguente collezione:

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

Di seguito verrà compilato con successo e creare una collezione con un 3-tuple:

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

E 'possibile fare la seguente List sottoclasse:

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

E inizializzarlo con la sintassi desiderata:

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

Ma per List<string []>, come altri hanno notato, è necessario inizializzare l'elenco sinonimi assegnando esplicitamente ogni voce string [], piuttosto che utilizzare una collezione intializer implicita per ogni voce:

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

È necessario aggiungere un array di stringhe

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

Crea array implicitamente tipizzate per il vostro List inizializzatore:

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

new [] { ... } è equivalente a fare new string[] { ... } quando i tipi di oggetti nell'array sono tutti string. Si otterrà un errore utilizzando la sintassi implicita se i tipi di oggetti nell'array sono diversi.

8

Non sta creando le matrici nel tuo esempio, provare quanto segue:

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

È necessario specificare che gli oggetti interni sono array in modo che non sembra per il multi-parametro Aggiungere metodi.

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

Penso che potrebbe essere che non stai facendo alcun esempio degli array.

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