C# List

The `List<T>` class in C# is a part of the `System.Collections.Generic` namespace and represents a strongly typed list of objects that can be accessed by index. It provides methods to search, sort, and manipulate lists efficiently. Understanding `List<T>` is fundamental for effective data management in C# applications.

Table of Contents

1. Introduction to List<T>
- What is List<T>?
- Benefits of Using List<T>

2. Declaring and Initializing List<T>
- Declaration Syntax
- Initialization Methods
- Collection Initializers

3. Adding and Removing Elements
- Adding Elements
- Removing Elements
- Clearing the List

4. Accessing Elements
- By Index
- Using LINQ
- Range Operations

5. Iterating Through List<T>
- Using foreach Loop
- Using for Loop
- Using LINQ Queries

6. Searching and Sorting
- Searching Elements
- Sorting the List
- Custom Sorting with Comparer

7. Capacity and Performance
- Understanding Capacity vs. Count
- Managing Capacity
- Performance Considerations

8. Common Methods and Properties
- Key Methods
- Important Properties
- Useful Events

9. Best Practices
10. Common Mistakes with List<T>
11. Advanced Topics
- List<T> with Custom Objects
- Using LINQ with List<T>
- Thread Safety

12. Real-World Example
13. Summary

1. Introduction to List<T>

What is List<T>?

using System.Collections.Generic;

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

Benefits of Using List<T>

2. Declaring and Initializing List<T>

2.1 Declaration Syntax

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int>();
    }
}

2.2 Initialization Methods

List<string> fruits = new List<string>();

List<string> fruits = new List<string>(100);

2.3 Collection Initializers

List<string> fruits = new List<string> { "Apple", "Banana", "Cherry" };

3. Adding and Removing Elements

3.1 Adding Elements

List<string> fruits = new List<string>();
fruits.Add("Apple");
fruits.Add("Banana");

List<string> moreFruits = new List<string> { "Cherry", "Date" };
fruits.AddRange(moreFruits);

fruits.Insert(1, "Blueberry"); // Inserts "Blueberry" at index 1

3.2 Removing Elements

fruits.Remove("Banana"); // Removes "Banana"

fruits.RemoveAt(0); // Removes the first element

fruits.RemoveAll(f => f.StartsWith("B")); // Removes all fruits starting with 'B'

3.3 Clearing the List

fruits.Clear();

4. Accessing Elements

4.1 By Index

List<string> fruits = new List<string> { "Apple", "Banana", "Cherry" };
string firstFruit = fruits[0]; // "Apple"
string secondFruit = fruits[1]; // "Banana"

// Updating an element
fruits[2] = "Date"; // Replaces "Cherry" with "Date"

4.2 Using LINQ

using System.Linq;

var banana = fruits.FirstOrDefault(f => f == "Banana");

4.3 Range Operations

List<string> selectedFruits = fruits.GetRange(0, 2); // Gets first two elements

5. Iterating Through List<T>

5.1 Using foreach Loop

foreach(string fruit in fruits)
{
    Console.WriteLine(fruit);
}

5.2 Using for Loop

for(int i = 0; i < fruits.Count; i++)
{
    Console.WriteLine($"Fruit at index {i}: {fruits[i]}");
}

5.3 Using LINQ Queries

var longNamedFruits = fruits.Where(f => f.Length > 5);

foreach(var fruit in longNamedFruits)
{
    Console.WriteLine(fruit);
}

6. Searching and Sorting

6.1 Searching Elements

bool hasApple = fruits.Contains("Apple"); // true or false

int index = fruits.IndexOf("Banana"); // Returns the index or -1 if not found

string foundFruit = fruits.Find(f => f.StartsWith("C")); // Finds first fruit starting with 'C'

6.2 Sorting the List

fruits.Sort();

fruits.Sort((a, b) => b.CompareTo(a)); // Sorts in descending order

public class LengthComparer : IComparer<string>
{
    public int Compare(string x, string y)
    {
        return x.Length.CompareTo(y.Length);
    }
}

// Usage
fruits.Sort(new LengthComparer());

6.3 Sorting with LINQ

var sortedFruits = fruits.OrderBy(f => f);

