Explication détaillée des objets anonymes, var et type dynamique dynamique en C#

Avec le développement du C#, le contenu du langage continue de s'enrichir, le développement devient plus pratique et plus rapide, et la netteté du C# se révèle sans aucun doute. Le langage C# est un langage fortement typé depuis sa naissance. Cette nature n'a pas changé aujourd'hui, et je pense qu'elle ne changera pas dans le futur. Puisqu'il s'agit d'un langage fortement typé, l'écriture de n'importe quel programme nécessite de remplir les conditions de base suivantes :

1 La déclaration de variable doit indiquer son type

2. , son type doit être spécifié. Le type ne peut pas être modifié au moment de l'exécution

Le code est le suivant :

    public  class Student
    {        
    public string Name { get; set; }        
    public int Age { get; set; }        
    public string Like { get; set; }
    }

static void Main(string[] args)
{    int a = 10;    string s = "abc";
    Student student = new Student();    //下面出现编译错误，变量类型在声明后无法再变更
    s = a;
    student = s;
    a = 10.1f;
}

Cependant, dans le développement réel, nous sommes souvent confrontés aux problèmes courants suivants. :

1. Dans un programme plus vaste, seulement un ou quelques endroits (pas plus de 3 endroits) doivent utiliser un ou plusieurs types (comme Student ci-dessus), et ces types ne sont plus nécessaires dans d'autres endroits. Pour déclarer un type Student séparément, la quantité de code requise peut dépasser la quantité de code lors de l'utilisation de ce type, et le rapport investissement/production n'est pas rentable.

2. Dans un programme, seuls certains attributs ou méthodes d'un certain type d'objet sont requis pour participer à l'opération. Dans ce cas, la conversion temporaire de ce type d'objet en un objet doté de certaines des propriétés et méthodes requises par le programme peut rendre le programme plus rationalisé.

3. Autres situations... Je n'ai pas encore remarqué... Bienvenue pour ajouter...

Le développement actuel de C# ci-dessus Il existe des solutions relativement bonnes aux problèmes courants dans le développement JavaScript , comme suit :

//在此处js中需要模拟一个学生对象
student = {"name":"张三","age":20,"like":"LOL"};
//在此处js中需要模拟一个老师对象
teacher = {"name":"李老师","like":"没收学生手机，自己LOL"};
//此处需要将学生student转换成只有name和age的对象
person = {"name":student.name,"age":student.age};

