Is it better to use Enumerable.Empty<T>() as opposed to new List<T>() to initialize an IEnumerable<T>?
c#, constructor, linq
Solution
I think most postings missed the main point. Even if you use an empty array or empty list, those are objects and they are stored in memory. The Garbage Collector has to take care of them. If you are dealing with a high throughput application, it could be a noticeable impact.
`Enumerable.Empty` does not create an object per call thus putting less load on the GC.
If the code is in low-throughput location, then it boils down to aesthetic considerations though.
Problem
Suppose you have a class Person : ``` public class Person { public string Name { get; set;} public IEnumerable<Role> Roles {get; set;} } ``` I should obviously instantiate the Roles in the constructor. Now, I used to do it with a List like this : ``` public Person() { Roles = new List<Role>(); } ``` But I discovered this static method in the `System.Linq` namespace ``` IEnumerable<T> Enumerable.Empty<T>(); ``` From MSDN: The `Empty(TResult)()` method caches an empty sequence of type `TResult`. When the object it returns is enumerated, it yields no elements. In some cases, this method is useful for passing an empty sequence to a user-defined method that takes an `IEnumerable(T)`. It can also be used to generate a neutral element for methods such as `Union`. See the Example section for an example of this use of So is it better to write the constructor like that? Do you use it? Why? or if not, Why not? ``` public Person() { Roles = Enumerable.Empty<Role>(); } ```