Ausführliche Erklärung anonymer Objekte, var und dynamischer dynamischer Typen in C#

Mit der Entwicklung von C# wird der Inhalt der Sprache weiter bereichert, die Entwicklung wird bequemer und schneller und die Schärfe von C# wird zweifellos deutlich. Die C#-Sprache ist seit ihrer Geburt eine stark typisierte Sprache. Diese Natur hat sich heute nicht geändert, und ich denke, dass sie sich auch in Zukunft nicht ändern wird. Da es sich um eine stark typisierte Sprache handelt, muss das Schreiben eines Programms die folgenden Grundbedingungen erfüllen:

1 Die Variablendeklaration muss ihren Typ angeben

2 , sein Typ muss zur Laufzeit angegeben werden.

Der Code lautet wie folgt:

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

In der tatsächlichen Entwicklung treten jedoch häufig die folgenden häufigen Probleme auf :

1. In einem größeren Programm müssen nur eine oder wenige Stellen (nicht mehr als 3 Stellen) einen oder mehrere bestimmte Typen verwenden (z. B. Student oben), und diese Typen werden in nicht mehr benötigt andere Orte. Um einen Student-Typ separat zu deklarieren, kann die erforderliche Codemenge die bei Verwendung dieses Typs erforderliche Codemenge überschreiten und das Investitions-Output-Verhältnis ist nicht kosteneffektiv.

2. In einem Programm sind nur einige Attribute oder Methoden eines bestimmten Objekttyps erforderlich, um an der Operation teilzunehmen. In diesem Fall kann die vorübergehende Konvertierung dieses Objekttyps in ein Objekt mit einigen der für das Programm erforderlichen Eigenschaften und Methoden das Programm rationalisieren.

3. Andere Situationen... Ich habe es noch nicht bemerkt... Willkommen zum Hinzufügen...

Die oben genannte tatsächliche Entwicklung von C# Es gibt relativ gute Lösungen für häufige Probleme in der JavaScript-Entwicklung , wie folgt:

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

Wenn Sie mit der oben genannten js-Syntax nicht vertraut sind, können Sie zu Baidu gehen, um nach „json-Syntax“ zu suchen, und ich werde Ihnen sagen, dass es sehr einfach ist (und das ist es auch). wichtig).

Anonymes Objekt (anonymer Typ)

Daher hat C# in Version 3.0 die grammatikalischen Vorteile der JavaScript-Skriptsprache übernommen und entsprechende Upgrades an C# vorgenommen, um es auch so zu machen Syntax wird unterstützt (C# ist immer noch eine stark typisierte Sprache). Der Beispielcode lautet wie folgt:

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

Der obige C#-Code verwendet das Schlüsselwort new, um den Compiler anzuweisen, ein Objekt zu erstellen: Name, Alter und „Gefällt mir“ gefolgt von der Wert, der dem Attribut entspricht. Auf diese Weise vermeiden wir „Bei der Erstellung eines Objekts müssen zunächst die Einschränkungen des Objekttyps gelten“, Daher müssen wir während des Entwicklungsprozesses keine separaten Klassen mehr für weniger verwendete Typen erstellen, die genannten Probleme oben 1 wurde gelöst .

Das jetzt erstellte Objekt gibt keinen bestimmten Typ an, daher wird es anonymes Objekt genannt.

Var erscheint

Um nun ein anonymes Objekt zu verwenden, müssen Sie eine Variable verwenden, um darauf zu verweisen. Obwohl wir beim Erstellen nicht den Typ des Objekts angeben, hilft uns der Compiler beim Erstellen eines Typs mit zugehörigen Eigenschaften und Methoden während des Kompilierungsprozesses. Der zu diesem Zeitpunkt kompilierte Typname wird zufällig generiert, sodass der Variablentyp nicht bestimmt werden kann. Ein Beispiel lautet wie folgt:

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

Obwohl wir den vom Compiler generierten Typnamen nicht kennen, können wir den Compiler den Variablentyp basierend auf den Kompilierungsergebnissen ableiten lassen. Das Schlüsselwort var kommt zu diesem Zeitpunkt ins Spiel:

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

Das Schlüsselwort var gibt den Typ von an, wie unten gezeigt:

Hinweise zur Verwendung von var:

1 var kann nur lokale Variablen innerhalb einer Methode deklarieren

2 Die von var deklarierte Deklaration wird nach der Zuweisung bestimmt, und andere Wertetypen können in nachfolgenden Programmen nicht zugewiesen werden

3. var x = new object() ist bedeutungslos, nicht wahr Schreiben Sie solchen Code....

Jetzt mit der Unterstützung für anonyme Objekte und var-abgeleitete Typen können wir Problem 2 lösen oben erwähnt. Der Beispielcode lautet wie folgt:

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

Das Obige ist nur ein Beispiel. Wenn Sie mit Linq oder Entity Framework vertraut sind, wird die Verwendung entsprechend Frage 2 überwältigend sein...

Dynamische Typdynamik erscheint

Die Verwendung anonymer Typen ist im Allgemeinen auf den Teil der Methode beschränkt, der als verstanden werden kann: definiert, wie Sie ihn verwenden, und verschwindet danach verwenden. Was sollten Sie in den folgenden Situationen tun?

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

Gibt ein anonymes Objekt über die GetObject-Methode zurück, sodass der Name des Methodenrückgabewerttyps nicht ermittelt werden kann und hier vorübergehend durch XXX ersetzt wird. In diesem Fall ist der Rückgabetyp undefiniert und kann mit „dynamic“ angegeben werden. Wie folgt:

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

Zu diesem Zeitpunkt liegen keine Syntaxfehler in der Methode vor und das Programm kann erfolgreich kompiliert und ausgeführt werden. Was genau macht Dynamic also, damit das obige Programm erfolgreich kompiliert wird?

Die Rolle des dynamischen Typs:

1. Der dynamische Typ bedeutet, dass der Typ während der Programmschreib- und Kompilierungsphase unsicher ist der relevanten Objekte werden durch den Reflexionsmechanismus bestimmt. Daher wird während der Schreibphase keine Syntaxprüfung durchgeführt.

2. Dynamic kann zum Deklarieren von Feldern, Attributen, Methodenparametern und Methodenrückgabewerten verwendet werden.

3 Dynamic unterstützt keine intelligenten Eingabeaufforderungen, da Sie nicht wissen können, was Dynamic ist, wenn Sie es tun Code schreiben (Reflexion)

Dynamisch deklarierte Variablen können als Objekttypvariablen verstanden werden. Daher ist es korrekt, einer dynamischen Variablen jede Art von Wert zuzuweisen. Wenn Sie jedoch eine Variable verwenden, um einen Eigenschaftswert zu erhalten oder eine Methode aufzurufen (das Programm muss sich zu diesem Zeitpunkt im Laufzeitstatus befinden), prüft die CLR (. Reflexion) Unabhängig davon, ob die aufgerufene Eigenschaft oder Methode vorhanden ist, wird keine Laufzeitausnahme gemeldet.

dynamisch wird überall in der Asp.net Mvc-Webentwicklung verwendet. Obwohl es kompliziert aussieht, ist das Wesentliche das, was oben erwähnt wurde.

Erklärung:

Var und Dynamic scheinen ähnliche Funktionen zu haben, aber sie sind unterschiedlich:

Das obige ist der detaillierte Inhalt vonAusführliche Erklärung anonymer Objekte, var und dynamischer dynamischer Typen in C#. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!