Backing Fields

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

Automatisch implementierte Eigenschaften sind praktisch, aber manchmal benötigen Sie mehr Kontrolle darüber, wie eine Eigenschaft ihren Wert speichert oder abruft. Hier kommen Backing Fields ins Spiel. Ein Backing Field ist ein privates Feld, das die tatsächlichen Daten für eine Eigenschaft speichert.

public class Product
{
    private decimal _price;  // Backing-Feld
    
    public decimal Price
    {
        get { return _price; }
        set { _price = value; }
    }
}

Das sieht nach Mehrarbeit im Vergleich zu Auto-Properties aus, aber Backing-Fields ermöglichen es Ihnen, Logik hinzuzufügen. Zum Beispiel können Sie Daten validieren, bevor Sie sie speichern:

public class Product
{
    private decimal _price;
    
    public decimal Price
    {
        get => _price;
        set => _price = value < 0 ? 0 : value;
    }
}

Jetzt werden negative Preise automatisch zu Null. Sie können Daten auch beim Lesen oder Schreiben transformieren, Änderungen protokollieren oder andere Aktionen auslösen.

Die Benennungskonvention für Backing Fields verwendet normalerweise ein Unterstrich-Präfix (_price) oder Kleinschreibung (price), um es von der Eigenschaft zu unterscheiden.

Wenn Sie automatisch implementierte Eigenschaften wie public decimal Price { get; set; } verwenden, erstellt der Compiler tatsächlich ein verstecktes Backing-Feld für Sie. Explizite Backing-Felder bieten Ihnen denselben Speicherplatz bei voller Kontrolle über das Verhalten.

Aufgabe

Einfach

Lassen Sie uns ein Temperatursensorsystem bauen, das Backing Fields verwendet, um Daten beim Speichern und Abrufen zu validieren und zu transformieren.

Sie werden zwei Dateien erstellen, um Ihren Code zu organisieren:

TemperatureSensor.cs: Definieren Sie eine TemperatureSensor-Klasse im Namespace Sensors. Dieser Sensor misst die Temperatur in Celsius, aber wir müssen sicherstellen, dass die Messwerte innerhalb gültiger Grenzen bleiben. Verwenden Sie Backing Fields, um Folgendes zu implementieren:
- Eine Location-Eigenschaft (string) mit einem Backing Field _location. Wenn der Standort festgelegt wird und der Wert null oder leer ist, speichern Sie stattdessen "Unknown".
- Eine Temperature-Eigenschaft (double) mit einem Backing Field _temperature. Wenn die Temperatur festgelegt wird, begrenzen Sie den Wert zwischen -50 und 150 (wenn er unter -50 liegt, speichern Sie -50; wenn er über 150 liegt, speichern Sie 150).
- Eine schreibgeschützte Eigenschaft TemperatureFahrenheit, die die Temperatur in Fahrenheit mit der Formel (celsius * 9 / 5) + 32 berechnet und zurückgibt. Diese sollte das Backing Field direkt verwenden.
- Ein Konstruktor, der Werte für den Standort und die Anfangstemperatur akzeptiert.
Program.cs: Erstellen Sie in Ihrer Hauptdatei einen Sensor unter Verwendung von Eingabewerten und zeigen Sie dessen Messwerte an. Aktualisieren Sie dann die Temperatur mit einem zweiten Eingabewert und zeigen Sie die aktualisierten Messwerte an.

Sie erhalten drei Eingaben:

Sensorstandort
Anfänglicher Temperaturmesswert
Aktualisierter Temperaturmesswert

Geben Sie die Ausgabe in diesem Format aus:

Sensor: {Location}
Temperature: {Temperature}C ({TemperatureFahrenheit}F)
Updated Temperature: {Temperature}C ({TemperatureFahrenheit}F)

Wenn die Eingaben beispielsweise Lab Room, 25 und 200 sind, sollte die Ausgabe wie folgt aussehen:

Sensor: Lab Room
Temperature: 25C (77F)
Updated Temperature: 150C (302F)

Beachten Sie, wie der zweite Messwert von 200 auf 150 begrenzt wird, da er die maximale gültige Temperatur überschreitet. Ihre Backing Fields geben Ihnen diese Kontrolle darüber, wie Daten gespeichert werden!

Spickzettel

Ein Backing Field ist ein privates Feld, das die tatsächlichen Daten für eine Eigenschaft speichert und es Ihnen ermöglicht, benutzerdefinierte Logik für das Abrufen und Festlegen von Werten hinzuzufügen.

Grundlegende Backing-Field-Syntax

public class Product
{
    private decimal _price;  // Backing Field
    
    public decimal Price
    {
        get { return _price; }
        set { _price = value; }
    }
}

Expression-Bodied-Syntax

public decimal Price
{
    get => _price;
    set => _price = value;
}

Validierungslogik hinzufügen

Backing Fields ermöglichen es Ihnen, Daten zu validieren oder zu transformieren, bevor sie gespeichert werden:

private decimal _price;

public decimal Price
{
    get => _price;
    set => _price = value < 0 ? 0 : value;  // Negative Preise verhindern
}

Namenskonvention

Backing Fields verwenden in der Regel ein Unterstrich-Präfix (_price) oder Kleinschreibung (price), um sie vom Eigenschaftsnamen zu unterscheiden.

Auto-Properties vs. Backing Fields

Automatisch implementierte Eigenschaften wie public decimal Price { get; set; } erstellen automatisch ein verstecktes Backing Field. Explizite Backing Fields bieten Ihnen denselben Speicherplatz bei voller Kontrolle über das Verhalten.

Probier es selbst

using System;
using Sensors;

class Program
{
    public static void Main(string[] args)
    {
        // Eingaben lesen
        string location = Console.ReadLine();
        double initialTemp = Convert.ToDouble(Console.ReadLine());
        double updatedTemp = Convert.ToDouble(Console.ReadLine());

        // TODO: Erstellen Sie einen TemperatureSensor mit dem Standort und der Anfangstemperatur

        // TODO: Geben Sie den Sensorstandort und die ersten Temperaturmesswerte aus
        // Format: "Sensor: {Location}"
        // Format: "Temperature: {Temperature}C ({TemperatureFahrenheit}F)"

        // TODO: Aktualisieren Sie die Temperatur des Sensors mit dem aktualisierten Wert

        // TODO: Geben Sie die aktualisierten Temperaturmesswerte aus
        // Format: "Updated Temperature: {Temperature}C ({TemperatureFahrenheit}F)"
    }
}