Static vs Instance ⚡

Shared vs Personal - What Belongs to Everyone vs Each Person?

Beginner Friendly 20 min read Lesson 9 of 11

Hey There! Ready to Learn Static vs Instance? 🎯

Static and Instance are two types of members in C#. It's like the difference between something shared by everyone vs something that belongs to just one person.

Quick Question: Think about a school!

🏫 School Name is SHARED by everyone (static)
👨‍🎓 Student Name belongs to each student (instance)

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

✅ Explain static vs instance like a pro
✅ Use static members (shared stuff)
✅ Use instance members (personal stuff)
✅ Know when to use each
✅ Build better, cleaner code

Part 1: What's the Difference? (The Easy Way)

👥 Static - Shared by Everyone

Static members belong to the class itself, not to any specific object.

✅ One copy shared by all
✅ Accessed through the class name
✅ Like a school name - everyone uses the same one

Example: Math.PI - everyone uses the same Pi!

👤 Instance - Personal to Each

Instance members belong to each object individually.

✅ Separate copies for each object
✅ Accessed through an object variable
✅ Like a student name - each student has their own

Example: person.Name - each person has their own name!

Remember:

Static = Class level (one for all)
Instance = Object level (one per object)

😂 Fun Joke: Why did the static method break up with the instance method? Because it couldn't handle the personal space! (Okay, I'll stop 😅)

Part 2: Instance Members - Personal Stuff

Instance members are like personal belongings - each object has its own copy.

📝 Instance Fields

public class Person
{
    // Each person has their own Name and Age
    public string Name { get; set; }
    public int Age { get; set; }
}

Each Person object has its own Name and Age!

🎯 Using Instance Members

// Create two people
Person person1 = new Person();
person1.Name = "Alice";
person1.Age = 25;

Person person2 = new Person();
person2.Name = "Bob";
person2.Age = 30;

// Each has their own values!

✅ person1 and person2 have different values

Key Point: You MUST create an object to use instance members!
Person p = new Person(); → p.Name works ✅
Person.Name doesn't work ❌ (needs an object)

Part 3: Static Members - Shared Stuff

Static members are like shared resources - one copy for everyone.

📝 Static Fields

public class School
{
    // Shared by ALL students
    public static string SchoolName = "C# Academy";
    
    // Each student has their own
    public string StudentName { get; set; }
}

One SchoolName for ALL students!

🎯 Using Static Members

// ✅ Access through class name
Console.WriteLine(School.SchoolName);  // "C# Academy"

// ❌ Can't access through object
School s = new School();
// s.SchoolName doesn't work!

Remember: Static members use the class name, not an object!

📊 Static vs Instance - Visual Comparison

Feature	Static	Instance
Belongs to	Class	Object
How many copies	One (shared)	Many (one per object)
How to access	`ClassName.Member`	`object.Member`
Example	`Math.PI`	`person.Name`

Part 4: Static Methods - Utility Functions

📝 Static Method Example

public class MathHelper
{
    // Static method - no object needed
    public static int Add(int a, int b)
    {
        return a + b;
    }
    
    // Instance method - needs an object
    private int result;
    public void AddToResult(int value)
    {
        result += value;
    }
}

🎯 Using Static Methods

// ✅ No object needed!
int sum = MathHelper.Add(5, 3);
Console.WriteLine(sum);  // 8

// ❌ Need an object for instance method
MathHelper helper = new MathHelper();
helper.AddToResult(10);

When to use static methods:

✅ Utility functions (like Math.Sqrt())
✅ No object data needed
✅ Helper methods

Part 5: Static Constructor - One-Time Setup

What's a Static Constructor? It runs ONCE when the class is first used.

📝 Static Constructor

public class Config
{
    public static string AppName;
    public static string Version;
    
    // Runs ONCE when class is first used
    static Config()
    {
        AppName = "MyApp";
        Version = "1.0.0";
        Console.WriteLine("⚙️ Config loaded!");
    }
}

🎯 When It Runs

// Static constructor runs HERE
Console.WriteLine(Config.AppName);  // "MyApp"

// Static constructor already ran
Console.WriteLine(Config.Version);  // "1.0.0"

Key Points:

