Properties zur Kapselung

Teil des Abschnitts Objektorientierte Programmierung der C#-Journey von Coddy — Lektion 32 von 70.

Properties sind das primäre Werkzeug zur Implementierung von Kapselung in C#. Anstatt Felder direkt offenzulegen, umschließen Sie diese mit Properties, die steuern, wie auf Daten zugegriffen wird und wie diese geändert werden.

Das Muster kombiniert ein privates Feld mit einer öffentlichen Eigenschaft, die Validierung oder Logik in ihren Accessoren enthält:

public class Temperature
{
    private double celsius;
    
    public double Celsius
    {
        get { return celsius; }
        set
        {
            if (value < -273.15)
                celsius = -273.15;  // Minimum am absoluten Nullpunkt
            else
                celsius = value;
        }
    }
}

Jetzt kann externer Code keine unmögliche Temperatur festlegen. Die Eigenschaft fungiert als Gatekeeper und stellt sicher, dass Ihr Objekt immer in einem gültigen Zustand bleibt. Dies ist Kapselung in Aktion – die internen Daten sind geschützt, während sie dennoch über eine kontrollierte Schnittstelle zugänglich bleiben.

Sie können Eigenschaften auch verwenden, um Werte zu berechnen oder Seiteneffekte auszulösen:

public double Fahrenheit
{
    get { return celsius * 9 / 5 + 32; }
    set { celsius = (value - 32) * 5 / 9; }
}

Die Außenwelt sieht zwei Properties, aber intern gibt es nur ein Feld. Properties ermöglichen es Ihnen, Implementierungsdetails zu ändern, ohne Code zu beeinträchtigen, der Ihre Klasse verwendet – ein wesentlicher Vorteil einer sauberen Kapselung.

Aufgabe

Einfach

Lassen Sie uns ein Produktinventarsystem erstellen, das Eigenschaften nutzt, um die Datenintegrität zu schützen. Sie werden eine Klasse erstellen, in der Preise niemals negativ sein können und Mengen immer innerhalb gültiger Grenzen gehalten werden – dies demonstriert, wie Eigenschaften als Wächter für Ihre Daten fungieren.

Sie werden Ihren Code auf zwei Dateien aufteilen:

Product.cs: Erstellen Sie eine Product-Klasse im Namespace Inventory, die Produktinformationen mit Validierung durch Eigenschaften verwaltet. Ihr Produkt benötigt:
- Ein privates Feld price (decimal) mit einer öffentlichen Price-Eigenschaft, die sicherstellt, dass der Preis niemals unter 0 fällt – wenn jemand versucht, einen negativen Preis festzulegen, sollte dieser stattdessen als 0 gespeichert werden
- Ein privates Feld quantity (int) mit einer öffentlichen Quantity-Eigenschaft, die Werte zwischen 0 und 1000 hält – Werte unter 0 werden zu 0, Werte über 1000 werden zu 1000
- Eine öffentliche automatisch implementierte Eigenschaft Name (string)
- Eine berechnete schreibgeschützte Eigenschaft TotalValue, die Price * Quantity zurückgibt
Fügen Sie einen Konstruktor hinzu, der Name, Preis und Menge (in dieser Reihenfolge) akzeptiert und alle Werte über die Eigenschaften setzt, damit die Validierung angewendet wird.
Program.cs: Erstellen Sie in Ihrer Hauptdatei ein Product unter Verwendung von Eingabewerten. Versuchen Sie dann, den Preis und die Menge mit zusätzlichen Eingabewerten zu ändern, die ungültig sein könnten. Geben Sie den Zustand des Produkts nach der Erstellung und nach jeder Änderung aus, um zu sehen, wie die Eigenschaften die Daten schützen.

Sie erhalten fünf Eingaben:

Produktname
Anfangspreis (decimal)
Anfangsmenge (integer)
Neuer festzulegender Preis (decimal, kann negativ sein)
Neue festzulegende Menge (integer, kann außerhalb des Bereichs liegen)

Geben Sie die Ausgabe in diesem Format aus:

After creation:
{Name}: Price={Price}, Qty={Quantity}, Total={TotalValue}
After modifications:
{Name}: Price={Price}, Qty={Quantity}, Total={TotalValue}

Wenn die Eingaben beispielsweise Laptop, 999.99, 50, -100 und 1500 sind, sollte die Ausgabe wie folgt aussehen:

After creation:
Laptop: Price=999.99, Qty=50, Total=49999.50
After modifications:
Laptop: Price=0, Qty=1000, Total=0

Beachten Sie, wie der negative Preis zu 0 wurde und die Menge von 1500 auf 1000 begrenzt wurde. Ihre Eigenschaften schützen das Objekt vor ungültigen Zuständen – das ist Kapselung in Aktion!

Spickzettel

Eigenschaften (Properties) kapseln private Felder mit kontrolliertem Zugriff über get- und set-Accessoren und ermöglichen so Validierung und Kapselung:

public class Temperature
{
    private double celsius;
    
    public double Celsius
    {
        get { return celsius; }
        set
        {
            if (value < -273.15)
                celsius = -273.15;
            else
                celsius = value;
        }
    }
}

Eigenschaften können Werte basierend auf internen Feldern berechnen:

public double Fahrenheit
{
    get { return celsius * 9 / 5 + 32; }
    set { celsius = (value - 32) * 5 / 9; }
}

Schreibgeschützte Eigenschaften lassen den set-Accessor weg und ermöglichen nur das Abrufen von berechneten oder gespeicherten Werten.

Probier es selbst

using System;
using Inventory;

class Program
{
    public static void Main(string[] args)
    {
        // Eingaben lesen
        string name = Console.ReadLine();
        decimal initialPrice = Convert.ToDecimal(Console.ReadLine());
        int initialQuantity = Convert.ToInt32(Console.ReadLine());
        decimal newPrice = Convert.ToDecimal(Console.ReadLine());
        int newQuantity = Convert.ToInt32(Console.ReadLine());

        // TODO: Erstellen Sie ein Produkt mit den Anfangswerten
        
        // TODO: Geben Sie den Produktzustand nach der Erstellung aus
        Console.WriteLine("After creation:");
        // Ausgabeformat: {Name}: Price={Price}, Qty={Quantity}, Total={TotalValue}
        
        // TODO: Ändern Sie den Preis und die Menge mit den neuen Werten
        
        // TODO: Geben Sie den Produktzustand nach den Änderungen aus
        Console.WriteLine("After modifications:");
        // Ausgabeformat: {Name}: Price={Price}, Qty={Quantity}, Total={TotalValue}
    }
}