Åtkomstmoderatorer

💡 Vad är åtkomstmoderatorer?

Åtkomstmoderatorer är som säkerhetsvakter för din kod! 🚨

Tänk dig ett företag med olika säkerhetsområden. Alla anställda får inte gå överallt - receptionen är öppen för alla, men VD:ns kontor är låst, personalregistret är endast för HR, och vissa dokument får bara avdelningen se.

Åtkomstmoderatorer fungerar precis likadant i C-Sharp! De bestämmer vilka delar av din kod som andra klasser och objekt får se och använda. Det här är en fundamental del av inkapsling - en av OOP:s viktigaste principer.

🎯 TL;DR

Åtkomstmoderatorer = kodtrafikkontroll. public = alla får se, private = bara klassen själv, protected = klassen + barn, internal = klassen + samma projekt.

📋 Efter att ha läst detta kommer du att kunna

Förstå varför åtkomstmoderatorer är viktiga för säker kod 🔐
Använda public, private, protected och internal korrekt 🎯
Designa klasser med rätt säkerhetsnivå för olika medlemmar 🏗️
Undvika vanliga säkerhetsmisstag i OOP 🚫
Implementera inkapsling som en professionell utvecklare ✨

🔧 De fem åtkomstmoderatörerna

🌍 Public - “Alla får komma in”

public class BankAccount
{
    public string AccountHolder { get; set; }  // ✅ Alla kan se vem som äger kontot
    public decimal GetBalance()                // ✅ Alla kan kolla saldo
    {
        return balance;
    }
}

När använda public:

Metoder som andra klasser ska kunna anropa
Properties som är “säkra” att visa utåt
Constructors som skapar objekt

🔒 Private - “Bara jag själv”

public class BankAccount
{
    private decimal balance;           // 🔐 Hemlig information!
    private string accountNumber;      // 🔐 Känslig data!

    private bool ValidateTransaction(decimal amount)  // 🔐 Intern logik
    {
        return amount > 0 && amount <= balance;
    }
}

När använda private:

Känslig data som balance, lösenord, hemligheter
Intern logik som andra inte behöver veta om
Helper-metoder som bara klassen använder

👨‍👩‍👧‍👦 Protected - “Familjen får veta”

public class Animal
{
    protected string species;         // 🔐 Bara Animal och dess barn
    protected void Breathe()          // 🔐 Grundfunktion för alla djur
    {
        Console.WriteLine("Andas...");
    }
}

public class Dog : Animal
{
    public void ShowSpecies()
    {
        Console.WriteLine($"Jag är en {species}");  // ✅ Fungerar! Dog ärver från Animal
    }
}

När använda protected:

Saker som barn-klasser behöver men inte andra
“Familje-hemligheter” i arvshierarkin
Basklassens interna funktioner

🏢 Internal - “Bara vi som jobbar här”

// I samma projekt/assembly
internal class DatabaseHelper      // Bara detta projekt kan använda klassen
{
    internal string connectionString;

    internal void LogError(string message)  // Bara vårt projekt kan logga
    {
        // Intern felhantering
    }
}

När använda internal:

Klasser som bara ditt projekt ska använda
Utilities som inte ska exponeras till andra projekt
“Företagsintern” funktionalitet

🔐 Protected Internal - “Familj + kollegor”

public class BaseService
{
    protected internal void Initialize()  // Både barn-klasser OCH samma assembly
    {
        // Setup-logik
    }
}

📊 Åtkomstnivå-tabell

Modifierare	Samma klass	Barn-klass	Samma projekt	Andra projekt
`private`	✅	❌	❌	❌
`protected`	✅	✅	❌	❌
`internal`	✅	❌	✅	❌
`protected internal`	✅	✅	✅	❌
`public`	✅	✅	✅	✅

🚀 Praktiska exempel

🟢 Grundläggande säkerhet

public class User
{
    private string password;           // 🔐 Hemligt!
    public string Username { get; set; } // 🌍 Alla kan se

