Vollständige Properties mit Backing Fields
Fügen Sie Gettern und Settern eigene Logik hinzu.
Vollständige Properties mit Backing Fields ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.
Über automatisch implementierte Eigenschaften hinaus
Wenn Sie Logik innerhalb von get oder set benötigen, schreiben Sie eine vollständige Eigenschaft mit einem expliziten Backing-Feld. Das Feld speichert die Daten, während die Accessoren den Zugriff steuern.
using System;
class Temperature
{
private double _celsius;
public double Celsius
{
get { return _celsius; }
set { _celsius = value; }
}
}
class Program
{
static void Main()
{
var t = new Temperature();
t.Celsius = 21.5;
Console.WriteLine(t.Celsius);
}
}Konvention für Backing-Felder
Gemäß Konvention ist ein Backing-Feld private und trägt einen führenden Unterstrich, beispielsweise _name. Die öffentliche Eigenschaft stellt es bereit.
using System;
class Person
{
private string _name;
public string Name
{
get { return _name; }
set { _name = value; }
}
}
class Program
{
static void Main()
{
var p = new Person();
p.Name = "Grace";
Console.WriteLine(p.Name);
}
}Das Schlüsselwort value
Innerhalb eines set-Accessors enthält der implizite Parameter value den zugewiesenen Wert. Sie entscheiden, wie Sie damit umgehen.
using System;
class Box
{
private int _size;
public int Size
{
get { return _size; }
set { _size = value * 2; }
}
}
class Program
{
static void Main()
{
var box = new Box();
box.Size = 10;
Console.WriteLine("Stored size: " + box.Size);
}
}Validierung im Setter
Eine häufige Verwendung einer vollständigen Eigenschaft besteht darin, Eingaben vor dem Speichern zu validieren und bei einem ungültigen Wert eine Ausnahme auszulösen.
using System;
class Account
{
private decimal _balance;
public decimal Balance
{
get { return _balance; }
set
{
if (value < 0)
throw new ArgumentException("Balance cannot be negative");
_balance = value;
}
}
}
class Program
{
static void Main()
{
var a = new Account();
a.Balance = 500m;
Console.WriteLine("Balance: " + a.Balance);
}
}Berechnete (schreibgeschützte) Eigenschaften
Eine Eigenschaft, die nur über einen get-Accessor verfügt, kann ihren Wert aus anderen Feldern berechnen. Da nichts gespeichert wird, gibt es kein Backing-Feld.
using System;
class Rectangle
{
private double _width;
private double _height;
public Rectangle(double w, double h)
{
_width = w;
_height = h;
}
public double Area
{
get { return _width * _height; }
}
}
class Program
{
static void Main()
{
var r = new Rectangle(4, 5);
Console.WriteLine("Area: " + r.Area);
}
}Seiteneffekte in Settern
Ein Setter kann mehr tun, als nur zu speichern: Er kann Eingaben normalisieren, zugehörigen Zustand aktualisieren oder Änderungen protokollieren.
using System;
class User
{
private string _email;
public string Email
{
get { return _email; }
set { _email = value.Trim().ToLower(); }
}
}
class Program
{
static void Main()
{
var u = new User();
u.Email = " Hello@Example.COM ";
Console.WriteLine("Normalized: " + u.Email);
}
}Verzögerte Berechnung in einem Getter
Ein Getter kann ein aufwendiges Ergebnis beim ersten Abruf in einem Backing-Feld zwischenspeichern.
using System;
class Report
{
private string _cached;
public string Content
{
get
{
if (_cached == null)
_cached = "Generated at runtime";
return _cached;
}
}
}
class Program
{
static void Main()
{
var r = new Report();
Console.WriteLine(r.Content);
Console.WriteLine(r.Content);
}
}Ungültigen Zustand verhindern
Kombinieren Sie ein Backing-Feld mit Logik, damit ein Objekt immer gültig bleibt. Hier begrenzt der Setter den Wert auf einen bestimmten Bereich.
using System;
class Volume
{
private int _level;
public int Level
{
get { return _level; }
set
{
if (value < 0) _level = 0;
else if (value > 100) _level = 100;
else _level = value;
}
}
}
class Program
{
static void Main()
{
var v = new Volume();
v.Level = 150;
Console.WriteLine("Clamped: " + v.Level);
}
}Gespeicherte und berechnete Werte kombinieren
Eine Klasse kombiniert häufig gespeicherte Eigenschaften mit Backing-Feldern und daraus abgeleitete, berechnete schreibgeschützte Eigenschaften.
using System;
class Employee
{
private string _first;
private string _last;
public string First { get { return _first; } set { _first = value; } }
public string Last { get { return _last; } set { _last = value; } }
public string FullName { get { return _first + " " + _last; } }
}
class Program
{
static void Main()
{
var e = new Employee { First = "Marie", Last = "Curie" };
Console.WriteLine(e.FullName);
}
}Änderungsbenachrichtigungen auslösen
Setter sind der natürliche Ort, um bei Datenänderungen eine Benachrichtigung auszulösen – ein Muster, das häufig in UI-Frameworks verwendet wird.
using System;
class Model
{
private int _count;
public int Count
{
get { return _count; }
set
{
if (_count != value)
{
_count = value;
Console.WriteLine("Count changed to " + _count);
}
}
}
}
class Program
{
static void Main()
{
var m = new Model();
m.Count = 1;
m.Count = 1;
m.Count = 2;
}
}Alles zusammenführen
Vollständige Eigenschaften ermöglichen es einer Klasse, Invarianten durchzusetzen und abgeleitete Daten bereitzustellen – und das alles hinter einer übersichtlichen, feldähnlichen Schnittstelle.
using System;
class Thermostat
{
private double _target;
public double Target
{
get { return _target; }
set { _target = value < 10 ? 10 : value; }
}
public string Status { get { return _target >= 22 ? "Warm" : "Cool"; } }
}
class Program
{
static void Main()
{
var th = new Thermostat();
th.Target = 5;
Console.WriteLine(th.Target + " -> " + th.Status);
th.Target = 24;
Console.WriteLine(th.Target + " -> " + th.Status);
}
}Kurze Überprüfung
Testen Sie Ihr Verständnis von vollständigen Eigenschaften.
Zusammenfassung
Eine vollständige Eigenschaft verbindet ein privates Backing-Feld mit expliziten get- und set-Accessoren. Dadurch können Sie Validierung, Normalisierung, Caching oder Änderungsbenachrichtigungen hinzufügen. Berechnete schreibgeschützte Eigenschaften verfügen nur über einen Getter und kein Backing-Feld. Das Schlüsselwort value enthält im Setter den zugewiesenen Wert.
using System;
class Demo
{
private int _n;
public int N
{
get { return _n; }
set { _n = value < 0 ? 0 : value; }
}
public int Doubled { get { return _n * 2; } }
}
class Program
{
static void Main()
{
var d = new Demo();
d.N = -5;
Console.WriteLine(d.N + ", " + d.Doubled);
}
}Häufig gestellte Fragen
Ist die Lektion „Vollständige Properties mit Backing Fields“ kostenlos?
Ja — der vollständige Text von „Vollständige Properties mit Backing Fields“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Vollständige Properties mit Backing Fields“?
Fügen Sie Gettern und Settern eigene Logik hinzu. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um C# Academy zu starten?
Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Vollständige Properties mit Backing Fields“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?
Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Automatisch implementierte Properties
- Vollständige Properties mit Backing Fields
- Ausdruckskörper für Member
- Indexer