Advanced Class Features

C# Advanced Class Features: Your Superpower Toolkit 🛠️

Imagine you have a magic toolbox. Every time you need a new tool, you can create one from thin air. That’s what Advanced Class Features in C# give you—the power to extend, customize, and supercharge your classes!

The Big Picture

Think of a class as a toy robot. It can walk and talk. But what if you want it to dance? Normally, you’d have to open up the robot and add new parts inside.

But C# gives you magic wands that let you:

• Add new tricks without opening the robot (Extension Methods)
• Let the robot respond when you say a number, like “Robot, give me toy #3!” (Indexers)
• Teach the robot what “+” or “-” means in robot language (Operator Overloading)
• Build the robot in pieces across different rooms (Partial Classes)

Let’s explore each superpower!

1. Extension Methods: Adding Superpowers from the Outside

What Is It?

Imagine your friend has a toy car. You can’t open it, but you have a magic sticker that gives it wings! The car can now fly—without anyone touching its insides.

Extension methods are like magic stickers for classes. You add new abilities to a class from the outside, without changing the original code.

Why Is This Awesome?

• You can add methods to classes you didn’t create (like string or int)
• The original class stays safe and unchanged
• Your new methods look like they were always part of the class!

Simple Example

// The magic sticker factory
public static class StringExtensions
{
    // Add a new power to ALL strings!
    public static string Shout(this string text)
    {
        return text.ToUpper() + "!!!";
    }
}

// Now use it anywhere:
string greeting = "hello";
string loud = greeting.Shout();
// Result: "HELLO!!!"

The Secret Recipe

1. Create a static class (the sticker factory)
2. Create a static method (the sticker)
3. Use this before the first parameter (the magic word!)

graph TD
    A["Original Class"] --> B["Cannot Modify"]
    C["Extension Method"] --> D["Add this keyword"]
    D --> E["New Power Added!"]
    A --> E

Real-Life Use

public static class NumberExtensions
{
    public static bool IsEven(this int number)
    {
        return number % 2 == 0;
    }
}

// Use it like it was always there:
int myNumber = 4;
bool result = myNumber.IsEven(); // true!

2. Indexers: Access Items Like a Library

What Is It?

Imagine a bookshelf. You say “Give me book number 3” and—poof—you get it! You don’t care how the books are stored. You just use the number.

Indexers let you access items in your class using brackets [], just like an array.

Why Is This Awesome?

• Makes your class easy to use (just like a list!)
• Hides the complicated storage logic
• Works with numbers, strings, or any type as the “key”

Simple Example

public class Backpack
{
    private string[] items = new string[5];

    // The indexer - notice the brackets!
    public string this[int slot]
    {
        get { return items[slot]; }
        set { items[slot] = value; }
    }
}

// Use it like magic:
Backpack myBag = new Backpack();
myBag[0] = "Apple";      // Put apple in slot 0
myBag[1] = "Book";       // Put book in slot 1
string item = myBag[0];  // Get "Apple"

The Pattern

public TYPE this[KEY_TYPE key]
{
    get { /* return something */ }
    set { /* store something */ }
}

graph TD
    A["Your Object"] -->|object#91;key#93;| B["Indexer"]
    B --> C["Get or Set Value"]
    C --> D["Internal Storage"]

Using Strings as Keys

public class Scoreboard
{
    private Dictionary<string, int> scores
        = new Dictionary<string, int>();

    public int this[string player]
    {
        get { return scores[player]; }
        set { scores[player] = value; }
    }
}

// Natural to use:
Scoreboard game = new Scoreboard();
game["Alice"] = 100;
game["Bob"] = 85;
int aliceScore = game["Alice"]; // 100

3. Operator Overloading: Teaching Math to Your Classes

What Is It?

When you write 2 + 3, C# knows that + means “add numbers.” But what if you have a Vector class? What should vector1 + vector2 mean?

Operator overloading lets you teach C# what +, -, *, and other symbols mean for your custom classes!

Why Is This Awesome?

• Your code reads naturally: money1 + money2 instead of money1.Add(money2)
• Works with +, -, *, /, ==, >, <, and more!
• Makes your classes feel like built-in types

