反射与特性 #

Type type1 = typeof(string);
Type type2 = "Hello".GetType();
Type type3 = Type.GetType("System.String");

Type listType = typeof(List<int>);
Type genericType = typeof(List<>);

Type type = typeof(List<int>);

Console.WriteLine($"名称: {type.Name}");
Console.WriteLine($"全名: {type.FullName}");
Console.WriteLine($"命名空间: {type.Namespace}");
Console.WriteLine($"基类: {type.BaseType}");
Console.WriteLine($"是否泛型: {type.IsGenericType}");
Console.WriteLine($"是否数组: {type.IsArray}");
Console.WriteLine($"是否值类型: {type.IsValueType}");

Type type = typeof(string);

MethodInfo[] methods = type.GetMethods();
MethodInfo? method = type.GetMethod("Substring", new[] { typeof(int), typeof(int) });

foreach (var m in methods)
{
    Console.WriteLine($"{m.ReturnType.Name} {m.Name}({string.Join(", ", m.GetParameters().Select(p => p.ParameterType.Name))})");
}

Type type = typeof(Person);

PropertyInfo[] properties = type.GetProperties();
PropertyInfo? property = type.GetProperty("Name");

foreach (var p in properties)
{
    Console.WriteLine($"{p.PropertyType.Name} {p.Name}");
}

Type type = typeof(Person);

FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
FieldInfo? field = type.GetField("_name", BindingFlags.NonPublic | BindingFlags.Instance);

Type type = typeof(Person);

ConstructorInfo[] constructors = type.GetConstructors();
ConstructorInfo? constructor = type.GetConstructor(new[] { typeof(string), typeof(int) });

Type type = typeof(List<int>);
object? instance = Activator.CreateInstance(type);

object? instance2 = Activator.CreateInstance(type, new object[] { 100 });

Type type = typeof(List<int>);
object? list = Activator.CreateInstance(type);

MethodInfo? addMethod = type.GetMethod("Add");
addMethod?.Invoke(list, new object[] { 42 });

MethodInfo? countProperty = type.GetProperty("Count")?.GetGetMethod();
int count = (int?)countProperty?.Invoke(list, null) ?? 0;

Type type = typeof(Person);
object? person = Activator.CreateInstance(type);

PropertyInfo? nameProperty = type.GetProperty("Name");
nameProperty?.SetValue(person, "张三");

string? name = (string?)nameProperty?.GetValue(person);

[Obsolete("请使用新方法", true)]
public void OldMethod() { }

[Serializable]
public class Person { }

[Conditional("DEBUG")]
public void DebugMethod() { }

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)]
public class AuthorAttribute : Attribute
{
    public string Name { get; }
    public string? Email { get; set; }
    
    public AuthorAttribute(string name)
    {
        Name = name;
    }
}

[Author("张三", Email = "zhangsan@example.com")]
public class MyClass
{
    [Author("李四")]
    public void DoWork() { }
}

Type type = typeof(MyClass);

var attributes = type.GetCustomAttributes<AuthorAttribute>();
foreach (var attr in attributes)
{
    Console.WriteLine($"作者: {attr.Name}, 邮箱: {attr.Email}");
}

MethodInfo? method = type.GetMethod("DoWork");
var methodAttributes = method?.GetCustomAttributes<AuthorAttribute>();

public static TTarget Map<TSource, TTarget>(TSource source)
    where TTarget : new()
{
    var target = new TTarget();
    var sourceType = typeof(TSource);
    var targetType = typeof(TTarget);
    
    foreach (var sourceProp in sourceType.GetProperties())
    {
        var targetProp = targetType.GetProperty(sourceProp.Name);
        if (targetProp != null && targetProp.PropertyType == sourceProp.PropertyType)
        {
            var value = sourceProp.GetValue(source);
            targetProp.SetValue(target, value);
        }
    }
    
    return target;
}

[AttributeUsage(AttributeTargets.Property)]
public class RequiredAttribute : Attribute
{
    public string? ErrorMessage { get; set; }
}

[AttributeUsage(AttributeTargets.Property)]
public class RangeAttribute : Attribute
{
    public int Min { get; }
    public int Max { get; }
    
    public RangeAttribute(int min, int max)
    {
        Min = min;
        Max = max;
    }
}

public static bool Validate(object obj, out List<string> errors)
{
    errors = new List<string>();
    var type = obj.GetType();
    
    foreach (var prop in type.GetProperties())
    {
        var value = prop.GetValue(obj);
        
        var required = prop.GetCustomAttribute<RequiredAttribute>();
        if (required != null && value == null)
        {
            errors.Add(required.ErrorMessage ?? $"{prop.Name} 是必填项");
        }
        
        var range = prop.GetCustomAttribute<RangeAttribute>();
        if (range != null && value is int intValue)
        {
            if (intValue < range.Min || intValue > range.Max)
            {
                errors.Add($"{prop.Name} 必须在 {range.Min} 和 {range.Max} 之间");
            }
        }
    }
    
    return errors.Count == 0;
}