Beispiele für die beste Kombination aus Reflexion und Dynamik in C#

In diesem Artikel wird hauptsächlich der Beispielcode für die beste Kombination aus Reflexion und Dynamik in C# vorgestellt. Freunde, die ihn benötigen, können darauf zurückgreifen.

Reflexionstechnologie wird in C# häufig verwendet. ..Wenn Sie es nicht verstehen, lesen Sie bitte die Erklärung im nächsten Absatz, andernfalls überspringen Sie bitte den nächsten Absatz. Werbung: Freunde, denen meine Artikel gefallen, achten Sie bitte auf meinen Blog, was auch dazu beitragen wird, meine Motivation zum Schreiben zu verbessern.

Reflexion: Wenn Sie einer schönen Frau oder einem gutaussehenden Mann den Rücken zukehren, sich aber nicht umdrehen können, um es genau zu beobachten und zu studieren (das ist rein fiktiv, irgendein Zufall oder eine Ähnlichkeit), kann ein kleiner Spiegel Ihnen begegnen Bedürfnisse. Bei der C#-Programmierung stoßen wir häufig auf eine ähnliche Situation: Es gibt eine von anderen geschriebene DLL-Klassenbibliothek, die Sie verwenden möchten, aber es gibt keine Programmdokumentation ... Zu diesem Zeitpunkt können Sie über die von C# Runtime bereitgestellten Funktionen Sie können die DLL-Klassenbibliothek verwenden. Laden Sie die Bibliothek in Ihr Programm und studieren Sie jeden Teil der DLL. Dies ist eine Reflexion in C#.

Ich persönlich denke, dass der wichtigste Vorteil oder die größte Rationalität der Reflexion darin besteht: dynamische Anpassung von Programmfunktionen (dynamische Objekterstellung zur Laufzeit), ohne den ursprünglichen Code des Programms zu ändern:

Wenn die oben genannte Run-Funktion nicht unbedingt von Person ausgeführt wird, muss es sich manchmal um Car und manchmal um Person handeln. Eine übliche Lösung besteht darin, Beurteilungsstrukturen wie folgt hinzuzufügen:

 interface IRun {
  void Run();
 }
 class Person : IRun
 {
  public void Run()
  {
   Console.WriteLine("走，去LOL啊！");
  }
 }
 class Car : IRun
 {
  public void Run()
  {
   Console.WriteLine("呜...........");
  }
 }
 class Program
 {
  static void Main(string[] args)
  {
   IRun e = new Person();
   e.Run();
   Console.ReadLine();
  }
 }

Diese Struktur erfüllt zwar die aktuellen Anforderungen, ist jedoch nicht robust. Mit der Zunahme der Implementierung der IRun-Schnittstelle und der Vererbung verwandter Klassen wird auch die obige Beurteilungsstruktur schnell wachsen. Eines der Hauptprinzipien objektorientierter Programmierung und Entwurfsmuster besteht darin, Transformationen zu kapseln, sodass das obige Programm Änderungen nicht gut bewältigen kann. Wir beziehen hier nicht das Wissen über „Entwurfsmuster“ ein, daher dient der folgende Beispielcode nur der Vereinfachung des obigen Programms und wendet das Wissen im Zusammenhang mit Entwurfsmustern nicht bewusst an. Wie folgt:

 static void Main(string[] args)
  {
   Console.WriteLine("请输入：Car或Person");
   string type = Console.ReadLine();
   IRun e = null;
   if ("Car" == type)
   {
    e = new Car();
   }else if("Person" == type)
   {
    e = new Person();
   }
   if(null != e)
    e.Run();
   Console.ReadLine();
  }

Nach der obigen Änderung kann das Programm eine Instanz von IRun über Activator.CreateInstance basierend auf der Eingabe des Benutzers erstellen Aufgrund der Auswirkungen dieses Problems treten Änderungen auf, wenn die Anzahl der Implementierer zunimmt. Die oben genannten Vorteile werden durch Reflexion erzielt, was meiner Meinung nach die „Vernünftigkeit der Existenz von Reflexion“ ist.

 static void Main(string[] args)
  {
   Console.WriteLine("请输入：Car或Person");
   string type = Console.ReadLine();
   string classPath = String.Format("namespace.{0}", type);
   IRun e = Activator.CreateInstance(null, classPath).Unwrap() as IRun;

   if(null != e)
    e.Run();
   Console.ReadLine();
  }

