Generics 📦

One Size Fits All - But Safely!

Beginner Friendly 25 min read Lesson 10 of 11

Hey There! Ready to Learn Generics? 📦

Generics sounds fancy, but it's actually super simple! It lets you write code that works with any type of data, while keeping everything safe and organized.

Quick Question: Have you ever used a container?

📦 A box can hold books, toys, or clothes
📦 The box is the same - what's inside changes
📦 That's exactly what Generics do!

🎯 After this lesson, you'll be able to:

✅ Explain generics like a pro (but in simple words)
✅ Create generic classes (reusable containers)
✅ Use generic methods (flexible functions)
✅ Add constraints (rules for what types can be used)
✅ Master generic collections (List, Dictionary)

Part 1: What are Generics? (The Easy Way)

In Simple Words: Generics let you write code that works with any type of data, but still keeps everything type-safe (no mistakes!).

📦 The Box Analogy

Think of a generic class as a box:

📦 The box is the same shape (the class)
📦 You can put books in it (strings)
📦 You can put toys in it (integers)
📦 You can put clothes in it (custom objects)
📦 The box remembers what's inside!

That's Generics: One box, many types!

💻 Code Time!

Generic Class:

// 📦 A Box that can hold ANY type
public class Box<T>  // T = Type placeholder
{
    private T item;  // Can be any type!
    
    public void Store(T value) => item = value;
    public T Retrieve() => item;
}

Using the Box:

// Box for numbers
Box<int> intBox = new Box<int>();
intBox.Store(42);
int value = intBox.Retrieve();  // Safe! No casting!

// Box for text
Box<string> strBox = new Box<string>();
strBox.Store("Hello!");

🎉 Same class, different types!

😂 Fun Joke: Why did the generic class break up with the specific type? Because it wanted to see other types! (Okay, I'll stop 😅)

Part 2: Generic Classes - The Reusable Container

A generic class uses a placeholder type (like T) that you fill in later.

📝 Generic Class Example

// 📦 A generic storage class
public class Storage<T>
{
    private List<T> items = new List<T>();
    
    public void Add(T item) => items.Add(item);
    public T Get(int index) => items[index];
    public int Count => items.Count;
}

🎯 Using It

// Storage for numbers
Storage<int> numStore = new Storage<int>();
numStore.Add(5);
numStore.Add(10);

// Storage for names
Storage<string> nameStore = new Storage<string>();
nameStore.Add("Alice");
nameStore.Add("Bob");

✅ One class, many types!

Why Use Generic Classes?

✅ Reusable - Write once, use with any type
✅ Type-Safe - No casting errors
✅ Clean - No messy object code

Part 3: Generic Methods - Flexible Functions

A generic method can work with different types, even if the class isn't generic!

📝 Generic Method

public class Helper
{
    // 🔄 Swaps any two values
    public void Swap<T>(ref T a, ref T b)
    {
        T temp = a;
        a = b;
        b = temp;
    }
    
    // 📏 Returns the bigger of two
    public T Max<T>(T a, T b) where T : IComparable<T>
    {
        return a.CompareTo(b) > 0 ? a : b;
    }
}

🎯 Using It

Helper helper = new Helper();

// Swap integers
int x = 5, y = 10;
helper.Swap(ref x, ref y);
// x=10, y=5

// Swap strings
string a = "Hello", b = "World";
helper.Swap(ref a, ref b);

// Get max
int max = helper.Max(5, 10);  // 10

✅ Same method, different types!

Remember: The <T> after the method name tells C# "This method uses generics!"

Part 4: Generic Constraints - Setting Rules

What are Constraints? They're rules about what types can be used with your generic!

📝 Constraints Examples

// 🚫 T must be a class (reference type)
public class Processor<T> where T : class
{
    public T Process(T item) => item;
}

// ✅ T must have a default constructor
public class Creator<T> where T : new()
{
    public T Create() => new T();
}

// 📊 T must be comparable
public T Max<T>(T a, T b) where T : IComparable<T>
{
    return a.CompareTo(b) > 0 ? a : b;
}

✅ Why Constraints?

✅ Safety - Only valid types can be used
✅ Features - Access methods like CompareTo()
✅ Clarity - Other developers know what's allowed

Common Constraints:

where T : class - T must be a class
where T : struct - T must be a struct
where T : new() - T must have a default constructor
where T : SomeClass - T must inherit from SomeClass

Part 5: Generic Collections - The Most Common Generics

C# has built-in generic collections that you'll use every day!

📝 List<T> - A Flexible List

List<string> names = new List<string>();
names.Add("Alice");
names.Add("Bob");
string first = names[0];

List Like an array that can grow and shrink

📝 Dictionary<TKey, TValue>

Dictionary<string, int> ages = new Dictionary<string, int>();
ages.Add("Alice", 25);
ages.Add("Bob", 30);
int age = ages["Alice"];  // 25

Dictionary Key-Value pairs (like a real dictionary)

Other Useful Collections

// 🚶 Queue - First In, First Out
Queue<string> line = new Queue<string>();
line.Enqueue("Person1");
line.Enqueue("Person2");
string next = line.Dequeue();  // "Person1"

// 📚 Stack - Last In, First Out
Stack<string> stack = new Stack<string>();
stack.Push("First");
stack.Push("Second");
string last = stack.Pop();  // "Second"

✅ Benefits of Generic Collections

✅ Type-Safe - No casting needed
✅ Fast - No boxing/unboxing
✅ Clean - Easy to read and use
✅ Powerful - Built-in methods (Sort, Find, etc.)

Pro Tip: Always use generic collections instead of non-generic ones like ArrayList!

Part 6: Real-World Example - Online Store 🛒

Let's build an Online Store with generics!

// 🛒 Generic Shopping Cart
public class ShoppingCart<T>  // T = Product type
{
    private List<T> items = new List<T>();
    private static int cartCount = 0;
    
    public ShoppingCart() => cartCount++;
    
    public void Add(T item) => items.Add(item);
    public void Remove(T item) => items.Remove(item);
    public int Count => items.Count;
    public static int TotalCarts => cartCount;
    
    public void Display()
    {
        Console.WriteLine($"📦 Cart has {Count} items:");
        foreach (var item in items)
        {
            Console.WriteLine($"   • {item}");
        }
    }
}

// 🎮 Product classes
public class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
    public override string ToString() => $"{Name} (${Price})";
}

