C# Academy · Lekcja

Przechwytywanie parametrów w elementach składowych

Używaj parametrów konstruktora głównego w całym typie.

Lekcja 2 z 413 kroki

Przechwytywanie parametrów w elementach składowych to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C# Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C# Academy zawiera 4 lekcji w sumie.

Używanie parametrów w składowych

Siła konstruktorów podstawowych wynika z możliwości używania parametrów wewnątrz składowych: metod, właściwości i inicjalizatorów pól. Kompilator zapewnia potrzebne miejsce na ich przechowywanie.

using System;

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

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

Przechwytywanie a użycie tylko w inicjalizatorze

Jeśli parametr jest używany wyłącznie w inicjalizatorze pola lub właściwości, dodatkowe miejsce nie jest potrzebne. Jeśli jest używany w metodzie, kompilator przechwytuje go w ukrytym polu.

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

Parametry są modyfikowalne

Parametry konstruktora podstawowego zachowują się jak zwykłe parametry: można je modyfikować w instancji, chyba że traktuje się je jako tylko do odczytu. Modyfikacja parametru zmienia przechwycone pole.

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

Udostępnianie jako właściwości tylko do odczytu

Typowym rozwiązaniem jest udostępnienie parametru za pomocą właściwości tylko z akcesorem get, co zapewnia przejrzysty publiczny interfejs i jednocześnie pozostawia parametr wewnątrz klasy.

using System;

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

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

Właściwości obliczane na podstawie parametrów

Parametry można naturalnie wykorzystywać w obliczanych właściwościach z ciałem wyrażeniowym.

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

Parametry w wielu metodach

Ten sam przechwycony parametr może być współdzielony przez wiele metod, działając jak prywatne pole zainicjowane podczas tworzenia obiektu.

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

Przechwytywanie typów referencyjnych

Przechwycone parametry typów referencyjnych pozwalają przechowywać wstrzyknięte zależności i wywoływać je z dowolnej metody.

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

Unikanie przypadkowego podwójnego przechowywania

Jeśli zarówno przypisze się parametr do pola, jak i używa się go w metodach, wartość może zostać przechowana dwukrotnie. Dla większej przejrzystości należy wybrać jedno podejście.

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

Parametry w lambdach

Parametry mogą być przechwytywane przez lambdy zdefiniowane wewnątrz klasy, podobnie jak pola.

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

Czas życia zakresu

Przechwycony parametr istnieje tak długo jak obiekt. W praktyce jest stanem instancji, dlatego nie należy zakładać, że zostanie zresetowany między wywołaniami metod.

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

Połączenie wszystkiego

Ten serwis przechwytuje dwie zależności i używa ich w różnych metodach, pokazując typową strukturę spotykaną w rzeczywistych zastosowaniach.

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

Szybkie sprawdzenie

Proszę potwierdzić, jak przechowywane są parametry konstruktora podstawowego.

Odpowiedz w interaktywnej lekcji

Podsumowanie

W tej części poznano sposób używania parametrów konstruktora podstawowego w składowych.

Używane w metodach parametry są przechwytywane do ukrytych pól.
Parametry używane wyłącznie w inicjalizatorach nie wymagają dodatkowego przechowywania.
W celu utworzenia przejrzystego interfejsu można udostępnić je za pomocą właściwości tylko do odczytu.
Zachowują się jak stan instancji przez cały czas życia obiektu.

Bezpłatny start

Ucz się C# dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 93
Lekcje: 346

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Przechwytywanie parametrów w elementach składowych” jest bezpłatna?

Tak — pełny tekst „Przechwytywanie parametrów w elementach składowych” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C# Academy, przejdź na CoddyKit PRO. Kurs C# Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Przechwytywanie parametrów w elementach składowych”?

Używaj parametrów konstruktora głównego w całym typie. Ćwiczysz C# Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C# Academy?

Nie wymagamy żadnego doświadczenia. C# Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Przechwytywanie parametrów w elementach składowych”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C# Academy?

Tak. Każda lekcja C# Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Konstruktory główne w klasach
Przechwytywanie parametrów w elementach składowych
Konstruktory główne w strukturach
Łączenie z właściwościami i typami bazowymi

← Powrót do C# Academy