C# List Class

Last Updated : 21 Apr, 2025

In C#, the List<T> class represents the list of objects that can be accessed by index. It comes under the System.Collections.Generic namespace. List class can be used to create a collection of different types like integers, strings, etc. List<T> class also provides the methods to search, sort, and manipulate lists.

It is different from the arrays. A List<T> can be resized dynamically but arrays cannot.
List<T> class can accept null as a valid value for reference types and it also allows duplicate elements.
If the Count becomes equal to Capacity, then the capacity of the List increases automatically by reallocating the internal array. The existing elements will be copied to the new array before the addition of the new element.
List<T> class is the generic equivalent of the ArrayList class by implementing the IList<T> generic interface.
This class can use both equality and ordering comparisons.
List<T> class is not sorted by default and elements are accessed by a zero-based index.
For very large List<T> objects, you can increase the maximum capacity to 2 billion elements on a 64-bit system by setting the enabled attribute of the configuration element to true in the run-time environment.

Example: This example demonstrates how to create a list, add elements to it, and then display the elements using the for-each loop.

// C# program to add elements to a List using System; using System.Collections.Generic;  class Geeks {     static void Main()     {         // Create a new list of integers         List<int> l = new List<int>();          // Add elements to the list         l.Add(10);         l.Add(20);         l.Add(30);         l.Add(40);          // Display the elements in the list         Console.WriteLine("Elements in the list:");         foreach (int i in l)         {             Console.WriteLine(i);         }     } }

Output

Elements in the list: 10 20 30 40

Declaration of List

List<T> listName = new List<T>();

Constructors

Constructors	Description
List<T>()	Initializes a new instance of the List<T> class that is empty and has the default initial capacity.
List<T>(IEnumerable<T>)	Initializes a new instance of the List<T> class that contains elements copied from the specified collection and has sufficient capacity to accommodate the number of elements copied.
List<T>(Int32)	Initializes a new instance of the List<T> class that is empty and has the specified initial capacity

Example: This example demonstrates how to create an empty List and display its initial count.

// C# program to demonstrates the count of an emptyList using System; using System.Collections.Generic;  class Geeks {      public static void Main(String[] args)     {          // Creating a List of integers         List<int> l = new List<int>();          // displaying the number         // of elements of List<T>         Console.WriteLine(l.Count);     } }

Output

Properties

The List class provides several properties to access its state.

Properties	Description
Capacity	Gets or sets the total number of elements the internal data structure can hold without resizing.
Count	Gets the number of elements contained in the List<T>.
Item[Int32]	Gets or sets the element at the specified index.

Example: This example, demonstrates the list capacity and count.

// C# Program to demonstrates the  // properties how count and capacity work using System; using System.Collections.Generic;  class Geeks {      public static void Main(String[] args)     {         // Creating a List of integers         List<int> l = new List<int>();          // Adding elements to the List one by one         l.Add(1);         l.Add(2);         l.Add(3);         l.Add(4);         l.Add(5);         l.Add(6);          // Printing the Capacity and Count of l         Console.WriteLine("Capacity: " + l.Capacity);         Console.WriteLine("Count: " + l.Count);     } }

Output

Capacity: 8 Count: 6

Methods

