C# Academy · Lekcja

Łączenie z właściwościami i typami bazowymi

Przekazuj parametry do typów bazowych i właściwości.

Łączenie z właściwościami i typami bazowymi to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 4 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.

Łączenie konstruktorów podstawowych z dziedziczeniem

Klasa pochodna z konstruktorem podstawowym może przekazywać swoje parametry do klasy bazowej za pomocą składni : Base(args) w nagłówku.

using System;

class Animal(string name) {
    public string Name => name;
}

class Dog(string name) : Animal(name) {
    public string Speak() => Name + " says Woof";
}

Console.WriteLine(new Dog("Rex").Speak()); // Rex says Woof

Przekazywanie podzbioru parametrów

Klasa pochodna może przyjmować więcej parametrów niż klasa bazowa i przekazywać do niej tylko te istotne.

using System;

class Shape(string color) {
    public string Color => color;
}

class Box(string color, int size) : Shape(color) {
    public int Size => size;
}

var b = new Box("red", 5);
Console.WriteLine(b.Color + " " + b.Size); // red 5

Przekształcanie argumentów dla klasy bazowej

Argumenty konstruktora klasy bazowej można obliczać na podstawie parametrów klasy pochodnej bezpośrednio w nagłówku.

using System;

class Label(string text) {
    public string Text => text;
}

class UpperLabel(string text) : Label(text.ToUpper()) {
}

Console.WriteLine(new UpperLabel("hi").Text); // HI

Dodawanie właściwości obok

Konstruktor podstawowy i jawne właściwości mogą współistnieć. Właściwości można inicjalizować parametrami już w deklaracji.

using System;

class Product(string name, decimal price) {
    public string Name { get; } = name;
    public decimal Price { get; set; } = price;
}

var p = new Product("Book", 12m);
p.Price = 10m;
Console.WriteLine(p.Name + " " + p.Price); // Book 10

Parametry klasy bazowej i użycie w klasie pochodnej

Nawet po przekazaniu parametru do klasy bazowej parametr konstruktora podstawowego klasy pochodnej nadal może być używany w jej treści.

using System;

class Base(int id) {
    public int Id => id;
}

class Item(int id, string label) : Base(id) {
    public string Describe() => "#" + id + ": " + label;
}

Console.WriteLine(new Item(7, "Widget").Describe()); // #7: Widget

Rekordy i konstruktory podstawowe

Rekordy używają konstruktorów podstawowych do automatycznego generowania publicznych właściwości tylko z akcesorem init. Rekord pozycyjny jest najbardziej zwięzłym wariantem.

using System;

record Person(string First, string Last) {
    public string Full => First + " " + Last;
}

Console.WriteLine(new Person("Ada", "Lovelace").Full); // Ada Lovelace

Dziedziczenie rekordów

Rekordy pochodne przekazują argumenty pozycyjnie do rekordu bazowego, generując połączony zestaw właściwości.

using System;

record Vehicle(string Make);
record Car(string Make, int Doors) : Vehicle(Make);

var c = new Car("Toyota", 4);
Console.WriteLine(c.Make + " " + c.Doors); // Toyota 4

Walidacja przed wywołaniem klasy bazowej

Jeśli potrzebna jest walidacja, należy wykonać ją w inicjalizatorze właściwości za pomocą wyrażenia throw; wywołanie klasy bazowej i tak nastąpi wcześniej.

using System;

class Base(string tag) { public string Tag => tag; }

class Node(string tag) : Base(tag) {
    public string Tag2 { get; } =
        tag.Length > 0 ? tag : throw new ArgumentException("empty");
}

Console.WriteLine(new Node("a").Tag); // a

Łączenie przechwyconych parametrów i właściwości

Niektóre parametry można zachować jako przechwycony prywatny stan, a inne udostępnić jako właściwości, dostosowując w ten sposób publiczny interfejs.

using System;

class Order(int id, decimal total) {
    public decimal Total { get; } = total; // public
    public string Reference() => "ORD-" + id;   // id stays private
}

var o = new Order(42, 99m);
Console.WriteLine(o.Reference() + " " + o.Total); // ORD-42 99

Domyślne wartości właściwości

Właściwości niezwiązane z parametrami nadal mogą mieć domyślne inicjalizatory i swobodnie współpracować z parametrami konstruktora podstawowego.

using System;

class Session(string user) {
    public string User { get; } = user;
    public bool Active { get; set; } = true;
}

var s = new Session("kai");
Console.WriteLine(s.User + " " + s.Active); // kai True

Połączenie wszystkiego

Klasa pochodna, która przekazuje argumenty do klasy bazowej, dodaje właściwość i udostępnia składową obliczaną.

using System;

class Employee(string name) {
    public string Name => name;
}

class Manager(string name, int teamSize) : Employee(name) {
    public int TeamSize { get; } = teamSize;
    public string Title => Name + " (manages " + TeamSize + ")";
}

Console.WriteLine(new Manager("Sam", 5).Title); // Sam (manages 5)

Szybkie sprawdzenie

Proszę potwierdzić, jak konstruktory podstawowe przekazują argumenty do klas bazowych.

Podsumowanie

W tej części poznano sposób łączenia konstruktorów podstawowych z właściwościami i klasami bazowymi.

class D(...) : Base(args) przekazuje argumenty do klasy bazowej.
Argumenty dla klasy bazowej można obliczać bezpośrednio w nagłówku.
Właściwości można inicjalizować parametrami już w deklaracji.
Rekordy generują publiczne właściwości tylko z akcesorem init na podstawie parametrów pozycyjnych.

Często zadawane pytania

Czy lekcja „Łączenie z właściwościami i typami bazowymi” jest bezpłatna?

Tak — pełny tekst „Łączenie z właściwościami i typami bazowymi” 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 „Łączenie z właściwościami i typami bazowymi”?

Przekazuj parametry do typów bazowych i właściwości. Ć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 4 z 4.

Ile czasu zajmuje lekcja „Łączenie z właściwościami i typami bazowymi”?

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