✅ Runs ONCE (not every time)
✅ No parameters allowed
✅ Used for one-time setup

Part 6: Static Classes - Pure Utility

What's a Static Class? A class that cannot be created - it's just a container for static members!

📝 Static Class

public static class FileHelper
{
    // All members MUST be static
    public static void WriteFile(string path)
    {
        Console.WriteLine($"Writing to {path}");
    }
}

🚫 Cannot create FileHelper objects!

✅ Using Static Class

// ✅ Use directly through class name
FileHelper.WriteFile("data.txt");

// ❌ Can't do this:
// FileHelper helper = new FileHelper();

When to use static classes:

✅ Math - Math.Sqrt()
✅ File helpers - File.ReadAllText()
✅ Convert - Convert.ToInt32()

Part 7: Real-World Example - Bank System 💰

Let's build a Bank System showing static and instance members!

// Bank System - Static vs Instance
public class Bank
{
    // 🔵 STATIC - Shared by all accounts
    public static string BankName = "C# National Bank";
    private static int totalAccounts = 0;
    private static double interestRate = 0.05;
    
    // 🟢 INSTANCE - Belongs to each account
    public string AccountNumber { get; private set; }
    public string Owner { get; set; }
    public decimal Balance { get; private set; }
    
    // Static method - shared functionality
    public static int GetTotalAccounts() => totalAccounts;
    
    public static void SetInterestRate(double rate)
    {
        if (rate >= 0) interestRate = rate;
    }
    
    // Constructor - creates new account
    public Bank(string owner, decimal initial)
    {
        Owner = owner;
        Balance = initial;
        AccountNumber = GenerateAccountNumber();
        totalAccounts++;
    }

    // Private static method
    private static string GenerateAccountNumber()
    {
        return $"ACC-{DateTime.Now.Year}-{totalAccounts + 1:D4}";
    }
    
    // Instance methods - per account
    public void Deposit(decimal amount)
    {
        if (amount > 0) Balance += amount;
    }
    
    public bool Withdraw(decimal amount)
    {
        if (amount > 0 && amount <= Balance)
        {
            Balance -= amount;
            return true;
        }
        return false;
    }
    
    public void ApplyInterest()
    {
        Balance += Balance * (decimal)interestRate;
    }
    
    public void DisplayInfo()
    {
        Console.WriteLine($"🏦 {BankName}");
        Console.WriteLine($"📋 Account: {AccountNumber}");
        Console.WriteLine($"👤 Owner: {Owner}");
        Console.WriteLine($"💰 Balance: ${Balance:F2}");
        Console.WriteLine($"📊 Total Accounts: {GetTotalAccounts()}");
    }
}

// Program.cs - Testing the Bank
class Program
{
    static void Main()
    {
        Console.WriteLine("🏦 WELCOME TO THE BANK\n");
        
        // Static members - shared
        Console.WriteLine($"🏛️ Bank Name: {Bank.BankName}");
        Console.WriteLine($"📊 Interest Rate: 5%\n");
        
        // Create accounts - instance
        Bank account1 = new Bank("John Doe", 1000.00m);
        Bank account2 = new Bank("Jane Smith", 2000.00m);
        
        // Instance operations
        account1.Deposit(500.00m);
        account2.Withdraw(200.00m);
        account1.ApplyInterest();
        
        // Display info
        account1.DisplayInfo();
        Console.WriteLine();
        account2.DisplayInfo();
        
        // Static members - shared
        Console.WriteLine($"\n📊 Total Accounts: {Bank.GetTotalAccounts()}");
    }
}

🎉 What this shows:

✅ Static: BankName, totalAccounts, interestRate (shared)
✅ Instance: AccountNumber, Owner, Balance (personal)
✅ Static Methods: GetTotalAccounts(), SetInterestRate()
✅ Instance Methods: Deposit(), Withdraw(), ApplyInterest()

😂 Bank Joke: Why did the static variable break up with the instance variable? Because it couldn't handle the personal space! (Okay, I'll stop now 😅)

Part 8: Let's Practice! 🎮

What You're Building: A Product Inventory System for a store!
Track products and inventory with both shared and personal data.

🛒 About This Application

This is a Store Inventory System like:

