È meglio utilizzare Enumerable.Empty <T>() in opposizione al nuovo Elenco <T>() per inizializzare un IEnumerable <T>?

Question

Supponiamo di avere una classe Persona:

public class Person 
{ 
    public string Name { get; set;} 
    public IEnumerable<Role> Roles {get; set;} 
} 

dovrei ovviamente istanziare i ruoli nel costruttore. Ora, ho usato per farlo con una lista come questa:

public Person() 
{ 
    Roles = new List<Role>(); 
} 

Ma ho scoperto questo metodo statico nella System.Linq namespace

IEnumerable<T> Enumerable.Empty<T>(); 

Da MSDN:

Il Il metodo Empty(TResult)() memorizza nella cache una sequenza vuota di tipo TResult. Quando l'oggetto restituito viene enumerato, non produce elementi.

In alcuni casi, questo metodo è utile per passare una sequenza vuota a un metodo definito dall'utente che prende un IEnumerable(T). Può anche essere utilizzato per generare un elemento neutro per i metodi come Union. Vedere la sezione Esempio per un esempio di questo uso di

Quindi è meglio scrivere il costruttore in questo modo? Lo usi? Perché? o se no, perché no?

public Person() 
{ 
    Roles = Enumerable.Empty<Role>(); 
} 

Answer 1

penso che la maggior parte delle registrazioni mancato il punto principale. Anche se si utilizza un array vuoto o una lista vuota, questi sono oggetti e sono archiviati in memoria. Than Garbage Collector deve prendersi cura di loro. Se hai a che fare con applicazioni ad alto throughput, potrebbe essere un impatto notevole.

Enumerable.Empty non crea un oggetto per chiamata, quindi mette meno carico su GC.

Se il codice si trova in una posizione a basso throughput, quindi si riduce a considerazioni estetiche però.

Answer 2

Credo Enumerable.Empty<T> è meglio perché è più esplicito: il codice indica chiaramente le vostre intenzioni. Potrebbe anche essere un po 'più efficiente, ma questo è solo un vantaggio secondario.

Answer 3

Il problema più grande sarebbe quello di esporre Roles come campo pubblico .

il seguente aspetto migliore:

public class Person 
{ 
    public string Name { get; set; } 

    private List<Role> _roles = null; 
    public IEnumerable<Role> Roles 
    { 
     get { 
     if (_roles != null) 
      return _roles; 
     else 
      return Enumerable.Empty<Role>(); 
     } 
    } 
} 

E forse si dovrebbe dare un'occhiata a tornare come un ReadonlyCollection, a seconda di come si desidera utilizzarlo.

E Enumerable.Empty non è better qui, solo un po 'più efficiente quando i ruoli di solito rimane vuoto.

Answer 4

Il problema con il vostro approccio è che non è possibile aggiungere tutti gli elementi per la raccolta - vorrei avere una struttura privata come lista e poi esporre gli oggetti come un Enumerable:

public class Person 
{ 
    private IList<Role> _roles; 

    public Person() 
    { 
     this._roles = new List<Role>(); 
    } 

    public string Name { get; set; } 

    public void AddRole(Role role) 
    { 
     //implementation 
    } 

    public IEnumerable<Role> Roles 
    { 
     get { return this._roles.AsEnumerable(); } 
    } 
} 

Se si intende un po ' l'altra classe per creare l'elenco dei ruoli (che non consiglierei) quindi non inizializzerei affatto l'enumerabile in Person.

Answer 5

si Supponendo che in realtà desidera popolare alla proprietà Roles in qualche modo, poi incapsulare che facendo è setter privata e l'inizializzazione a un nuovo elenco nel costruttore:

public class Person 
{ 
    public string Name { get; set; } 
    public IList<Role> Roles { get; private set; } 

    public Person() 
    { 
     Roles = new List<Role>(); 
    } 
} 

Se davvero si vuole veramente avere il pubblico setter, lasciare Roles con un valore di null ed evitare l'allocazione dell'oggetto.

Answer 6

Il tipico problema con l'esposizione dell'elenco privato come un oggetto IEnumerable è che il client della classe può interferire con esso mediante il cast. Questo codice avrebbe funzionato:

var p = new Person(); 
    List<Role> roles = p.Roles as List<Role>; 
    roles.Add(Role.Admin); 

È possibile evitare questo mediante l'attuazione di un iteratore:

public IEnumerable<Role> Roles { 
    get { 
    foreach (var role in mRoles) 
     yield return role; 
    } 
} 

Answer 7

Sul fronte delle prestazioni, vediamo come è implementato Enumerable.Empty<T>.

Esso restituisce EmptyEnumerable<T>.Instance, che è definito come:

internal class EmptyEnumerable<T> 
{ 
    public static readonly T[] Instance = new T[0]; 
} 

campi statici sui tipi generici sono assegnati per parametro di tipo generico. Ciò significa che il runtime può creare pigramente questi array vuoti solo per i tipi richiesti dal codice utente e riutilizzare le istanze tutte le volte necessarie senza aggiungere alcuna pressione sul garbage collector.

Vale a dire:

Debug.Assert(ReferenceEquals(Enumerable.Empty<int>(), Enumerable.Empty<int>()));