C# Geschachtelte Klassen verstehen: Definition, Verwendung und Vererbung

C# Geschachtelte Klassen verstehen

Erkunden Sie, wie man geschachtelte Klassen in C# definiert, zugreift und vererbt, mit praktischen Beispielen, die Best Practices demonstrieren.

In C# kann eine Klasse innerhalb einer anderen Klasse deklariert werden. Der innere Typ wird als geschachtelte Klasse bezeichnet. Zum Beispiel:

class OuterClass {
    // ... äußere Member
    class InnerClass {
        // ... innere Member
    }
}

Dieses Beispiel erstellt InnerClass innerhalb von OuterClass. Der innere Typ ist nur innerhalb des äußeren Typs sichtbar, es sei denn, sein Zugriffsmodifizierer erlaubt anderes.

---

Auf geschachtelte Klassenmember zugreifen

Um mit geschachtelten Typen zu arbeiten, instanziieren Sie zuerst jede Klasse separat.

1. Instanz der äußeren Klasse erstellen

OuterClass outer = new OuterClass();

Hier ist outer ein Objekt von OuterClass.

2. Instanz der geschachtelten Klasse erstellen

OuterClass.InnerClass inner = new OuterClass.InnerClass();

Da InnerClass in OuterClass geschachtelt ist, qualifizieren Sie es mit dem äußeren Typnamen.

Nach der Instanziierung können Sie Member über die Objektreferenz aufrufen.

Beispiel: Geschachtelte Klasse mit Methoden

using System;
namespace NestedClassDemo {
    public class Car {
        public void DisplayCar() => Console.WriteLine("Car: Bugatti");
        public class Engine {
            public void DisplayEngine() => Console.WriteLine("Engine: Petrol Engine");
        }
    }
    class Program {
        static void Main(string[] args) {
            Car sportsCar = new Car();
            sportsCar.DisplayCar();
            Car.Engine petrolEngine = new Car.Engine();
            petrolEngine.DisplayEngine();
            Console.ReadLine();
        }
    }
}

Ausgabe

Car: Bugatti Engine: Petrol Engine

Das Beispiel zeigt, wie man Objekte sowohl der äußeren Car als auch der geschachtelten Engine erstellt und deren Methoden aufruft.

Beachten Sie, dass Sie eine Methode des geschachtelten Typs nicht direkt von der äußeren Instanz aufrufen können:

// Ungültig
sportsCar.DisplayEngine();

Auf äußere Klassenmember von innerhalb einer geschachtelten Klasse zugreifen

Geschachtelte Klassen können Member ihres enthaltenden Typs referenzieren. Sie können eine Instanz des äußeren Typs oder den äußeren Typnamen für statische Member verwenden.

Instanzzugriff auf Instanzmember

using System;
namespace NestedClassDemo {
    public class Car {
        public string Brand = "Bugatti";
        public class Engine {
            public void ShowBrand() {
                Car car = new Car();
                Console.WriteLine("Brand: " + car.Brand);
            }
        }
    }
    class Program {
        static void Main(string[] args) {
            Car.Engine engine = new Car.Engine();
            engine.ShowBrand();
            Console.ReadLine();
        }
    }
}

Ausgabe

Brand: Bugatti

Statische Member ohne Instanziierung zugreifen

using System;
namespace NestedClassDemo {
    public class Car {
        public static string Brand = "Bugatti";
        public class Engine {
            public void ShowBrand() {
                Console.WriteLine("Brand: " + Car.Brand);
            }
        }
    }
    class Program {
        static void Main(string[] args) {
            Car.Engine engine = new Car.Engine();
            engine.ShowBrand();
            Console.ReadLine();
        }
    }
}

Ausgabe

Brand: Bugatti

Vererbung mit geschachtelten Klassen

Geschachtelte Klassen können an Vererbung teilnehmen wie jeder andere Typ.

Klasse von einer äußeren Klasse ableiten

using System;
namespace NestedClassDemo {
    class Computer {
        public void Display() => Console.WriteLine("Method of Computer class");
        public class CPU {
            // Weitere Member können hier hinzugefügt werden
        }
    }
    class Laptop : Computer {
        // Laptop erbt alle Member von Computer
    }
    class Program {
        static void Main(string[] args) {
            Laptop laptop = new Laptop();
            laptop.Display();
            Console.ReadLine();
        }
    }
}

Ausgabe

Method of Computer class

Klasse von einer geschachtelten Klasse ableiten

using System;
namespace NestedClassDemo {
    class Computer {
        public class CPU {
            public void Display() => Console.WriteLine("Method of CPU class");
        }
    }
    class Laptop : Computer.CPU {
        // Laptop erbt Member von Computer.CPU
    }
    class Program {
        static void Main(string[] args) {
            Laptop laptop = new Laptop();
            laptop.Display();
            Console.ReadLine();
        }
    }
}

Ausgabe

Method of CPU class

Beim Erben einer geschachtelten Klasse müssen Sie den Typ mit seinem äußeren Klassennamen qualifizieren, z.B. Computer.CPU.