反射类

 

using System;
using System.Data;
using System.Configuration;
using System.Linq;
using System.Web;
using System.Xml.Linq;
using System.Reflection;

/// <summary>
///Reflect 的摘要说明
/// </summary>
public static class Reflect
{
    static BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic|BindingFlags.Instance;
    /// <summary>
    /// 根据程序集名称加载一个程序集
    /// </summary>
    /// <param name="asm">程序集名称</param>
    /// <returns>程序集</returns>
    public static Assembly GetAssembly(string asm)
    {
        return Assembly.Load(asm);
    }

    /// <summary>
    /// 根据路径加载程序集
    /// </summary>
    /// <param name="asmPath">Bin文件路径</param>
    /// <returns>程序集</returns>
    public static Assembly GetAssemblyByPath(string asmPath)
    {
        return Assembly.LoadFile(asmPath);
    }

    /// <summary>
    /// 返回一个对象类型
    /// </summary>
    /// <param name="asm">程序集</param>
    /// <param name="objFullName">对象完全名称 namespace+classname</param>
    /// <returns></returns>
    public static Type GetType(Assembly asm, string objFullName)
    {
        return asm.GetType(objFullName, true, true);
    }

    /// <summary>
    /// 创建一个对象实例
    /// </summary>
    /// <param name="asm">程序集</param>
    /// <param name="objFullName">对象路径 namespace+classname</param>
    /// <returns></returns>
    public static object CreateInstance(Assembly asm, string objFullName)
    {
        return asm.CreateInstance(objFullName, true);
    }

    /// <summary>
    /// 初始化构造函数并返回对象类型实例
    /// </summary>
    /// <param name="type">对象类型</param>
    /// <param name="paramTypes">构造函数参数类型</param>
    /// <param name="parameters">构造函数参数</param>
    /// <returns></returns>
    public static object CreateInstance(Type type, Type[] paramTypes, params object[] parameters)
    {
        return GetConstructor(type, paramTypes).Invoke(parameters);
    }

    /// <summary>
    /// 初始化构造函数返回指定类型的对象实例
    /// </summary>
    /// <param name="type">对象类型</param>
    /// <param name="parameters">构造函数参数</param>
    /// <returns>对象类型实例</returns>
    public static object CreateInstance(Type type, params object[] parameters)
    {
        return GetConstructor(type, GetTypesFromObjects(parameters)).Invoke(parameters);
    }
    /// <summary>
    /// 获得指定对象的方法对象
    /// </summary>
    /// <param name="type">对象类型</param>
    /// <param name="method">方法名称</param>
    /// <returns>方法对象</returns>
    public static MethodInfo GetMethod(Type type, string method)
    {
        return type.GetMethod(method);
    }

    /// <summary>
    /// 获得指定对象的方法对象，区别重载
    /// </summary>
    /// <param name="type">对象类型</param>
    /// <param name="method">方法名称</param>
    /// <param name="types">参数类型: 如参数为0时，new Type[0]</param>
    /// <returns>方法对象</returns>
    public static MethodInfo GetMethod(Type type, string method, params Type[] types)
    {
        return type.GetMethod(method, types);
    }


    /// <summary>
    /// 执行方法(不区别重载)
    /// </summary>
    /// <param name="type">对象类型</param>
    /// <param name="obj">对象实例</param>
    /// <param name="method">方法名称</param>
    /// <param name="parameters">参数集合</param>
    public static object RunInvoke(Type type, object obj, string methodName, object[] parameters)
    {
        MethodInfo method = GetMethod(type, methodName);
        if (method != null)
            return method.Invoke(obj, parameters);
        return null;
    }


    /// <summary>
    /// 执行方法(区别重载),静态方法的话obj可以为null
    /// </summary>
    /// <param name="type">对象类型</param>
    /// <param name="obj">对象实例</param>
    /// <param name="method">方法名称</param>
    /// <param name="types">方法参数类型</param>
    /// <param name="parameters">方法参数</param>
    public static object RunInvoke(Type type, object obj, string methodName, Type[] types, object[] parameters)
    {
        MethodInfo method = GetMethod(type, methodName, types);
        if (method != null)
        {
            return method.Invoke(obj, parameters);
        }
        return null;
    }

    //public static object GetProperty(object obj, string propertyName)
    //{
    //    return GetProperty(obj, propertyName, null);
    //}

    /// <summary>
    /// 返回一个属性的值
    /// </summary>
    /// <param name="obj">对象实例</param>
    /// <param name="propertyName">属性名称</param>
    /// <param name="index">索引话属性的的可选索引值，无的话为null</param>
    /// <returns>属性值</returns>
    public static object GetProperty(object obj, string propertyName, params object[] index)
    {
        Type type = obj.GetType();
        return type.GetProperty(propertyName, flags).GetValue(obj, index);
    }

