C# Dynamique

Pour éviter les vérifications lors de la compilation, un nouveau type a été introduit avec la sortie de C# 4.0 appelé type dynamique. Fondamentalement, un type est attribué en fonction de la valeur de l'expression par le compilateur alors que ce type dynamique ne subit pas de vérification de type pendant la compilation, c'est-à-dire qu'il échappe à la vérification du type pendant la compilation au lieu de cela, le type est résolu pendant l'exécution et le Le mot-clé dynamique est utilisé pour définir un type dynamique et les types dynamiques sont compilés en types d'objet par le compilateur et le type réel de dynamique est résolu pendant l'exécution.

Ssyntaxe :

dynamic variable_name;

Travail du type Dynamic en C#

• Le type dynamique a été introduit avec la sortie de C# 4.0. La vérification du type pendant la compilation peut être évitée en utilisant le type dynamique.
• Le type est vérifié par le compilateur lors de l'exécution.
• Le comportement du type dynamique est comme le comportement des types d'objet.
• La méthode GetType() peut être utilisée pour obtenir le type réel de la variable dynamique.
• Le type du type dynamique est modifié pendant l'exécution en fonction de la valeur sur le côté droit.
• Lorsqu'un objet de classe est affecté au type dynamique, la méthode correcte et le nom de la propriété contenant l'objet de classe ne sont pas vérifiés par le compilateur.
• Un paramètre de type dynamique peut également être transmis à une méthode afin que tout type de paramètre puisse être accepté par la méthode pendant l'exécution.
• Une exception est levée par le compilateur lors de l'exécution si les propriétés et les méthodes ne s'avèrent pas compatibles.
• Une erreur n'est pas générée par le compilateur sur le type dynamique pendant la compilation car il n'y a aucune vérification du type pour les types dynamiques par le compilateur pendant la compilation.

Considérez l'exemple ci-dessous pour expliquer l'utilisation du type Dynamic dans un programme C# :

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());
}
}

Sortie :

Dans le programme ci-dessus, le programme est la classe définie. Ensuite, la méthode principale est appelée. Ensuite, les variables dynamiques sont déclarées dont les types réels ne sont pas connus. Ensuite, la méthode GetType() est utilisée pour obtenir le type réel des variables dynamiques utilisées précédemment. Le résultat du programme est tel qu'indiqué dans l'instantané ci-dessus.

Exemples

Voici les exemples suivants mentionnés ci-dessous :

Exemple n°1

Programme C# pour démontrer l'utilisation de paramètres de type dynamique pouvant être transmis à une méthode

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");
}
}

Sortie :

Dans le programme ci-dessus, le programme est la classe définie. Ensuite, une méthode appelée add est définie à laquelle les variables de type dynamique sont transmises en tant que paramètres dont le type réel n'est pas connu. Ensuite, la méthode principale est appelée. Ensuite, la méthode add est appelée pour ajouter tout ce qui est passé en paramètres à la méthode puisque la méthode accepte les variables de type dynamique. La sortie du programme est comme indiqué dans l'instantané ci-dessus.

Exemple n°2

Programme C# pour démontrer l'utilisation de paramètres de type dynamique pouvant être transmis à une méthode :

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);
}
}
}

Sortie :

Dans le programme ci-dessus, un espace de noms appelé exemple est défini. Ensuite, le programme est la classe définie. Ensuite, la méthode principale est appelée. Ensuite, une méthode GetDet est appelée et définie ultérieurement, à laquelle sont transmises des variables de type dynamique en tant que paramètres dont le type réel n'est pas connu. Ensuite, la méthode GetDet est définie à quelle variable de type dynamique est transmise en tant que paramètre afin qu'elle accepte tout type de paramètre. Le résultat du programme est tel qu'indiqué dans l'instantané ci-dessus.

L'utilisation de types dynamiques présente plusieurs avantages. Ce sont :

• La communication avec d'autres langages dynamiques devient plus simple grâce à l'utilisation du type dynamique en C#.
• Les réponses aux appels de l'interface de programmation d'application peuvent être simplifiées en C# lorsque nous ne savons pas à quel type d'objet s'attendre.
• Des bibliothèques peuvent être créées et utilisées entre plusieurs langages en utilisant le type dynamique en C#.
• Si la préoccupation principale n'est pas la vitesse, des solutions génériques peuvent être apportées en utilisant la dynamique en C#.
• Le code de réflexion peut être remplacé et simplifié en utilisant dynamique.

Conclusion

Dans ce tutoriel, nous comprenons le concept de type dynamique en C# à travers la définition, la syntaxe du type dynamique en C#, le fonctionnement du type dynamique en C# à travers des exemples de programmation et leurs sorties, et les avantages de l'utilisation du type dynamique en C#.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!