Si vous n'êtes pas familier avec la syntaxe js ci-dessus, vous pouvez aller sur Baidu pour rechercher "syntaxe json" et je vous dirai que c'est très simple (et c'est. important).

Objet anonyme (type anonyme)

Par conséquent, C# a absorbé les avantages grammaticaux du langage de script JavaScript dans la version 3.0 et a effectué les mises à niveau correspondantes vers C# pour le rendre également This la syntaxe est prise en charge (C# est toujours un langage fortement typé). L'exemple de code est le suivant :

static void Main(string[] args)
{     new {Name="张三",Age=20,Like="LOL"};
}

Le code C# ci-dessus utilise le nouveau mot-clé pour indiquer au compilateur de créer un objet. L'objet a trois attributs : Nom, Âge et Like =. la valeur correspondant à l'attribut. De cette façon, on évite "La création d'un objet doit d'abord avoir les contraintes du type d'objet", Ainsi, lors du processus de développement, on n'a plus besoin de créer des classes séparées pour les types les moins utilisés, les problèmes mentionnés au-dessus de 1 a été résolu .

L'objet créé n'a désormais aucun type spécifique spécifié, il est donc appelé objet anonyme.

Var apparaît

Maintenant, pour utiliser un objet anonyme, vous devez utiliser une variable pour le référencer. Bien que nous ne spécifions pas le type d'objet lors de sa création, le compilateur nous aidera à créer un type avec des propriétés et des méthodes associées pendant le processus de compilation. Le nom du type compilé à ce moment est généré de manière aléatoire, le type de variable ne peut donc pas être déterminé. Un exemple est le suivant :

static void Main(string[] args)
{    //XXX为类型声明    //x为引用变量 
     XXX x = new {Name="张三",Age=20,Like="LOL"};
}

Bien que nous ne connaissions pas le nom du type généré par le compilateur, nous pouvons laisser le compilateur déduire le type de variable en fonction des résultats de la compilation. Le mot-clé var entre en jeu à ce moment :

static void Main(string[] args)
{     var x = new {Name="张三",Age=20,Like="LOL"};
}

Le mot-clé var indique que le type de , comme indiqué ci-dessous :

Remarques sur l'utilisation de var :

1. var ne peut déclarer que des variables locales dans une méthode

2. déclaré par var est déterminé après qu'une valeur lui ait été attribuée. Les valeurs d'autres types ne peuvent pas être attribuées dans les programmes suivants

3. var x = new object() n'a aucun sens, ne le faites pas. t écrire un tel code.............

Désormais, avec la prise en charge des objets anonymes et des types déduits var, nous pouvons gérer problème 2 mentionné ci-dessus. L'exemple de code est le suivant :

        static void Main(string[] args)
        {            
        var x = new { Name = "张三", Age = 20, Like = "LOL" };            
        var s = new { Name = x.Name, Age = x.Age };  
        }

Ce qui précède n'est qu'un exemple. Si vous êtes familier avec Linq ou Entity Framework, l'utilisation correspondant à la question 2 sera écrasante...

Le type dynamique apparaît

L'utilisation des types anonymes est généralement limitée à la partie de la méthode, qui peut être comprise comme

: définie au fur et à mesure de votre utilisation, et disparaît après utiliser. Que devez-vous faire dans les situations suivantes ?

        static void Main(string[] args)
        {            
        var x = GetObject(); 
        }        
        private static XXX GetObject()
        {            
        return new { Name = "张三", Age = 20, Like = "LOL" };
        }

Renvoie un objet anonyme via la méthode GetObject, de sorte que le nom du type de valeur de retour de la méthode ne peut pas être déterminé et est temporairement remplacé par XXX ici. Dans ce cas, le type de retour n'est pas défini et peut être spécifié à l'aide de Dynamic . Comme suit :

          Main( x =    { Name = , Age = , Like =

À ce stade, il n'y aura aucune erreur de syntaxe dans la méthode et le programme pourra être compilé et exécuté avec succès. Alors, que fait exactement Dynamic pour que le programme ci-dessus soit compilé avec succès ?

Le rôle de la dynamique :

1. Dynamic représente le type dynamique La signification du type dynamique est que le type est incertain lors des étapes d'écriture et de compilation du programme, les propriétés ou les attributs. des objets pertinents sont déterminés par la méthode de réflexion. Par conséquent, la vérification de la syntaxe n’est pas effectuée pendant la phase d’écriture.

2. Dynamic peut être utilisé pour déclarer des champs, des attributs, des paramètres de méthode et des valeurs de retour de méthode

3 Dynamic ne prend pas en charge les invites intelligentes car vous ne pouvez pas savoir ce qu'est la dynamique lorsque vous le faites. écrire du code (réflexion)

Les variables déclarées dynamiques peuvent être comprises comme des variables de type objet. Par conséquent, il est correct d'attribuer n'importe quel type de valeur à une variable dynamique. Cependant, lors de l'utilisation d'une variable pour obtenir une valeur de propriété ou appeler une méthode (le programme doit être dans l'état Runtime à ce moment), le CLR vérifiera (. réflexion) que la propriété ou la méthode appelée existe, aucune exception d'exécution n'est signalée.

la dynamique est utilisée partout dans le développement Web Asp.net Mvc Bien que cela semble compliqué, l'essentiel est ce qui est mentionné ci-dessus.

Explication :

var et Dynamic peuvent sembler avoir des fonctions similaires, mais elles sont différentes :

	var	dynamic
声明字段	×	√
局部变量	√	√
方法参数类型	×	√
方法返回值类型	×	√

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!