C# Academy · Lekcja

Dekonstrukcja

Rozpakowuj krotki do osobnych zmiennych.

Dekonstrukcja 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.

Czym jest dekonstrukcja

Dekonstrukcja rozdziela krotkę lub obiekt na osobne zmienne w jednej instrukcji, dzięki czemu można bezpośrednio nazwać każdą część.

using System;

class Program
{
    static void Main()
    {
        var point = (3, 4);
        (int x, int y) = point;
        Console.WriteLine("x=" + x + ", y=" + y);
    }
}

Dekonstrukcja krotki

Umieść zmienne docelowe w nawiasach po lewej stronie znaku =. Każda z nich otrzyma odpowiadający jej element krotki.

using System;

class Program
{
    static void Main()
    {
        var user = ("Ada", 36);
        (string name, int age) = user;
        Console.WriteLine(name + " is " + age);
    }
}

Używanie var w dekonstrukcji

Można pozwolić kompilatorowi wywnioskować typy za pomocą var — osobno dla każdej zmiennej lub dla całej grupy.

using System;

class Program
{
    static void Main()
    {
        var data = (1, "one", true);
        var (id, word, flag) = data;
        Console.WriteLine(id + " " + word + " " + flag);
    }
}

Dekonstrukcja wyniku metody

Można bezpośrednio zdekonstruować krotkę zwracaną przez metodę do nazwanych zmiennych.

using System;

class Program
{
    static (int, int) MinMax(int a, int b) => a < b ? (a, b) : (b, a);

    static void Main()
    {
        var (lo, hi) = MinMax(8, 3);
        Console.WriteLine("min=" + lo + ", max=" + hi);
    }
}

Pomijanie wartości

Użyj podkreślenia _, aby podczas dekonstrukcji zignorować niepotrzebne części.

using System;

class Program
{
    static (int, int, int) Rgb() => (255, 128, 0);

    static void Main()
    {
        var (r, _, _) = Rgb();
        Console.WriteLine("Red channel: " + r);
    }
}

Dekonstrukcja do istniejących zmiennych

Można przypisać wartości do już zadeklarowanych zmiennych, pomijając nazwy typów.

using System;

class Program
{
    static void Main()
    {
        int a = 0, b = 0;
        (a, b) = (10, 20);
        Console.WriteLine(a + ", " + b);
    }
}

Zamiana wartości za pomocą krotek

Przydatny trik: zamień wartości dwóch zmiennych w jednym wierszu za pomocą dekonstrukcji krotki — zmienna tymczasowa nie jest potrzebna.

using System;

class Program
{
    static void Main()
    {
        int x = 1, y = 2;
        (x, y) = (y, x);
        Console.WriteLine("x=" + x + ", y=" + y);
    }
}

Metoda Deconstruct

Własne klasy mogą obsługiwać dekonstrukcję przez zdefiniowanie metody Deconstruct z parametrami out.

using System;

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

    public void Deconstruct(out int x, out int y)
    {
        x = X;
        y = Y;
    }
}

class Program
{
    static void Main()
    {
        var p = new Point(5, 9);
        var (px, py) = p;
        Console.WriteLine(px + ", " + py);
    }
}

Wiele przeciążeń Deconstruct

Klasa może udostępniać kilka przeciążeń Deconstruct, zwracających różne liczby wartości.

using System;

class Person
{
    public string Name; public int Age; public string City;
    public Person(string n, int a, string c) { Name = n; Age = a; City = c; }

    public void Deconstruct(out string name, out int age)
    {
        name = Name; age = Age;
    }
}

class Program
{
    static void Main()
    {
        var p = new Person("Ada", 36, "London");
        var (name, age) = p;
        Console.WriteLine(name + ", " + age);
    }
}

Dekonstrukcja w foreach

Podczas iterowania po kolekcji krotek można zdekonstruować każdy element bezpośrednio w nagłówku pętli foreach.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var pairs = new List<(string, int)>
        {
            ("Ann", 30),
            ("Bob", 25)
        };
        foreach (var (name, age) in pairs)
            Console.WriteLine(name + " is " + age);
    }
}

Podsumowanie

Dekonstrukcja sprawia, że kod zwracający lub przechowujący wiele wartości jest czytelniejszy, ponieważ każda część otrzymuje nazwę w miejscu użycia.

using System;

class Program
{
    static (int Quotient, int Remainder) Divide(int a, int b) => (a / b, a % b);

    static void Main()
    {
        var (q, r) = Divide(17, 5);
        Console.WriteLine("17 / 5 = " + q + " remainder " + r);
    }
}

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat dekonstrukcji.

Podsumowanie

Dekonstrukcja rozdziela krotkę lub obiekt na nazwane zmienne w jednej instrukcji. Używaj var (a, b) = ..., pomijaj części za pomocą _, zamieniaj zmienne i wykonuj dekonstrukcję w pętli foreach. Własne klasy włączają obsługę tej funkcji za pomocą metody Deconstruct używającej parametrów out, którą można opcjonalnie przeciążać.

using System;

class Program
{
    static void Main()
    {
        var (a, b, c) = (1, 2, 3);
        Console.WriteLine(a + b + c);
    }
}

Często zadawane pytania

Czy lekcja „Dekonstrukcja” jest bezpłatna?

Tak — pełny tekst „Dekonstrukcja” 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 „Dekonstrukcja”?

Rozpakowuj krotki do osobnych zmiennych. Ć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 „Dekonstrukcja”?

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