Switch o un dizionario durante l'assegnazione a un nuovo oggetto

Di recente, sono venuto a preferire la mappatura delle relazioni 1-1 utilizzando Dictionariesanziché le Switchistruzioni. Trovo che sia un po 'più veloce da scrivere e più facile da elaborare mentalmente. Sfortunatamente, quando si mappa su una nuova istanza di un oggetto, non voglio definirlo in questo modo:

var fooDict = new Dictionary<int, IBigObject>()
{
    { 0, new Foo() }, // Creates an instance of Foo
    { 1, new Bar() }, // Creates an instance of Bar
    { 2, new Baz() }  // Creates an instance of Baz
}

var quux = fooDict[0]; // quux references Foo

Dato quel costrutto, ho sprecato i cicli della CPU e la memoria creando 3 oggetti, facendo tutto ciò che i loro costruttori potrebbero contenere e alla fine ne ho usato solo uno. Credo anche che la mappatura di altri oggetti fooDict[0]in questo caso li indurrà a fare riferimento alla stessa cosa, piuttosto che creare una nuova istanza Foocome previsto. Una soluzione sarebbe invece usare un lambda:

var fooDict = new Dictionary<int, Func<IBigObject>>()
{
    { 0, () => new Foo() }, // Returns a new instance of Foo when invoked
    { 1, () => new Bar() }, // Ditto Bar
    { 2, () => new Baz() }  // Ditto Baz
}

var quux = fooDict[0](); // equivalent to saying 'var quux = new Foo();'

Sta arrivando a un punto in cui è troppo confuso? È facile perderlo ()alla fine. O la mappatura su una funzione / espressione è una pratica abbastanza comune? L'alternativa sarebbe usare un interruttore:

IBigObject quux;
switch(someInt)
{
    case 0: quux = new Foo(); break;
    case 1: quux = new Bar(); break;
    case 2: quux = new Baz(); break;
}

Quale invocazione è più accettabile?

• Dizionario, per ricerche più rapide e meno parole chiave (maiuscole e minuscole)
• Switch: più comunemente presente nel codice, non richiede l'uso di un oggetto Func <> per l'indirizzamento indiretto.

È un'interpretazione interessante del modello di fabbrica . Mi piace la combinazione del Dizionario e dell'espressione lambda; mi ha fatto guardare quel contenitore in un modo nuovo.

Sto ignorando la preoccupazione nella tua domanda sui cicli della CPU come hai menzionato nei commenti che l'approccio non lambda non fornisce ciò di cui hai bisogno.

Penso che entrambi gli approcci (switch vs. Dictionary + lambda) andranno bene. L'unica limitazione è che usando il Dizionario, stai limitando i tipi di input che potresti ricevere per generare la classe restituita.

L'uso di un'istruzione switch fornirebbe maggiore flessibilità sui parametri di input. Tuttavia, se questo dovesse essere un problema, potresti racchiudere il Dizionario all'interno di un metodo e avere lo stesso risultato finale.

Se è nuovo per il tuo team, commenta il codice e spiega cosa sta succedendo. Chiama per una revisione del codice del team, guidali attraverso ciò che è stato fatto e rendili consapevoli. A parte questo, sembra a posto.

C # 4.0 ti dà la Lazy<T>classe, che è simile alla tua seconda soluzione, ma grida più esplicitamente "Inizializzazione pigra".

var fooDict = new Dictionary<int, Lazy<IBigObject>>()
{
    { 0, new Lazy(() => new Foo()) }, // Returns a new instance of Foo when invoked
    { 1, new Lazy(() => new Bar()) }, // Ditto Bar
    { 2, new Lazy(() => new Baz()) }  // Ditto Baz
}

Stilisticamente penso che la leggibilità sia uguale tra loro. È più facile fare l'iniezione di dipendenza con Dictionary.

Non dimenticare che è necessario verificare se la chiave esiste quando si utilizza Dictionarye, in caso contrario, fornire un fallback.

Preferirei la switchdichiarazione per i percorsi di codice statico e la Dictionaryper i percorsi di codice dinamico (in cui è possibile aggiungere o rimuovere voci). Il compilatore potrebbe essere in grado di eseguire alcune ottimizzazioni statiche con switchciò che non può con Dictionary.

È interessante notare che questo Dictionarymodello è ciò che le persone a volte fanno in Python, perché a Python manca l' switchaffermazione. Altrimenti usano catene if-else.

In generale, non preferirei nessuno dei due.

Qualunque cosa stia consumando questo dovrebbe funzionare con a Func<int, IBigObject>. Quindi la fonte della tua mappatura può essere un Dizionario o un metodo che ha un'istruzione switch o una chiamata al servizio web o una ricerca di file ... qualunque cosa.

Per quanto riguarda l'implementazione, preferirei il dizionario dal momento che è più facilmente rifattorizzato da "dizionario hard code, chiave di ricerca, restituisce il risultato" a "carica dizionario da file, chiave di ricerca, restituisce risultato".