Verstehen von C#-Variablen und Datentypen

Dynamischer vs. Var Unterschied

In C# wird var für implizit typisierte lokale Variablen verwendet, bei denen der Typ zur Kompilierzeit bestimmt wird, was die Typsicherheit und IntelliSense-Unterstützung gewährleistet. Im Gegensatz dazu erlaubt dynamic Variablen, die Typprüfung zur Kompilierzeit zu umgehen, wobei der Typ zur Laufzeit aufgelöst wird, was mehr Flexibilität bietet, aber das Risiko von Laufzeitfehlern und verminderter Leistung birgt.

Tim Corey erklärt, dass var Typsicherheit mit Typbestimmung zur Kompilierzeit gewährleistet, da es sich um statische Variablen handelt, während dynamic Flexibilität mit Typauflösung zur Laufzeit bietet, was zu Laufzeitfehlern und Leistungsproblemen führen kann.

// Declaration of a dynamic variable that can change types at runtime
dynamic testDynamic;

// Declaration of a dynamic variable that can change types at runtime
dynamic testDynamic;

// This will result in a compile-time error due to lack of type inference
// var testVar;

// This will result in a compile-time error due to lack of type inference
// var testVar;

// var assignment with type inference from the initial value
var testVar = 2; // testVar is inferred to be of type int

// var assignment with type inference from the initial value
var testVar = 2; // testVar is inferred to be of type int

// Attempting to change the type from int to double causes an error
// testVar = 1.1; // Error: Cannot implicitly convert type 'double' to 'int'

// Attempting to change the type from int to double causes an error
// testVar = 1.1; // Error: Cannot implicitly convert type 'double' to 'int'

// Another example with dynamic typing
var testVar = 2.1; // Now testVar is a double

// Another example with dynamic typing
var testVar = 2.1; // Now testVar is a double

// Declaring a constant variable
const int MaxValue = 100;

// Declaring a constant variable
const int MaxValue = 100;

Dynamische automatische Typkonvertierung

Tim betont, wie das dynamic Schlüsselwort eine flexible Typbehandlung ermöglicht, indem es sich etwas wie object verhält, jedoch mit zusätzlichen Fähigkeiten. Um 3:53 demonstriert Tim, wie dynamic während der Laufzeit nahtlos zwischen verschiedenen Typen konvertieren kann, was seine Fähigkeit zeigt, Berechnungen mit Ganzzahlen und doubles ohne explizite Typkonvertierung durchzuführen, wie in seinem Codebeispiel gezeigt:

// Demonstrating dynamic type conversion at runtime
dynamic testDynamic = 1;
testDynamic = testDynamic + 2.1;
Console.WriteLine(testDynamic); // Outputs 3.1 as it converts the integer to a double

// Demonstrating dynamic type conversion at runtime
dynamic testDynamic = 1;
testDynamic = testDynamic + 2.1;
Console.WriteLine(testDynamic); // Outputs 3.1 as it converts the integer to a double

Hierbei zeigt Tim (4:39), dass testDynamic zunächst einen Ganzzahlwert hält, aber mühelos in ein double konvertiert wird, wenn 2,1 hinzugefügt wird, was zu dem Ergebnis 3,1 führt.

Trotz seiner Flexibilität warnt Tim vor dem übermäßigen Gebrauch von dynamic aufgrund der Leistungskosten, die durch häufige Typkonvertierungen entstehen. Er betont um 5:55, dass dynamic sparsam in der C#-Entwicklung verwendet werden sollte, um unnötige Prozessorbelastung sowie den Verlust der Typprüfung zur Kompilierzeit und der IntelliSense-Unterstützung zu vermeiden, die für die Wartung robuster und fehlerfreier Codebasen entscheidend sind.

Nachteile von Dynamic in der Entwicklung

Tim Corey veranschaulicht, wie dynamic zu Laufzeitfehlern und unerwartetem Verhalten in Ihren Anwendungen führen kann. Er beginnt damit, dass er zeigt, wie man eine dynamische Variable deklariert und ihr einen anfänglichen leeren String zuweist, um einen sofortigen Fehler zu vermeiden. Er versucht dann, eine nicht vorhandene Methode sayHi auf der dynamischen Variable aufzurufen, was keinen Kompilierzeitfehler verursacht, jedoch zu einer Laufzeitausnahme führt und einen wesentlichen Nachteil von dynamic demonstriert: das Fehlen der Überprüfung zur Kompilierzeit.

// Demonstrating lack of compile-time checks with dynamic
dynamic testDynamic = "";
// testDynamic.sayHi(); // Runtime error: method does not exist

// Demonstrating lack of compile-time checks with dynamic
dynamic testDynamic = "";
// testDynamic.sayHi(); // Runtime error: method does not exist

Außerdem zeigt Tim bei 8:38, wie dynamische Variablen ihren Typ zur Laufzeit ändern können, was zu unerwartetem Verhalten führen kann. Er weist ein Person Objekt einer dynamischen Variable zu, weist es dann einer Zeichenfolge zu und zeigt, wie diese Flexibilität zu logischen Fehlern führen kann und das Debuggen erschwert.