Method	Description
Add(T)	Adds an object to the end of the List<T>.
AddRange(IEnumerable<T>)	Adds the elements of the specified collection to the end of the List<T>.
AsReadOnly()	Returns a read-only ReadOnlyCollection<T> wrapper for the current collection.
BinarySearch()	Uses a binary search algorithm to locate a specific element in the sorted List<T> or a portion of it.
Clear()	Removes all elements from the List<T>.
Contains(T)	Determines whether an element is in the List<T>.
ConvertAll(Converter)	Converts the elements in the current List<T> to another type, and returns a list containing the converted elements.
CopyTo()	Copies the List<T> or a portion of it to an array.
Equals(Object)	Determines whether the specified object is equal to the current object.
Exists(Predicate<T>)	Determines whether the List<T> contains elements that match the conditions defined by the specified predicate.
Find(Predicate<T>)	Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire List<T>.
FindAll(Predicate<T>)	Retrieves all the elements that match the conditions defined by the specified predicate.
FindIndex()	Searches for an element that matches the conditions defined by a specified predicate, and returns the zero-based index of the first occurrence within the List<T> or a portion of it. This method returns -1 if an item that matches the conditions is not found.
FindLast(Predicate<T>)	Searches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire List<T>.
FindLastIndex()	Searches for an element that matches the conditions defined by a specified predicate, and returns the zero-based index of the last occurrence within the List<T> or a portion of it.
ForEach(Action<T>)	Performs the specified action on each element of the List<T>.
GetEnumerator()	Returns an enumerator that iterates through the List<T>.
GetHashCode()	Serves as the default hash function.
GetRange(Int32, Int32)	Creates a shallow copy of a range of elements in the source List<T>.
GetType()	Gets the Type of the current instance.
IndexOf()	Returns the zero-based index of the first occurrence of a value in the List<T> or in a portion of it.
Insert(Int32, T)	Inserts an element into the List<T> at the specified index.
InsertRange(Int32, IEnumerable<T>)	Inserts the elements of a collection into the List<T> at the specified index.
LastIndexOf()	Returns the zero-based index of the last occurrence of a value in the List<T> or in a portion of it.
MemberwiseClone()	Creates a shallow copy of the current Object.
Remove(T)	Removes the first occurrence of a specific object from the List<T>.
RemoveAll(Predicate<T>)	Removes all the elements that match the conditions defined by the specified predicate.
RemoveAt(Int32)	Removes the element at the specified index of the List<T>.
RemoveRange(Int32, Int32)	Removes a range of elements from the List<T>.
Reverse()	Reverses the order of the elements in the List<T> or a portion of it.
Sort()	Sorts the elements or a portion of the elements in the List<T> using either the specified or default IComparer<T> implementation or a provided Comparison<T> delegate to compare list elements.
ToArray()	Copies the elements of the List<T> to a new array.
ToString()	Returns a string that represents the current object.
TrimExcess()	Sets the capacity to the actual number of elements in the List<T>, if that number is less than a threshold value.
TrueForAll(Predicate<T>)	Determines whether every element in the List<T> matches the conditions defined by the specified predicate.

Example 1: This example demonstrates how to check if a specified element is present in the list using Contains().

// C# Program to check whether the // element is present in the List or not using System; using System.Collections.Generic;  class Geeks {      // Main Method     public static void Main(String[] args)     {          // Creating an List<T> of Integers         List<int> l = new List<int>();          // Adding elements to List         l.Add(1);         l.Add(2);         l.Add(3);          // Checking whether 2 is present         // in List or not         Console.Write("Element 2 is presnt in the List?: " + l.Contains(2));     } }

Output

Element 2 is presnt in the List?: True

Example 2: This example printing the list before and after removing elements at specified index.

// C# Program to remove the element at // the specified index of the List<T> using System; using System.Collections.Generic;  class Geeks {          public static void Main(String[] args)     {         // Creating a new List and          // adding elements to it         List<int> l = new List<int>();         l.Add(17);         l.Add(19);         l.Add(21);         l.Add(9);         l.Add(75);         l.Add(19);         l.Add(73);          // Printing the initial list         Console.WriteLine("Initial List: "                            + string.Join(", ", l));          // Removing elements from the list         l.RemoveAt(3);          l.Remove(19);            // Printing the updated list         Console.WriteLine("Updated List: "                            + string.Join(", ", l));     } }

Output

Initial List: 17, 19, 21, 9, 75, 19, 73 Updated List: 17, 21, 75, 19, 73

C# LinkedList Class

Kirti_Mangal

Improve

Article Tags :

C# List Class

Declaration of List

Constructors

Properties

Methods

Similar Reads