// Class definition (Blueprint)
public class Car
{
    public string Model { get; set; }
    public string Color { get; set; }

    public void Drive()
    {
        Console.WriteLine($"Driving {Model} car");
    }
}

// Objects (Instances of the class)
Car car1 = new Car { Model = "Honda", Color = "Red" };
Car car2 = new Car { Model = "Toyota", Color = "Blue" };

car1.Drive(); // Output: Driving Honda car
car2.Drive(); // Output: Driving Toyota car

// Compile-time Polymorphism (Method Overloading)
public class Calculator
{
    public int Add(int a, int b) => a + b;
    public double Add(double a, double b) => a + b;
}

// Runtime Polymorphism (Method Overriding)
public class Animal { public virtual void Speak() { } }
public class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Woof!");
    }
}
public class Cat : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Meow!");
    }
}

Animal dog = new Dog();
Animal cat = new Cat();
dog.Speak(); // Output: Woof!
cat.Speak(); // Output: Meow!

// Sealed class - cannot be inherited
public sealed class FinalClass
{
    public void Display() => Console.WriteLine("This is a sealed class");
}

// This will cause a compilation error
// public class DerivedClass : FinalClass { } // ERROR!

// Can seal individual methods too
public class BaseClass
{
    public virtual void Method1() { }
}

public class DerivedClass : BaseClass
{
    public sealed override void Method1() { } // Cannot override in further derived classes
}

int value = 42;

// Boxing - converting value type to reference type
object boxedValue = value; // value is wrapped in an object

// Unboxing - converting reference type back to value type
int unboxedValue = (int)boxedValue; // Explicit cast required

Console.WriteLine($"Original: {value}");
Console.WriteLine($"Boxed: {boxedValue}");
Console.WriteLine($"Unboxed: {unboxedValue}");

// Incorrect unboxing - throws InvalidCastException
// double wrongUnbox = (double)boxedValue; // ERROR!

public class ResourceManager : IDisposable
{
    private bool disposed = false;

    ~ResourceManager() // Destructor
    {
        Dispose(false);
    }

    public void Dispose() // Dispose method
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                // Release managed resources
            }
            // Release unmanaged resources
            disposed = true;
        }
    }
}

public class Complex
{
    public double Real { get; set; }
    public double Imaginary { get; set; }

    public Complex(double real, double imaginary)
    {
        Real = real;
        Imaginary = imaginary;
    }

    // Overload + operator
    public static Complex operator +(Complex a, Complex b)
    {
        return new Complex(a.Real + b.Real, a.Imaginary + b.Imaginary);
    }

    // Overload == operator
    public static bool operator ==(Complex a, Complex b)
    {
        return a.Real == b.Real && a.Imaginary == b.Imaginary;
    }

    public static bool operator !=(Complex a, Complex b) => !(a == b);
}

Complex c1 = new Complex(3, 4);
Complex c2 = new Complex(1, 2);
Complex c3 = c1 + c2; // Uses overloaded + operator

public class Repository<T> where T : class, new()
{
    public T Create()
    {
        return new T(); // Valid because T has new() constraint
    }
}

public class NumberProcessor<T> where T : struct
{
    public double Average(T[] numbers) where T : struct
    {
        return 0; // Ensures T is a value type
    }
}

public class Comparer<T> where T : IComparable<T>
{
    public T Max(T a, T b)
    {
        return a.CompareTo(b) > 0 ? a : b;
    }
}

public class InvalidAgeException : Exception
{
    public int ProvidedAge { get; set; }

    public InvalidAgeException(string message, int age)
        : base(message)
    {
        ProvidedAge = age;
    }

    public InvalidAgeException(string message, int age, Exception innerException)
        : base(message, innerException)
    {
        ProvidedAge = age;
    }
}

// Usage
public void SetAge(int age)
{
    if (age < 0 || age > 150)
    {
        throw new InvalidAgeException("Age must be between 0 and 150", age);
    }
}

public class Counter
{
    private int count = 0;
    private object lockObject = new object();

    public void Increment()
    {
        lock (lockObject)
        {
            count++; // Only one thread can execute this at a time
        }
    }

    public int GetCount()
    {
        lock (lockObject)
        {
            return count;
        }
    }
}

#nullable enable

public class Person
{
    public string Name { get; set; } // Cannot be null
    public string? NickName { get; set; } // Can be null

    public void Greet()
    {
        Console.WriteLine($"Hello {Name}"); // Safe - Name is not null

        // This would produce a warning without null check
        if (NickName != null)
        {
            Console.WriteLine($"Also known as {NickName}");
        }
    }
}