C#反射避坑指南：那些年我们踩过的"天劫雷"

// 三种获取Type对象的方式
Type t1 = typeof(string);          // 通过typeof运算符
Type t2 = Type.GetType("System.String"); // 通过类型名称
Type t3 = "hello".GetType();       // 通过实例获取

Console.WriteLine($"类型名称：{t1.Name}");
Console.WriteLine($"命名空间：{t1.Namespace}");
Console.WriteLine($"是类吗？{t1.IsClass}");
Console.WriteLine($"基类型：{t1.BaseType}");

// 创建不同类型的实例
object list = Activator.CreateInstance(typeof(List<string>));
object dt = Activator.CreateInstance(typeof(DateTime), 2023, 1, 1);

// 带参数的构造
Type sbType = typeof(StringBuilder);
StringBuilder sb = (StringBuilder)Activator.CreateInstance(
    sbType, 
    new object[] { "初始值", 100 });

// 获取并调用方法
Type mathType = typeof(Math);
MethodInfo maxMethod = mathType.GetMethod("Max", 
    new[] { typeof(int), typeof(int) });

int result = (int)maxMethod.Invoke(null, new object[] { 5, 10 });
Console.WriteLine($"最大值：{result}"); // 输出10

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

// 反射操作属性
Person p = new Person();
Type personType = typeof(Person);

PropertyInfo nameProp = personType.GetProperty("Name");
nameProp.SetValue(p, "张三");

PropertyInfo ageProp = personType.GetProperty("Age");
ageProp.SetValue(p, 25);

Console.WriteLine($"{p.Name}, {p.Age}岁");

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, 
    AllowMultiple = true)]
public class CultivationStageAttribute : Attribute
{
    public string Stage { get; }
    public int RequiredLevel { get; set; }
    
    public CultivationStageAttribute(string stage)
    {
        Stage = stage;
    }
}

[CultivationStage("金丹期", RequiredLevel = 5)]
public class GoldenCoreTechnique
{
    [CultivationStage("小成")]
    public void Practice() { }
}

// 探查特性
Type techniqueType = typeof(GoldenCoreTechnique);

// 类级别特性
var classAttributes = techniqueType.GetCustomAttributes(
    typeof(CultivationStageAttribute), false);
foreach(CultivationStageAttribute attr in classAttributes)
{
    Console.WriteLine($"修炼阶段：{attr.Stage}，要求等级{attr.RequiredLevel}");
}

// 方法级别特性
MethodInfo method = techniqueType.GetMethod("Practice");
var methodAttributes = method.GetCustomAttributes(
    typeof(CultivationStageAttribute), false);
// ...类似处理

private static readonly Type _cachedType = typeof(MyClass);
private static readonly MethodInfo _cachedMethod = _cachedType.GetMethod("MyMethod");

MethodInfo method = typeof(MyClass).GetMethod("MyMethod");
var del = (Func<MyClass, int>)Delegate.CreateDelegate(
    typeof(Func<MyClass, int>), method);

int result = del(myInstance); // 比Invoke快10倍

var param = Expression.Parameter(typeof(MyClass));
var call = Expression.Call(param, method);
var lambda = Expression.Lambda<Func<MyClass, int>>(call, param);
var compiled = lambda.Compile(); // 编译成委托

int result = compiled(myInstance); // 接近原生调用性能

// 创建动态方法
var dynamicMethod = new DynamicMethod(
    "DynamicAdd",                      // 方法名
    typeof(int),                       // 返回类型
    new[] { typeof(int), typeof(int) }, // 参数类型
    typeof(Program).Module);           // 关联模块

// 生成IL代码
var il = dynamicMethod.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);   // 加载第一个参数
il.Emit(OpCodes.Ldarg_1);   // 加载第二个参数
il.Emit(OpCodes.Add);       // 执行加法
il.Emit(OpCodes.Ret);       // 返回结果

// 创建并调用委托
var addDel = (Func<int, int, int>)dynamicMethod.CreateDelegate(
    typeof(Func<int, int, int>));

int sum = addDel(5, 7); // 输出12

public interfaceIPlugin
{
    string Name { get; }
    void Execute();
}

public class PluginLoader
{
    public List<IPlugin> LoadPlugins(string path)
    {
        var plugins = new List<IPlugin>();
        
        foreach(string dll in Directory.GetFiles(path, "*.dll"))
        {
            Assembly assembly = Assembly.LoadFrom(dll);
            
            foreach(Type type in assembly.GetTypes())
            {
                if(typeof(IPlugin).IsAssignableFrom(type) && !type.IsAbstract)
                {
                    IPlugin plugin = (IPlugin)Activator.CreateInstance(type);
                    plugins.Add(plugin);
                }
            }
        }
        
        return plugins;
    }
}

public class EntityMapper<T> whereT : new()
{
    public T Map(DbDataReader reader)
    {
        T entity = new T();
        Type type = typeof(T);
        
        for(int i = 0; i < reader.FieldCount; i++)
        {
            string name = reader.GetName(i);
            PropertyInfo prop = type.GetProperty(name);
            
            if(prop != null && !reader.IsDBNull(i))
            {
                object value = reader.GetValue(i);
                prop.SetValue(entity, value);
            }
        }
        
        return entity;
    }
}

public static class ReflectionUtil
{
    // 获取友好类型名称
    public static string GetFriendlyTypeName(Type type)
    {
        if(!type.IsGenericType) return type.Name;
        
        string name = type.Name.Split('`')[0];
        var args = type.GetGenericArguments()
                     .Select(t => GetFriendlyTypeName(t));
        return $"{name}<{string.Join(",", args)}>";
    }
    
    // 深度克隆对象
    public static T DeepClone<T>(T obj)
    {
        if(obj == null) return default;
        
        Type type = obj.GetType();
        if(type.IsValueType || type == typeof(string))
            return obj;
            
        if(type.IsArray)
        {
            Array array = (Array)(object)obj;
            Array cloned = (Array)array.Clone();
            for(int i = 0; i < array.Length; i++)
                cloned.SetValue(DeepClone(array.GetValue(i)), i);
            return (T)(object)cloned;
        }
        
        T clonedObj = (T)Activator.CreateInstance(type);
        foreach(FieldInfo field in type.GetFields(
            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
        {
            field.SetValue(clonedObj, DeepClone(field.GetValue(obj)));
        }
        
        return clonedObj;
    }
}