c# 反射帮助类

海底星光

已于 2024-01-30 21:37:14 修改

阅读量460

点赞数 10

分类专栏：奇葩问题文章标签： c# 开发语言

于 2024-01-30 17:52:53 首次发布

本文链接：https://blog.csdn.net/qq_36522188/article/details/135937886

版权

奇葩问题专栏收录该内容

16 篇文章 0 订阅

订阅专栏

作用：动态指定需要运行的方法

public class ReflectionHelper
{
   private static readonly ConcurrentDictionary<string, object> instances = new ConcurrentDictionary<string, object>();//存放类

   private static readonly ConcurrentDictionary<string, object> methods = new ConcurrentDictionary<string, object>();//存放方法
    private ReflectionHelper()
 {
 }
 // Assembly 表示一个程序集，它是一个可重用、无版本冲突并且可自我描述的公共语言运行时应用程序构建基块
  public static bool ReflectionMethod(Assembly assembly, string Namespace, string Classname, string Method, object[] Paramsters, out string errmsg)
 {
     string key = assembly.FullName + Namespace + Classname;
     string key2 = assembly.FullName + Namespace + Classname + Method;
     errmsg = "";
     if (instances.ContainsKey(key) && methods.ContainsKey(key2))//类和方法全部都存在
     {
         try
         {
             object obj = instances[key];//获取类
             MethodInfo methodInfo = methods[key2] as MethodInfo;//获取方法
             if (methodInfo != null)
             {
                 methodInfo.Invoke(obj, Paramsters);//执行这个方法 Paramsters-参数 obj-类
                 return true;
             }

             errmsg = "方法不存在";
             return false;
         }
         catch (Exception ex)
         {
             errmsg = ex.Message;
             return false;
         }
     }

     try
     {
         Type type = ((!(Namespace == "")) ? assembly.GetType(Namespace + "." + Classname) : assembly.GetType(Classname));
         if (type == null)
         {
             errmsg = "类不存在";
             return false;
         }

         MethodInfo method = type.GetMethod(Method);//从程序集中获取
         methods[key2] = method;//将方法添加到methods字典中
         if (method == null)
         {
             errmsg = "方法不存在";
             return false;
         }

         ParameterInfo[] parameters = method.GetParameters();//当在派生类中重写时，获取指定的方法或构造函数的参数。
         for (int i = 0; i < parameters.Length; i++)
         {
             Type parameterType = parameters[i].ParameterType;
             Paramsters[i] = SD_ChanageType(Paramsters[i], parameterType);//获得一个可用对象
         }

         object obj2 = Activator.CreateInstance(type);//合成可用类
         instances[key] = obj2;//将类存放在字典中
         method.Invoke(obj2, Paramsters);//运行方法
     }
     catch (Exception ex2)
     {
         methods.TryRemove(key2, out var value);
         instances.TryRemove(key, out value);
         errmsg = ex2.Message;
         return false;
     }

     return true;
 }
 //value->ParameterInfo[i]   convertsionType-> parameters[i].ParameterType
   private static object SD_ChanageType(object value, Type convertsionType)
  {
  // convertsionType.IsGenericType -> true 如果当前类型是泛型类型，则为 ;否则为 false。
  //GetGenericTypeDefinition -> 表示可用于构造当前类型的泛型类型的 Type 对象
      if (convertsionType.IsGenericType && convertsionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
      {
          if (value == null || value.ToString().Length == 0)
          {
              return null;
          }

          NullableConverter nullableConverter = new NullableConverter(convertsionType);
          convertsionType = nullableConverter.UnderlyingType;
      }

      return Convert.ChangeType(value, convertsionType);//返回一个指定类型的对象，该对象的值等效于指定的对象。
  }
}

完整测试代码

项目结构
在这里插入图片描述

mian方法

using Newtonsoft.Json;
using Reflex;
using System;
using System.Reflection;


string jsonFilePath = "json1.json";
using (var timer = new PeriodicTimer(TimeSpan.FromSeconds(1)))
{
    //在到达指定周期后执行方法
    while (await timer.WaitForNextTickAsync())
    {
        await Task.Delay(3000);

        Console.WriteLine($"Timer Thread: {Thread.CurrentThread.ManagedThreadId}");
        Console.WriteLine($"{DateTime.Now.Second} PeriodicTimer tick");
        using (StreamReader sr = new StreamReader(jsonFilePath))
        {
            string errmsg;
            object[] objects = new object[1];
            string json = sr.ReadToEnd();
            var person = JsonConvert.DeserializeObject<Data>(json);
            var assembly = Assembly.LoadFrom(person.Namespace + ".dll");
            objects.Append(person);
            ReflectionHelper.ReflectionMethod(assembly, person.Namespace, person.Classname, person.Method, objects, out errmsg);
        }
    }
}

Console.ReadLine();

Data类

