C# - Verkapselung: Ein Anfängerleitfaden

Hallo da draußen, zukünftiger Codingsuperstar! Heute machen wir uns auf eine aufregende Reise in die Welt von C# und erkunden eines seiner grundlegenden Konzepte: Verkapselung. Mach dir keine Sorgen, wenn du noch nie eine Zeile Code geschrieben hast – ich bin hier, um dich Schritt für Schritt zu führen. Also, tauchen wir ein!

Was ist Verkapselung?

Bevor wir uns den Details widmen, lassen's uns verstehen, was Verkapselung überhaupt ist. Stell dir vor, du hast eine magische Box, die erstaunliche Dinge tun kann, aber du musst nicht wissen, wie sie innen funktioniert – du musst nur wissen, wie man sie verwendet. Das ist Verkapselung in der Kürze!

In C# geht es bei der Verkapselung darum, Daten (Variablen) und die Methoden, die mit diesen Daten operieren, in einer Einheit oder einem Objekt zu bündeln. Es ist so, als würde man um deinen Code eine schützende Kapsel erstellen, daher der Name "Verkapselung".

Nun, lassen's uns erkunden, wie C# die Verkapselung durch Zugriffsbezeichner implementiert.

Zugriffsbezeichner in C

Zugriffsbezeichner sind Schlüsselwörter, die die Zugriffsrechte einer Klasse, Methode oder Eigenschaft in deinem Code definieren. Denke daran als verschiedene Sicherheitsstufen. C# bietet fünf Hauptzugriffsbezeichner:

1. Public
2. Private
3. Protected
4. Internal
5. Protected Internal

Lassen's sie einzeln durchgehen.

Public-Zugriffsbezeichner

Das public Schlüsselwort ist wie ein "Zugangforall Areas"-Pass. Wenn du ein Mitglied als public deklarierst, kann es von jedem Teil deines Programms aus erreicht werden.

public class Person
{
public string Name { get; set; }

public void SayHello()
{
Console.WriteLine($"Hallo, mein Name ist {Name}!");
}
}

class Program
{
static void Main(string[] args)
{
Person person = new Person();
person.Name = "Alice";  // Public-Eigenschaft wird erreicht
person.SayHello();  // Public-Methode wird aufgerufen
}
}

In diesem Beispiel sind sowohl Name als auch SayHello() public, daher können wir sie direkt aus der Main-Methode erreichen.

Private-Zugriffsbezeichner

private ist wie ein "nur für Mitarbeiter"-Bereich. Private Mitglieder können nur innerhalb derselben Klasse erreicht werden.

public class BankAccount
{
private double balance;

public void Deposit(double amount)
{
if (amount > 0)
{
balance += amount;
}
}

public double GetBalance()
{
return balance;
}
}

class Program
{
static void Main(string[] args)
{
BankAccount account = new BankAccount();
account.Deposit(100);
// account.balance = 1000000;  // Dies würde einen Fehler verursachen!
Console.WriteLine($"Guthaben: {account.GetBalance()}");
}
}

Hier ist balance privat, daher können wir nicht direkt von außerhalb der BankAccount-Klasse darauf zugreifen. Wir müssen öffentliche Methoden wie Deposit() und GetBalance() verwenden, um mit ihr zu interagieren.

Protected-Zugriffsbezeichner

protected Mitglieder sind zugänglich innerhalb derselben Klasse und von abgeleiteten Klassen. Es ist wie ein "nur für die Familie"-Bereich.

public class Animal
{
protected string name;

public Animal(string name)
{
this.name = name;
}

protected void Eat()
{
Console.WriteLine($"{name} isst.");
}
}

public class Dog : Animal
{
public Dog(string name) : base(name) { }

public void Bark()
{
Console.WriteLine($"{name} bellt!");  // Kann auf protected Mitglied zugreifen
Eat();  // Kann protected Methode aufrufen
}
}

class Program
{
static void Main(string[] args)
{
Dog dog = new Dog("Buddy");
dog.Bark();
// dog.name = "Max";  // Dies würde einen Fehler verursachen!
// dog.Eat();  // Dies würde ebenfalls einen Fehler verursachen!
}
}

In diesem Beispiel kann Dog auf die protected name und Eat() Methode aus seiner Elternklasse Animal zugreifen, aber wir können diese nicht direkt aus Main erreichen.

Internal-Zugriffsbezeichner

internal Mitglieder sind zugänglich innerhalb desselben Assemblierens (denke an ein kompiliertes .dll oder .exe Datei). Es ist wie ein "nur für Unternehmensmitarbeiter"-Bereich.

// In AssemblyOne.cs
internal class InternalClass
{
internal void InternalMethod()
{
Console.WriteLine("Dies ist eine interne Methode.");
}
}

// In Program.cs (gleiche Assemblierung)
class Program
{
static void Main(string[] args)
{
InternalClass obj = new InternalClass();
obj.InternalMethod();  // Dies funktioniert!
}
}

// In einer anderen Assemblierung, dies würde nicht funktionieren:
// InternalClass obj = new InternalClass();  // Fehler!

Protected Internal-Zugriffsbezeichner

Schließlich ist protected internal eine Kombination aus protected und internal. Es ist zugänglich innerhalb desselben Assemblierens oder von abgeleiteten Klassen in anderen Assemblierungen.

// In AssemblyOne.cs
public class BaseClass
{
protected internal void ProtectedInternalMethod()
{
Console.WriteLine("Dies ist eine protected internal Methode.");
}
}

// In AssemblyTwo.cs
public class DerivedClass : BaseClass
{
public void CallProtectedInternalMethod()
{
ProtectedInternalMethod();  // Dies funktioniert!
}
}

// In Program.cs (AssemblyTwo)
class Program
{
static void Main(string[] args)
{
DerivedClass obj = new DerivedClass();
obj.CallProtectedInternalMethod();
// obj.ProtectedInternalMethod();  // Dies würde nicht funktionieren!
}
}

Zusammenfassung der Zugriffsbezeichner

Hier ist eine praktische Tabelle, die die Zugriffsstufen zusammenfasst:

Zugriffsbezeichner	Selbe Klasse	Abgeleitete Klasse (gleiche Assemblierung)	Nicht abgeleitete Klasse (gleiche Assemblierung)	Abgeleitete Klasse (andere Assemblierung)	Nicht abgeleitete Klasse (andere Assemblierung)
Public	Ja	Ja	Ja	Ja	Ja
Private	Ja	Nein	Nein	Nein	Nein
Protected	Ja	Ja	Nein	Ja	Nein
Internal	Ja	Ja	Ja	Nein	Nein
Protected Internal	Ja	Ja	Ja	Ja	Nein

Und das war's! Du hast gerade deine ersten Schritte in die Welt der Verkapselung in C# unternommen. Denke daran, Verkapselung dreht sich alles um die Kontrolle des Zugriffs auf deinen Code und deine Daten. Es hilft dir, sicherere, wartbarere und flexiblere Programme zu schreiben.

Während du deine编码-Reise fortsetzt, wirst du feststellen, dass Verkapselung zur zweiten Natur wird. Es ist wie das Fahrradfahren zu lernen – am Anfang etwas wackelig, aber bald wirst du ohne nachzudenken davonrasen!

Weiters üben, neugierig bleiben und viel Spaß beim Coden!

Credits: Image by storyset