// Demonstrating the potential errors with dynamic type reassignment
dynamic testDynamic = new Person();
testDynamic = "Hi";
Console.WriteLine(testDynamic); // Works fine, but not ideal for type safety

// Demonstrating the potential errors with dynamic type reassignment
dynamic testDynamic = new Person();
testDynamic = "Hi";
Console.WriteLine(testDynamic); // Works fine, but not ideal for type safety

Tim erklärt auch, wie dynamische Variablen nicht von IntelliSense unterstützt werden, was zu Laufzeitfehlern aufgrund von Tippfehlern oder falschen Methodennamen führen kann. Zum Beispiel ruft er um 14:05 einen Eigenschaftsnamen Email auf, der nicht existiert und veranschaulicht, wie dieser Fehler bis zur Laufzeit unbemerkt bleibt. Der Code kompiliert fehlerfrei, schlägt jedoch zur Laufzeit fehl, wenn erwartete Methoden oder Eigenschaften auf dem Person Objekt in der Zeichenfolge nicht gefunden werden.

// Demonstrating a runtime error due to missing property
// testDynamic.Email = "Test@test.com"; // property not found until runtime

// Demonstrating a runtime error due to missing property
// testDynamic.Email = "Test@test.com"; // property not found until runtime

// Using var for strongly-typed assignments
var testVar = new Person();
testVar.FirstName = "Sue";
testVar.LastName = "Storm";

// The use of IntelliSense assists in reducing runtime errors
Console.WriteLine(testVar.SayHello()); // Ideally a method in Person class

// Using var for strongly-typed assignments
var testVar = new Person();
testVar.FirstName = "Sue";
testVar.LastName = "Storm";

// The use of IntelliSense assists in reducing runtime errors
Console.WriteLine(testVar.SayHello()); // Ideally a method in Person class

// Attempting to change type results in compile-time errors with var
// testVar = "Hi"; // Compile-time error

// Attempting to change type results in compile-time errors with var
// testVar = "Hi"; // Compile-time error

// Method returning a dynamic type
public dynamic GetMessage() {
    return "This is a test";
}

// Method returning a dynamic type
public dynamic GetMessage() {
    return "This is a test";
}

Warum und wann man Dynamic verwenden sollte

Tim erläutert die spezifischen Szenarien, in denen dynamic unerlässlich wird. Er erklärt, dass C# grundsätzlich eine stark typisierte Sprache ist, was bedeutet, dass jeder Variablen ein definitiver Typ zugewiesen wird, der während ihres gesamten Lebenszyklus konsistent bleibt. Dies steht im Gegensatz zu Sprachen wie JavaScript, wo Variablen ihren Typ dynamisch ändern können.

Tim zeigt bei 18:14, dass C# zwar für stark typisierte Variablen ausgelegt ist, es aber Situationen gibt, insbesondere bei der Interaktion mit externen Systemen oder Sprachen wie Python, Ruby oder COM-Objekten, in denen eine dynamische Typisierung von Vorteil sein kann. Er verwendet das Beispiel der Integration einer Python-API, um die praktische Notwendigkeit von dynamic zu verdeutlichen. In diesen Fällen vereinfacht ein flexibles Typensystem, das sich an verschiedene Datentypen aus externen Quellen anpassen kann, die Interaktion.

Tim Corey betont um 18:44, dass obwohl dynamic für plattformübergreifende Interaktionen nützlich ist, es allgemein nicht für reinen C#-Code empfohlen wird, da dadurch die Fehlerprüfung zur Kompilierzeit und die IntelliSense-Unterstützung verloren gehen. Er warnt, dass die Flexibilität von dynamic auf Kosten der Leistung und Typsicherheit geht, wodurch es eine weniger wünschenswerte Wahl für reguläre C#-Programmierung ist, bei der stark typisierte Variablen bevorzugt werden sollten.

Warum und wann man das Schlüsselwort Var verwendet

Tim diskutiert anschließend die Verwendung und Philosophie des var Schlüsselworts in C#. Er weist darauf hin, dass es zwei Hauptlager bei der Verwendung von var gibt: diejenigen, die es ausschließlich verwenden möchten, und diejenigen, die explizite Typdeklarationen bevorzugen.

Tim erklärt um 19:43, dass Befürworter von var argumentieren, dass es zu besseren Namenskonventionen anregt und der Code dadurch selbstdokumentierend wird. Sie glauben, dass Variablennamen beschreibend genug sein sollten, um den Typ zu vermitteln, ohne dass eine explizite Deklaration erforderlich ist.

Auf der anderen Seite (20:46) argumentieren diejenigen, die explizite Typendeklarationen bevorzugen, dass der Typ einer lokalen Variablen sofort ersichtlich ist, wenn man den tatsächlichen Typ direkt im Code sieht, ohne dass man den Mauszeiger über die Variable bewegen muss, um ihren Typ zu sehen. Zum Beispiel:

