title: Is it better to use Enumerable.Empty<T>() as opposed to new List<T>() to initialize an IEnumerable<T>?
body: <p>Suppose you have a class Person : </p>
  
  <pre><code>public class Person
  {
     public string Name { get; set;}
     public IEnumerable&lt;Role&gt; Roles {get; set;}
  }
  </code></pre>
  
  <p>I should obviously instantiate the Roles in the constructor.
  Now, I used to do it with a List like this : </p>
  
  <pre><code>public Person()
  {
     Roles = new List&lt;Role&gt;();
  }
  </code></pre>
  
  <p>But I discovered this static method in the <code>System.Linq</code> namespace</p>
  
  <pre><code>IEnumerable&lt;T&gt; Enumerable.Empty&lt;T&gt;();
  </code></pre>
  
  <p><strong>From <a href="http://msdn.microsoft.com/en-us/library/bb341042.aspx" rel="noreferrer">MSDN</a>:</strong></p>
  
  <blockquote>
    <p>The <code>Empty(TResult)()</code> method caches an
    empty sequence of type <code>TResult</code>. When
    the object it returns is enumerated,
    it yields no elements.</p>
    
    <p>In some cases, this method is useful
    for passing an empty sequence to a
    user-defined method that takes an
    <code>IEnumerable(T)</code>. It can also be used to
    generate a neutral element for methods
    such as <code>Union</code>. See the Example section
    for an example of this use of</p>
  </blockquote>
  
  <p>So is it better to write the constructor like that? Do you use it? Why? or if not, Why not? </p>
  
  <pre><code>public Person()
  {
     Roles = Enumerable.Empty&lt;Role&gt;();
  }
  </code></pre>