Generics and Collections in C#

# CHAPTER 20

Generics and Collections #

1. Introduction #

2. Learning Objectives #

• Understand the concept of Generics (<T>).

• Write your own Generic Methods and Classes.

• Use Dictionary<TKey, TValue> for key-value pairs.

• Use Queue<T> (First-In, First-Out).

• Use Stack<T> (Last-In, First-Out).

3. Generic Methods #

using System;

class Program
{
    // <T> acts as a placeholder for the data type
    static void Swap<T>(ref T a, ref T b)
    {
        T temp = a;
        a = b;
        b = temp;
    }

    static void Main()
    {
        int x = 5, y = 10;
        Swap<int>(ref x, ref y); // Passing integers

        string s1 = "Hello", s2 = "World";
        Swap<string>(ref s1, ref s2); // Passing strings!
        
        Console.WriteLine($"{s1} {s2}"); // Prints "World Hello"
    }
}

4. Generic Classes #

class Box<T>
{
    private T _content;

    public void AddContent(T item)
    {
        _content = item;
    }

    public T GetContent()
    {
        return _content;
    }
}

class Program
{
    static void Main()
    {
        // A box that holds an int
        Box<int> intBox = new Box<int>();
        intBox.AddContent(123);

        // A box that holds a string
        Box<string> stringBox = new Box<string>();
        stringBox.AddContent("Secret Document");
    }
}

5. Advanced Collections: Dictionary<TKey, TValue> #

using System.Collections.Generic;

Dictionary<string, int> ages = new Dictionary<string, int>();

// Adding Key-Value pairs
ages.Add("Alice", 25);
ages.Add("Bob", 30);

// Looking up a value by its Key (Very Fast!)
Console.WriteLine($"Bob is {ages["Bob"]} years old.");

// Iterating through a Dictionary
foreach (KeyValuePair<string, int> pair in ages)
{
    Console.WriteLine($"{pair.Key} : {pair.Value}");
}

6. Advanced Collections: Queue<T> #

Queue<string> line = new Queue<string>();

line.Enqueue("Alice"); // Joins the line
line.Enqueue("Bob");

string served = line.Dequeue(); // Removes and returns the first person ("Alice")

7. Advanced Collections: Stack<T> #

Stack<string> browserHistory = new Stack<string>();

browserHistory.Push("google.com");
browserHistory.Push("github.com");

// Removes and returns the top item ("github.com")
string lastVisited = browserHistory.Pop(); 

8. Common Mistakes #

• Accessing a missing Dictionary key: If you ask for ages["Charlie"] but "Charlie" isn't in the dictionary, the program will crash. Always check first using if (ages.ContainsKey("Charlie")).

• Using non-generic collections: Avoid ArrayList and Hashtable. Always use their modern generic equivalents: List<T> and Dictionary<TKey, TValue> to ensure type safety.

9. Best Practices #

• Use constraints to limit generics if necessary. E.g., class MathOperation<T> where T : struct ensures T can only be a value type (like a number), preventing someone from doing math on strings.

10. Exercises #

1. 1. Create a Dictionary<int, string> to map employee IDs (Key) to employee names (Value). Add 3 employees and print one out by looking up their ID.

1. 2. Create a generic class Storage<T> that holds an array of 3 items of type T.

11. MCQs with Answers #

12. Interview Questions #

• Q: What is the difference between List<T> and Dictionary<TKey, TValue>? When would you use one over the other?

• Q: Explain the difference between Queue and Stack. Provide a real-world use case for each in software development (e.g., Undo functionality vs. Task scheduling).

• Q: Why are Generics more performant than using object references (Boxing/Unboxing)?

13. Summary #

14. Next Chapter Recommendation #