// Explicit type declaration provides clarity
string firstName = "Tim";

// Explicit type declaration provides clarity
string firstName = "Tim";

Manche bevorzugen diese Art der Übersetzung, weil sie jede Zweideutigkeit über den Typ der Variablen ausschließt.

Tim teilt seinen ausgewogenen Ansatz um 21:15 und erklärt, dass er in der Regel explizite Typen für allgemeine Datentypen wie string, int, double und decimal verwendet, weil der Code dadurch klarer wird und potenzielle Probleme, wie die Verwirrung von double und decimal, vermieden werden. Zum Beispiel:

// Explicit type ensures there's no ambiguity between float types
double myMoney = 1.1; // This is a double
decimal myMoney = 1.1M; // This is a decimal

// Explicit type ensures there's no ambiguity between float types
double myMoney = 1.1; // This is a double
decimal myMoney = 1.1M; // This is a decimal

Tim betont, dass die explizite Deklaration des Typs sicherstellt, dass der richtige Typ verwendet wird, insbesondere wenn es zu Verwechslungen zwischen ähnlichen Typen kommen kann.

Jedoch erkennt Tim auch an, dass var besonders nützlich sein kann, wenn es um lange oder komplexe Typen geht. Er liefert ein Beispiel um 23:37, bei dem die Deklaration einer List<List<Person>> ausführlich sein kann:

// Declaring a complex type using var
var rounds = new List<List<Person>>();

// Declaring a complex type using var
var rounds = new List<List<Person>>();

Er veranschaulicht auch dessen Nutzen in foreach Schleifen (23:55):

// Utilizing var in loop for cleaner code
foreach (var round in rounds) {
    // Do something with each round
}

// Utilizing var in loop for cleaner code
foreach (var round in rounds) {
    // Do something with each round
}

Tim schließt mit der Feststellung, dass var zwar die Ausführlichkeit reduzieren kann, es jedoch wichtig ist, sicherzustellen, dass die Variablennamen klar und aussagekräftig sind, um die Lesbarkeit zu gewährleisten und Verwirrung zu vermeiden.

Durch die Balance der Verwendung von var mit expliziten Typen können Entwickler klaren, wartbaren und effizienten Code schreiben, indem sie die Stärken beider Ansätze je nach Kontext nutzen.

Var als anonymes Objekt

Tim diskutiert die Verwendung von var für Situationen, in denen der Typ nicht explizit bekannt ist oder bei Verwendung von anonymen Typen. Er zeigt dies, indem er spontan ein anonymes Objekt erstellt, das keinen vordefinierten Typ hat. Hier ist der von ihm verwendete Code:

// Creating an anonymous object with var
var myItem = new { FirstName = "Tim", Email = "test@test.com" };

// Creating an anonymous object with var
var myItem = new { FirstName = "Tim", Email = "test@test.com" };

Tim erklärt um 25:30, dass, da dieses Objekt anonym ist und keinen spezifischen Typnamen hat, die einzige Möglichkeit, Variablen dafür zu deklarieren, die Verwendung von var ist. Dieser Ansatz ermöglicht die Erstellung und Verwendung von Objekten, ohne dass eine formale Klasse definiert werden muss.

Um zu veranschaulichen, wie dies in der Praxis funktioniert, schreibt Tim (25:52):

// Outputting properties of an anonymous object
Console.WriteLine($"Hello {myItem.FirstName}: your email is {myItem.Email}");

// Outputting properties of an anonymous object
Console.WriteLine($"Hello {myItem.FirstName}: your email is {myItem.Email}");

Wenn er den Code bei 26:25 ausführt, wird er ausgegeben:

Dies zeigt, dass var die Eigenschaften eines anonymen Objekts handhaben kann, und Visual Studio bietet IntelliSense-Unterstützung für diese Eigenschaften, obwohl das Objekt anonym ist.

Tim klärt um 26:54, dass er die Verwendung expliziter Typen für einfache und häufige Typen wie string, Ganzzahlen und Klasseninstanzen bevorzugt, da der Code dadurch klarer wird. Er verwendet jedoch var in Fällen, in denen der Typ entweder lang, komplex oder nicht explizit bekannt ist, wie bei anonymen Typen oder komplexen Typdeklarationen.

Abschluss

Und da haben Sie es - ein klares Verständnis von C#-Variablen und -Datentypen sowie die strategische Verwendung der var und dynamic Schlüsselwörter. Wenn Sie Tim Coreys ausgewogenen Ansatz verfolgen, können Sie mit dem var Schlüsselwort Typensicherheit und Klarheit in Ihrem Code gewährleisten und dabei die Flexibilität des dynamic Schlüsselworts für spezifische Szenarien wie die Interaktion mit externen Systemen nutzen.

Für detailliertere Einblicke sollten Sie sich das Video von Tim Corey zum Thema "Dynamic vs Var in C#" ansehen und seinen YouTube Channel für weitere C# Lernthemen besuchen.