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 Kompilierungszeit bestimmt wird, was Typsicherheit und IntelliSense-Unterstützung gewährleistet. Im Gegensatz dazu ermöglicht dynamic Variablen, die Überprüfung des Typs zur Kompilierungszeit zu umgehen, wobei der Typ zur Laufzeit aufgelöst wird, was mehr Flexibilität bietet, jedoch mit dem Risiko von Laufzeitfehlern und reduzierter Leistung.

Tim Corey erklärt, dass var Typsicherheit mit Typbestimmung zur Kompilierungszeit sicherstellt, da sie statische Variablen sind, 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 nahtlos zwischen verschiedenen Typen zur Laufzeit konvertieren kann, und zeigt seine Fähigkeit, Berechnungen mit Ganzzahlen und Doppelwerten ohne explizite Umwandlung zu handhaben, wie in seinem Codebeispiel dargestellt:

// 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

Hier zeigt Tim (4:39), dass testDynamic zunächst einen Ganzzahlwert hält, aber mühelos in ein Doppel konvertiert wird, indem es 2,1 hinzufügt, was zum Ergebnis 3,1 führt.

Trotz seiner Flexibilität warnt Tim vor übermäßigem Gebrauch von dynamic wegen der durch häufige Typumwandlungen verursachten Leistungseinbußen. Er betont um 5:55, dass dynamic sparsam in der C#-Entwicklung eingesetzt werden sollte, um unnötige Prozessorbelastung und den Verlust von Typsicherheitsprüfungen zur Kompilierungszeit und IntelliSense-Unterstützung zu vermeiden, die entscheidend sind, um robuste und fehlerfreie Codebasen zu erhalten.

Nachteile von Dynamic in der Entwicklung

Tim Corey illustriert, wie dynamic in Ihren Anwendungen zu Laufzeitfehlern und unerwartetem Verhalten 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. Dann versucht er, eine nicht vorhandene Methode sayHi auf der dynamischen Variable aufzurufen, was keinen Kompilierungszeitfehler verursacht, jedoch zu einer Laufzeitausnahme führt, die einen wesentlichen Nachteil von dynamic demonstriert: Fehlen der Überprüfung zur Kompilierungszeit.

// 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 Variablen zu, dann weist er es einer Zeichenfolge zu und zeigt, wie diese Flexibilität zu logischen Fehlern führen und das Debuggen erschweren kann.

// 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, wodurch dieser Fehler unbemerkt zur Laufzeit bleibt. Der Code kompiliert ohne Fehler, schlägt jedoch zur Laufzeit fehl, wenn Methoden oder Eigenschaften, die auf dem Person Objekt erwartet werden, auf 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 wesentlich 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 nutzt das Beispiel der Integration einer Python-API, um das praktische Bedürfnis nach dynamic hervorzuheben. 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 nützlich für Sprachübergreifende Interaktionen ist, es allgemein für reinen C#-Code nicht empfohlen wird, da die Fehlerüberprüfung zur Kompilierungszeit und die IntelliSense-Unterstützung verloren gehen. Er warnt, dass die Flexibilität von dynamic auf Kosten von Leistung und Typsicherheit geht, was es zu einer weniger wünschenswerten Wahl für reguläre C#-Programmierung macht, wo stark typisierte Variablen bevorzugt werden sollten.

Warum und wann man das Schlüsselwort Var verwendet

Tim diskutiert dann die Verwendung und Philosophie hinter dem var Schlüsselwort in C#. Er stellt fest, dass es zwei Hauptgruppen gibt, wenn es um die Verwendung von var geht: die, die es ausschließlich verwenden, und die, die explizite Typdeklarationen bevorzugen.

Tim erklärt um 19:43, dass Befürworter von var argumentieren, dass es bessere Namenskonventionen fördert, wodurch der Code selbst dokumentierend 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 mit und erklärt, dass er normalerweise explizite Typen für allgemeine Datentypen wie string, int, double und decimal verwendet, da dies den Code klarer macht und potenzielle Probleme wie das Verwechseln von double und decimal vermeidet. 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.

Tim räumt jedoch auch ein, dass var besonders nützlich sein kann, wenn man mit langen oder komplexen Typen arbeitet. Er gibt ein Beispiel um 23:37, wo die Deklaration eines 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 demonstriert auch seinen 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 Bemerkung, dass, obwohl var die Ausführlichkeit reduzieren kann, es entscheidend ist, sicherzustellen, dass die Variablennamen klar und beschreibend sind, um die Lesbarkeit zu erhalten und Verwirrung zu vermeiden.

Indem man den Einsatz von var mit expliziten Typen ausbalanciert, können Entwickler klaren, wartbaren und effizienten Code schreiben, indem man die Stärken beider Ansätze je nach Kontext nutzt.

Var als anonymes Objekt

Tim diskutiert die Verwendung von var für Situationen, in denen der Typ nicht explizit bekannt ist oder wenn man mit anonymen Typen arbeitet. Er demonstriert 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 bestimmten 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 verarbeiten kann und Visual Studio IntelliSense-Unterstützung für diese Eigenschaften bietet, obwohl das Objekt anonym ist.

Tim klärt um 26:54, dass er es vorzieht, explizite Typen für einfache und gängige Typen wie string, Ganzzahlen und Klasseninstanzen zu verwenden, weil es den Code klarer macht. 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—aein klare Verständnis von C# Variablen und Datentypen sowie den strategischen Einsatz von var und dynamic Schlüsselwörtern. Indem Sie Tim Coreys ausbalancierten Ansatz folgen, können Sie Typsicherheit und Klarheit in Ihrem Code mit dem var Schlüsselwort sicherstellen und 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.