Automatisch implementierte Properties
Deklarieren Sie Properties mit der kompakten Auto-Syntax.
Automatisch implementierte Properties ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.
Was ist eine Eigenschaft?
Eine Eigenschaft sieht von außen wie ein Feld aus, wird aber durch Zugriffsmethoden (get und set) unterstützt. Eigenschaften ermöglichen es Ihnen, Daten bereitzustellen und gleichzeitig zu kontrollieren, wie sie gelesen und geschrieben werden.
using System;
class Program
{
public string Name { get; set; }
static void Main()
{
var p = new Program();
p.Name = "Coddy";
Console.WriteLine(p.Name);
}
}Syntax automatisch implementierter Eigenschaften
Eine automatisch implementierte Eigenschaft verwendet { get; set; }. Der Compiler erzeugt für Sie ein verborgenes Backing-Feld, sodass Sie es nicht von Hand schreiben müssen.
using System;
class Person
{
public string FirstName { get; set; }
public int Age { get; set; }
}
class Program
{
static void Main()
{
var person = new Person { FirstName = "Ada", Age = 36 };
Console.WriteLine(person.FirstName + " is " + person.Age);
}
}Warum Eigenschaften statt Felder verwenden?
Öffentliche Eigenschaften bieten Ihnen eine stabile API. Sie können später eine Validierung hinzufügen oder die Speicherung ändern, ohne den aufrufenden Code zu beeinträchtigen. Öffentliche Felder bieten diese Möglichkeit nicht.
using System;
class Account
{
public decimal Balance { get; set; }
}
class Program
{
static void Main()
{
var a = new Account();
a.Balance = 100.50m;
Console.WriteLine("Balance: " + a.Balance);
}
}Schreibgeschützte automatisch implementierte Eigenschaften
Lassen Sie set weg, um eine Eigenschaft schreibgeschützt zu machen. Sie kann nur im Konstruktor oder über einen Initialisierer zugewiesen werden. Dadurch sind Werte standardmäßig unveränderlich.
using System;
class Circle
{
public double Radius { get; }
public Circle(double radius)
{
Radius = radius;
}
}
class Program
{
static void Main()
{
var c = new Circle(5.0);
Console.WriteLine("Radius: " + c.Radius);
}
}Standardwerte für Eigenschaften
Sie können einer automatisch implementierten Eigenschaft mit = value; einen Anfangswert geben. Dieser wird beim Erstellen des Objekts und vor dem Rumpf eines Konstruktors festgelegt.
using System;
class Settings
{
public bool DarkMode { get; set; } = true;
public int Volume { get; set; } = 50;
}
class Program
{
static void Main()
{
var s = new Settings();
Console.WriteLine("DarkMode: " + s.DarkMode + ", Volume: " + s.Volume);
}
}Private Setter
Mit einem private set kann die Klasse den Wert intern ändern, während externer Code daran gehindert wird, ihn zu verändern. Dies ist ein häufig verwendetes Kapselungsmuster.
using System;
class Counter
{
public int Count { get; private set; }
public void Increment()
{
Count++;
}
}
class Program
{
static void Main()
{
var counter = new Counter();
counter.Increment();
counter.Increment();
Console.WriteLine("Count: " + counter.Count);
}
}Init-only-Setter
Der init-Accessor erlaubt Zuweisungen nur während der Objektinitialisierung (C# 9+). Nach der Erstellung ist der Wert gesperrt.
using System;
class Product
{
public string Name { get; init; }
public decimal Price { get; init; }
}
class Program
{
static void Main()
{
var p = new Product { Name = "Book", Price = 12.99m };
Console.WriteLine(p.Name + ": " + p.Price);
}
}Eigenschaften mit unterschiedlichen Zugriffsebenen
Für Eigenschaften gelten die üblichen Zugriffsmodifizierer. Sie können Ebenen kombinieren: einen öffentlichen Getter mit einem privaten Setter oder eine vollständig interne Eigenschaft.
using System;
class User
{
public string Id { get; private set; }
public User(string id)
{
Id = id;
}
}
class Program
{
static void Main()
{
var u = new User("u-001");
Console.WriteLine("User Id: " + u.Id);
}
}Automatisch implementierte Eigenschaften, die wie Berechnungen aussehen
Automatisch implementierte Eigenschaften speichern Daten, sie berechnen sie nicht. Wenn Sie einen berechneten Wert benötigen, verwenden Sie eine vollständige Eigenschaft, die später behandelt wird. Betrachten Sie automatisch implementierte Eigenschaften vorerst als einfache Speicherung.
using System;
class Rectangle
{
public double Width { get; set; }
public double Height { get; set; }
}
class Program
{
static void Main()
{
var r = new Rectangle { Width = 4, Height = 3 };
double area = r.Width * r.Height;
Console.WriteLine("Area: " + area);
}
}Automatisch implementierte Eigenschaften aktualisieren
Sie können eine setzbare automatisch implementierte Eigenschaft beliebig oft lesen und neu zuweisen, genau wie eine Variable.
using System;
class Player
{
public int Score { get; set; }
}
class Program
{
static void Main()
{
var player = new Player();
player.Score = 10;
player.Score += 5;
player.Score *= 2;
Console.WriteLine("Score: " + player.Score);
}
}Alles zusammenführen
Eine typische Modellklasse besteht größtenteils aus automatisch implementierten Eigenschaften: Einige sind setzbar, andere nur mit init, und wieder andere haben private Setter. Das hält die Klasse kompakt und übersichtlich.
using System;
class BankAccount
{
public string Owner { get; init; }
public decimal Balance { get; private set; }
public void Deposit(decimal amount)
{
Balance += amount;
}
}
class Program
{
static void Main()
{
var acct = new BankAccount { Owner = "Lin" };
acct.Deposit(250m);
Console.WriteLine(acct.Owner + ": " + acct.Balance);
}
}Kurze Überprüfung
Testen Sie Ihr Verständnis von automatisch implementierten Eigenschaften.
Zusammenfassung
Sie haben gelernt, dass automatisch implementierte Eigenschaften { get; set; } mit einem vom Compiler erzeugten Backing-Feld verwenden. Zu den Varianten gehören schreibgeschützte Eigenschaften mit { get; }, private set für kontrollierte Änderungen und init für Werte, die nur einmal festgelegt werden. Sie sind die standardmäßige Möglichkeit, Daten in einer Klasse bereitzustellen.
using System;
class Demo
{
public string A { get; set; } = "settable";
public string B { get; } = "read-only";
public string C { get; init; } = "init-only";
}
class Program
{
static void Main()
{
var d = new Demo { C = "changed-at-init" };
Console.WriteLine(d.A + ", " + d.B + ", " + d.C);
}
}Häufig gestellte Fragen
Ist die Lektion „Automatisch implementierte Properties“ kostenlos?
Ja — der vollständige Text von „Automatisch implementierte Properties“ 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 „Automatisch implementierte Properties“?
Deklarieren Sie Properties mit der kompakten Auto-Syntax. 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 1 von 4.
Wie lange dauert die Lektion „Automatisch implementierte Properties“?
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