public class DigitalProduct : Product
{
    public string DownloadLink { get; set; }
    public override string ToString() => 
        $"{Name} (Digital, ${Price})";
}

// Program.cs - Shopping System
class Program
{
    static void Main()
    {
        Console.WriteLine("🛒 ONLINE STORE\n");
        
        // 📦 Create products
        Product laptop = new Product 
        { 
            Name = "Gaming Laptop", 
            Price = 999.99m 
        };
        
        DigitalProduct ebook = new DigitalProduct
        {
            Name = "C# Guide",
            Price = 29.99m,
            DownloadLink = "https://example.com/book"
        };
        
        // 🛒 Generic shopping carts
        ShoppingCart<Product> cart1 = new ShoppingCart<Product>();
        cart1.Add(laptop);
        cart1.Add(ebook);
        
        ShoppingCart<string> wishlist = new ShoppingCart<string>();
        wishlist.Add("New Headphones");
        wishlist.Add("Wireless Charger");
        
        // 📊 Display
        Console.WriteLine("📦 PRODUCT CART:");
        cart1.Display();
        
        Console.WriteLine("\n💭 WISHLIST:");
        wishlist.Display();
        
        Console.WriteLine($"\n📊 Total Carts: {ShoppingCart<Product>.TotalCarts}");
    }
}

🎉 What this shows:

✅ Generic Class - ShoppingCart works with any type
✅ Type Safety - Product cart vs String wishlist
✅ Static Members - TotalCarts tracks all carts
✅ Inheritance - DigitalProduct inherits from Product

😂 Shopping Joke: Why did the generic shopping cart break up with the specific product? Because it couldn't handle the type of commitment! (Okay, that was a stretch 😅)

Part 7: Let's Practice! 🎮

What You're Building: A Cache System for storing any type of data!
Like a temporary storage that can hold anything.

🗄️ About This Application

This is a Cache System used in:

🌐 Web Browsers - Store web pages
📱 Apps - Store user preferences
💾 Databases - Store query results

You'll create a generic cache that can store any type of data:

✅ Store numbers, text, or objects
✅ Check if data is cached
✅ Remove data when needed
✅ Count how many items are cached

Your Mission:

Generic Class: Cache<T>
- Private field: Dictionary<string, T> (key = cache key)
- Method: Add(string key, T value)
- Method: Get(string key) - returns T
- Method: Remove(string key) - returns bool
- Method: Clear() - removes all
- Property: Count - returns number of items
- Property: Contains(string key) - returns bool
Program.cs:
- Create Cache<int>, Cache<string>, Cache<Product>
- Add data to each
- Retrieve and display data
- Show cache statistics

💡 What You're Learning:

✅ Generic Class - Cache works with ANY type
✅ Type Safety - No casting needed
✅ Dictionary - Store by key
✅ Reusable - One class, many uses

