C# Academy · Lektion

Der Typ dynamic

Verschieben Sie die Typauflösung mit dynamic auf die Laufzeit.

Der Typ dynamic 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 dynamic?

Der Typ dynamic umgeht die Typprüfung zur Kompilierzeit. Memberzugriffe und Operationen werden stattdessen zur Laufzeit aufgelöst.

using System;

class Program {
    static void Main() {
        dynamic value = 10;
        Console.WriteLine(value + 5);
    }
}

Verschiedene Typen erneut zuweisen

Eine dynamic-Variable kann jeden Typ enthalten und ihren Typ sogar zwischen Zuweisungen ändern.

using System;

class Program {
    static void Main() {
        dynamic x = 1;
        Console.WriteLine(x);
        x = "now a string";
        Console.WriteLine(x);
    }
}

Bindung zur Laufzeit

Bei dynamic vertraut der Compiler Ihnen. Methoden- und Eigenschaftsauflösungen finden beim Ausführen der Zeile statt, nicht beim Kompilieren.

using System;

class Program {
    static void Main() {
        dynamic text = "hello";
        Console.WriteLine(text.ToUpper());
    }
}

Fehler treten zur Laufzeit auf

Da die Prüfung aufgeschoben wird, löst ein falsches Member zur Laufzeit eine RuntimeBinderException aus, statt einen Kompilierfehler zu verursachen.

using System;
using Microsoft.CSharp.RuntimeBinder;

class Program {
    static void Main() {
        dynamic n = 5;
        try {
            n.NoSuchMethod();
        } catch (RuntimeBinderException) {
            Console.WriteLine("No such member");
        }
    }
}

dynamic im Vergleich zu var

var wird zur Kompilierzeit festgelegt, während dynamic zur Laufzeit flexibel bleibt. Beide sehen ähnlich aus, verhalten sich aber sehr unterschiedlich.

using System;

class Program {
    static void Main() {
        var fixedType = 10;
        dynamic flexible = 10;
        flexible = "changed";
        Console.WriteLine(fixedType + " " + flexible);
    }
}

Arithmetik mit dynamic

Operatoren für dynamic werden zur Laufzeit anhand der tatsächlich beteiligten Werte aufgelöst.

using System;

class Program {
    static void Main() {
        dynamic a = 3;
        dynamic b = 4;
        Console.WriteLine(a * b);
    }
}

dynamic-Rückgabewerte

Eine Methode kann dynamic zurückgeben, wenn der Typ tatsächlich variiert. Aufrufer verlieren dadurch jedoch die Unterstützung zur Kompilierzeit.

using System;

class Program {
    static dynamic GetValue(bool flag) {
        return flag ? (dynamic)42 : "text";
    }
    static void Main() {
        Console.WriteLine(GetValue(true));
        Console.WriteLine(GetValue(false));
    }
}

Anwendungsfälle für dynamic

dynamic ist hilfreich bei COM-Interop, JSON-ähnlichen Daten und beim Aufrufen von Code, dessen Struktur erst zur Laufzeit bekannt ist.

using System;

class Program {
    static void Main() {
        dynamic data = 100;
        data += 1;
        Console.WriteLine(data);
    }
}

Leistungskosten

Die Bindung zur Laufzeit verursacht zusätzlichen Aufwand. Bevorzugen Sie in engen Schleifen oder einfachem Code statische Typen für mehr Geschwindigkeit und Sicherheit.

using System;

class Program {
    static void Main() {
        int fast = 0;
        for (int i = 0; i < 5; i++) fast += i;
        Console.WriteLine(fast);
    }
}

Kein IntelliSense

Editoren können keine Member für ein dynamic vorschlagen, da der Typ erst zur Laufzeit bekannt ist. Das verlangsamt die Entwicklung.

using System;

class Program {
    static void Main() {
        dynamic s = "Code";
        Console.WriteLine(s.Length);
    }
}

Sparsam einsetzen

Verwenden Sie dynamic nur dann, wenn statische Typisierung das Szenario wirklich nicht ausdrücken kann. Andernfalls sollten Sie konkrete Typen bevorzugen.

using System;

class Program {
    static void Main() {
        dynamic flexible = 7;
        Console.WriteLine(flexible.GetType().Name);
    }
}

Kurzer Test

Testen Sie Ihr Verständnis von dynamic.

Zusammenfassung

dynamic schaltet die Typprüfung zur Kompilierzeit aus und löst Member zur Laufzeit auf. Daher kann eine dynamic-Variable ihren Typ ändern, und ungültige Aufrufe lösen eine RuntimeBinderException aus.

Im Gegensatz zu var (zur Kompilierzeit festgelegt) ist dynamic flexibel, kostet aber Leistung, bietet kein IntelliSense und sollte sparsam eingesetzt werden.

Häufig gestellte Fragen

Ist die Lektion „Der Typ dynamic“ kostenlos?

Ja — der vollständige Text von „Der Typ dynamic“ 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 „Der Typ dynamic“?

Verschieben Sie die Typauflösung mit dynamic auf die Laufzeit. 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 „Der Typ dynamic“?

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