Activator und Assembly implementieren die Reflektionsmethode zum Erstellen von Objekten Das Erstellen von Objekten in der Reflektionsmethode in C# kann über Activator.CreateInstance (statisch) erfolgen. und Assembly.CreateInstance (nicht statisch), wobei Assembly.CreateInstance weiterhin Activator.CreateInstance intern aufruft.

Je nachdem, ob sich das dynamisch zu erstellende Typobjekt in der aktuellen Assembly befindet, können durch Reflexion erstellte Objekte unterteilt werden in: Erstellen von Typobjekten innerhalb der Assembly und Erstellen von Typobjekten außerhalb der Assembly.

Erstellen Sie ein Typobjekt innerhalb der Assembly

  private static void ReflectionIRun1(string className)
  {
   string classPath = String.Format("namespace.{0}", className);
   //参数 null ,指出所要创建类型对象位于当前程序集 
   var handler = Activator.CreateInstance(null, classPath);
   IRun e = (IRun)handler.Unwrap();
   Console.WriteLine(e.Run());
  }
  private static void ReflectionIRun2(string className)
  {
   string classPath = String.Format("namespace.{0}", className);
   //typeof(IRun).Assembly 获取 IRun 类型所在的程序集
   object obj = typeof(IRun).Assembly.CreateInstance(null, classPath);
   IRun e = (IRun)obj;
   Console.WriteLine(e.Run());
  }

Erstellen Sie ein Typobjekt außerhalb der Assembly

Fügen Sie dem Projekt eine Klassenbibliothek (eine weitere Assembly) hinzu, wie unten gezeigt:

Fügen Sie eine Boss-Klasse hinzu, wie unten gezeigt:

Bevor Sie ein Boss-Objekt erhalten, fügen Sie zunächst einen Verweis auf Lib hinzu. Das Erfassungsbeispiel lautet wie folgt:

namespace Lib
{
 public class Boss
 {
  private string name = "老大";
  
  public string Name{
   get {return name;}
  }
  public string Talk()
  {
   return "你们都被开除了......";
  }
  //老板不会算账，总是多付钱，所以很有自知之明的将Payfor设为private，防止外部人员调用
  private int Payfor(int total)
  {
   return total + 10;
  }
 }
}

Informationen zur Reflektion Wie die CLR die zu ladende Assembly findet und lokalisiert, finden Sie im MSDN. Informationen zur Reflektion finden Sie hier.

 private static void ReflectionBoss1()
  {
   string classPath ="Lib.Boss";
   //"Lib" 参数指明要加载的程序集（即要创建的对象类型在哪个程序集中定义）
   var handler = Activator.CreateInstance("Lib", classPath);
   Boss b = handler.Unwrap() as Boss;
   Console.WriteLine(b.Talk());
  }
  private static void ReflectionBoss2()
  {
   string classPath ="Lib.Boss";
   //Assembly.Load("Lib") 加载的程序集（即要创建的对象类型在哪个程序集中定义）
   var assembly = Assembly.Load("Lib");
   Boss b = (Boss)assembly.CreateInstance(classPath);
   Console.WriteLine(b.Talk());
  }

Reflection-Zugriffsfelder und Aufrufmethoden (Eigenschaften)

Reflection hilft uns nicht nur dabei, dynamisch Objekte zu erstellen, sondern kann uns auch dabei helfen, dynamisch auf Methoden (Eigenschaften) von Objekten zuzugreifen oder Feld, die spezifische Methode wird aufgrund unterschiedlicher C#-Versionen geändert oder erweitert. Weitere Informationen finden Sie im MSDN. Das Folgende ist nur ein einfaches Beispiel (Standardverwendung).