Result: A powerful cache system that stores ANY type of data!

// ===== CACHE SYSTEM =====
// A generic cache that can store ANY type

public class Cache<T>
{
    private Dictionary<string, T> data = new Dictionary<string, T>();
    private static int cacheCount = 0;
    
    public Cache() => cacheCount++;
    
    // Add or update
    public void Add(string key, T value)
    {
        data[key] = value;
        Console.WriteLine($"✅ Added: {key} → {value}");
    }
    
    // Get value by key
    public T Get(string key)
    {
        if (data.ContainsKey(key))
        {
            Console.WriteLine($"📤 Retrieved: {key} → {data[key]}");
            return data[key];
        }
        Console.WriteLine($"❌ Key '{key}' not found");
        return default(T);
    }
    
    // Remove by key
    public bool Remove(string key)
    {
        if (data.Remove(key))
        {
            Console.WriteLine($"🗑️ Removed: {key}");
            return true;
        }
        Console.WriteLine($"❌ Key '{key}' not found");
        return false;
    }
    
    // Clear all data
    public void Clear()
    {
        data.Clear();
        Console.WriteLine("🧹 Cache cleared");
    }
    
    // Properties
    public int Count => data.Count;
    public bool Contains(string key) => data.ContainsKey(key);
    public static int TotalCaches => cacheCount;
    
    public void DisplayAll()
    {
        Console.WriteLine($"📋 Cache has {Count} items:");
        foreach (var kvp in data)
        {
            Console.WriteLine($"   • {kvp.Key}: {kvp.Value}");
        }
    }
}

// Simple Product class for testing
public class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
    public override string ToString() => $"{Name} (${Price})";
}

// Program.cs - Testing the Cache
class Program
{
    static void Main()
    {
        Console.WriteLine("🗄️ CACHE SYSTEM\n");
        
        // 📦 Cache for numbers
        Cache<int> numCache = new Cache<int>();
        numCache.Add("age", 25);
        numCache.Add("score", 100);
        
        // 📦 Cache for text
        Cache<string> textCache = new Cache<string>();
        textCache.Add("name", "Alice");
        textCache.Add("city", "New York");
        
        // 📦 Cache for products
        Cache<Product> productCache = new Cache<Product>();
        productCache.Add("laptop", new Product { Name = "Gaming Laptop", Price = 999.99m });
        
        Console.WriteLine();
        
        // 🔍 Retrieve data
        int age = numCache.Get("age");
        string name = textCache.Get("name");
        Product laptop = productCache.Get("laptop");
        
        Console.WriteLine();
        
        // 📊 Display all caches
        Console.WriteLine("📊 CACHE STATISTICS:");
        Console.WriteLine($"Total Caches: {Cache<int>.TotalCaches}");
        
        Console.WriteLine("\n🔢 Number Cache:");
        numCache.DisplayAll();
        
        Console.WriteLine("\n📝 Text Cache:");
        textCache.DisplayAll();
        
        Console.WriteLine("\n📦 Product Cache:");
        productCache.DisplayAll();
        
        // 🗑️ Remove and check
        Console.WriteLine("\n🗑️ Removing 'score':");
        numCache.Remove("score");
        Console.WriteLine($"Contains 'score'? {numCache.Contains("score")}");
    }
}

✅ Complete Solution! You've built a real cache system using generics!

🎉 What You Learned Today!

Generics

Work with any type

Generic Classes

Reusable containers

Generic Methods

Flexible functions

Constraints

Rules for types

Generic Collections

List, Dictionary

Real Example

Online Store! 🛒

Cache System

Store anything!

Previous Lesson Next Lesson

Test Your Knowledge - Take Quiz

Generics 📦

Hey There! Ready to Learn Generics? 📦

Part 1: What are Generics? (The Easy Way)

📦 The Box Analogy

💻 Code Time!

Part 2: Generic Classes - The Reusable Container

📝 Generic Class Example

🎯 Using It

Part 3: Generic Methods - Flexible Functions

📝 Generic Method

🎯 Using It

Part 4: Generic Constraints - Setting Rules

📝 Constraints Examples

✅ Why Constraints?

Part 5: Generic Collections - The Most Common Generics

📝 List<T> - A Flexible List

📝 Dictionary<TKey, TValue>

Other Useful Collections

✅ Benefits of Generic Collections

Part 6: Real-World Example - Online Store 🛒

Part 7: Let's Practice! 🎮

🗄️ About This Application

Your Mission:

💡 What You're Learning:

🎉 What You Learned Today!

Generics

Generic Classes

Generic Methods

Constraints

Generic Collections

Real Example

Cache System

Lessons