Simple Example

public class Point
{
    public int X { get; set; }
    public int Y { get; set; }

    // Teach C# what + means for Points
    public static Point operator +(
        Point a, Point b)
    {
        return new Point
        {
            X = a.X + b.X,
            Y = a.Y + b.Y
        };
    }
}

// Now addition just works!
Point p1 = new Point { X = 1, Y = 2 };
Point p2 = new Point { X = 3, Y = 4 };
Point p3 = p1 + p2; // X=4, Y=6

The Pattern

public static RETURN_TYPE operator SYMBOL(
    PARAMETERS)
{
    // Your logic here
    return result;
}

Common Operators You Can Override

Complete Example: Money Class

public class Money
{
    public decimal Amount { get; set; }

    public static Money operator +(
        Money a, Money b)
    {
        return new Money
        {
            Amount = a.Amount + b.Amount
        };
    }

    public static bool operator >(
        Money a, Money b)
    {
        return a.Amount > b.Amount;
    }

    public static bool operator <(
        Money a, Money b)
    {
        return a.Amount < b.Amount;
    }
}

// Use it naturally:
Money wallet = new Money { Amount = 50 };
Money piggyBank = new Money { Amount = 30 };
Money total = wallet + piggyBank; // 80
bool hasMore = wallet > piggyBank; // true

4. Partial Classes & Methods: Building in Pieces

What Is It?

Imagine building a LEGO castle. One friend builds the towers. Another friend builds the walls. At the end, you snap them together into one complete castle!

Partial classes let you split a class across multiple files. C# combines them into one class when you run your program.

Why Is This Awesome?

• Teamwork: Different developers can work on different parts
• Organization: Keep generated code separate from your code
• Clean code: Split huge classes into manageable pieces

Simple Example

File 1: Robot.Movement.cs

public partial class Robot
{
    public void Walk()
    {
        Console.WriteLine("Walking...");
    }

    public void Run()
    {
        Console.WriteLine("Running!");
    }
}

File 2: Robot.Speech.cs

public partial class Robot
{
    public void SayHello()
    {
        Console.WriteLine("Hello, human!");
    }

    public void Sing()
    {
        Console.WriteLine("La la la!");
    }
}

Using the Robot (it’s ONE class!):

Robot r = new Robot();
r.Walk();      // From file 1
r.SayHello();  // From file 2

graph TD
    A["Robot.Movement.cs"] -->|partial class| C["Complete Robot Class"]
    B["Robot.Speech.cs"] -->|partial class| C
    C --> D["Walk, Run, SayHello, Sing"]

Partial Methods: Optional Hooks

Partial methods are like empty hooks that can be filled in later. If no one fills them, they disappear!

// File 1: Generated code
public partial class Order
{
    partial void OnOrderCreated(); // Hook!

    public void Create()
    {
        // ... order logic ...
        OnOrderCreated(); // Call the hook
    }
}

// File 2: Your custom code
public partial class Order
{
    partial void OnOrderCreated()
    {
        Console.WriteLine("Order was created!");
    }
}

Rules for Partial Methods

Summary: Your New Superpowers

Quick Reference Code

// EXTENSION METHOD
public static class Ext
{
    public static int Double(this int n)
        => n * 2;
}

// INDEXER
public class Box
{
    string[] items = new string[3];
    public string this[int i]
    {
        get => items[i];
        set => items[i] = value;
    }
}

// OPERATOR OVERLOADING
public class Vec
{
    public int X, Y;
    public static Vec operator +(Vec a, Vec b)
        => new Vec { X = a.X+b.X, Y = a.Y+b.Y };
}

// PARTIAL CLASS
// File1.cs
public partial class Cat { public void Meow(){} }
// File2.cs
public partial class Cat { public void Purr(){} }

You Did It! 🎉

You now have four new superpowers in your C# toolbox:

1. Extension Methods — Add powers without changing the original
2. Indexers — Access things with simple brackets
3. Operator Overloading — Make + and - work your way
4. Partial Classes — Build together, piece by piece

Go forth and build amazing things! These tools will make your code cleaner, more natural, and more powerful than ever before.