0Pricing
C# Academy · Lektion

Parameter in Membern erfassen

Verwenden Sie Primärkonstruktorparameter im gesamten Typ.

Parameter in Membern erfassen 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.

Parameter in Membern verwenden

Die Stärke von Primärkonstruktoren zeigt sich bei der Verwendung der Parameter in Membern: Methoden, Properties und Feld-Initialisierern. Der Compiler richtet den benötigten Speicher automatisch ein.

using System;

class Multiplier(int factor) {
    public int Apply(int n) => n * factor;
}

Console.WriteLine(new Multiplier(3).Apply(5)); // 15

Erfassung und reine Initialisierung

Wenn ein Parameter nur in einem Feld- oder Property-Initialisierer verwendet wird, ist kein zusätzlicher Speicher erforderlich. Wird er in einer Methode verwendet, erfasst der Compiler ihn in einem verborgenen Feld.

using System;

class A(int x) {
    public int Stored = x;     // initializer only
}
class B(int x) {
    public int Get() => x;     // captured into a field
}

Console.WriteLine(new A(7).Stored); // 7
Console.WriteLine(new B(9).Get());  // 9

Parameter sind veränderlich

Parameter eines Primärkonstruktors verhalten sich wie gewöhnliche Parameter: Innerhalb der Instanz sind sie veränderlich, sofern Sie sie nicht als schreibgeschützt behandeln. Eine Änderung wirkt sich auf das erfasste Feld aus.

using System;

class Toggle(bool on) {
    public void Flip() => on = !on;
    public bool State => on;
}

var t = new Toggle(false);
t.Flip();
Console.WriteLine(t.State); // True

Als schreibgeschützte Properties bereitstellen

Ein häufig verwendetes Muster besteht darin, einen Parameter über eine Property mit ausschließlich lesbarem Getter bereitzustellen. So erhalten Sie eine klare öffentliche Schnittstelle und halten den Parameter intern.

using System;

class User(string email) {
    public string Email { get; } = email;
}

Console.WriteLine(new User("a@b.com").Email); // a@b.com

Berechnete Properties aus Parametern

Parameter fließen ganz natürlich in berechnete Properties mit Expression-Bodied-Syntax ein.

using System;

class Money(decimal amount, string currency) {
    public string Display => amount.ToString("0.00") + " " + currency;
}

Console.WriteLine(new Money(9.5m, "USD").Display); // 9.50 USD

Parameter in mehreren Methoden

Ein und derselbe erfasste Parameter kann von vielen Methoden gemeinsam verwendet werden und verhält sich wie ein bei der Erstellung initialisiertes privates Feld.

using System;

class Range2(int lo, int hi) {
    public bool Contains(int n) => n >= lo && n <= hi;
    public int Clamp(int n) => Math.Max(lo, Math.Min(hi, n));
}

var r = new Range2(0, 10);
Console.WriteLine(r.Contains(5)); // True
Console.WriteLine(r.Clamp(15));   // 10

Referenztypen erfassen

Mit erfassten Parametern von Referenztypen können Sie injizierte Abhängigkeiten speichern und aus jeder Methode aufrufen.

using System;
using System.Collections.Generic;

class Repo(List<string> store) {
    public void Add(string item) => store.Add(item);
    public int Count => store.Count;
}

var list = new List<string>();
var repo = new Repo(list);
repo.Add("x");
Console.WriteLine(repo.Count); // 1

Unbeabsichtigtes doppeltes Speichern vermeiden

Wenn Sie einen Parameter sowohl einem Feld zuweisen als auch den Parameter in Methoden verwenden, speichern Sie den Wert möglicherweise zweimal. Bevorzugen Sie aus Gründen der Klarheit einen Ansatz.

using System;

class Clean(int x) {
    // expose once via property, reference property in methods
    public int Value { get; } = x;
    public int Doubled() => Value * 2;
}

Console.WriteLine(new Clean(4).Doubled()); // 8

Parameter in Lambdas

Parameter können von Lambdas erfasst werden, die innerhalb der Klasse definiert sind, genau wie Felder.

using System;
using System.Collections.Generic;
using System.Linq;

class Filter(int threshold) {
    public IEnumerable<int> KeepAbove(IEnumerable<int> xs) =>
        xs.Where(n => n > threshold);
}

var f = new Filter(3);
Console.WriteLine(string.Join(",", f.KeepAbove(new[]{1,2,3,4,5}))); // 4,5

Lebensdauer des Gültigkeitsbereichs

Ein erfasster Parameter lebt so lange wie das Objekt. Er ist praktisch ein Instanzzustand. Gehen Sie daher nicht davon aus, dass er zwischen Methodenaufrufen zurückgesetzt wird.

using System;

class Accumulator(int seed) {
    private int total = seed;
    public int Add(int n) { total += n; return total; }
}

var a = new Accumulator(100);
Console.WriteLine(a.Add(1)); // 101
Console.WriteLine(a.Add(1)); // 102

Alles zusammenführen

Dieser Dienst erfasst zwei Abhängigkeiten und verwendet sie in mehreren Methoden. So sieht die typische Struktur in der Praxis aus.

using System;

class PriceService(decimal taxRate, string currency) {
    public decimal WithTax(decimal net) => net * (1 + taxRate);
    public string Format(decimal v) => v.ToString("0.00") + " " + currency;
}

var s = new PriceService(0.2m, "EUR");
Console.WriteLine(s.Format(s.WithTax(100m))); // 120.00 EUR

Kurze Überprüfung

Überprüfen Sie, wie Parameter primärer Konstruktoren gespeichert werden.

Zusammenfassung

Sie haben gelernt, wie Parameter primärer Konstruktoren in Membern verwendet werden.

  • Bei der Verwendung in Methoden werden Parameter in verborgene Felder erfasst.
  • Bei ausschließlicher Verwendung in Initialisierern ist kein zusätzlicher Speicher erforderlich.
  • Über get-only-Eigenschaften können Sie sie über eine klare öffentliche Schnittstelle bereitstellen.
  • Sie verhalten sich während der gesamten Lebensdauer des Objekts wie ein Instanzzustand.

Häufig gestellte Fragen

Ist die Lektion „Parameter in Membern erfassen“ kostenlos?

Ja — der vollständige Text von „Parameter in Membern erfassen“ 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 „Parameter in Membern erfassen“?

Verwenden Sie Primärkonstruktorparameter im gesamten Typ. 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 „Parameter in Membern erfassen“?

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

  1. Primärkonstruktoren für Klassen
  2. Parameter in Membern erfassen
  3. Primärkonstruktoren für Structs
  4. Kombination mit Properties und Basistypen
← Zurück zu C# Academy