C# dynamisch

Um eine Überprüfung während der Kompilierungszeit zu vermeiden, wurde mit der Veröffentlichung von C# 4.0 ein neuer Typ namens dynamischer Typ eingeführt. Grundsätzlich wird ein Typ basierend auf dem Ausdruckswert vom Compiler zugewiesen, während dieser dynamische Typ während der Kompilierungszeit keiner Typprüfung unterzogen wird, d Das dynamische Schlüsselwort wird zum Definieren eines dynamischen Typs verwendet. Die dynamischen Typen werden vom Compiler in Objekttypen kompiliert und der tatsächliche dynamische Typ wird während der Laufzeit aufgelöst.

SSyntax:

dynamic variable_name;

Funktionieren des dynamischen Typs in C#

• Der dynamische Typ wurde mit der Veröffentlichung von C# 4.0 eingeführt. Die Typprüfung während der Kompilierungszeit kann durch die Verwendung des dynamischen Typs vermieden werden.
• Der Typ wird vom Compiler zur Laufzeit überprüft.
• Das Verhalten dynamischer Typen ähnelt dem Verhalten von Objekttypen.
• Die Methode GetType() kann verwendet werden, um den tatsächlichen Typ der dynamischen Variablen abzurufen.
• Der Typ des dynamischen Typs wird zur Laufzeit abhängig vom Wert auf der rechten Seite geändert.
• Wenn ein Klassenobjekt dem dynamischen Typ zugewiesen wird, werden die richtige Methode und der Name der Eigenschaft, die das Klassenobjekt enthält, vom Compiler nicht überprüft.
• Ein dynamischer Typparameter kann auch an eine Methode übergeben werden, sodass jede Art von Parameter während der Laufzeit von der Methode akzeptiert werden kann.
• Eine Ausnahme wird vom Compiler während der Laufzeit ausgelöst, wenn festgestellt wird, dass die Eigenschaften und Methoden nicht kompatibel sind.
• Während der Kompilierungszeit wird vom Compiler kein Fehler für dynamische Typen ausgegeben, da der Compiler während der Kompilierungszeit keine Typprüfung für dynamische Typen durchführt.

Betrachten Sie das folgende Beispiel, um die Verwendung des dynamischen Typs in einem C#-Programm zu erläutern:

using System;
//a class called program is defined
class program
{
//main method is called
static public void Main()
{
// Dynamic variables are declared
dynamic val1 = 1234;
dynamic val2 = 1234.40;
dynamic val3 = false;
dynamic val4 = "Hello";
//GetType() method is used to obtain the actual type of the dynamic variables used earlier
Console.WriteLine("The actual type of val1 is: {0}", val1.GetType().ToString());
Console.WriteLine("The actual type of val2 is: {0}",
val2.GetType().ToString());
Console.WriteLine("The actual type of val3 is: {0}",
val3.GetType().ToString());
Console.WriteLine("The actual type of val4 is: {0}",
val4.GetType().ToString());
}
}

Ausgabe:

Im obigen Programm ist das Programm die definierte Klasse. Dann wird die Hauptmethode aufgerufen. Dann werden die dynamischen Variablen deklariert, deren tatsächliche Typen nicht bekannt sind. Dann wird die Methode GetType() verwendet, um den tatsächlichen Typ der zuvor verwendeten dynamischen Variablen zu erhalten. Die Ausgabe des Programms ist wie im Schnappschuss oben dargestellt.

Beispiele

Hier sind die folgenden Beispiele:

Beispiel #1

C#-Programm zur Demonstration der Verwendung dynamischer Typparameter, die an eine Methode übergeben werden können

Code:

using System;
//a class called program is defined
class program
{
// a method called add is defined to which dynamic type variables are passed as parameters
public static void add(dynamic r1, dynamic r2)
{
Console.WriteLine(r1 + r2);
}
// Main method is called
static public void Main()
{
//add method is called to add whatever is passed as parameters to the method since the method accepts dynamic type variables
add("H", "I");
add("Welcome to", " dynamic type");
add(20, 20);
add(20.5, 1.5);
add(100, "fun");
}
}

Ausgabe:

Im obigen Programm ist das Programm die definierte Klasse. Dann wird eine Methode namens add definiert, an die dynamische Typvariablen als Parameter übergeben werden, deren tatsächlicher Typ nicht bekannt ist. Dann wird die Hauptmethode aufgerufen. Dann wird die Add-Methode aufgerufen, um alles hinzuzufügen, was als Parameter an die Methode übergeben wird, da die Methode dynamische Typvariablen akzeptiert. Die Ausgabe des Programms ist wie im obigen Schnappschuss dargestellt.

Beispiel #2

C#-Programm zur Demonstration der Verwendung dynamischer Typparameter, die an eine Methode übergeben werden können:

Code:

using System;
//a namespace called example is defined
namespace example
{
//a class called program is defined
class Program
{
//main method is called
static void Main(string[] args)
{
//different types of values are passed as a parameter to GetDetails method
GetDet("Learning is fun and welcome to learning dynamic type in C#");
GetDet(false);
GetDet(100.22);
GetDet(20);
Console.ReadLine();
}
//a method called getdetails is defined to which dynamic type variable is passed as a parameter so it accepts any type of parameter
static void GetDet(dynamic r)
{
Console.WriteLine(r);
}
}
}

Ausgabe:

Im obigen Programm ist ein Namespace namens example definiert. Dann ist das Programm die definierte Klasse. Dann wird die Hauptmethode aufgerufen. Anschließend wird eine später definierte Methode GetDet aufgerufen, an die dynamische Typvariablen als Parameter übergeben werden, deren tatsächlicher Typ nicht bekannt ist. Dann wird die GetDet-Methode definiert, an die eine dynamische Typvariable als Parameter übergeben wird, sodass sie jeden Parametertyp akzeptiert. Die Ausgabe des Programms ist wie im Schnappschuss oben dargestellt.

Die Verwendung dynamischer Typen bietet mehrere Vorteile. Sie sind:

• Die Kommunikation mit anderen dynamischen Sprachen wird durch die Verwendung dynamischer Typen in C# einfacher.
• Die Antworten von Application Programming Interface-Aufrufen können in C# vereinfacht werden, wenn wir nicht wissen, welchen Objekttyp wir erwarten können.
• Mit dynamischem Typ in C# können Bibliotheken erstellt werden, die zwischen mehreren Sprachen verwendet werden können.
• Wenn das Hauptanliegen nicht die Geschwindigkeit ist, können generische Lösungen mithilfe von Dynamic in C# erstellt werden.
• Der Reflexionscode kann mithilfe von Dynamic ersetzt und vereinfacht werden.

Fazit

In diesem Tutorial verstehen wir das Konzept des dynamischen Typs in C# durch Definition, die Syntax des dynamischen Typs in C#, die Funktionsweise des dynamischen Typs in C# anhand von Programmierbeispielen und deren Ausgaben sowie die Vorteile der Verwendung dynamischer Typen in C#.

Das obige ist der detaillierte Inhalt vonC# dynamisch. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!