在 Net7.0环境下通过反射创建对象和调用方法

作者：可均可可时间：2023-09-21 阅读数：277 人阅读

一、介绍
最近没事干，就用闲暇时间写点东西，也记录一下温习历程。老人说的好，好记性，不如烂笔头。时间一长，当时记忆的再清楚，都会变得模糊，索性就写博客记录下来，如果下次需要，直接打开博客就找到了，不用去网上乱找了。
今天我要写一些有关反射创建类型实例和调用方法的文章，泛型的类型的创建和泛型方法的调用是普通类型（非泛型类型）的创建和调用还是有区别的，如果不知道，肯定会憋出一身臭汗，其实知道了，也没什么。怕时间长了，忘记。就把关键的代码写出来，为自己提个醒。
测试环境说明：
操作系统：Windows10 Professinal
开发工具：Visual Studio 2022
测试平台：Windows Console Application
框架平台：Net 7.0

二、我的代码
我的测试很简单，包含的很全，静态方法、实例方法、私有方法、重载构造函数和方法调用都有涉及，我更关注泛型，分为两种，一种是泛型类型的创建和实例化，第二种是泛型方法的调用。当然了，泛型方法的调用，也区分为：泛型类型的泛型方法的调用和非泛型类型的泛型方法的调用，废话不多说，直接上代码。
当然有泛型的创建使用，还有其他类型的访问，把所有情况都包好了。
辅助类型：

/// <summary>
/// 非泛型类型的泛型方法反射调用。
/// </summary>
internal class InstanceGenericMethod
{
/// <summary>
/// 泛型方法不是生成占位符。
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="S"></typeparam>
/// <param name="parameter"></param>
/// <param name="s"></param>
/// <returns></returns>
public T Generate<T, S>(T parameter, S s)
{
Console.WriteLine("非泛型类-泛型方法：Generate<T, S>(T parameter, S s) 执行");
return parameter;
}
}

/// <summary>
/// 泛型类型的泛型方法反射调用。
/// </summary>
/// <typeparam name="X"></typeparam>
internal class GenericClassMethod<X>
{
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="S"></typeparam>
/// <param name="parameter"></param>
/// <param name="s"></param>
/// <returns></returns>
public X Generate<T, S>(X x, T t, S s)
{
Console.WriteLine("泛型类-泛型方法：Generate<T, S>(T parameter, S s) 执行");
return x;
}
}

实例方法调用类型：

/// <summary>
/// 针对实例类型方法反射的调用，包含重载方法的反射调用。
/// </summary>
internal class InstanceMethod
{
/// <summary>
/// 无参唯一实例方法。
/// </summary>
public void Process()
{
Console.WriteLine("Process()无参实例方法执行。");
}

/// <summary>
/// 多参实例方法。
/// </summary>
/// <param name="age"></param>
/// <param name="name"></param>
/// <param name="dateTime"></param>
public void DoSomething(int age,string name,DateTime dateTime)
{
Console.WriteLine("DoSomething(int age,string name,DateTime dateTime)多参实例方法执行。");
}

/// <summary>
/// 重载方法
/// </summary>
public void Generate()
{
Console.WriteLine($"Generate()");
}

/// <summary>
/// 重载方法
/// </summary>
/// <param name="age"></param>
/// <param name="name"></param>
public void Generate(int age,string name)
{
Console.WriteLine($"Generate(int age,string name)");
}

/// <summary>
/// 重载方法
/// </summary>
/// <param name="age"></param>
/// <param name="name"></param>
/// <param name="stream"></param>
public void Generate(int age, string name, Stream stream)
{
Console.WriteLine($"Generate(int age, string name, Stream stream)已执行");
}

/// <summary>
/// 有返回值的重载方法
/// </summary>
/// <param name="age"></param>
/// <param name="name"></param>
/// <param name="stream"></param>
public decimal Generate(int age, string name, Stream stream,decimal money)
{
Console.WriteLine($" Generate(int age, string name, Stream stream,decimal money) 已执行");
return money;
}
}

使用静态和实例方法反射调用的类型：

