Inizializzazione condizionale di una lista di stringhe

Un sacco di volte, puoi davvero risolvere un problema come questo, esprimendo i tuoi dati in un formato con meno sintassi di un linguaggio di programmazione, come una stringa CSV. Non conosco C #, ma un esempio in Scala è:

def headersForDataSource(dataSource: String): Option[Array[String]] = {
  val headers = """
    Source1,header1,header2,header3,...,header18
    Source2,headerA,headerB,headerC,...,headerJ
    """

  val lines = headers.lines map (_.trim split ',')
  lines find (_(0) == dataSource) map (_.tail)
}

Puoi vedere che questo rende la tua lista di intestazioni molto più compatta e più facile da leggere, perché non ingombra e la mescola con la sintassi della struttura dei dati. Lo sta inserendo nel formato preferito, invece del formato forzato su di te dal linguaggio di programmazione.

Qual è il problema che stai tentando di risolvere?

Se stai cercando di migliorare le prestazioni, questo è sicuramente un caso di ottimizzazione prematura. Ognuno dei tre metodi che fornisci potrebbe riempire un elenco di migliaia di elementi nella frazione di un secondo necessario per sollevare il dito dal mouse dopo aver fatto clic su un pulsante.

Se stai solo cercando di rendere il tuo codice meno dettagliato, una variante dell'opzione 3 è la migliore.

var headers = new List<string>();
switch (dataSource)
{
    case "Source 1":
        headers.AddRange(new [] { "header1", "header2", "header3", "...", "header18" })
        break;
    case "Source 2":
        headers.AddRange(new [] { "headerA", "headerB", "headerC", "...", "headerJ" })
        break;
    default:
        // TODO: Handle bad sources.
        break;
}

Si noti che non è necessario specificare il tipo di elenco o le matrici per gli elementi: questi verranno automaticamente dedotti dal compilatore.

Puoi anche evitare switch e if usando maps . Userò la sintassi Java, ma suppongo che si possa fare facilmente in C #

Descrittore non modificabile (statico o costante)

Map<String,String[]> HEADERS_MAP = new HashMap<String,String[]>();
HEADERS_MAP.put("Source 1",new String[]{"header1","headerN"});
HEADERS_MAP.put("Source 2",new String[]{"headerA","headerZ"});
...
//Preventing Map from changes
HEADERS_MAP = Collections.unmodifiableMap(HEADERS_MAP);

Nota: penso che le mappe siano Dictorinary in C #

Generatore di intestazione

//Each consumer will have it's onw list
return Arrays.asList(HEADERS_MAP.get(dataSource));

Modifica : Ho modificato per prima risposta il commento di @ unholysampler

Ora Mappa memorizza String [] e builder restituisce un nuovo elenco nuovo / non associato. Quindi il consumatore del costruttore sarà in grado di modificare il contenuto dell'elenco e impedirà il codice da modifiche indesiderate. Potrebbe essere fatto con Collections.unmodificableList , ma in questo modo aggiunge un po 'più di codice e complessità. Fa codice meno leggibile.

Penso che un'opzione leggermente modificata 2 sia la soluzione migliore. Lascia la dichiarazione delle intestazioni al di fuori dell'interruttore e all'interno dell'interruttore basta impostare le intestazioni = nuova lista

Inoltre non hai bisogno delle parentesi graffe per creare blocchi per ogni dichiarazione di caso; C # ti costringerà ad avere un'interruzione alla fine di ogni caso.

Il vantaggio di fare questo è che se aggiungi un nuovo caso, sarai avvisato che le intestazioni non sono inizializzate se provi ad usarlo più tardi, dove il tuo attuale numero 2 finirà con una lista vuota , che potrebbe essere un errore logico da rintracciare più tardi.

Ecco una versione più breve, che combina i suggerimenti di Peregrine e Karl Bielefeldt:

string hline;
switch (dataSource)
{
    case "Source 1":
        hline = "header1,header2,header3,...,header18";
        break;
    case "Source 2":
        hline = "headerA,headerB,headerC,...,headerZ";
        break;
    default:
        // TODO: Handle bad sources.
        break;
}
var headers = new List<string>();
headers.AddRange(hline.Split(','));

Se puoi fare riferimento alle tue diverse origini dati per un indice da un intervallo consecutivo, vorrei considerare di evitare l'intero caso-switch e inizializzare hline in questo modo:

 string hLine = new []{
   "header1,header2,header3,...,header18",
   "headerA,headerB,headerC,...,headerZ",
   "..."}[dataSourceIndex];

Perché non usare un dizionario?

var headers = new List<string>();
var headersToAdd = new Dictionary<string, string[]>
{
    {"Source 1", new string[] {"header1", "header2"} },
    {"Source 2", new string[] {"headerA", "headerB"} }
};

headers.AddRange(headersToAdd["Source 1"]);
headers.AddRange(headersToAdd["Source 2"]);