C# utilise la réflexion pour créer un objet instance d'une classe basé sur le nom de la classe.

Cet article présente principalement l'explication détaillée de C# utilisant la réflexion pour créer une instance d'un objet de classe basé sur le nom de la classe "Reflection" utilise en fait les informations de métadonnées du. assemblée Si vous êtes intéressé, les amis, vous pouvez vous y référer.

"Reflection" utilise en fait les informations de métadonnées de l'assembly. Reflection peut avoir de nombreuses méthodes lors de l'écriture d'un programme, veuillez d'abord importer l'espace de noms System.Reflection .

1. Supposons que vous souhaitiez refléter une classe dans DLL, et qu'il n'y ait pas de référence à celle-ci (c'est-à-dire un type inconnu) :

Assembly assembly = Assembly.LoadFile("程序集路径，不能是相对路径"); // 加载程序集（EXE 或 DLL） 
dynamic obj = assembly.CreateInstance("类的完全限定名（即包括命名空间）"); // 创建类的实例

2. Si vous souhaitez refléter la classe dans le projet actuel (c'est-à-dire que le projet actuel l'a référencée ), vous pouvez faire :

Assembly assembly = Assembly.GetExecutingAssembly(); // 获取当前程序集 
dynamic obj = assembly.CreateInstance("类的完全限定名（即包括命名空间）"); 
// 创建类的实例，返回为 object 类型，需要强制类型转换

3. Cela peut aussi être :

Type type = Type.GetType("类的完全限定名"); 
dynamic obj = type.Assembly.CreateInstance(type);

4. S'il s'agit d'assemblys différents, ils doivent être chargés et appelés. Le code est le suivant :

System.Reflection.Assembly. .Load("Nom de l'assembly (à l'exclusion du nom du suffixe du fichier)").CreateInstance(" Namespace.Class name", false);

Par exemple :

Le code est la suivante :

dynamic o = System.Reflection.Assembly.Load("MyDll").CreateInstance("MyNameSpace.A", false);

Remarque : En raison de l'utilisation de Dynamic, vous devez modifier la cible en 4.0. Si « Un ou plusieurs types. requise pour compiler l' expression dynamique introuvable lors de la compilation. L'erreur "Référence manquante ?" est-elle due au fait qu'une référence est manquante. Faites référence à la bibliothèque de classes Miscorsoft.CSharp dans le projet, et ce sera le cas. être compilé avec succès après l'avoir ajouté.

========================================= ===== ==============

Supplément :

1) Lors de la création d'une instance d'une classe par réflexion , vous devez vous assurer que vous utilisez le nom complet (nom de classe d'espace de noms). Si la méthode Type.GetType renvoie null, cela signifie que la recherche des informations pertinentes dans les métadonnées a échoué (échec de la réflexion). Veuillez vous assurer d'utiliser le nom complet de la classe. lors de la réflexion.

2) La fonction de réflexion est très puissante et il n'y a rien qui ne puisse être réalisé. Si vous souhaitez implémenter le "cross-assembly", veuillez utiliser la première méthode pour créer une instance de la classe et refléter les champs, propriétés, méthodes, événements... de la instance, puis appelez-la dynamiquement.

  /// <summary>
  /// 反射帮助类
  /// </summary>
  public static class ReflectionHelper
  {
    /// <summary>
    /// 创建对象实例
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="fullName">命名空间.类型名</param>
    /// <param name="assemblyName">程序集</param>
    /// <returns></returns>
    public static T CreateInstance<T>(string fullName, string assemblyName)
    {
      string path = fullName + "," + assemblyName;//命名空间.类型名,程序集
      Type o = Type.GetType(path);//加载类型
      object obj = Activator.CreateInstance(o, true);//根据类型创建实例
      return (T)obj;//类型转换并返回
    }

    /// <summary>
    /// 创建对象实例
    /// </summary>
    /// <typeparam name="T">要创建对象的类型</typeparam>
    /// <param name="assemblyName">类型所在程序集名称</param>
    /// <param name="nameSpace">类型所在命名空间</param>
    /// <param name="className">类型名</param>
    /// <returns></returns>
    public static T CreateInstance<T>(string assemblyName, string nameSpace, string className)
    {
      try
      {
        string fullName = nameSpace + "." + className;//命名空间.类型名
        //此为第一种写法
        object ect = Assembly.Load(assemblyName).CreateInstance(fullName);//加载程序集，创建程序集里面的 命名空间.类型名 实例
        return (T)ect;//类型转换并返回
        //下面是第二种写法
        //string path = fullName + "," + assemblyName;//命名空间.类型名,程序集
        //Type o = Type.GetType(path);//加载类型
        //object obj = Activator.CreateInstance(o, true);//根据类型创建实例
        //return (T)obj;//类型转换并返回
      }
      catch
      {
        //发生异常，返回类型的默认值
        return default(T);
      }
    }
  }

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!