/// <summary>
/// 通过反射调用私有方法。
/// </summary>
internal class PrivateMethodDemo
{
/// <summary>
/// 有参数的实例私有方法。
/// </summary>
/// <param name="age"></param>
/// <param name="name"></param>
private void PrivateInstanceMethodTest(int age, string name)
{
Console.WriteLine($"实例方法：年龄：{age};姓名：{name}");
}

/// <summary>
/// 有参数的静态私有方法。
/// </summary>
/// <param name="age"></param>
/// <param name="name"></param>
private static void PrivateStaticMethodTest(int age, string name)
{
Console.WriteLine($"静态方法：年龄：{age};姓名：{name}");
}
}

静态方法反射调用的类型：

/// <summary>
/// 静态方法反射调用，包含重载静态方法
/// </summary>
internal class StaticMethod
{
/// <summary>
///
/// </summary>
public static void Process()
{
Console.WriteLine("Process()无参实例方法执行。");
}

/// <summary>
///
/// </summary>
/// <param name="age"></param>
/// <param name="name"></param>
/// <param name="dateTime"></param>
public static void DoSomething(int age, string name, DateTime dateTime)
{
Console.WriteLine("DoSomething(int age,string name,DateTime dateTime)多参实例方法执行。");
}

/// <summary>
/// 重载方法
/// </summary>
public static void Generate()
{
Console.WriteLine("重载方法：Generate() 方法执行。");
}

/// <summary>
/// 重载方法
/// </summary>
/// <param name="age"></param>
/// <param name="name"></param>
public static void Generate(int age, string name)
{
Console.WriteLine("重载方法：Generate(int age, string name) 方法执行。");
}

/// <summary>
/// 重载方法
/// </summary>
/// <param name="age"></param>
/// <param name="name"></param>
/// <param name="stream"></param>
public static void Generate(int age, string name, Stream stream)
{
Console.WriteLine("重载方法：Generate(int age, string name, Stream stream) 方法执行。");
}

/// <summary>
/// 有返回值的重载方法
/// </summary>
/// <param name="age"></param>
/// <param name="name"></param>
/// <param name="stream"></param>
public static decimal Generate(int age, string name, Stream stream, decimal money)
{
Console.WriteLine("重载方法：Generate(int age, string name, Stream stream, decimal money) 方法执行。");
return money;
}
}

反射调用重载构造函数的类型：

/// <summary>
/// 反射调用重载构造函数
/// </summary>
internal class MultiCtorDemo
{
private readonly string? name;
private readonly DateTime dateTime;
private readonly int age;

/// <summary>
/// 无参构造函数
/// </summary>
public MultiCtorDemo()
{

}

/// <summary>
/// 重载构造函数
/// </summary>
/// <param name="name"></param>
public MultiCtorDemo(string name)
{
this.name = name;
}

/// <summary>
/// 重载构造函数
/// </summary>
/// <param name="age"></param>
public MultiCtorDemo(int age)
{
this.age = age;
}

/// <summary>
/// 重载构造函数
/// </summary>
/// <param name="age"></param>
/// <param name="name"></param>
/// <param name="dateTime"></param>
public MultiCtorDemo(int age,string name,DateTime dateTime)
{
this.age = age;
this.name = name;
this.dateTime = dateTime;
}
}
私有和受保护的构造函数反射调用的类型：

/// <summary>
/// 私有和受保护的构造函数反射调用
/// </summary>
internal class PrivateCtorDemo
{
private readonly int age;

/// <summary>
/// 私有构造函数
/// </summary>
private PrivateCtorDemo() { }

/// <summary>
/// 受保护的构造函数
/// </summary>
/// <param name="age"></param>
protected PrivateCtorDemo(int age)
{
this.age = age;
}
}
测试代码：

//202309181126、多构造函数反射调用
{
Assembly assembly = Assembly.Load("PatrickLiu.DelegateDeep.AllStudy");
var myType = assembly.GetType("PatrickLiu.DelegateDeep.AllStudy.Reflections.MultiCtorDemo");
if (myType != null)
{
var instance = Activator.CreateInstance(myType);
var instance2 = Activator.CreateInstance(myType, new object[] { "魏延" });
var instance3 = Activator.CreateInstance(myType, new object[] { 123 });
var instance4 = Activator.CreateInstance(myType, new object[] { 123, "黄飞虎", DateTime.Now });
}
}

