C# Academy · Lektion

Dekonstruktion

Packen Sie Tupel in einzelne Variablen aus.

Dekonstruktion ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist Dekonstruktion?

Dekonstruktion zerlegt ein Tupel oder Objekt in einer einzigen Anweisung in separate Variablen, sodass Sie jeden Teil direkt benennen können.

using System;

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

Ein Tupel dekonstruieren

Setzen Sie die Zielvariablen links von = in Klammern. Jede Variable erhält das passende Tupel-Element.

using System;

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

var bei der Dekonstruktion verwenden

Sie können die Typen vom Compiler mithilfe von var ableiten lassen – entweder für jede Variable einzeln oder für die gesamte Gruppe.

using System;

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

Ein Methodenergebnis dekonstruieren

Sie können das von einer Methode zurückgegebene Tupel direkt in benannte Variablen dekonstruieren.

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);
    }
}

Werte verwerfen

Verwenden Sie einen Unterstrich _, um bei der Dekonstruktion nicht benötigte Teile zu ignorieren.

using System;

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

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

In vorhandene Variablen dekonstruieren

Sie können bereits deklarierte Variablen zuweisen, indem Sie die Typnamen weglassen.

using System;

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

Variablen mit Tupeln vertauschen

Ein praktischer Trick: Vertauschen Sie zwei Variablen in einer Zeile mithilfe der Tupel-Dekonstruktion, ganz ohne temporäre Variable.

using System;

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

Die Deconstruct-Methode

Ihre eigenen Klassen können die Dekonstruktion unterstützen, indem Sie eine Deconstruct-Methode mit out-Parametern definieren.

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);
    }
}

Mehrere Deconstruct-Überladungen

Eine Klasse kann mehrere Deconstruct-Überladungen anbieten, die unterschiedliche Anzahlen von Werten bereitstellen.

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);
    }
}

Dekonstruktion in foreach

Wenn Sie eine Sammlung von Tupeln durchlaufen, können Sie jedes Element direkt im foreach-Header dekonstruieren.

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);
    }
}

Alles zusammenführen

Dekonstruktion sorgt dafür, dass Code, der mehrere Werte zurückgibt oder speichert, übersichtlich lesbar bleibt, weil jeder Teil am Verwendungsort benannt wird.

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);
    }
}

Kurze Überprüfung

Testen Sie Ihr Verständnis der Dekonstruktion.

Zusammenfassung

Dekonstruktion zerlegt ein Tupel oder Objekt in einer einzigen Anweisung in benannte Variablen. Verwenden Sie var (a, b) = ..., verwerfen Sie Teile mit _, vertauschen Sie Variablen und dekonstruieren Sie in foreach. Eigene Klassen können dies mit einer Deconstruct-Methode und out-Parametern unterstützen; diese Methode kann optional überladen werden.

using System;

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

Häufig gestellte Fragen

Ist die Lektion „Dekonstruktion“ kostenlos?

Ja — der vollständige Text von „Dekonstruktion“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Dekonstruktion“?

Packen Sie Tupel in einzelne Variablen aus. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Dekonstruktion“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C# Academy