🏪 Walmart - Track thousands of products
📦 Amazon - Manage inventory across warehouses
🛍️ Local Store - Track stock and sales

Each product has personal data (name, price) and shared data (store name, total products):

✅ All products share the same Store Name
✅ Each product has its own Name, Price, Quantity
✅ Track Total Products in the system

Your Mission:

Class: Product
- 🟢 Instance - Id, Name, Price, Quantity
- 🔵 Static - StoreName, totalProducts
- 🔵 Static Method - GetTotalProducts()
- 🟢 Instance Method - AddStock(), RemoveStock()
- 🟢 Instance Method - DisplayInfo()
Program.cs:
- Create 3+ products
- Add/remove stock
- Display product info
- Show total products

💡 What You're Learning:

✅ Static = Store Name, Total Products (shared)
✅ Instance = Product details (personal)
✅ Static Method = Get total products
✅ Instance Method = Manage each product

Result: A complete inventory system with both shared and personal data!

// ===== PRODUCT INVENTORY SYSTEM =====
// This shows static vs instance members in action

public class Product
{
    // 🔵 STATIC MEMBERS - Shared by all products
    public static string StoreName = "C# Superstore";
    private static int totalProducts = 0;
    private static int nextId = 1000;
    
    // 🟢 INSTANCE MEMBERS - Belongs to each product
    public int Id { get; private set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int Quantity { get; private set; }
    
    // 🔵 Static method - shared functionality
    public static int GetTotalProducts() => totalProducts;
    
    public static void ResetInventory()
    {
        totalProducts = 0;
        nextId = 1000;
        Console.WriteLine("🔄 Inventory reset!");
    }
    
    // 🟢 Constructor - creates new product
    public Product(string name, decimal price, int quantity)
    {
        Name = name;
        Price = price;
        Quantity = quantity;
        Id = GenerateId();
        totalProducts++;
    }
    
    // 🔵 Private static helper
    private static int GenerateId() => ++nextId;
    
    // 🟢 Instance methods - per product
    public void AddStock(int amount)
    {
        if (amount > 0) Quantity += amount;
    }
    
    public bool RemoveStock(int amount)
    {
        if (amount > 0 && amount <= Quantity)
        {
            Quantity -= amount;
            return true;
        }
        return false;
    }
    
    public decimal GetTotalValue() => Price * Quantity;
    
    public void DisplayInfo()
    {
        Console.WriteLine($"🏪 {StoreName} - Product #{Id}");
        Console.WriteLine($"📦 {Name}");
        Console.WriteLine($"💰 ${Price:F2}");
        Console.WriteLine($"📊 Quantity: {Quantity}");
        Console.WriteLine($"💵 Total Value: ${GetTotalValue():F2}");
        Console.WriteLine();
    }
}

// Program.cs - Inventory System
class Program
{
    static void Main()
    {
        Console.WriteLine("📦 PRODUCT INVENTORY SYSTEM");
        Console.WriteLine("═══════════════════════════════════\n");
        
        // Static member - store name
        Console.WriteLine($"🏪 Store: {Product.StoreName}\n");
        
        // Create products (instance)
        Product product1 = new Product("Laptop", 999.99m, 5);
        Product product2 = new Product("Mouse", 25.50m, 20);
        Product product3 = new Product("Keyboard", 45.00m, 15);
        
        // Instance operations
        product1.AddStock(2);   // Add 2 more laptops
        product2.RemoveStock(5);  // Sell 5 mice
        
        // Display all products
        product1.DisplayInfo();
        product2.DisplayInfo();
        product3.DisplayInfo();
        
        // Static method - total products
        Console.WriteLine($"📊 Total Products: {Product.GetTotalProducts()}");
        Console.WriteLine($"🏪 Store: {Product.StoreName}");
    }
}

✅ Complete Solution! You've built a real inventory system using static and instance members!

🎉 What You Learned Today!

Static

Shared by everyone

Instance

Personal to each

Static Methods

Utility functions

Static Classes

Pure containers

Real Example

Bank System! 💰

Inventory System

Store Example! 🛒

Smart Choice

Static vs Instance

Previous Lesson Next Lesson

Test Your Knowledge - Take Quiz