Egenskaper

// ❌ GAMMAL & FARLIG - ingen kontroll!
public class BadBankAccount
{
    public decimal balance;  // Vem som helst kan sätta vad som helst!
}

// Somewhere else in code:
var account = new BadBankAccount();
account.balance = -1000000;  // 💸 BANKRUPTCY! Ingen kan stoppa oss!

// ✅ KLASSISK - full kontroll men verbose
public class ClassicBankAccount
{
    private decimal _balance;  // Private field - the real data

    // Full property with validation
    public decimal Balance
    {
        get
        {
            Console.WriteLine($"🔍 Balance requested: {_balance}");
            return _balance;
        }
        set
        {
            if (value < 0)
                throw new ArgumentException("❌ Saldot kan inte vara negativt!");

            Console.WriteLine($"💰 Setting balance from {_balance} to {value}");
            _balance = value;
        }
    }
}

// ✅ MODERN - kortare men fortfarande kraftfull
public class ModernBankAccount
{
    // Auto-property - compiler skapar private field automatically
    public decimal Balance { get; set; }

    // Auto-property med validation
    private decimal _balance;
    public decimal ValidatedBalance
    {
        get => _balance;
        set => _balance = value >= 0 ? value : throw new ArgumentException("❌ Negativt saldo!");
    }

    // Read-only auto property
    public string AccountNumber { get; private set; }

    // Get-only computed property
    public string DisplayBalance => $"{Balance:C} SEK";
}

// ✅ C-Sharp 14 STYLE - immutable by default!
public class FuturisticBankAccount
{
    // Init-only - can only be set during construction
    public string AccountNumber { get; init; } = string.Empty;
    public string Owner { get; init; } = string.Empty;
    public DateTime CreatedDate { get; init; } = DateTime.Now;

    // Regular property for things that change
    public decimal Balance { get; set; }

    // Required property - must be set during construction
    public required string Bank { get; init; }

    // Computed property with expression body
    public string AccountInfo => $"🏦 {Bank}: {AccountNumber} ({Owner})";

    // Complex computed property
    public string BalanceStatus => Balance switch
    {
        < 0 => "🔴 Skuld",
        < 1000 => "🟡 Lågt saldo",
        < 10000 => "🟢 Normalt saldo",
        _ => "💎 Rik person!"
    };
}

public class SecurityExample
{
    // Public get/set - alla kan läsa och skriva
    public string PublicData { get; set; } = "Everyone can access";

    // Public get, private set - alla kan läsa, bara denna class kan skriva
    public string ReadOnlyForOthers { get; private set; } = "Read-only outside";

    // Public get, protected set - alla kan läsa, bara denna class + barn kan skriva
    public string ReadOnlyForPublic { get; protected set; } = "Family can write";

    // Public get, init set - alla kan läsa, bara constructor kan skriva
    public string SetOnceOnly { get; init; } = "Set during construction only";

    // Private property - bara denna class
    private string SecretData { get; set; } = "Top secret";

    // Protected property - bara denna class + barn
    protected string FamilySecret { get; set; } = "Family only";

    public void DemonstrateAccess()
    {
        // Denna class kan göra allt
        PublicData = "Changed by owner";
        ReadOnlyForOthers = "Owner can change";
        ReadOnlyForPublic = "Owner can change";
        SecretData = "Owner knows all secrets";
        FamilySecret = "Owner shares with family";

        // SetOnceOnly kan INTE ändras här - bara i constructor/init!
        // SetOnceOnly = "Nope!";  // ❌ Compilation error
    }
}

public class SecurityChild : SecurityExample
{
    public void ChildAccess()
    {
        // Child class kan accessa protected
        FamilySecret = "Child changed family secret";
        ReadOnlyForPublic = "Child can write this";

        // Men inte private
        // SecretData = "Nope!";  // ❌ Not accessible
    }
}

public class BestPracticeExample
{
    // ✅ Use init for immutable data
    public required string Id { get; init; }

    // ✅ Use auto-properties for simple data
    public string Name { get; set; } = string.Empty;

    // ✅ Use expression bodies for computed properties
    public string DisplayName => string.IsNullOrEmpty(Name) ? "Unknown" : Name;

    // ✅ Use validation in setters when needed
    private int _age;
    public int Age
    {
        get => _age;
        set => _age = value >= 0 ? value : throw new ArgumentException("Age cannot be negative");
    }

    // ✅ Use private setters for controlled access
    public DateTime CreatedAt { get; private set; } = DateTime.Now;

    // ✅ Use collections with private setters
    public List<string> Tags { get; private set; } = [];

    public void AddTag(string tag)
    {
        if (!string.IsNullOrEmpty(tag))
            Tags.Add(tag);
    }
}