Search
Close this search box.
Ein Entwickler, der Code in Visual Studio schreibt und den C#-Zugriffsmodifizierer verwendet.

C# Zugriffsmodifizierer: Eine Übersicht

In der Programmiersprache C# gibt es eine Vielzahl von Zugriffsmodifizierern, die bestimmen, wer auf eine bestimmte Klasse, ein Feld, eine Methode oder ein Attribut zugreifen darf. Zugriffsmodifizierer sind wichtig, um die Sichtbarkeit von Code-Elementen zu steuern und sicherzustellen, dass sie nur von den richtigen Stellen aus zugänglich sind. In diesem Artikel werden wir uns die verschiedenen Zugriffsmodifizierer in C# ansehen und ihre Funktionen und Anwendungen erklären.

C# bietet fünf verschiedene Zugriffsmodifizierer, die auf unterschiedliche Bereiche des Codes angewendet werden können. Hier sind die verschiedenen Zugriffsmodifizierer, die in C# verfügbar sind:

  1. public: Ein öffentlicher Zugriffsmodifizierer ermöglicht den Zugriff auf ein Element von überall aus. Eine Klasse, ein Feld, eine Methode oder ein Attribut, das als public deklariert ist, kann von jeder anderen Klasse oder jedem anderen Code-Element aus aufgerufen werden.

  2. private: Ein privater Zugriffsmodifizierer beschränkt den Zugriff auf das Element auf die Klasse, in der es definiert ist. Ein privates Feld, eine private Methode oder ein privates Attribut kann nur innerhalb der Klasse aufgerufen werden, in der es definiert ist. Es ist nicht von anderen Klassen oder Code-Elementen aus zugänglich.

  3. protected: Ein geschützter Zugriffsmodifizierer erlaubt den Zugriff auf das Element innerhalb der Klasse, in der es definiert ist, sowie in allen abgeleiteten Klassen. Eine geschützte Methode, ein geschütztes Feld oder ein geschütztes Attribut kann also von jeder Klasse aus aufgerufen werden, die von der ursprünglichen Klasse abgeleitet ist.

  4. internal: Ein interner Zugriffsmodifizierer ermöglicht den Zugriff auf das Element innerhalb der Assembly, in der es definiert ist. Eine Assembly ist eine Sammlung von Code-Dateien, die als Einheit kompiliert werden. Ein interner Typ, ein internes Feld oder eine interne Methode kann von jeder Klasse innerhalb derselben Assembly aufgerufen werden, aber von keiner Klasse außerhalb der Assembly.

  5. protected internal: Ein geschützt-interner Zugriffsmodifizierer ermöglicht den Zugriff auf das Element innerhalb der Assembly, in der es definiert ist, sowie in allen abgeleiteten Klassen, unabhängig davon, ob sie sich in derselben oder einer anderen Assembly befinden. Ein geschützt-interner Typ, ein geschützt-internes Feld oder eine geschützt-interne Methode kann von jeder Klasse aus aufgerufen werden, die entweder von der ursprünglichen Klasse abgeleitet ist oder sich in derselben Assembly befindet.

Hier sind einige Beispiele für Zugriffsmodifizierer in C#:

  • Beispiel für private Zugriffmodifizierer:
				
					class Beispielklasse
{
    private int privateVariable = 42;

    private void privateMethode()
    {
        Console.WriteLine("Dies ist eine private Methode.");
    }

    public void PublicMethode()
    {
        Console.WriteLine("Dies ist eine öffentliche Methode, die auf die private Variable zugreift: " + privateVariable);
        privateMethode();
    }
}

				
			

In diesem Beispiel sind sowohl die Variable als auch die Methode als privat deklariert. Dies bedeutet, dass sie nur innerhalb der Klasse Beispielklasse zugänglich sind. Die öffentliche Methode PublicMethode kann jedoch auf die private Variable und die private Methode zugreifen und sie verwenden.

  • Beispiel für protected Zugriffmodifizierer:
				
					class Fahrzeug
{
    protected int geschwindigkeit;

    public virtual void Beschleunigen()
    {
        geschwindigkeit += 10;
        Console.WriteLine("Das Fahrzeug beschleunigt auf " + geschwindigkeit + " km/h.");
    }
}

class Auto : Fahrzeug
{
    public override void Beschleunigen()
    {
        geschwindigkeit += 20;
        Console.WriteLine("Das Auto beschleunigt auf " + geschwindigkeit + " km/h.");
    }
}

class Beispiel
{
    static void Main()
    {
        Fahrzeug fahrzeug = new Fahrzeug();
        fahrzeug.Beschleunigen(); // Das Fahrzeug beschleunigt auf 10 km/h.

        Auto auto = new Auto();
        auto.Beschleunigen(); // Das Auto beschleunigt auf 20 km/h.
    }
}

				
			

In diesem Beispiel ist die Variable geschwindigkeit als protected deklariert. Dies bedeutet, dass sie in der Klasse Fahrzeug und in allen Klassen, die von Fahrzeug erben, zugänglich ist. Die Klasse Auto erbt von Fahrzeug und überschreibt die Methode Beschleunigen. Diese Methode kann auf die geschwindigkeit-Variable zugreifen und sie verwenden, da sie von der Basisklasse geerbt wird.

  • Beispiel für internal Zugriffmodifizierer:
				
					class Beispielklasse
{
    internal int interneVariable = 42;

