List Collection Class in C#

List is a collection class in C# and .NET. Code examples in this article show how to work with List<T> class in C#. Also code examples on C# Lists and C# Collections.

Introduction

A List is one of the generic collection classes in the "System.Collection.Generic" namespace. There are several generic collection classes in the System.Collection.Generic namespace that includes the following:

  1. Dictionary
  2. List
  3. Stack
  4. Queue

A List class can be used to create a collection of any type. For example, we can create a list of Integers, strings and even any complex types.

Why to use a List

  1. Unlike arrays, a List can grow in size automatically in other words a list can be re-sized dynamically but arrays cannot.
  2. List is a generic type. 
  3. The List class also provides methods to search, sort and manipulate lists.
Example 1 - Using Array

I am taking an example to store data in an array and see what the problem is in storing the data in the array.

  1. using System;  
  2. using System.Collections.Generic;  
  3.   
  4. namespace List_Methods_Properties  
  5. {  
  6.     class Program  
  7.     {  
  8.         static void Main(string[] args)  
  9.         {  
  10.             customer customer1 = new customer()  
  11.             {  
  12.                 EmpID = 1,  
  13.                 EmpName = "Sourabh",  
  14.                 EmpSalary = 50000  
  15.             };  
  16.             customer customer2 = new customer()  
  17.             {  
  18.                 EmpID = 2,  
  19.                 EmpName = "Shaili",  
  20.                 EmpSalary = 60000  
  21.             };  
  22.             customer customer3 = new customer()  
  23.             {  
  24.                 EmpID = 3,  
  25.                 EmpName = "Saloni",  
  26.                 EmpSalary = 55000  
  27.             };  
  28.             //Customer array
  29.             customer[] customers = new customer[2];  
  30.             customers[0] = customer1;  
  31.             customers[1] = customer2;  
  32.   
  33.             //here I am adding one more cutomer to customers array and building the programs  
  34.             customers[2] = customer3;  
  35.         }  
  36.     }  
  37.     class customer  
  38.     {  
  39.         public int EmpID { getset; }  
  40.         public string EmpName { getset; }  
  41.         public int EmpSalary { getset; }  
  42.   
  43.     }  
  44. }  
In the example above I have created one class named "customer" and In the main method I have created an array named customers with a size of two. When I build this program (using CTRL+SHIFT+B) then I will get output like built successfully but when I run this program then I get the error: 
 
 
When I run this program then at run time I will get the exception index was out of the bound of the array. 

 
 
 
 
So now we use List
 
A list is a generic data type that can hold any type of data that may be integer, float, string or may be complex type. To create a list we have 3 types of constructors.
  1. List<Type> Customers = new List<Type>();//default constructor  
  2. List<Type> Customers = new List<Type>(int capacity);//with spacific capacity
  3. List<Type> Customers = new List(IEnumerable<Type> collection);//with spacific collection  

Example 2 - Using List

  1. using System;  
  2. using System.Collections.Generic;  
  3.   
  4. namespace List_Methods_Properties  
  5. {  
  6.     class Program  
  7.     {  
  8.         static void Main(string[] args)  
  9.         {  
  10.             customer customer1 = new customer()  
  11.             {  
  12.                 EmpID = 1,  
  13.                 EmpName = "Sourabh",  
  14.                 EmpSalary = 50000  
  15.             };  
  16.             customer customer2 = new customer()  
  17.             {  
  18.                 EmpID = 2,  
  19.                 EmpName = "Shaili",  
  20.                 EmpSalary = 60000  
  21.             };  
  22.             customer customer3 = new customer()  
  23.             {  
  24.                 EmpID = 3,  
  25.                 EmpName = "Saloni",  
  26.                 EmpSalary = 55000  
  27.             };  
  28.   
  29.             //using list  
  30.             // Creating List with initial capacity 2  
  31.             List<customer> Customers = new List<customer>(2);  
  32.             Customers.Add(customer1);  // Here Add Method is used to add the item to the list
  33.             Customers.Add(customer2);  
  34.   
  35.             //adding one more customer wheather capacity is 2 only  
  36.             Customers.Add(customer3);  
  37.         }  
  38.     }  
  39.     class customer  
  40.     {  
  41.         public int EmpID { getset; }  
  42.         public string EmpName { getset; }  
  43.         public int EmpSalary { getset; }  
  44.   
  45.     }  
  46. }  
Output

 
In the preceding example we are adding 3 items to the list wereas the capacity is only two so it proves that a List can be automatically re-sized.

Add Method
 
