What is the difference between static and instance members?

Static members belong to the class itself, while instance members belong to individual objects (instances) of the class. This fundamental difference affects memory allocation, access patterns, and usage scenarios.

Key Differences:

Example:

public class Counter
{
    // Static field - shared across all instances
    private static int totalCount = 0;
    
    // Instance field - each object has its own copy
    private int instanceCount = 0;
    
    // Static property - accessed via class name
    public static int TotalCount
    {
        get { return totalCount; }
        private set { totalCount = value; }
    }
    
    // Instance property - accessed via object reference
    public int InstanceCount
    {
        get { return instanceCount; }
        private set { instanceCount = value; }
    }
    
    // Static constructor - called once when class is first used
    static Counter()
    {
        Console.WriteLine("Static constructor called - Counter class initialized");
        TotalCount = 0;
    }
    
    // Instance constructor - called for each new object
    public Counter()
    {
        Console.WriteLine("Instance constructor called - new Counter created");
        InstanceCount = 0;
    }
    
    // Static method - can only access static members
    public static void ResetTotalCount()
    {
        TotalCount = 0;
        Console.WriteLine("Total count reset to 0");
    }
    
    // Instance method - can access both static and instance members
    public void Increment()
    {
        InstanceCount++;
        TotalCount++; // Can access static members from instance methods
        Console.WriteLine($"Instance count: {InstanceCount}, Total count: {TotalCount}");
    }
    
    // Static method that creates and returns instances
    public static Counter CreateCounter()
    {
        return new Counter();
    }
    
    // Instance method that uses static members
    public void DisplayStats()
    {
        Console.WriteLine($"This counter: {InstanceCount}");
        Console.WriteLine($"All counters total: {TotalCount}");
    }
}

// Usage demonstration
public class StaticVsInstanceDemo
{
    public static void Demonstrate()
    {
        Console.WriteLine("=== Static vs Instance Members Demo ===");
        
        // Access static members via class name
        Console.WriteLine($"Initial total count: {Counter.TotalCount}");
        Counter.ResetTotalCount();
        
        // Create instances
        Counter counter1 = new Counter();
        Counter counter2 = new Counter();
        Counter counter3 = new Counter();
        
        // Use instance methods
        counter1.Increment(); // Instance: 1, Total: 1
        counter1.Increment(); // Instance: 2, Total: 2
        
        counter2.Increment(); // Instance: 1, Total: 3
        counter2.Increment(); // Instance: 2, Total: 4
        counter2.Increment(); // Instance: 3, Total: 5
        
        counter3.Increment(); // Instance: 1, Total: 6
        
        // Display stats for each instance
        counter1.DisplayStats();
        counter2.DisplayStats();
        counter3.DisplayStats();
        
        // Static count is shared across all instances
        Console.WriteLine($"Final total count: {Counter.TotalCount}");
    }
}

When to Use Static Members:

• Utility methods that don't need instance data
• Constants and configuration values
• Factory methods
• Extension methods
• Shared state across instances

When to Use Instance Members:

• Object-specific data and behavior
• Methods that need access to instance fields
• Stateful operations
• Object lifecycle management