Pełne właściwości z polami zapasowymi
Dodawaj logikę do metod pobierających i ustawiających.
Pełne właściwości z polami zapasowymi 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.
Poza właściwości automatyczne
Gdy potrzebna jest logika wewnątrz get lub set, należy napisać pełną właściwość z jawnym polem zapasowym. Pole przechowuje dane, a akcesory kontrolują dostęp do nich.
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);
}
}Konwencja nazewnictwa pola zapasowego
Zgodnie z konwencją pole zapasowe jest private i ma nazwę rozpoczynającą się od podkreślenia, na przykład _name. Publiczna właściwość udostępnia dostęp do tego pola.
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);
}
}Słowo kluczowe value
Wewnątrz akcesora set niejawny parametr value zawiera przypisywaną wartość. To Państwo decydują, co z nią zrobić.
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);
}
}Walidacja w setterze
Częstym zastosowaniem pełnej właściwości jest walidowanie danych wejściowych przed ich zapisaniem i zgłoszenie wyjątku, jeśli wartość jest nieprawidłowa.
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);
}
}Właściwości obliczane tylko do odczytu
Właściwość zawierająca tylko get może obliczać swoją wartość na podstawie innych pól. Nie ma pola zapasowego, ponieważ niczego nie przechowuje.
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);
}
}Efekty uboczne w setterach
Setter może robić więcej niż tylko przechowywać wartość: może normalizować dane wejściowe, aktualizować powiązany stan lub rejestrować zmiany.
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);
}
}Leniwe obliczanie w getterze
Getter może przy pierwszym żądaniu zapisać kosztowny wynik obliczeń w polu zapasowym i używać go ponownie.
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);
}
}Ochrona przed nieprawidłowym stanem
Połączenie pola zapasowego z logiką pozwala utrzymywać obiekt w poprawnym stanie. W tym przypadku setter ogranicza wartość do określonego zakresu.
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);
}
}Połączenie danych przechowywanych i obliczanych
Klasa często łączy właściwości przechowujące dane (z polami zapasowymi) oraz obliczane właściwości tylko do odczytu, wyprowadzane na ich podstawie.
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);
}
}Zgłaszanie powiadomień o zmianach
Settery są naturalnym miejscem do wysyłania powiadomień o zmianie danych. Jest to wzorzec szeroko stosowany w frameworkach interfejsu użytkownika.
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;
}
}Połączenie elementów
Pełne właściwości pozwalają klasie egzekwować niezmienniki i udostępniać dane pochodne, a wszystko to za pośrednictwem prostego interfejsu przypominającego pole.
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);
}
}Szybkie sprawdzenie
Proszę sprawdzić zrozumienie pełnych właściwości.
Podsumowanie
Pełna właściwość łączy prywatne pole zapasowe z jawnymi akcesorami get/set, dzięki czemu można dodać walidację, normalizację, buforowanie lub powiadomienia o zmianach. Obliczane właściwości tylko do odczytu mają wyłącznie getter i nie mają pola zapasowego. Słowo kluczowe value przechowuje przypisywaną wartość w setterze.
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);
}
}Często zadawane pytania
Czy lekcja „Pełne właściwości z polami zapasowymi” jest bezpłatna?
Tak — pełny tekst „Pełne właściwości z polami zapasowymi” 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 „Pełne właściwości z polami zapasowymi”?
Dodawaj logikę do metod pobierających i ustawiających. Ć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 „Pełne właściwości z polami zapasowymi”?
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
- Właściwości implementowane automatycznie
- Pełne właściwości z polami zapasowymi
- Elementy składowe z treścią wyrażeniową
- Indeksery