Stile per la creazione di IEnumerable unions [closed]

Question

Stile per la creazione di IEnumerable unions [closed]

#1 da (4 voti)
#2 da (1 voti)

1

Non esiste uno zucchero LINQ per la creazione di unioni. Il metodo Enumerable.Union() viene solitamente chiamato in questo modo:

var bigList = list1.Union(list2);

L'alternativa è chiamare Enumerable.Union() che può essere più leggibile:

var bigList = Enumerable.Union(list1, list2);

Tuttavia nessuno di questi metodi è molto elegante (soprattutto, leggibile) durante il ridimensionamento Il seguente è probabilmente il metodo migliore:

var reallyBigList = list1.Union(list2).Union(list3);

Che può risultare in qualche incatenamento del metodo. Le alternative richiedono variabili incidentali:

var list1and2 = list1.Union(list2);
var reallyBigList = list1and2.Union(list3);

o

var list1and2 = Enumerable.Union(list1, list2);
var reallyBigList = Enumerable.Union(list1and2, list2);

C'è un modo pulito per creare questi sindacati più complessi? Un'estensione come Enumerable.Union(params IEnumerable<T> collections) (usata come var reallyBigList = Enumerable.Union(list1, list2, list3) ) dovrebbe essere migliore?

coding-style c# linq

posta Ben Scott 14.02.2013 - 05:56

fonte

2 risposte

Leggi altre domande sui tag coding-style c# linq

Come tornare fluentemente? Come impostare la proprietà nullable / facoltativa dell'oggetto database su NULL nel backend?

score 4 · Answer 1

Non considero affatto l'opzione concatenamento del metodo. Certo, qualcosa come

 var reallyBigList = (from ... where ... select ...).Union(from ... where ... select)...

può facilmente diventare illeggibile, ma, d'altra parte,

 var mp3s = from ... where ... select ...
 var videos = from ... where ... select ...
 var alreadyProcessed = from ... where ... select ...

 var toDo = mp3s.Union(videos).Except(alreadyProcessed)

legge in modo abbastanza naturale. Quindi, quando si usano le variabili intermedie con nome , l'approccio di concatenamento del metodo è estremamente leggibile.

score 1 · Answer 2

Il metodo che concatena lo stile è abbastanza leggibile, secondo me. Certamente potresti scrivere il tuo metodo di estensione per prendere molti IEnumerable<T> .

Ecco un esempio che utilizza l'iterazione. Anche la ricorsione funziona, ma non mi è piaciuta molto.

public static IEnumerable<T> MyUnion<T>(
    this IEnumerable<T> original, params IEnumerable<T>[] toUnion)
{
    var enumerable = original;
    foreach (var other in toUnion)
    {
        enumerable = enumerable.Union(other);
    }

    return enumerable;
}