Benennen Sie den Boss um, Beispiel: Geld:

Ausgabe:

 private static void ReflectionBoss1()
  {
   string classPath = "Lib.Boss";
   //"Lib" 参数指明要加载的程序集（即要创建的对象类型在哪个程序集中定义）
   var handler = Activator.CreateInstance("Lib", classPath);
   Boss b = handler.Unwrap() as Boss;
   //关键代码
   FieldInfo f = b.GetType().GetField("name", BindingFlags.GetField | BindingFlags.NonPublic | BindingFlags.Instance);
   f.SetValue(b, "小二");
   Console.WriteLine("{0}:{1}", b.Name, b.Talk());
  }

Dynamik und Reflexion kombiniert

private static void ReflectionBoss1()
  {
   string classPath = "Lib.Boss";
   //"Lib" 参数指明要加载的程序集（即要创建的对象类型在哪个程序集中定义）
   var handler = Activator.CreateInstance("Lib", classPath);
   Boss b = handler.Unwrap() as Boss;
   //关键代码
   MethodInfo method = b.GetType().GetMethod("Payfor", BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Instance);
   object money = method.Invoke(b, new object[] { 10 });
   Console.WriteLine("DW039：老大给我报销10元钱车费......");
   Console.WriteLine("{0}:.....，算不清了，给你这些吧。",b.Name);
   Console.WriteLine("DW039：......");
   Console.WriteLine("{0}:{1}", b.Name,money);
   Console.WriteLine("DW039：老大你真棒!");
  }

Da Reflexion eine Typoperation zur Laufzeit ist, besteht beim Programmieren das Problem der Typunsicherheit. Gemäß dem vorherigen Artikel „C# Anonymous Object (Anonymous Type), Var, Dynamic Type Dynamic“ kann der dynamische dynamische Typ in Kombination mit dem von uns geschriebenen Reflexionsprogramm die Programmlogik erheblich optimieren (der Zugriff auf Code, der durch die Schutzstufe eingeschränkt ist, liegt nicht innerhalb). diesem Bereich).

Optimierung des obigen Codes:

Über das dynamische dynamische Typobjekt b zum Aufrufen der Reflektion können die Eigenschaften und Methoden des Objekts aufgerufen werden direkt, wodurch Go häufige Typkonvertierungsvorgänge erspart.

Häufige Anwendungsszenarien der Reflexion

Das Anwendungsszenario, das mich am meisten beeindruckt hat, war das MS Petshop-Beispiel. Beim Wechsel von einer SQL Server-Datenbank zu einer Oracle-Datenbank erhält Reflection unterschiedliche Datenzugriffsebenen. Allerdings bin ich in tatsächlichen Projekten noch nie auf die Situation gestoßen, dass die Datenbank auf halbem Weg gewechselt werden muss. Andere Anwendungsszenarien ähneln im Wesentlichen den oben genannten Beispielen. Wenn Sie weitere Anwendungsszenarien finden, fügen Sie bitte 3ks hinzu.

Vor- und Nachteile der Reflexion

Vorteile: Reflexion macht das Programm flexibler

Nachteile: Reflexion läuft relativ langsam

As denn Reflection ist langsamer als gewöhnliche Programme. Ich habe es nicht getestet und habe auch nicht vor, es zu testen. Die Realität ist: Ms befürwortet die Verwendung von Dynamik, Mvc ist beliebt, Ms optimiert kontinuierlich CLR und verbessert die Maschinenleistung, sodass Sie bei der Entwicklung nicht zu viele Probleme mit der Reflexionsleistung berücksichtigen müssen. Wenn die Laufgeschwindigkeit des von Ihnen geschriebenen Programms einen Engpass aufweist (Sie sollten zunächst sicherstellen, dass Ihr Programm angemessen geschrieben ist), ist es meiner Meinung nach praktischer, Datenbankoptimierung, Daten-Caching, Web-Caching, Lastausgleich und andere Technologien zu studieren.

Das obige ist der detaillierte Inhalt vonBeispiele für die beste Kombination aus Reflexion und Dynamik in C#. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!