Es mejor usar Enumerable.Empty () en lugar de new List () para inicializar unerableumerable?

Creo que Enumerable.Empty<T> es mejor porque es más explícito: su código indica claramente sus intenciones. También podría ser un poco más eficiente, pero eso es solo una ventaja secundaria.

En el frente de rendimiento, veamos cómo se implementa Enumerable.Empty<T>.

Devuelve EmptyEnumerable<T>.Instance, que se define como:

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

Los campos estáticos en tipos genéricos se asignan por parámetro de tipo genérico. Esto significa que el tiempo de ejecución puede crear perezosamente estos arrays vacíos solo para los tipos que el código de usuario necesita, y reutilizar las instancias tantas veces como sea necesario sin agregar ninguna presión al recolector de basura.

A saber:

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

Suponiendo que realmente desea rellenar la propiedad Roles de alguna manera, encapsule eso haciendo que su setter sea privado e inicializándolo en una nueva lista en el constructor:

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

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

Si realmente quieres tener el configurador público, deja Roles con un valor de null y evita la asignación de objetos.

El problema con su enfoque es que no puede agregar ningún elemento a la colección: tendría una estructura privada como list y luego expondría los elementos como Enumerables:

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(); }
    }
}

Si tiene la intención de que otra clase cree la lista de roles (lo cual no recomendaría), entonces no inicializaría el enumerable en Persona.

El problema típico con la exposición de la Lista privada como unEnumerable es que el cliente de su clase puede meterse con ella mediante casting. Este código funcionaría:

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

Puede evitar esto implementando un iterador:

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

El problema más grande aquí sería exponer Roles como un campo público .

Lo siguiente se ve mejor:

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>();
        }
   }
}

Y tal vez deberías echarle un vistazo a devolverlo como una ReadOnlyCollection, dependiendo de cómo quieras usarlo.

Y Enumerable.Empty isn't better here, just a little more efficient when Roles usually stays empty.