List Class in C#

Last Updated : 12 Sep, 2025

The List<T> class in C# (in the System.Collections.Generic namespace) represents a strongly typed collection of objects that can be accessed by index and resized dynamically.

Example: Creating a list of integers

List<int> numbers = new List<int> { 5, 2, 9 };

Key Features of List<T> in C#

Unlike arrays, List<T> can grow or shrink dynamically as elements are added or removed.
Allows duplicate elements and accepts null values for reference types.
Provides built-in methods to add, remove, search, sort and manipulate elements.
Not sorted by default, elements are accessed using a zero-based index.
Capacity grows automatically when needed by reallocating the internal array.
Generic equivalent of ArrayList, implementing IList<T> for type safety.

Declaration of List

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

Example: Creating a list, adding elements to it and then displaying the elements using the for-each loop.

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

Constructors

Constructors	Description
List<T>()	Initializes an empty list with the default initial capacity.
List<T>(IEnumerable<T>)	Initializes a list with elements copied from the specified collection, with capacity set to fit them.
List<T>(Int32)	Initializes an empty list with the specified initial capacity.

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

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 of List Class

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.

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 elements of a collection to the end of the list.
AsReadOnly()	Returns a read-only wrapper for the list.
BinarySearch()	Searches for an element using binary search (list must be sorted).
Clear()	Removes all elements from the list.
Contains(T)	Determines whether an element is in the List<T>.
CopyTo()	Copies elements (or a range) to an array.
Exists(Predicate<T>)	Returns true if any element matches the condition.
Find(Predicate<T>)	Returns the first element matching a condition.
FindAll(Predicate<T>)	Returns all elements matching a condition.
FindIndex()	Returns the index of the first matching element.
FindLast(Predicate<T>)	Returns the last element matching a condition.
FindLastIndex()	Returns the index of the last matching element.
ForEach(Action<T>)	Performs the specified action on each element of the List<T>.
GetRange(int, int)	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 index of the first occurrence of a value.
Insert(Int32, T)	Inserts an element into the List<T> at the specified index.
InsertRange(Int32,IEnumerable<>)	Inserts a collection at a specific index.
LastIndexOf()	Returns the index of the last occurrence of a value.
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().

using System;
using System.Collections.Generic;

class Geeks {

    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.

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

Suggested Quiz

4 Questions

Which of the following statements about List<T> in C# is true?

A

List<T> cannot contain duplicate elements
B

List<T> is always sorted by default
C

List<T> allows null values for reference types
D

List<T> has a fixed capacity and cannot grow

Explanation:

List<T> can store duplicate values and null values for reference types. It is not sorted by default, and its capacity grows dynamically when required.

Which constructor creates a list with a specified initial capacity?

A

List<T>()
B

List<T>(IEnumerable<T>)
C

List<T>(Int32)
D

List<T>(Capacity<T>)

Explanation:

This constructor initializes an empty list with the given capacity.

Which of the following statements about List<T> is TRUE?

A

List<T> has a fixed size like an array
B

List<T> cannot store duplicate values
C

List<T> automatically increases capacity when needed
D

List<T> does not allow null values

Explanation:

What does the Capacity property of a List<T> represent?

A

The number of elements currently stored in the list
B

The maximum number of lists that can be created
C

The total number of elements the list can hold before resizing
D

The highest index of the list

Explanation:

Quiz Completed Successfully

Your Score : 2/4

Accuracy : 0%

1/4 1/4 < Previous Next >

Kirti_Mangal

Improve

Article Tags :

List Class in C#

Key Features of List<T> in C#

Declaration of List

Constructors

Properties of List Class

Methods

Explore

Introduction

Fundamentals

Control Statements

OOP Concepts

Methods

Arrays

ArrayList

String

Tuple

Indexers

Thank You!

What kind of Experience do you want to share?