Modern Initialization

🏗️ Modern Initialization in C#: Building Things the Smart Way

The Big Picture: Like Building with LEGO Instructions

Imagine you’re building a spaceship with LEGO blocks. You need certain pieces to make it work—like wings and an engine. Modern C# gives you three super-cool tools to make sure everything is built correctly every time:

1. Primary Constructors – The blueprint that says “Here’s what I need to build this!”
2. Required Members – The checklist that says “Don’t forget these pieces!”
3. Init Accessors – The lock that says “Set it once, then hands off!”

Let’s explore each one like we’re on an adventure! 🚀

🎯 Primary Constructors: The Quick Recipe

What’s the Problem?

Before, making a class with some starting values was like writing the same thing over and over:

// OLD WAY - So much typing! 😩
public class Person
{
    private string _name;
    private int _age;

    public Person(string name, int age)
    {
        _name = name;
        _age = age;
    }
}

That’s a lot of work just to say “I need a name and age!”

The Modern Way: Primary Constructors

Now, you can put the ingredients right in the class name:

// NEW WAY - Clean and simple! ✨
public class Person(string name, int age)
{
    public string Name => name;
    public int Age => age;
}

Think of it like a cookie recipe: Instead of writing “Step 1: Get flour. Step 2: Put flour in bowl”—you just write “Flour → Bowl” right at the top!

Real Example: A Game Character

public class Hero(string heroName, int health)
{
    public string HeroName => heroName;
    public int Health => health;

    public void TakeDamage(int damage)
    {
        // We can use 'health' directly!
        Console.WriteLine(
            quot;{heroName} took {damage} damage!");
    }
}

// Using it:
var link = new Hero("Link", 100);

Key Points About Primary Constructors

graph TD
    A["Primary Constructor"] --> B["Parameters in class declaration"]
    B --> C["Available throughout the class"]
    C --> D["Less boilerplate code"]
    D --> E["Cleaner, readable classes"]

✅ Required Members: The “Don’t Forget!” Checklist

What’s the Problem?

Sometimes you create an object but forget to fill in important stuff:

// OOPS! We forgot the email!
var user = new User
{
    Name = "Alice"
    // Email is missing... 😱
};

The program runs, but later crashes because Email is empty!

The Solution: required Keyword

Mark important properties as required. The computer won’t let you forget!

public class User
{
    public required string Name { get; set; }
    public required string Email { get; set; }
}

// Now this WON'T COMPILE: ❌
var user = new User { Name = "Alice" };
// Error: Email is required!

// This WORKS: ✅
var user = new User
{
    Name = "Alice",
    Email = "alice@mail.com"
};

It’s Like a Safety Net!

Think of ordering a pizza: The pizza shop requires your address. They won’t even start making your pizza until you tell them where to deliver it!

public class PizzaOrder
{
    public required string CustomerName { get; set; }
    public required string Address { get; set; }
    public string? SpecialInstructions { get; set; }
}

// Must provide name AND address:
var order = new PizzaOrder
{
    CustomerName = "Mario",
    Address = "123 Mushroom Lane"
    // SpecialInstructions is optional
};

Required + Primary Constructor Together

You can mix both! The constructor handles some things, required handles others:

public class Product(int id)
{
    public int Id => id;
    public required string Name { get; set; }
    public required decimal Price { get; set; }
}

var item = new Product(42)
{
    Name = "Magic Sword",
    Price = 99.99m
};

🔒 Init Accessors: Set It and Forget It

What’s the Problem?

Sometimes you want to set a value once when you create something, but never change it after:

// Regular setter - can be changed anytime 😟
person.BirthDate = newDate; // Uh oh!

But you can’t change your birthday in real life!

The Solution: init Accessor

Use init instead of set. You can only set the value when creating the object:

public class Person
{
    public string Name { get; init; }
    public DateTime BirthDate { get; init; }
}

// When creating - works fine! ✅
var person = new Person
{
    Name = "Emma",
    BirthDate = new DateTime(2010, 5, 15)
};

// Later - BLOCKED! ❌
person.BirthDate = DateTime.Now;
// Error: Can only set during initialization!

Real-World Comparison

Think of a certificate: When you graduate, they print your name and date on the certificate. After it’s printed, you can’t erase and change it!

public class Certificate
{
    public required string StudentName { get; init; }
    public required DateTime GraduationDate { get; init; }
    public required string Degree { get; init; }
}

var diploma = new Certificate
{
    StudentName = "Alex",
    GraduationDate = DateTime.Now,
    Degree = "Computer Science"
};

// This is PERMANENT! Can't be changed later.

Init + Required = Super Safe!

Combine them for maximum safety:

public class BankAccount
{
    public required string AccountNumber { get; init; }
    public required string OwnerName { get; init; }
    public decimal Balance { get; set; } // Can change
}

• AccountNumber → Must provide, can’t change later
• OwnerName → Must provide, can’t change later
• Balance → Can change (money goes in and out!)

🎨 The Complete Picture: All Three Together!

Here’s a real example using ALL three features:

// Primary constructor for the ID
public class GameCharacter(Guid id)
{
    // From primary constructor - always available
    public Guid Id => id;

    // Required + init = must set, can't change
    public required string Name { get; init; }
    public required string Class { get; init; }

    // Just required = must set, CAN change
    public required int Level { get; set; }

    // Optional with default
    public int Gold { get; set; } = 0;
}

// Creating a character:
var hero = new GameCharacter(Guid.NewGuid())
{
    Name = "Zelda",
    Class = "Mage",
    Level = 1
};

// Later in the game:
hero.Level = 50;  // ✅ Level can change
hero.Gold = 9999; // ✅ Gold can change
// hero.Name = "New Name"; // ❌ BLOCKED!

🧠 Quick Comparison Chart

🌟 Remember This!

graph TD
    A["Modern Initialization"] --> B["Primary Constructors"]
    A --> C["Required Members"]
    A --> D["Init Accessors"]
    B --> E["Less code, more clarity"]
    C --> F["Never forget important data"]
    D --> G["Immutable after creation"]

Primary Constructors = Quick recipe at the top Required Members = Don’t forget the important stuff Init Accessors = Set it, then lock it forever

You’re now ready to build C# objects the modern way—safe, clean, and smart! 🎉