Introduction to List<T>collection in C#

A List in C# is a collection class that implements the IList interface. It allows you to store a collection of elements, which can be of any data type, in a single variable.

The List class is defined in the System.Collections.Generic namespace provides a number of useful methods for adding, removing, and manipulating elements in the list.

C# - List<T>

In the c#, the List<T> is a collection of strongly typed objects that can be accessed by index and having methods for sorting, searching, and modifying the list. It is the generic version of the ArrayList that comes under System.Collections.Generic namespace

List<T> Characteristics

List<T> is a generic collection class in C#, where T specifies the type of elements that the list can hold. Some of the characteristics of List<T> are:

Dynamic size: The size of a List<T> can change dynamically, as elements are added or removed. This makes it flexible and adaptable to changing requirements.
Index-based access: List<T> elements can be accessed using an index, making it easy to retrieve a specific element or to loop through the list.
Built-in methods: List<T> provides several built-in methods for adding, removing, and manipulating elements in the list, such as Add, Remove, Insert, and Clear.
Strong typing: List<T> is a strongly-typed collection, which means that the elements in the list must all be of the same type, specified by the type parameter T. This helps prevent type-related errors in your code.
Sort and search: List<T> supports sorting and searching operations, making it easy to sort and find elements in the list.
Compatibility with other collections: List<T> implements the IList<T> and IEnumerable<T> interfaces, which makes it compatible with other collection classes and with LINQ, a powerful language feature for working with collections.
- Elements can be added using the Add(), and AddRange() methods or collection-initializer syntax.
- Elements can be accessed by passing an index e.g. myList[0]. Indexes start from zero.
- List<T> performs faster and is less error-prone than the ArrayList.
- List<T> equivalent of the ArrayList, which implements IList<T>.
- It comes under System.Collections.Generic namespace.

Note: The characteristics of List<T> make it a convenient and powerful choice for many common use cases, such as storing a list of items, storing a list of objects, and more.

Creating a List

Here's a basic example of how you can use a List in C#:

using System;
using System.Collections.Generic;
namespace ListExample
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> numbers = new List<int>();
            numbers.Add(1);
            numbers.Add(2);
            numbers.Add(3);
            numbers.Add(4);
            numbers.Add(5);
            Console.WriteLine("The list of numbers:");
            foreach (int number in numbers)
            {
                Console.WriteLine(number);
            }
            Console.ReadLine();
        }
    }
}

C# List Sort

C# List<T> provides several methods for sorting the elements in a list, including the following:

Sort(): Sorts the elements in the list in ascending order by default.

List<int> numbers = new List<int> { 5, 4, 1, 3, 2 };
numbers.Sort();
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

Output:

Sort(Comparison<T>): Sorts the elements in the list based on a custom comparison.

List<string> names = new List<string> { "John", "David", "Adam", "Zoe" };
names.Sort((x, y) => x.Length.CompareTo(y.Length));
foreach (string name in names)
{
    Console.WriteLine(name);
}

Output:

Zoe
John
Adam
David

Sort(IComparer<T>): Sorts the elements in the list based on a custom comparer.

List<Person> people = new List<Person>
{
    new Person { Name = "John", Age = 20 },
    new Person { Name = "David", Age = 25 },
    new Person { Name = "Adam", Age = 30 },
    new Person { Name = "Zoe", Age = 18 },
};
people.Sort(new PersonComparer());
foreach (Person person in people)
{
    Console.WriteLine(person.Name + " - " + person.Age);
}

Output:

Zoe - 18
John - 20
David - 25
Adam - 30

Note: The sorting methods provided by the List<T> class allow you to easily sort the elements in a list, based on various criteria, such as ascending or descending order, length, or custom comparisons.

C# List Length

In C#, you can determine the length or count of elements in a List<T> using the Count property. This property returns an integer value that represents the number of elements in the list.

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
int count = numbers.Count;
Console.WriteLine("The number of elements in the list is: " + count);

output

The number of elements in the list is: 5

Note: You can use the Count property to determine the number of elements in a list and use that information in various operations, such as looping through the list or checking if the list is empty.

Adding an Array in a List

UIn C#, you can add an array of elements to a List<T> using the AddRange method. This method takes an IEnumerable<T> as an argument, which includes arrays.

int[] numbersArray = new int[] { 6, 7, 8, 9, 10 };
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
numbers.AddRange(numbersArray);
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

Output

C# List Remove

In C#, you can remove elements from a List<T> using several methods, including the following:

Remove(T): Removes the first occurrence of a specific element from the list.

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
numbers.Remove(3);
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

Output:

RemoveAll(Predicate<T>): Removes all elements that match a certain condition.

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
numbers.RemoveAll(x => x % 2 == 0);
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

Output:

1
3
5

RemoveAt(int): Removes the element at a specific index.

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
numbers.RemoveAt(2);
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

Output:

Note: The Remove methods allow you to remove elements from a List<T> based on different criteria, such as the value of an element, a condition, or the index of an element. Keep in mind that removing elements from a list can cause the list to change its size and affect its indexing.

Accessing a List

In C#, you can access elements in a List<T> using an indexer, just like an array. The indexer allows you to retrieve or set the value of an element at a specific index. The index of the first element in a List<T> is 0, and the index of the last element is Count - 1.

Here's an example of retrieving an element from a List<T>:

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
int thirdElement = numbers[2];
Console.WriteLine("The third element is: " + thirdElement);

Output:

The third element is: 3

Here's an example of setting an element in a List<T>:

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
numbers[2] = 100;
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

Output:

Note: When accessing elements in a List<T> using an indexer, it's important to make sure the index is within the bounds of the list. If you try to access an index that is outside the bounds, an IndexOutOfRangeException will be thrown. You can use the Count property to check the number of elements in the list before accessing elements using an indexer.

List initialization

In C#, you can initialize a List<T> in several ways:

Using a Collection Initializer:

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

Output:

Using the Add Method:

List<int> numbers = new List<int>();
numbers.Add(1);
numbers.Add(2);
numbers.Add(3);
numbers.Add(4);
numbers.Add(5);
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

Output:

Using an Array:

int[] numbersArray = new int[] { 1, 2, 3, 4, 5 };
List<int> numbers = new List<int>(numbersArray);
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

Output:

Note: The first method, using a collection initializer, is the most concise and readable way to initialize a List<T>. However, the other methods can be useful in different situations, such as when you need to add elements to the list incrementally or when you want to create a list based on an existing array.