//202309181135、私有构造函数反射调用（只有无参构造函数）
{
Assembly assembly = Assembly.Load("PatrickLiu.DelegateDeep.AllStudy");
var myType = assembly.GetType("PatrickLiu.DelegateDeep.AllStudy.Reflections.PrivateCtorDemo");
if (myType != null)
{
var obj = Activator.CreateInstance(myType, true);
}
}

//202309181151、泛型类型的反射实例
{
Assembly assembly = Assembly.Load("PatrickLiu.DelegateDeep.AllStudy");
var myType = assembly.GetType("PatrickLiu.DelegateDeep.AllStudy.Reflections.ReflectionGenericDemo`4");
if (myType != null)
{
var genericType = myType.MakeGenericType(new Type[] { typeof(int), typeof(string), typeof(float), typeof(decimal), });
var obj = Activator.CreateInstance(genericType);
}
}

//202309181309、实例方法反射调用
{
Assembly assembly = Assembly.Load("PatrickLiu.DelegateDeep.AllStudy");
var myType = assembly.GetType("PatrickLiu.DelegateDeep.AllStudy.Reflections.Methods.InstanceMethod");
if (myType != null)
{
var myInstance = Activator.CreateInstance(myType);
if (myInstance != null)
{
var method = myType.GetMethod("Process");
method!.Invoke(myInstance, null);

var method2 = myType.GetMethod("DoSomething", new Type[] { typeof(int), typeof(string), typeof(DateTime) });
method2!.Invoke(myInstance, new object[] { 112233, "魏延", DateTime.Now });
}
}
}

//202309181330、实例重载方法反射调用
{
Assembly assembly = Assembly.Load("PatrickLiu.DelegateDeep.AllStudy");
var myType = assembly.GetType("PatrickLiu.DelegateDeep.AllStudy.Reflections.Methods.InstanceMethod");
if (myType != null)
{
var myInstance = Activator.CreateInstance(myType);
if (myInstance != null)
{
var method = myType.GetMethod("Generate", new Type[] { });
method!.Invoke(myInstance, null);

var method2 = myType.GetMethod("Generate", new Type[] { typeof(int), typeof(string) });
method2!.Invoke(myInstance, new object[] { 112233, "魏延" });

var method3 = myType.GetMethod("Generate", new Type[] { typeof(int), typeof(string), typeof(Stream) });
method3!.Invoke(myInstance, new object[] { 112233, "魏延", null });

var method4 = myType.GetMethod("Generate", new Type[] { typeof(int), typeof(string), typeof(Stream), typeof(decimal) });
var value = method4!.Invoke(myInstance, new object[] { 112233, "魏延", null, 4933m });
Console.WriteLine(value);
}
}
}

//202309181345、静态方法、重载方法反射调用（实例对象为空）
{
Assembly assembly = Assembly.Load("PatrickLiu.DelegateDeep.AllStudy");
var myType = assembly.GetType("PatrickLiu.DelegateDeep.AllStudy.Reflections.Methods.StaticMethod");
if (myType != null)
{
var staticProcess = myType.GetMethod("Process");
staticProcess!.Invoke(null, null);

var staticDoSomething = myType.GetMethod("DoSomething", new Type[] { typeof(int), typeof(string), typeof(DateTime) });
staticDoSomething!.Invoke(null, new object[] { 123, "dddd", DateTime.Now });

var staticGenerate = myType.GetMethod("Generate", new Type[] { });
staticGenerate!.Invoke(null, null);

var staticGenerate2 = myType.GetMethod("Generate", new Type[] { typeof(int), typeof(string) });
staticGenerate2!.Invoke(null, new object[] { 123, "123" });

var staticGenerate3 = myType.GetMethod("Generate", new Type[] { typeof(int), typeof(string), typeof(Stream) });
staticGenerate3!.Invoke(null, new object[] { 123, "123", null });

var staticGenerate4 = myType.GetMethod("Generate", new Type[] { typeof(int), typeof(string), typeof(Stream), typeof(decimal) });
var value = staticGenerate4!.Invoke(null, new object[] { 123, "123", null, 2345m });
Console.WriteLine(value);
}
}