Add method is used to add the items to the list.

How to access items from the List
 
To add the item to the list we use an index number to access it.
  1. // <List Item>[index number]  
Code
  1. using System;    
  2. using System.Collections.Generic;    
  3.     
  4. namespace List_Methods_Properties    
  5. {    
  6.     class Program    
  7.     {    
  8.         static void Main(string[] args)    
  9.         {    
  10.             customer customer1 = new customer()    
  11.             {    
  12.                 EmpID = 1,    
  13.                 EmpName = "Sourabh",    
  14.                 EmpSalary = 50000    
  15.             };    
  16.             customer customer2 = new customer()    
  17.             {    
  18.                 EmpID = 2,    
  19.                 EmpName = "Shaili",    
  20.                 EmpSalary = 60000    
  21.             };    
  22.             customer customer3 = new customer()    
  23.             {    
  24.                 EmpID = 3,    
  25.                 EmpName = "Saloni",    
  26.                 EmpSalary = 55000    
  27.             };    
  28.     
  29.             //using list    
  30.             // Creating List with initial capacity 2    
  31.             List<customer> Customers = new List<customer>(2);    
  32.             Customers.Add(customer1);    
  33.             Customers.Add(customer2);    
  34.             Customers.Add(customer3);    
  35.     
  36.             //Accessing Item from the List    
  37.     
  38.             customer c1 = Customers[0];    
  39.             Console.WriteLine("ID={0}, Name={1}, Salary={2}",c1.EmpID,c1.EmpName,c1.EmpSalary);    
  40.     
  41.             customer c2 = Customers[1];    
  42.             Console.WriteLine("ID={0}, Name={1}, Salary={2}", c2.EmpID, c2.EmpName, c2.EmpSalary);    
  43.     
  44.             customer c3 = Customers[2];    
  45.             Console.WriteLine("ID={0}, Name={1}, Salary={2}", c3.EmpID, c3.EmpName, c3.EmpSalary);    
  46.         }    
  47.     }    
  48.     class customer    
  49.     {    
  50.         public int EmpID { get; set; }    
  51.         public string EmpName { get; set; }    
  52.         public int EmpSalary { get; set; }    
  53.     
  54.     }    
  55. }    
How to access all the items of the list using foreach loop,
  1. using System;  
  2. using System.Collections.Generic;  
  3.   
  4. namespace List_Methods_Properties  
  5. {  
  6.     class Program  
  7.     {  
  8.         static void Main(string[] args)  
  9.         {  
  10.             customer customer1 = new customer()  
  11.             {  
  12.                 EmpID = 1,  
  13.                 EmpName = "Sourabh",  
  14.                 EmpSalary = 50000  
  15.             };  
  16.             customer customer2 = new customer()  
  17.             {  
  18.                 EmpID = 2,  
  19.                 EmpName = "Shaili",  
  20.                 EmpSalary = 60000  
  21.             };  
  22.             customer customer3 = new customer()  
  23.             {  
  24.                 EmpID = 3,  
  25.                 EmpName = "Saloni",  
  26.                 EmpSalary = 55000  
  27.             };  
  28.   
  29.             //using list  
  30.             // Creating List with initial capacity 2  
  31.             List<customer> Customers = new List<customer>(2);  
  32.             Customers.Add(customer1);  
  33.             Customers.Add(customer2);  
  34.             Customers.Add(customer3);  
  35.   
  36.             //Accessing Item from the List using for loop  
  37.   
  38.             foreach (customer c in Customers)  
  39.             {  
  40.                 Console.WriteLine("ID={0}, Name={1}, Salary={2}", c.EmpID, c.EmpName, c.EmpSalary);  
  41.             }  
  42.         }  
  43.     }  
  44.     class customer  
  45.     {  
  46.         public int EmpID { getset; }  
  47.         public string EmpName { getset; }  
  48.         public int EmpSalary { getset; }  
  49.     }  
  50. }  
Output

   

Note
You can also use for or while loop to access all the items.

Different Properties of a "List"

  1. Count: This property is the number of items of the List.

  2. Capacity: This property is the capacity of the List. By default the capacity is 0, then starts with 4, 8, 16, 32.....
  1. using System;  
  2. using System.Collections.Generic;  
  3.   
  4. namespace List_Methods_Properties  
  5. {  
  6.     class Program  
  7.     {  
  8.         static void Main(string[] args)  
  9.         {  
  10.             List<string> Names = new List<string>();  
  11.             Names.Add("Sourabh");  
  12.             Names.Add("Shaili");  
  13.             Names.Add("Saloni");  
  14.             Console.WriteLine("Number of Items in the List is:" + Names.Count);  
  15.             Console.WriteLine("Capacity of the List is:" + Names.Capacity);  
  16.         }  
  17.     }  
  18. }  