    public bool Login(string inputPassword)
    {
        return VerifyPassword(inputPassword);  // ✅ Använder private metod
    }

    private bool VerifyPassword(string input)  // 🔐 Intern säkerhetslogik
    {
        // Hash-jämförelse etc.
        return input == password;
    }
}

🟡 Arv med protected

public class Vehicle
{
    protected string engineType;      // 🔐 Bara Vehicle-familjen
    private string chassisNumber;     // 🔐 Bara Vehicle själv

    protected void StartEngine()      // 🔐 Grundfunktion för alla fordon
    {
        Console.WriteLine($"Startar {engineType} motor");
    }
}

public class Car : Vehicle
{
    public void ShowEngineInfo()
    {
        Console.WriteLine($"Motor: {engineType}");     // ✅ Protected fungerar
        // Console.WriteLine(chassisNumber);          // ❌ Private funkar inte!
    }
}

🔴 Assembly-nivå med internal

// I MyLibrary.dll
internal class ConfigManager       // Bara MyLibrary kan använda
{
    internal static string ApiKey { get; set; }
}

public class PublicService        // Alla kan använda
{
    public void DoWork()
    {
        var key = ConfigManager.ApiKey;  // ✅ Samma assembly
        // Använd API key...
    }
}

// I annat projekt:
// var config = new ConfigManager();  // ❌ Kommer inte fungera!

⚠️ Vanliga misstag

Misstag 1: Allt public

// 🚨 FEL - ingen säkerhet!
public class BankAccount
{
    public decimal balance;           // Farligt!
    public string pin;               // Mycket farligt!
    public void TransferMoney(decimal amount) { }
}

// ✅ RÄTT - skyddad data
public class BankAccount
{
    private decimal balance;          // Säkert!
    private string pin;              // Säkert!

    public void Deposit(decimal amount)     // Kontrollerad åtkomst
    {
        if (amount > 0) balance += amount;
    }
}

Misstag 2: Förvirra protected och private

public class Parent
{
    private string secret = "hemligt";      // Bara Parent
    protected string familySecret = "bara familjen";  // Parent + barn
}

public class Child : Parent
{
    public void ShowSecrets()
    {
        Console.WriteLine(familySecret);     // ✅ Fungerar
        // Console.WriteLine(secret);        // ❌ Fungerar inte!
    }
}

🎯 Design-riktlinjer

Principen om minsta åtkomst

// Börja med private, öppna endast vid behov
public class Calculator
{
    private double lastResult;        // Behöver ingen se utåt

    public double Add(double a, double b)
    {
        lastResult = AddNumbers(a, b);  // Använd private helper
        return lastResult;
    }

    private double AddNumbers(double x, double y)  // Intern hjälpmetod
    {
        return x + y;
    }
}

Interface vs Implementation

public interface IPaymentProcessor
{
    void ProcessPayment(decimal amount);    // Public contract
}

public class CreditCardProcessor : IPaymentProcessor
{
    private string apiKey;                 // Implementation detail

    public void ProcessPayment(decimal amount)
    {
        ValidateCard();                    // Private validation
        SendToBank(amount);                // Private networking
    }

    private void ValidateCard() { /* implementation */ }
    private void SendToBank(decimal amount) { /* implementation */ }
}

📚 Sammanfattning

Åtkomstmoderatorer är din första försvarslinje mot buggar och säkerhetsproblem:

🔒 Private - För känslig data och intern logik
🌍 Public - För API:er och externa gränssnitt
👨‍👩‍👧‍👦 Protected - För arv och “familje-funktioner”
🏢 Internal - För projekt-intern funktionalitet
🔐 Protected Internal - Kombinationen av protected och internal

Golden Rule: Börja med private och öppna bara vid behov. Det är mycket enklare att göra något mer tillgängligt än att stänga det igen när koden redan används!

😄 Obligatorisk dad joke

Varför är private åtkomstmoderators favorit-restaurang?

För att de äter bara hemma - ingen annan får komma in! 🏠🔐