Iniziatore della raccolta C#: è possibile aggiungere un elemento facoltativamente, in base a una condizione?

Question

In questo momento il mio codice simile a questo:

var ids = projectId.HasValue ? new List<Guid> { projectId.Value } : new List<Guid>(); 

Esiste un modo più succinta di creazione di una lista in una sola riga di codice, con un elemento aggiunto opzionalmente?

Answer 1

Questo probabilmente non è una buona idea, ma in C# 6, collection initializers also work when Add() is an extension method .

Questo significa che è possibile scrivere l'estensione Add() in questo modo:

public static void Add<T>(this List<T> list, T? item) where T : struct 
{ 
    if (item.HasValue) 
    { 
     list.Add(item.Value); 
    } 
} 

E poi questo codice farà ciò che si vuole:

var list = new List<Guid> { projectId }; 

Si noti che questo funziona solo per i tipi di valore (perché della distinzione T/T?) e non esiste un modo semplice per farlo funzionare per i tipi di riferimento.

Inoltre, troverei la riga sopra molto sorprendente, essendo più succinta non è sempre migliore. Questo è il motivo per cui in realtà non utilizzerei questo codice.

Answer 2

che è piuttosto succinta, ma un'altra opzione sarebbe quella di utilizzare LINQ:

var ids = new[] { projectId }.Where(x => x.HasValue).Select(x => x.Value).ToList(); 

Answer 3

vorrei risolvere questo utilizzando un metodo di estensione come questo:

public static void AddIfNotNull<T>(this List<T> list, T? value) where T : struct 
{ 
    if(value != null) 
    { 
     list.Add(value.Value); 
    } 
} 

di quello che potrebbe essere utilizzato in questo modo:

var ids = new List<Guid>(); 
ids.AddIfNotNull(projectId); 

Forse non come "furbo" (e non un one-liner) come vostra proposta, ma a mio avviso è molto più facile da leggere e capire. Se si desidera utilizzarlo come one-liner, è possibile modificare il tipo di restituzione dell'estensione come lista. Ciò permetterebbe di utilizzare qualcosa come var ids = new List<Guid>().AddIfNotNull(projectId);

Answer 4

Se stai andando il percorso metodo di estensione, avrebbe dovuto essere simile:

public static void AddIfNotNull<T>(this List<T> list, T? value) 
    where T : struct 
{ 
    if (value.HasValue) 
    { 
     list.Add(value.Value); 
    } 
} 

Avresti per costruire un secondo metodo di estensione per i tipi di riferimento (where T : class) se necessario.

Answer 5

Un'altra idea per un metodo di estensione (il nome potrebbe sicuramente essere migliorato, forse PossiblyCreateSingletonList?):

public static class NullableExtensions 
{ 
    public static List<T> SingletonList<T>(this Nullable<T> item) where T : struct 
    { 
     return item.HasValue ? new List<T> { item.Value } : new List<T>(); 
    } 
} 

Usage:

Guid? projectId = null; 

List<Guid> projectIds = projectId.SingletonList(); // empty list