    internal void InterneMethode()
    {
        Console.WriteLine("Dies ist eine interne Methode.");
    }
}

class AndereKlasse
{
    static void Main()
    {
        Beispielklasse beispiel = new Beispielklasse();
        Console.WriteLine("Der Wert der internen Variable ist: " + beispiel.interneVariable);
        beispiel.InterneMethode();
    }
}

				
			

In diesem Beispiel sind sowohl die Variable als auch die Methode als internal deklariert. Dies bedeutet, dass sie innerhalb desselben Assemblys (Kompilierungseinheiten) zugänglich sind. In diesem Fall sind die Klassen Beispielklasse und AndereKlasse Teil desselben Assemblys, sodass AndereKlasse auf die interne Variable und Methode von Beispielklasse zugreifen kann.

  • Beispiel für protected internal Zugriffmodifizierer:
				
					public class Fahrzeug
{
    // protected internal Feld
    protected internal string Modellname;

    // Konstruktor
    public Fahrzeug(string modellname)
    {
        Modellname = modellname;
    }

    // protected interne Methode
    protected internal void Beschleunigen()
    {
        Console.WriteLine(Modellname + " beschleunigt!");
    }
}

public class Auto : Fahrzeug
{
    // Konstruktor
    public Auto(string modellname) : base(modellname)
    {
    }

    // öffentliche Methode, die auf die protected interne Methode zugreift
    public void AutoBeschleunigen()
    {
        Beschleunigen();
    }
}

public class Program
{
    static void Main(string[] args)
    {
        Auto meinAuto = new Auto("BMW");
        meinAuto.AutoBeschleunigen(); // gibt "BMW beschleunigt!" aus
    }
}

				
			

In diesem Beispiel wird die Klasse Fahrzeug definiert, die ein Feld Modellname und eine Methode Beschleunigen enthält. Beide haben den Zugriffmodifizierer protected internal.

Die Klasse Auto erbt von der Klasse Fahrzeug und enthält eine öffentliche Methode AutoBeschleunigen, die auf die Beschleunigen-Methode der Basisklasse zugreift. Da Beschleunigen den Zugriffsmodifizierer protected internal hat, kann auf die Methode von einer abgeleiteten Klasse und aus demselben Assembly zugegriffen werden.

In der Main-Methode wird ein Objekt der Klasse Auto erstellt und die AutoBeschleunigen-Methode aufgerufen, die dann die Beschleunigen-Methode aufruft und den Modellnamen des Autos ausgibt.

Fazit: Zugriffsmodifizierer sind ein wichtiger Bestandteil der Programmierung mit C#. Sie ermöglichen es, die Sichtbarkeit von Code-Elementen zu steuern und sicherzustellen

Aufgabe:

Aufgabe zum Mitmachen:

Erstelle eine C#-Klasse „Person“ mit den folgenden Eigenschaften und Methoden:

Eigenschaften:

  • Name (private)
  • Alter (public)
  • Geschlecht (protected)

Methoden:

  • GetFullName() (public)
  • SetName() (private)
  • SetGender() (protected)

Die SetName()-Methode soll den Namen der Person setzen und die SetGender()-Methode soll das Geschlecht setzen. Die GetFullName()-Methode soll den vollständigen Namen der Person zurückgeben.

Erstelle dann eine weitere Klasse „Student“, die von der „Person“-Klasse erbt. Die „Student“-Klasse soll eine öffentliche Methode „Study()“ enthalten, die „Ich studiere“ auf der Konsole ausgibt.

Um die Lösung anzuzeigen, fahre mit der Maus in die Mitte des darunterliegenden Fensters.

				
					using System;

public class Person
{
    private string Name;
    public int Age;
    protected string Gender;

    public Person(string name, int age, string gender)
    {
        SetName(name);
        Age = age;
        SetGender(gender);
    }

    public string GetFullName()
    {
        return Name;
    }

    private void SetName(string name)
    {
        Name = name;
    }

    protected void SetGender(string gender)
    {
        Gender = gender;
    }
}

public class Student : Person
{
    public Student(string name, int age, string gender) : base(name, age, gender)
    {

    }

    public void Study()
    {
        Console.WriteLine("Ich studiere.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Student student = new Student("Max Mustermann", 20, "männlich");
        Console.WriteLine("Name: " + student.GetFullName());
        Console.WriteLine("Alter: " + student.Age);
        student.Study();
    }
}

				
			

In diesem Beispiel wird die „Person“-Klasse mit den Eigenschaften „Name“, „Age“ und „Gender“ erstellt. Die „SetName()“ und „SetGender()“ Methoden sind private bzw. protected und können nur innerhalb der Klasse und ihren abgeleiteten Klassen aufgerufen werden. Die „GetFullName()“ Methode ist öffentlich und gibt den Namen zurück.

Die „Student“-Klasse erbt von der „Person“-Klasse und enthält eine öffentliche Methode „Study()“, die einfach „Ich studiere.“ auf der Konsole ausgibt.

In der Main-Methode wird eine Instanz der „Student“-Klasse erstellt und der Name, das Alter und die „Study()“ Methode aufgerufen.

Zurück zum vorherigen Teil des C# Kurses
Klicken Sie auf den Pfeil, um zum vorherigen Teil des Kurses zurückzukehren
Pfeil-Button zum nächsten Teil des Kurses
Klicken Sie auf den Pfeil, um zum nächsten Teil des Kurses zu gelangen