C# Academy · Lektion

Wertetypen versus Referenztypen

Sehen Sie, wie die beiden Typen gespeichert und kopiert werden.

Wertetypen versus Referenztypen ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Zwei Typfamilien

C#-Typen werden in Wertetypen (int, double, bool, Structs) und Referenztypen (Klassen, Zeichenfolgen, Arrays) unterteilt. Sie unterscheiden sich darin, wie sie gespeichert und kopiert werden.

using System;

class Program
{
    static void Main()
    {
        int valueType = 5;          // value type
        int[] referenceType = { 1, 2, 3 };  // reference type
        Console.WriteLine(valueType + ", length " + referenceType.Length);
    }
}

Wertetypen enthalten die Daten

Eine Variable eines Wertetyps enthält ihre Daten direkt. Typischerweise liegen diese auf dem Stack oder inline in ihrem übergeordneten Objekt.

using System;

class Program
{
    static void Main()
    {
        int a = 10;
        double b = 3.14;
        bool c = true;
        Console.WriteLine(a + ", " + b + ", " + c);
    }
}

Referenztypen enthalten eine Adresse

Eine Variable eines Referenztyps enthält eine Referenz (Adresse) auf Daten, die auf dem Heap gespeichert sind. Die Variable und das Objekt sind voneinander getrennt.

using System;

class Box { public int Value; }

class Program
{
    static void Main()
    {
        Box b = new Box();   // b refers to a heap object
        b.Value = 42;
        Console.WriteLine(b.Value);
    }
}

Kopiersemantik: Wertetypen

Beim Zuweisen eines Wertetyps werden die Daten kopiert. Eine Änderung an der Kopie wirkt sich niemals auf das Original aus.

using System;

class Program
{
    static void Main()
    {
        int a = 1;
        int b = a;   // copy
        b = 99;
        Console.WriteLine("a=" + a + ", b=" + b);
    }
}

Kopiersemantik: Referenztypen

Beim Zuweisen eines Referenztyps wird die Referenz, nicht das Objekt kopiert. Beide Variablen verweisen anschließend auf dasselbe Objekt.

using System;

class Box { public int Value; }

class Program
{
    static void Main()
    {
        Box a = new Box { Value = 1 };
        Box b = a;   // same object
        b.Value = 99;
        Console.WriteLine("a.Value=" + a.Value + ", b.Value=" + b.Value);
    }
}

Structs sind Werttypen

Ein von Ihnen definierter struct ist ein Werttyp und wird daher bei der Zuweisung wie int kopiert.

using System;

struct Point { public int X, Y; }

class Program
{
    static void Main()
    {
        Point p1 = new Point { X = 1, Y = 2 };
        Point p2 = p1;   // full copy
        p2.X = 99;
        Console.WriteLine("p1.X=" + p1.X + ", p2.X=" + p2.X);
    }
}

Übergabe an Methoden

Standardmäßig werden Werttypen als Kopie übergeben, während bei Referenztypen eine Kopie der Referenz übergeben wird. Eine Methode kann also ein Klassenobjekt ändern, das der Aufrufer sieht, aber keinen einfachen int-Wert.

using System;

class Counter { public int N; }

class Program
{
    static void BumpInt(int x) { x++; }
    static void BumpObj(Counter c) { c.N++; }

    static void Main()
    {
        int i = 0;
        BumpInt(i);
        var c = new Counter();
        BumpObj(c);
        Console.WriteLine("i=" + i + ", c.N=" + c.N);
    }
}

null und Referenztypen

Nur Referenztypen können null sein, also das Fehlen eines Objekts darstellen. Werttypen enthalten immer einen Wert, sofern sie nicht mit ? als nullable deklariert wurden.

using System;

class Program
{
    static void Main()
    {
        string text = null;        // reference type can be null
        int? maybe = null;          // nullable value type
        Console.WriteLine((text == null) + ", " + (maybe == null));
    }
}

Unterschiede bei der Gleichheit

Bei Werttypen vergleicht == die Daten. Bei Referenztypen vergleicht == normalerweise die Identität, also ob es sich um dasselbe Objekt handelt, sofern der Operator nicht überschrieben wurde.

using System;

class Program
{
    static void Main()
    {
        int a = 5, b = 5;
        Console.WriteLine("ints: " + (a == b));   // True - same value

        object o1 = new object();
        object o2 = new object();
        Console.WriteLine("objects: " + (o1 == o2));   // False - different identity
    }
}

Standardwerte

Werttypen haben einen standardmäßigen Wert ähnlich wie null (0, false); bei Referenztypen ist der Standardwert null.

using System;

class Program
{
    static void Main()
    {
        int defaultInt = default;
        bool defaultBool = default;
        string defaultString = default;
        Console.WriteLine(defaultInt + ", " + defaultBool + ", null? " + (defaultString == null));
    }
}

Alles zusammenführen

Wenn Sie wissen, ob ein Typ ein Wert- oder Referenztyp ist, können Sie das Kopierverhalten, die Nullable-Eigenschaften und die Änderungsmöglichkeiten durch Methoden vorhersagen. Das ist entscheidend für korrekten, fehlerfreien Code.

using System;

struct Money { public decimal Amount; }
class Wallet { public decimal Amount; }

class Program
{
    static void Main()
    {
        Money m1 = new Money { Amount = 10 };
        Money m2 = m1; m2.Amount = 99;

        Wallet w1 = new Wallet { Amount = 10 };
        Wallet w2 = w1; w2.Amount = 99;

        Console.WriteLine("Money copy: " + m1.Amount + " (independent)");
        Console.WriteLine("Wallet ref: " + w1.Amount + " (shared)");
    }
}

Kurzer Test

Testen Sie Ihr Verständnis von Wert- und Referenztypen.

Rückblick

Werttypen (int, double, bool, Structs) speichern Daten direkt und werden bei der Zuweisung kopiert; Referenztypen (Klassen, Zeichenfolgen, Arrays) speichern eine Referenz auf ein Objekt im Heap und kopieren diese Referenz. Nur Referenztypen sind standardmäßig nullable, und sowohl das Zuweisungsverhalten als auch die Gleichheit unterscheiden sich zwischen den beiden Gruppen.

using System;

struct V { public int N; }
class R { public int N; }

class Program
{
    static void Main()
    {
        V v1 = new V { N = 1 }; V v2 = v1; v2.N = 9;
        R r1 = new R { N = 1 }; R r2 = r1; r2.N = 9;
        Console.WriteLine(v1.N + " vs " + r1.N);
    }
}

Häufig gestellte Fragen

Ist die Lektion „Wertetypen versus Referenztypen“ kostenlos?

Ja — der vollständige Text von „Wertetypen versus Referenztypen“ 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 „Wertetypen versus Referenztypen“?

Sehen Sie, wie die beiden Typen gespeichert und kopiert werden. 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 1 von 4.

Wie lange dauert die Lektion „Wertetypen versus Referenztypen“?

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