    //public static object GetStaticProperty(Type type, string propertyName)
    //{
    //    return GetStaticProperty(type, propertyName, null);
    //}

    /// <summary>
    /// 返回一个静态属性值
    /// </summary>
    /// <param name="type">对象类型</param>
    /// <param name="propertyName">属性名称</param>
    /// <param name="index">索引话属性的的可选索引值，无的话为null</param>
    /// <returns>属性值</returns>
    public static object GetStaticProperty(Type type, string propertyName, params object[] index)
    {
        return type.GetProperty(propertyName, flags).GetValue(null, index);
    }

    //public static void SetProperty(object obj, string propertyName, object value)
    //{
    //    SetProperty(obj, propertyName, value, null);
    //}

    /// <summary>
    /// 设置一个属性的值
    /// </summary>
    /// <param name="obj">对象实例</param>
    /// <param name="propertyName">属性名称</param>
    /// <param name="value">设置属性的值</param>
    /// <param name="index">索引话属性的的可选索引值，无的话为null</param>
    public static void SetProperty(object obj, string propertyName, object value, params object[] index)
    {
        Type type = obj.GetType();
        type.GetProperty(propertyName, flags).SetValue(obj, value, index);
    }

    //public static void SetStaticProperty(Type type, string propertyName, object value)
    //{
    //    SetStaticProperty(type, propertyName, value, null);
    //}
    /// <summary>
    /// 设置一个静态属性的值
    /// </summary>
    /// <param name="obj">对象类型</param>
    /// <param name="propertyName">属性名称</param>
    /// <param name="value">设置属性的值</param>
    /// <param name="index">索引话属性的的可选索引值，无的话为null</param>
    public static void SetStaticProperty(Type type, string propertyName, object value, params object[] index)
    {
        type.GetProperty(propertyName, flags).SetValue(null, value, index);
    }

    /// <summary>
    /// 获取字段的值
    /// </summary>
    /// <param name="obj">对象实例</param>
    /// <param name="fieldName">字段名称</param>
    /// <returns>字段值</returns>
    public static object GetField(object obj, string fieldName)
    {
        Type type = obj.GetType();
        return type.GetField(fieldName, flags).GetValue(obj);
    }

    /// <summary>
    /// 获取一个静态字段的值
    /// </summary>
    /// <param name="type">对象类型</param>
    /// <param name="fieldName">字段名称</param>
    /// <returns>字段值</returns>
    public static object GetSaticField(Type type, string fieldName)
    {
        return type.GetField(fieldName, flags).GetValue(null);
    }

    /// <summary>
    /// 设置一个公共字段的值
    /// </summary>
    /// <param name="obj">对象实例</param>
    /// <param name="fieldName">字段名称</param>
    /// <param name="value">要设置的值</param>
    public static void SetField(object obj, string fieldName, object value)
    {
        Type type = obj.GetType();
        type.GetField(fieldName, flags).SetValue(obj, value);
    }

    /// <summary>
    /// 设置一个静态字段的值
    /// </summary>
    /// <param name="type">对象类型</param>
    /// <param name="fieldName">字段名称</param>
    /// <param name="value">要设置的值</param>
    public static void SetStaticField(Type type, string fieldName, object value)
    {
        type.GetField(fieldName, flags).SetValue(null, value);
    }

    /// <summary>
    /// 创建一个指定类型的公共构造函数构造器
    /// </summary>
    /// <param name="type">对象类型</param>
    /// <param name="paramTypes">构造函数参数类型</param>
    /// <returns></returns>
    private static ConstructorInfo GetConstructor(Type type, Type[] paramTypes)
    {
        return type.GetConstructor(paramTypes);
    }

   

    /// <summary>
    /// 获得一个数组对象中所有元素的类型
    /// </summary>
    /// <param name="objs">对象数组</param>
    /// <returns>类型数组</returns>
    private static Type[] GetTypesFromObjects(object[] objs)
    {
        Type[] types = new Type[objs.Length];
        for (int i = 0; i < types.Length; i++)
            types[i] = objs[i].GetType();
        return types;
    }


    public static void AddEventHandler(object obj, string eventName, MethodInfo method, object methodOwner)
    {
        EventInfo eventInfo = obj.GetType().GetEvent(eventName, flags);
        Delegate eventDeleg = Delegate.CreateDelegate(eventInfo.EventHandlerType, methodOwner, method);
        eventInfo.AddEventHandler(obj, eventDeleg);
    }

    public static void RemoveEventHandler(object obj, string eventName, MethodInfo method, object methodOwner)
    {
        EventInfo eventInfo = obj.GetType().GetEvent(eventName, flags);
        Delegate eventDeleg = Delegate.CreateDelegate(eventInfo.EventHandlerType, methodOwner, method);
        eventInfo.RemoveEventHandler(obj, eventDeleg);
    }


}