 public class Data
    {
        public string Namespace { get; set; }
        public string Classname { get; set; }
        public string Method { get; set; }
        public string Paramsters { get; set; }
    }

ReflectionHelper 反射帮助类

  public class ReflectionHelper
    {
        private static readonly ConcurrentDictionary<string, object> instances = new ConcurrentDictionary<string, object>();//存放类

        private static readonly ConcurrentDictionary<string, object> methods = new ConcurrentDictionary<string, object>();//存放方法
        private ReflectionHelper()
        {
        }
        // Assembly 表示一个程序集，它是一个可重用、无版本冲突并且可自我描述的公共语言运行时应用程序构建基块
        public static bool ReflectionMethod(Assembly assembly, string Namespace, string Classname, string Method, object[] Paramsters, out string errmsg)
        {
            string key = assembly.FullName + Namespace + Classname;
            string key2 = assembly.FullName + Namespace + Classname + Method;
            errmsg = "";
            if (instances.ContainsKey(key) && methods.ContainsKey(key2))//类和方法全部都存在
            {
                try
                {
                    object obj = instances[key];//获取类
                    MethodInfo methodInfo = methods[key2] as MethodInfo;//获取方法
                    if (methodInfo != null)
                    {
                        methodInfo.Invoke(obj, Paramsters);//执行这个方法 Paramsters-参数 obj-类
                        return true;
                    }

                    errmsg = "方法不存在";
                    return false;
                }
                catch (Exception ex)
                {
                    errmsg = ex.Message;
                    return false;
                }
            }

            try
            {
                Type type = ((!(Namespace == "")) ? assembly.GetType(Namespace + "." + Classname) : assembly.GetType(Classname));
                if (type == null)
                {
                    errmsg = "类不存在";
                    return false;
                }

                MethodInfo method = type.GetMethod(Method);//从程序集中获取
                methods[key2] = method;//将方法添加到methods字典中
                if (method == null)
                {
                    errmsg = "方法不存在";
                    return false;
                }

                ParameterInfo[] parameters = method.GetParameters();//当在派生类中重写时，获取指定的方法或构造函数的参数。
                for (int i = 0; i < parameters.Length; i++)
                {
                    Type parameterType = parameters[i].ParameterType;
                    Paramsters[i] = SD_ChanageType(Paramsters[i], parameterType);//获得一个可用对象
                }

                object obj2 = Activator.CreateInstance(type);//合成可用类
                instances[key] = obj2;//将类存放在字典中
                method.Invoke(obj2, Paramsters);//运行方法
            }
            catch (Exception ex2)
            {
                methods.TryRemove(key2, out var value);
                instances.TryRemove(key, out value);
                errmsg = ex2.Message;
                return false;
            }

            return true;
        }
        //value->ParameterInfo[i]   convertsionType-> parameters[i].ParameterType
        private static object SD_ChanageType(object value, Type convertsionType)
        {
            // convertsionType.IsGenericType -> true 如果当前类型是泛型类型，则为 ;否则为 false。
            //GetGenericTypeDefinition -> 表示可用于构造当前类型的泛型类型的 Type 对象
            if (convertsionType.IsGenericType && convertsionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
            {
                if (value == null || value.ToString().Length == 0)
                {
                    return null;
                }

                NullableConverter nullableConverter = new NullableConverter(convertsionType);
                convertsionType = nullableConverter.UnderlyingType;
            }

            return Convert.ChangeType(value, convertsionType);//返回一个指定类型的对象，该对象的值等效于指定的对象。
        }
    }

function_print 业务方法类

namespace Function
{
    public class function_print
    {

        public void Print_1(object Paramsters) {
            Console.WriteLine($"Print1");
        }
        public void Print_2(object Paramsters) {
            Console.WriteLine($"Print2");
        }
        public void Print_3(object Paramsters) {
            Console.WriteLine($"Print3");
        }

    }
}

指定运行方法配置文件

{
  "Namespace": "Function", //调用方法的命名空间
  "Classname": "function_print",//调用方法的类
  "Method": "Print_1",//调用方法的名称  ---- 修改此处可以在程序运行的过程中修改程序执行的方法
  "Paramsters":"哈哈哈成了！"
}