Class List<T>

Represents a strongly typed list of objects that can be accessed by index. Provides methods for manipulating the list.

Summary

The List<T> generic collection is the programmatic representation of a dynamic array. It can hold objects of any type, from any non-private code. The size of the List<T> is automatically increased as elements are added.

Each item in the list is an object. You can access any member of the item programmatically as long as you specify the correct index of the item.

The List<T> class provides performance that is similar to the ArrayList class. It is generally recommended to use the List<T> generic collection when programming in C# because it provides better performance and type safety.

Syntax

                
                    public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable
                
            

Type Parameters

• T: The type of elements in the list. This type parameter is covariant.

Constructors

• List()

  Initializes a new instance of the List<T> class that is empty, has the default initial capacity, and uses the default equality comparer for the type of elements that will be stored in the list.

• List(Int32 capacity)

  Initializes a new instance of the List<T> class that is empty, has the specified initial capacity, and uses the default equality comparer for the type of elements that will be stored in the list.

• List(IEnumerable<T> collection)

  Initializes a new instance of the List<T> class that contains elements copied from the specified collection and has enough available space to accommodate the number of elements copied.

Properties

• Capacity

  Gets or sets the number of elements that the List<T> can contain.

  public Int32 Capacity { get; set; }

• Count

  Gets the number of elements actually contained in the List<T>.

  public Int32 Count { get; }

• Item[Int32 index]

  Gets or sets the element at the specified index.

  public T Item[Int32 index] { get; set; }

Methods

• Add(T item)

  Adds an object to the end of the List<T>.

  public void Add(T item)

• AddRange(IEnumerable<T> collection)

  Adds the elements of the specified collection to the end of the List<T>.

  public void AddRange(IEnumerable<T> collection)

• AsReadOnly()

  Returns a read-only wrapper around the entire List<T>.

  public ReadOnlyCollection<T> AsReadOnly()

• BinarySearch(T item)

  Searches the entire sorted List<T> for an element using the default comparer and returns the zero-based index of the element.

  public Int32 BinarySearch(T item)

• Clear()

  Removes all elements from the List<T>.

  public void Clear()

• Contains(T item)

  Determines whether an element is in the List<T>.

  public bool Contains(T item)

• Exists(Predicate<T> match)

  Determines whether any element of the current List<T> matches the specified predicate.

  public bool Exists(Predicate<T> match)

• Find(Predicate<T> match)

  Searches for an element that matches the conditions defined by the specified predicate, and returns the first such element that can be found within the entire List<T>.

  public T Find(Predicate<T> match)

• FindAll(Predicate<T> match)

  Implements theсар.

  public List<T> FindAll(Predicate<T> match)

• ForEach(Action<T> action)

  Executes the specified action on each element of the List<T>.

  public void ForEach(Action<T> action)

• GetRange(Int32 index, Int32 count)

  Copies a range of elements from the List<T> to a new list.

  public List<T> GetRange(Int32 index, Int32 count)

• IndexOf(T item)

  Searches for the specified object and returns the zero-based index of the first occurrence within the entire List<T>.

  public Int32 IndexOf(T item)

• Insert(Int32 index, T item)

  Inserts an element into the List<T> at the specified index.

  public void Insert(Int32 index, T item)

• InsertRange(Int32 index, IEnumerable<T> collection)

  Inserts the elements of a collection into the List<T> at the specified index.

  public void InsertRange(Int32 index, IEnumerable<T> collection)

• LastIndexOf(T item)

  Searches for the specified object and returns the zero-based index of the last occurrence within the entire List<T>.

  public Int32 LastIndexOf(T item)

• Remove(T item)

  Removes the first occurrence of a specific object from the List<T>.

  public bool Remove(T item)

• RemoveAll(Predicate<T> match)

  Removes all the elements that match the conditions defined by the specified predicate.

  public Int32 RemoveAll(Predicate<T> match)

• RemoveAt(Int32 index)

  Removes the element at the specified index of the List<T>.

  public void RemoveAt(Int32 index)

• RemoveRange(Int32 index, Int32 count)

  Removes a range of elements from the List<T>.

  public void RemoveRange(Int32 index, Int32 count)

• Reverse()

  Reverses the order of the elements in the entire List<T>.

  public void Reverse()

• Sort()

  Sorts the elements in the entire List<T> using the default comparer.

  public void Sort()

• ToArray()

  Copies the elements of the List<T> to a new array.

  public T[] ToArray()

• TrimExcess()

  Sets the capacity to the actual number of elements in the List<T>, if that number is less than 90 percent of the current capacity.

  public void TrimExcess()

Examples

using System;
using System.Collections.Generic;

List<string> names = new List<string>();
names.Add("Alice");
names.Add("Bob");
names.Add("Charlie");

Console.WriteLine("Elements:");
foreach (string name in names)
{
    Console.WriteLine(name);
}

Console.WriteLine($"Element at index 1: {names[1]}"); // Output: Bob
            

using System;
using System.Collections.Generic;

List<int> numbers = new List<int> { 10, 20, 30, 40, 50 };

numbers.Remove(30); // Removes the first occurrence of 30
numbers.RemoveAt(0); // Removes the element at index 0 (which is 10)

Console.WriteLine("Updated numbers:");
foreach (int num in numbers)
{
    Console.WriteLine(num); // Output: 20, 40, 50
}
            

Remarks

The List<T> class implements the generic IList<T>, ICollection<T>, and IEnumerable<T> interfaces, and also the non-generic IList, ICollection, and IEnumerable interfaces.

If the capacity of the List<T> is insufficient to accommodate the new element, the elements are copied to a new underlying array before the new element is added.

Exceptions