foreach(var fruit in sortedFruits)
{
    Console.WriteLine(fruit);
}

7. Capacity and Performance

7.1 Understanding Capacity vs. Count

List<int> numbers = new List<int>();
Console.WriteLine($"Initial Capacity: {numbers.Capacity}"); // Typically 0

numbers.Add(1);
Console.WriteLine($"Capacity after adding one element: {numbers.Capacity}"); // Often 4

numbers.Add(2);
numbers.Add(3);
numbers.Add(4);
numbers.Add(5);
Console.WriteLine($"Capacity after adding five elements: {numbers.Capacity}"); // Often 8

7.2 Managing Capacity

numbers.EnsureCapacity(1000);

numbers.TrimExcess();

7.3 Performance Considerations

8. Common Methods and Properties

8.1 Key Methods

8.2 Important Properties

8.3 Useful Events

9. Best Practices

9.1 Prefer Generic Over Non-Generic Collections

9.2 Initialize with Appropriate Capacity

List<int> numbers = new List<int>(1000);

9.3 Use ReadOnly Collections When Necessary

ReadOnlyCollection<int> readOnlyNumbers = numbers.AsReadOnly();

9.4 Utilize LINQ for Complex Queries

var highScores = scores.Where(s => s > 90).OrderByDescending(s => s);

9.5 Minimize Capacity Overhead

numbers.TrimExcess();

9.6 Use Appropriate Iteration Methods

9.7 Handle Exceptions Gracefully

if(index >= 0 && index < list.Count)
{
    var item = list[index];
}
else
{
    // Handle invalid index
}

10. Common Mistakes with List<T>

10.1 Not Specifying the Type Parameter

List list = new List(); // Compilation Error

List<int> list = new List<int>();

10.2 Exceeding List Capacity Without Proper Initialization

List<int> numbers = new List<int>();
for(int i = 0; i < 10000; i++)
{
    numbers.Add(i);
}

List<int> numbers = new List<int>(10000);

10.3 Modifying the List During Iteration

foreach(var item in list)
{
    if(item == target)
    {
        list.Remove(item); // InvalidOperationException
    }
}

for(int i = list.Count - 1; i >= 0; i--)
{
    if(list[i] == target)
    {
        list.RemoveAt(i);
    }
}

10.4 Ignoring Null Values in Reference Types

List<string> names = new List<string> { "Alice", null, "Bob" };

foreach(var name in names)
{
    Console.WriteLine(name.ToUpper()); // Throws exception for null
}

foreach(var name in names)
{
    if(name != null)
    {
        Console.WriteLine(name.ToUpper());
    }
    else
    {
        Console.WriteLine("Null name encountered.");
    }
}

10.5 Misusing Sort Methods

List<int> numbers = new List<int> { 3, 1, 2 };
var sortedNumbers = numbers.Sort(); // Compilation Error: Sort() returns void

numbers.Sort();

11. Advanced Topics

11.1 List<T> with Custom Objects

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<Person> people = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 }
        };

        // Display all people
        foreach(var person in people)
        {
            Console.WriteLine(person);
        }

        // Sort by Age
        people.Sort();
        Console.WriteLine("\nAfter Sorting by Age:");
        foreach(var person in people)
        {
            Console.WriteLine(person);
        }
    }
}

public class Person : IComparable<Person>
{
    public string Name { get; set; }
    public int Age { get; set; }

    public int CompareTo(Person other)
    {
        if(other == null) return 1;
        return this.Age.CompareTo(other.Age);
    }

    public override string ToString()
    {
        return $"{Name}, Age: {Age}";
    }
}

Sample Output:
Alice, Age: 30
Bob, Age: 25
Charlie, Age: 35
After Sorting by Age:
Bob, Age: 25
Alice, Age: 30
Charlie, Age: 35

11.2 Using LINQ with List<T>

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

        var evenNumbers = numbers.Where(n => n % 2 == 0).Select(n => n * 10);

        Console.WriteLine("Even Numbers Multiplied by 10:");
        foreach(var num in evenNumbers)
        {
            Console.WriteLine(num);
        }
    }
}