Output

  

 Different Methods of a "List"

  1. Contains: This method determines whether or not an element is in the List, if the element is present in the List then this method returns "True" else "False". 
  2. Insert: This method is used to insert an element at a specific index.
  3. Remove: This method removes the first occurrence of the specific object from the list.
  4. RemoveAll: This method removes all the elements that matches the condition.
  5. RemoveAt: This method remove the element from the specified index.
  6. Clear: Removes all the element from the list.
  7. Sort: This method is used sort the List
  8. Reverse: This method reverses the order of the elements in the entire List.
  9. TrimExcess: This method sets the capacity to the actual number of elements in the list.

Example

  1. using System;  
  2. using System.Collections.Generic;  
  3.   
  4. namespace List_Methods_Properties  
  5. {  
  6.     class Program  
  7.     {  
  8.         static void Main(string[] args)  
  9.         {  
  10.             List<string> Names = new List<string>();  
  11.             Names.Add("Sourabh");  
  12.             Names.Add("Shaili");  
  13.             Names.Add("Saloni");  
  14.             Names.Add("Ankit");  
  15.             Names.Add("Bill");  
  16.             Names.Add("Dinesh");  
  17.             Names.Add("Mahesh Chand");  
  18.             Names.Add("DJ");  
  19.             Names.Add("Rajesh");  
  20.             Names.Add("Rajesh");  
  21.             Names.Add("Rajesh");  
  22.             //Contains: This method determines that weather the element is in List or not,   
  23.             //If element is present in List then this method returns "True" else return "False".   
  24.             Console.WriteLine(Names.Contains("Sourabh\n"));  
  25.   
  26.             //accessing all the element from the list  
  27.             foreach (string Name in Names)  
  28.             {  
  29.                 Console.WriteLine(Name);  
  30.             }  
  31.               
  32.             //Insert: This method is used to insert an element in particular index.  
  33.             Names.Insert(5, "Rajesh");  
  34.   
  35.             Console.WriteLine("\n\nAfter Inserting Rajesh at 5th index");  
  36.             foreach (string Name in Names)  
  37.             {  
  38.                 Console.WriteLine(Name);  
  39.             }  
  40.   
  41.             //Sort: Sorts the List  
  42.             Names.Sort();  
  43.             Console.WriteLine("\n\nSorting in List");  
  44.             foreach (string Name in Names)  
  45.             {  
  46.                 Console.WriteLine(Name);  
  47.             }  
  48.   
  49.             //Reverse: Reverse the order of the element of List  
  50.             Names.Reverse();  
  51.             Console.WriteLine("\n\nReverse Elements of List");  
  52.             foreach (string Name in Names)  
  53.             {  
  54.                 Console.WriteLine(Name);  
  55.             }  
  56.   
  57.             //Remove: Removes the elements from the list              
  58.             Names.Remove("Rajesh");  
  59.             Console.WriteLine("\n\nRemove Element from the List using Remove Method");  
  60.             foreach (string Name in Names)  
  61.             {  
  62.                 Console.WriteLine(Name);  
  63.             }  
  64.   
  65.             //RemoveAt:Remove the elements from the list at the specific index  
  66.             Names.RemoveAt(7);  
  67.             Console.WriteLine("\n\nRemove Element from the List using RemoveAt Method");  
  68.             foreach (string Name in Names)  
  69.             {  
  70.                 Console.WriteLine(Name);  
  71.             }  
  72.   
  73.             //nTrimExcess:Sets the capacity to the actual number of elements in the List  
  74.             Names.TrimExcess();  
  75.             Console.WriteLine("\n\nTrimExcess Method");  
  76.             Console.WriteLine("Capacity: {0}", Names.Capacity);  
  77.             Console.WriteLine("Count: {0}", Names.Count);  
  78.   
  79.   
  80.             //Clear:Removes all elements from the List  
  81.             Names.Clear();  
  82.             Console.WriteLine("\n\nClear Method");  
  83.             Console.WriteLine("Capacity: {0}", Names.Capacity);  
  84.             Console.WriteLine("Count: {0}", Names.Count);  
  85.             Console.ReadKey();  
  86.         }  
  87.     }  
  88. }  
Output

  
 
In this article, we saw some use cases of List<T>.  
 
Further readings