ImmutableList vs List in C#

Question

Hello,

What is the difference between these? Output is the same.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Immutable;


namespace HelloWorld
{ 
  class Person
  {
    public int Age { get; private set;}
    public Person(int _age)
    {
      Age = _age;
    }
  }
  class Program
    {
        static void Main(string[] args)
        {
         List<Person> listOfPerson = new List<Person>();
           listOfPerson.Add(new Person(10));
           listOfPerson.Add(new Person(20));
           listOfPerson.Add(new Person(30));

          foreach (var item in listOfPerson)
          {
            System.Console.WriteLine(item.Age);
          }
        }
    }
}

and

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Text;

namespace HelloWorld
{ 
  class Person
  {
    public int Age { get; private set;}
    public Person(int _age)
    {
      Age = _age;
    }
  }
  class Program
    {
        static void Main(string[] args)
        {
          ImmutableList<Person> listOfPerson = ImmutableList.Create<Person>();
          listOfPerson = listOfPerson.Add(new Person(10));
          listOfPerson = listOfPerson.Add(new Person(20));
          listOfPerson = listOfPerson.Add(new Person(30));

          foreach (var item in listOfPerson)
          {
            System.Console.WriteLine(item.Age);
          }
        }
    }
}

Answer 1

Hi @Shervan360 ,

Here is the documentation on ImmutableList<T> and List<T>.

In terms of differences:

ImmutableList<T> has no public constructor. List<T> has a constructor.

They all have Item[Int32] and Count properties, ImmutableList<T> has IsEmpty property, and List<T> has Capacity property.

ImmutableList<T> is thread-safe, while List<T> is thread-safe under correct operation.

Regarding the immutability of ImmutableLIst<T>, you can refer to Eric's explanation.

Best Regards,
Jiale Xue.

--------
If the answer is the right solution, please click "Accept Answer" and kindly upvote it. If you have extra questions about this answer, please click "Comment".
Note: Please follow the steps in our documentation to enable e-mail notifications if you want to receive the related email notification for this thread

Answer 2

an ImmutableList is one you can not add or delete items from. The add / delete operations create a new list. The advantage of them when passed to a method, the method knows the list can not change, that is the list is read only. the item in list may or may not be immutable items.

while the list itself is thread safe, assigning to a variable shared across threads is not unless proper locking is used. so if you pass to a thread via closure, be sure not to modify the variable. also the objects in the list may not be thread safe.

Answer 3

Suppose a request is made for data from a database that should not be changed, this is a case for ImmutableList . So it depends on your business rules which path to take.

The following prevents add/remove but with auto-properties we can still change properties

public static IReadOnlyList<Categories> GetCategoriesList()  
{  
    using var context = new NorthwindContext();  
    return context.Categories.ToList().ToImmutableList();  
}  
  
public static readonly IReadOnlyList<Categories> CategoriesList = GetCategoriesList();  

To prevent add/remove and property changes

public class FromDatabaseMock  
{  
    public static IReadOnlyList<Person> People()  
    {  
        return  new List<Person>()  
        {  
            new ("Karen", "Payne", new List<string>()),   
            new("Mary", "Jones", new List<string>())  
        };  
    }  
}  
public class Person  
{  
    public Person(string firstName, string lastName, List<string> items)  
    {  
        FirstName = firstName;  
        LastName = lastName;  
        Items = items;  
    }  
    public string LastName { get; }  
    public string FirstName { get; }  
    public List<string> Items { get; }  
}  

Another example, get possible time zones for a DateTimeOffset, we don't want the user to alter the collection.

In a static class

/// <summary>  
/// Get possible time zones for a DateTimeOffset  
/// </summary>  
/// <param name="offsetTime"></param>  
/// <returns>time zone names</returns>  
public static ImmutableList<string> PossibleTimeZones(this DateTimeOffset offsetTime)  
{  
    List<string> list = new();  
    TimeSpan offset = offsetTime.Offset;  
  
    ReadOnlyCollection<TimeZoneInfo> timeZones = TimeZoneInfo.GetSystemTimeZones();  
  
    list.AddRange(from TimeZoneInfo timeZone in timeZones  
        where timeZone.GetUtcOffset(offsetTime.DateTime).Equals(offset)  
        select timeZone.DaylightName);  
  
    return list.ToImmutableList();  
}  

current is a nullable DateTimeOffset