//202309181345、静态方法、重载方法反射调用（实例对象不为空）
{
Assembly assembly = Assembly.Load("PatrickLiu.DelegateDeep.AllStudy");
var myType = assembly.GetType("PatrickLiu.DelegateDeep.AllStudy.Reflections.Methods.StaticMethod");
if (myType != null)
{
var instance = Activator.CreateInstance(myType);
var staticProcess = myType.GetMethod("Process");
staticProcess!.Invoke(instance, null);

var staticDoSomething = myType.GetMethod("DoSomething", new Type[] { typeof(int), typeof(string), typeof(DateTime) });
staticDoSomething!.Invoke(instance, new object[] { 123, "dddd", DateTime.Now });

var staticGenerate = myType.GetMethod("Generate", new Type[] { });
staticGenerate!.Invoke(instance, null);

var staticGenerate2 = myType.GetMethod("Generate", new Type[] { typeof(int), typeof(string) });
staticGenerate2!.Invoke(instance, new object[] { 123, "123" });

var staticGenerate3 = myType.GetMethod("Generate", new Type[] { typeof(int), typeof(string), typeof(Stream) });
staticGenerate3!.Invoke(instance, new object[] { 123, "123", null });

var staticGenerate4 = myType.GetMethod("Generate", new Type[] { typeof(int), typeof(string), typeof(Stream), typeof(decimal) });
var value = staticGenerate4!.Invoke(instance, new object[] { 123, "123", null, 2345m });
Console.WriteLine(value);
}
}

//202309181349、泛型方法反射调用
{
//非泛型类型的泛型方法反射调用。
{
Assembly assembly = Assembly.Load("PatrickLiu.DelegateDeep.AllStudy");
var type = assembly.GetType("PatrickLiu.DelegateDeep.AllStudy.Reflections.Methods.InstanceGenericMethod");
if (type != null)
{
var instance = Activator.CreateInstance(type);
if (instance != null)
{
var method = type.GetMethod("Generate");
var genericMethod = method!.MakeGenericMethod(typeof(int), typeof(string));
var value = genericMethod.Invoke(instance, new object[] { 123, "魏延" });
Console.WriteLine(value);
}
}
}

//泛型类型的泛型方法反射调用。
{
Assembly assembly = Assembly.Load("PatrickLiu.DelegateDeep.AllStudy");
var type = assembly.GetType("PatrickLiu.DelegateDeep.AllStudy.Reflections.Methods.GenericClassMethod`1");
if (type != null)
{
var genericType = type.MakeGenericType(new Type[] { typeof(int) });
var instance = Activator.CreateInstance(genericType);
if (instance != null)
{
var method = genericType.GetMethod("Generate");
var genericMethod = method!.MakeGenericMethod(typeof(int), typeof(string));
var value = genericMethod.Invoke(instance, new object[] { 123, 456, "魏延" });
Console.WriteLine(value);
}
}
}
}

//202309191105、反射调用静态和实例私有方法
{
Assembly assembly = Assembly.Load("PatrickLiu.DelegateDeep.AllStudy");
var type = assembly.GetType("PatrickLiu.DelegateDeep.AllStudy.Reflections.Methods.PrivateMethodDemo");
if (type != null)
{
var instance = Activator.CreateInstance(type);
if (instance != null)
{
var privateInstanceMethod = type.GetMethod("PrivateInstanceMethodTest", BindingFlags.NonPublic|BindingFlags.Instance);
privateInstanceMethod?.Invoke(instance,new object[] {123,"魏文长" });

var privateStaticMethod = type.GetMethod("PrivateStaticMethodTest", BindingFlags.NonPublic | BindingFlags.Static);
privateStaticMethod?.Invoke(instance, new object[] { 123, "魏文长" });
}
}
}

三、总结
好了，写了不少了，其实这里不只是包含泛型类型，也包含其他的，私有方法的调用，静态方法的调用，重载方法和构造函数的调用，基本上都涉及到了，行了，以后有新的东西再写吧。每天努力一点点，老天不负有心人。

本站大部分文章、数据、图片均来自互联网,一切版权均归源网站或源作者所有。

如果侵犯了您的权益请来信告知我们删除。邮箱：1451803763@qq.com

标签：技术应用学习资料 .Net

上一篇:获取layer.open弹出层的返回值方法

下一篇:处理错误：Access to the path 'C:\Windows\TEMP\xxx.tmp' is denied.