Sample Output:
Even Numbers Multiplied by 10:
20
40

11.3 Thread Safety

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

class Program
{
    static List<int> numbers = new List<int>();
    static object lockObj = new object();

    static void Main()
    {
        Parallel.For(0, 1000, i =>
        {
            lock(lockObj)
            {
                numbers.Add(i);
            }
        });

        Console.WriteLine($"Total Numbers Added: {numbers.Count}"); // Output: 1000
    }
}

12. Real-World Example

Example: Task Management System Using List<T>

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        TaskManager taskManager = new TaskManager();

        // Adding tasks
        taskManager.AddTask(new TaskItem { Id = 1, Description = "Complete project report", IsCompleted = false });
        taskManager.AddTask(new TaskItem { Id = 2, Description = "Review pull requests", IsCompleted = false });
        taskManager.AddTask(new TaskItem { Id = 3, Description = "Plan team meeting", IsCompleted = false });

        // Display all tasks
        Console.WriteLine("All Tasks:");
        taskManager.DisplayAllTasks();

        // Complete a task
        taskManager.CompleteTask(2);

        // Display completed tasks
        Console.WriteLine("\nCompleted Tasks:");
        taskManager.DisplayCompletedTasks();

        // Display pending tasks
        Console.WriteLine("\nPending Tasks:");
        taskManager.DisplayPendingTasks();

        // Remove a task
        taskManager.RemoveTask(1);

        // Display all tasks after removal
        Console.WriteLine("\nAll Tasks After Removal:");
        taskManager.DisplayAllTasks();
    }
}

public class TaskItem
{
    public int Id { get; set; }
    public string Description { get; set; }
    public bool IsCompleted { get; set; }

    public override string ToString()
    {
        return $"ID: {Id}, Description: {Description}, Completed: {IsCompleted}";
    }
}

public class TaskManager
{
    private List<TaskItem> tasks = new List<TaskItem>();

    public void AddTask(TaskItem task)
    {
        if(tasks.Any(t => t.Id == task.Id))
        {
            Console.WriteLine($"Task with ID {task.Id} already exists.");
            return;
        }
        tasks.Add(task);
        Console.WriteLine($"Added Task: {task.Description}");
    }

    public void CompleteTask(int id)
    {
        TaskItem task = tasks.FirstOrDefault(t => t.Id == id);
        if(task != null)
        {
            task.IsCompleted = true;
            Console.WriteLine($"Completed Task: {task.Description}");
        }
        else
        {
            Console.WriteLine($"Task with ID {id} not found.");
        }
    }

    public void RemoveTask(int id)
    {
        TaskItem task = tasks.FirstOrDefault(t => t.Id == id);
        if(task != null)
        {
            tasks.Remove(task);
            Console.WriteLine($"Removed Task: {task.Description}");
        }
        else
        {
            Console.WriteLine($"Task with ID {id} not found.");
        }
    }

    public void DisplayAllTasks()
    {
        foreach(var task in tasks)
        {
            Console.WriteLine(task);
        }
    }

    public void DisplayCompletedTasks()
    {
        var completedTasks = tasks.Where(t => t.IsCompleted);
        foreach(var task in completedTasks)
        {
            Console.WriteLine(task);
        }
    }

    public void DisplayPendingTasks()
    {
        var pendingTasks = tasks.Where(t => !t.IsCompleted);
        foreach(var task in pendingTasks)
        {
            Console.WriteLine(task);
        }
    }
}

Sample Output:
Added Task: Complete project report
Added Task: Review pull requests
Added Task: Plan team meeting
All Tasks:
ID: 1, Description: Complete project report, Completed: False
ID: 2, Description: Review pull requests, Completed: False
ID: 3, Description: Plan team meeting, Completed: False
Completed Task: Review pull requests
Completed Tasks:
ID: 2, Description: Review pull requests, Completed: True
Pending Tasks:
ID: 1, Description: Complete project report, Completed: False
ID: 3, Description: Plan team meeting, Completed: False
Removed Task: Complete project report
All Tasks After Removal:
ID: 2, Description: Review pull requests, Completed: True
ID: 3, Description: Plan team meeting, Completed: False

13. Summary