C# Academy · Lekcja

Wzorce niezmiennych obiektów

Projektuj obiekty, które nie zmieniają się po utworzeniu.

Wzorce niezmiennych obiektów to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 3 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.

Projektowanie niezmiennych obiektów

Niezmienny obiekt nie zmienia się po utworzeniu. Niezmienność eliminuje całe klasy błędów związanych ze współdzielonym zmiennym stanem i sprawia, że obiekty można bezpiecznie przekazywać oraz buforować.

Właściwości tylko do odczytu

Najprostszą niezmienną właściwością jest właściwość tylko do odczytu, ustawiana raz w konstruktorze.

using System;

class Point {
    public int X { get; }
    public int Y { get; }
    public Point(int x, int y) { X = x; Y = y; }
}

var p = new Point(3, 4);
Console.WriteLine(p.X + "," + p.Y); // 3,4

init dla składni inicjalizatora

Właściwości init należy stosować wtedy, gdy potrzebna jest niezmienność połączona z wygodną składnią inicjalizatora obiektu.

using System;

class Color {
    public int R { get; init; }
    public int G { get; init; }
    public int B { get; init; }
}

var c = new Color { R = 255, G = 128, B = 0 };
Console.WriteLine(c.R + "," + c.G + "," + c.B); // 255,128,0

required dla obowiązkowych pól

Połącz required + init, aby nie można było zapomnieć o niezbędnych polach ani później ich zmienić.

using System;

class Money {
    public required decimal Amount { get; init; }
    public required string Currency { get; init; }
}

var m = new Money { Amount = 9.99m, Currency = "USD" };
Console.WriteLine(m.Amount + " " + m.Currency); // 9.99 USD

Zwracanie nowych obiektów zamiast modyfikowania

Niezmienne typy udostępniają operacje „zmiany” jako metody zwracające nową instancję, pozostawiając oryginał bez zmian.

using System;

class Point {
    public int X { get; init; }
    public int Y { get; init; }
    public Point Move(int dx, int dy) => new Point { X = X + dx, Y = Y + dy };
}

var a = new Point { X = 1, Y = 1 };
var b = a.Move(2, 3);
Console.WriteLine(a.X + "," + a.Y + " -> " + b.X + "," + b.Y); // 1,1 -> 3,4

Niezmienne kolekcje

W przypadku pól przechowujących kolekcje należy używać kolekcji niezmiennej lub tylko do odczytu, aby za pośrednictwem obiektu nie można było zmodyfikować ich zawartości.

using System;
using System.Collections.Immutable;

class Team {
    public ImmutableList<string> Members { get; init; } = ImmutableList<string>.Empty;
}

var t = new Team { Members = ["Ada", "Lin"] };
var t2 = new Team { Members = t.Members.Add("Sam") };
Console.WriteLine(t.Members.Count + " " + t2.Members.Count); // 2 3

Kopiowanie ochronne

Jeśli trzeba przyjąć zmienną kolekcję, należy skopiować ją przy wejściu, aby zewnętrzne zmiany nie mogły przeniknąć do obiektu.

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

class Snapshot {
    private readonly int[] data;
    public Snapshot(IEnumerable<int> source) => data = source.ToArray();
    public IReadOnlyList<int> Data => data;
}

var list = new List<int> { 1, 2, 3 };
var snap = new Snapshot(list);
list.Add(4); // does not affect snap
Console.WriteLine(snap.Data.Count); // 3

Równość wartości

Niezmienne obiekty często powinny używać równości opartej na wartościach: dwie instancje zawierające te same dane są uznawane za równe. Rekordy zapewniają to automatycznie, natomiast klasy wymagają przesłonięć.

using System;

record Coord(int X, int Y);

Console.WriteLine(new Coord(1, 2) == new Coord(1, 2)); // True

Bezpieczeństwo wątkowe bez dodatkowego wysiłku

Ponieważ niezmienne obiekty nigdy się nie zmieniają, ich współdzielenie bez blokad jest z natury bezpieczne wątkowo.

using System;

class ReadonlyConfig {
    public required string Env { get; init; }
}

var cfg = new ReadonlyConfig { Env = "prod" };
// safe to read from many threads without synchronization
Console.WriteLine(cfg.Env); // prod

Pola readonly i struktury

Używaj pól readonly oraz readonly struct, aby wymuszać niezmienność typów wartości na poziomie pól.

using System;

readonly struct Vector {
    public readonly double X, Y;
    public Vector(double x, double y) { X = x; Y = y; }
    public double Length => Math.Sqrt(X * X + Y * Y);
}

Console.WriteLine(new Vector(3, 4).Length); // 5

Połączenie wszystkiego

W pełni niezmienny typ łączący required, init, równość wartości i metodę aktualizacji, która nie modyfikuje obiektu.

using System;

record Account(string Id, decimal Balance) {
    public Account Deposit(decimal amount) => this with { Balance = Balance + amount };
}

var a = new Account("A1", 100m);
var b = a.Deposit(50m);
Console.WriteLine(a.Balance + " -> " + b.Balance); // 100 -> 150

Szybkie sprawdzenie

Proszę potwierdzić zasadę niezmiennej aktualizacji.

Podsumowanie

W tej części poznano wzorce projektowania niezmiennych obiektów.

Należy używać właściwości tylko do odczytu lub właściwości init, a dla obowiązkowych danych stosować required.
Zmiany należy modelować jako metody zwracające nowe instancje.
Należy przechowywać kolekcje niezmienne lub utworzone przez kopiowanie ochronne.
Rekordy zapewniają równość wartości i kopie tworzone za pomocą with, a niezmienność zapewnia bezpieczeństwo wątkowe.

Często zadawane pytania

Czy lekcja „Wzorce niezmiennych obiektów” jest bezpłatna?

Tak — pełny tekst „Wzorce niezmiennych obiektów” 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 „Wzorce niezmiennych obiektów”?

Projektuj obiekty, które nie zmieniają się po utworzeniu. Ć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 3 z 4.

Ile czasu zajmuje lekcja „Wzorce niezmiennych obiektów”?

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

← Powrót do C# Academy