反射代码集

 获取页面类的类型

if  (HostingEnvironment.VirtualPathProvider.FileExists(virtualPath))  ... {
                    Type compiledType = null;
                    try ...{
//Compiles a file given its virtual path and returns the compiled type. 
                        compiledType = BuildManager.GetCompiledType(virtualPath);                  
                        if (compiledType == null)...{                         
//Processes a file given its virtual path and creates an instance of the result.   
object page = BuildManager.CreateInstanceFromVirtualPath(virtualPath, typeof(System.Web.UI.Page));
                            compiledType = page.GetType();
                        }
                    }

调用方法

BindingFlags flags  =  BindingFlags.Public  |  BindingFlags.DeclaredOnly;
                 if  (_pageMethods) flags  |=  BindingFlags.Static;
                 else  flags  |=  BindingFlags.Instance;
               MethodInfo methodInfo  =  typeList[i].GetMethods(flags);
object  target  =   null ;
             if  ( ! _methodInfo.IsStatic) target  =  Activator.CreateInstance(methodData.Owner.TypeData.Type);          
            _methodInfo.Invoke(target, actualParams);

    Type t  =  Type.GetType( " WindowsTest.Form2 " );
     object  obj  =  System.Activator.CreateInstance(t);
    MethodInfo mif  =  t.GetMethod( " Show " );
    mif.Invoke(obj, null ); // or ((Form)obj).Show();

创建对象

using  System.Reflection;
1 、
Assembly assembly  =  Assembly.Load( " A " ) ;A为程序集名称
Type t =  assembly.GetType( " A.B.C " , true , true ) ;A.B.C为类的全称
// 动态创建实例
object  obj  =  Activator.CreateInstance (t);

2 、
System.Reflection.Assembly ass  =  System.Reflection.Assembly.Load(nameSpace);
object  obj  =  ass.CreateInstance(className);
Iobject op  =  (Iobject)obj; // Iobject为抽象类,是className的父类

3 、
using  System.Reflection;
Assembly assembly  =  Assembly.LoadFrom( " xxx.dll的路径 " );
Type[] aa  =  a.GetTypes();

foreach (Type t  in  aa)
... ... {
    if(t.FullName == "a.b.c")
    ......{
        object o = Activator.CreateInstance(t);
    }
}

创建动态类和其实例

private   static   void  EmitConstructor < IServiceInterfaceType > (TypeBuilder typeBuilder, Type baseType)
             where  IServiceInterfaceType : IServiceInterface
         ... {
            //define default constructor
            ConstructorBuilder consBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] ...{ typeof(IServiceContainer) }); //用给定的属性和签名，向类中添加新的构造函数。

            ILGenerator ctorIL = consBuilder.GetILGenerator();//获取此构造函数的 ILGenerator(生成 Microsoft 中间语言 (MSIL) 指令。MSIL 用作实时 (JIT) 编译器的输入。）
            ctorIL.Emit(OpCodes.Ldarg_0);  //把this推上堆栈
            
            ctorIL.Emit(OpCodes.Ldarg_1);  //构建函数的参数
            ctorIL.Emit(OpCodes.Ldtoken, typeof(IServiceInterfaceType)); //传递的标记被转换为 RuntimeHandle 并被推送到堆栈上。
            
            ctorIL.Emit(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle", BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public)); //获取由指定类型句柄引用的类型。this.GetTypeFromHandle(IServiceInterfaceType as RuntimeHandle);
            ctorIL.Emit(OpCodes.Call, baseType.GetConstructor(new Type[] ...{ typeof(IServiceContainer), typeof(Type) })); //调用this的基类构造函数。
            ctorIL.Emit(OpCodes.Ret);
        }
private  IServiceInterfaceType EmitDynamicServiceInterfaceImplType < IServiceInterfaceType > (AssemblyBuilder assBuilder, ModuleBuilder modBuilder)
             where  IServiceInterfaceType : IServiceInterface
         ... {
            TypeBuilder typeBuilder = modBuilder.DefineType(DYNAMIC_INTERFACEIMPL_NAMESPACE + "." + typeof(IServiceInterfaceType).FullName, TypeAttributes.Public);
            typeBuilder.AddInterfaceImplementation(typeof(IServiceInterfaceType));  //添加此类型实现的接口。

            Type baseType = typeof(BaseServiceInterfaceImpl);
            typeBuilder.SetParent(baseType);  //设置此 Type 的父类型。

            MethodInfo[] mis = typeof(IServiceInterfaceType).GetMethods();

            EmitConstructor<IServiceInterfaceType>(typeBuilder, baseType);

            EmitMethods<IServiceInterfaceType>(typeBuilder, baseType, mis);

            return (IServiceInterfaceType)Activator.CreateInstance(typeBuilder.CreateType(), container);  //创建该type的实例
        }

 

        private   static   void  EmitEntityUpdateOriginalKeyValuesMethod(Type baseType)
         ... {
            //define UpdateOriginalKeyValues()
            MethodInfo mi = typeof(IEntity).GetMethod("UpdateOriginalKeyValues");
            ParameterInfo[] paramInfos = mi.GetParameters();
            int paramlength = paramInfos.Length;
            Type[] paramTypes = new Type[paramlength];
            for (int i = 0; i < paramlength; i++)
            ...{
                paramTypes[i] = paramInfos[i].ParameterType;
            }
            MethodBuilder updateOriginalKeyValuesMethodBuilder = typeBuilder.DefineMethod(mi.Name, mi.Attributes & (~MethodAttributes.Abstract) | MethodAttributes.Public, mi.CallingConvention, mi.ReturnType, paramTypes);
            for (int i = 0; i < paramlength; i++)
            ...{
                ParameterInfo pi = paramInfos[i];
                updateOriginalKeyValuesMethodBuilder.DefineParameter(i + 1, pi.Attributes, pi.Name);
            }
            typeBuilder.DefineMethodOverride(updateOriginalKeyValuesMethodBuilder, mi);
            ILGenerator updateOriginalKeyValueslMethodIL = updateOriginalKeyValuesMethodBuilder.GetILGenerator();

            updateOriginalKeyValueslMethodIL.Emit(OpCodes.Ldarg_0);
            updateOriginalKeyValueslMethodIL.Emit(OpCodes.Callvirt, baseType.GetMethod("UpdateOriginalKeyValues", BindingFlags.Instance | BindingFlags.NonPublic));
            updateOriginalKeyValueslMethodIL.Emit(OpCodes.Ret);
        }

Type baseType  =   typeof (Entity < IEntityType > );

namespace  NBear.Common
... {
      [Serializable]
    public abstract class Entity<IEntityType>
        where IEntityType : IEntity
    ...{
         protected void UpdateOriginalKeyValues()
        ...{
            if (originalKeyValues != null)
            ...{
                originalKeyValues = keyValues.Clone();
            }
        }
}

获取对象

public  IEntityType Get < IEntityType > ( object  id)
             where  IEntityType : IEntity
         ... {
            string[] primaryKeys = Entity<IEntityType>.GetPrimaryKeyColumnNames();
            if (primaryKeys.Length != 1)
            ...{
                throw new NotSupportedException("Gateway.Get<IEntityType>(object id) only supports entities with single primary key.");
            }
            IDataReader reader = SimpleDbHelper.SelectReadOnly(
                db, ParseTableName(Entity<IEntityType>.GetTableName()), Entity<IEntityType>.GetColumnNames(),
                BuildCombinedWhere<IEntityType>(BuildDbColumnName(primaryKeys[0]) + " = " + BuildDbParamName(primaryKeys[0])), new object[] ...{ id }, null);
            if (!reader.Read())
            ...{
                return default(IEntityType);
            }
            IEntityType obj = EntityFactory<IEntityType>.CreateObject(reader, true);
            reader.Close();
            return obj;
        }
public   static  IEntityType CreateObject(IDataReader reader,  bool  readColumnByIndex)
         ... {
            Check.Require(reader != null, null, new ArgumentNullException("reader"));

            return readColumnByIndex ? CreateObjectByColumnIndex(reader) : CreateObjectByColumnName(reader);
        }
private   static  IEntityType CreateObjectByColumnName(IDataReader reader)
         ... {
            IEntityType retObj = EntityFactory<IEntityType>.CreateObject();
            KeyValueCollection keyValues = retObj.GetKeyValues();
            string[] keys = keyValues.GetKeys();
            
            for (int i = 0; i < keyValues.GetKeys().Length; i++)
            ...{
                try
                ...{
                    object val = reader.GetValue(reader.GetOrdinal(keys[i]));
                    if (val != DBNull.Value)
                    ...{
                        keyValues[i] = val;
                    }
                }
                catch
                ...{
                    //if column not in this query, just skip
                }
            }
            return retObj;
        }
private   static  IEntityType CreateObjectByColumnIndex(IDataReader reader)
         ... {
            IEntityType retObj = EntityFactory<IEntityType>.CreateObject();
            KeyValueCollection keyValues = retObj.GetKeyValues();
            for (int i = 0; i < keyValues.GetKeys().Length; i++)
            ...{
                object val = reader.GetValue(i);
                if (val != DBNull.Value)
                ...{
                    keyValues[i] = val;
                }
            }
            return retObj;
        }
  public   static  IEntityType CreateObject() // 创建动态类对象
         ... {
            return (IEntityType)Activator.CreateInstance(GetDynamicEntityType());
        }
public   static  Type GetDynamicEntityType()  // 获取动态类
         ... {
            Type t = null;

            if (customEntities.ContainsKey(typeof(IEntityType)))
            ...{
                t = customEntities[typeof(IEntityType)];
            }

            if (t != null)
            ...{
                return t;
            }

            try
            ...{
                t = assBuilder.GetType(DYNAMIC_ENTITY_NAMESPACE + "." + typeof(IEntityType).FullName);
            }
            catch
            ...{
            }

            if (t != null)
            ...{
                return t;
            }
            else
            ...{
                return typeBuilder.CreateType();
            }
        }

属性方法创建

private   static   void  EmitEntityProperties(Type keyValuesType, Type baseType, PropertyInfo[] pis)
         ... {
            //define properties
            for (int i = 0; i < pis.Length; i++)
            ...{
                PropertyInfo pi = pis[i];
                PropertyBuilder propBuilder = typeBuilder.DefineProperty(pi.Name, System.Reflection.PropertyAttributes.HasDefault, pi.PropertyType, null);
                MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig;

                CustomPropertyAttribute c = (GetEntityConfiguration() == null ? null : GetEntityConfiguration().GetCustomProperty(pi.Name));

                object[] customPropertyAttrs = (c == null ? pi.GetCustomAttributes(typeof(CustomPropertyAttribute), false) : new object[] ...{ c });

                if (customPropertyAttrs != null && customPropertyAttrs.Length > 0)
                ...{
                    //define custom property
                    CustomPropertyAttribute cpa = (CustomPropertyAttribute)customPropertyAttrs[0];
                    
                    MethodBuilder getPropMethodBuilder = typeBuilder.DefineMethod("get_" + pi.Name, pi.GetGetMethod().Attributes & (~MethodAttributes.Abstract) | getSetAttr, pi.PropertyType, Type.EmptyTypes);
                    typeBuilder.DefineMethodOverride(getPropMethodBuilder, pi.GetGetMethod());
                    ILGenerator getPropMethodIL = getPropMethodBuilder.GetILGenerator();
                    getPropMethodIL.DeclareLocal(typeof(string[]));

                    //load keyValues field
                    getPropMethodIL.Emit(OpCodes.Ldarg_0);
                    getPropMethodIL.Emit(OpCodes.Ldfld, baseType.GetField("keyValues", BindingFlags.Instance | BindingFlags.NonPublic));

                    if (cpa.Parameters != null && cpa.Parameters.Length > 0)
                    ...{
                        //create parms string array
                        EmitLoadInt32Value(getPropMethodIL, cpa.Parameters.Length);
                        getPropMethodIL.Emit(OpCodes.Newarr, typeof(string));
                        getPropMethodIL.Emit(OpCodes.Stloc_0);

                        int j = 0;
                        foreach (string p in cpa.Parameters)
                        ...{
                            getPropMethodIL.Emit(OpCodes.Ldloc_0);
                            EmitLoadInt32Value(getPropMethodIL, j);
                            getPropMethodIL.Emit(OpCodes.Ldstr, p);
                            getPropMethodIL.Emit(OpCodes.Stelem_Ref);

                            j++;
                        }
                    }
                    else
                    ...{
                        //create an empty parms string array
                        EmitLoadInt32Value(getPropMethodIL, 0);
                        getPropMethodIL.Emit(OpCodes.Newarr, typeof(string));
                        getPropMethodIL.Emit(OpCodes.Stloc_0);
                    }

                    getPropMethodIL.Emit(OpCodes.Ldloc_0);
                    getPropMethodIL.Emit(OpCodes.Newobj, pi.PropertyType.GetConstructor(new Type[] ...{ typeof(KeyValueCollection), typeof(string[]) }));
                    getPropMethodIL.Emit(OpCodes.Ret);
                    propBuilder.SetGetMethod(getPropMethodBuilder);
                }
                else
                ...{
                    //define standard property
                    if (pi.CanRead)
                    ...{
                        //define getMethod
                        MethodBuilder getPropMethodBuilder = typeBuilder.DefineMethod("get_" + pi.Name, pi.GetGetMethod().Attributes & (~MethodAttributes.Abstract) | getSetAttr, pi.PropertyType, Type.EmptyTypes);
                        typeBuilder.DefineMethodOverride(getPropMethodBuilder, pi.GetGetMethod());
                        ILGenerator getPropMethodIL = getPropMethodBuilder.GetILGenerator();
                        getPropMethodIL.Emit(OpCodes.Ldarg_0);
                        getPropMethodIL.Emit(OpCodes.Ldfld, baseType.GetField("keyValues", BindingFlags.Instance | BindingFlags.NonPublic));
                        EmitLoadInt32Value(getPropMethodIL, i);
                        getPropMethodIL.Emit(OpCodes.Callvirt, keyValuesType.GetMethod("get_Item", new Type[] ...{ typeof(int) }));
                        if (pi.PropertyType.IsValueType)
                        ...{
                            getPropMethodIL.Emit(OpCodes.Unbox_Any, pi.PropertyType);
                        }
                        else
                        ...{
                            getPropMethodIL.Emit(OpCodes.Castclass, pi.PropertyType);
                        }
                        getPropMethodIL.Emit(OpCodes.Ret);
                        propBuilder.SetGetMethod(getPropMethodBuilder);
                    }

                    if (pi.CanWrite)
                    ...{
                        //define setMethod
                        MethodBuilder setPropMethodBuilder = typeBuilder.DefineMethod("set_" + pi.PropertyType, pi.GetSetMethod().Attributes & (~MethodAttributes.Abstract) | getSetAttr, null, new Type[] ...{ pi.PropertyType });
                        typeBuilder.DefineMethodOverride(setPropMethodBuilder, pi.GetSetMethod());
                        ILGenerator setPropMethodIL = setPropMethodBuilder.GetILGenerator();
                        setPropMethodIL.Emit(OpCodes.Ldarg_0);
                        setPropMethodIL.Emit(OpCodes.Callvirt, baseType.GetMethod("CheckOriginalKeyValues", BindingFlags.Instance | BindingFlags.NonPublic));
                        setPropMethodIL.Emit(OpCodes.Ldarg_0);
                        setPropMethodIL.Emit(OpCodes.Ldfld, baseType.GetField("keyValues", BindingFlags.Instance | BindingFlags.NonPublic));
                        EmitLoadInt32Value(setPropMethodIL, i);
                        setPropMethodIL.Emit(OpCodes.Ldarg_1);
                        if (pi.PropertyType.IsValueType)
                        ...{
                            setPropMethodIL.Emit(OpCodes.Box, pi.PropertyType);
                        }
                        setPropMethodIL.Emit(OpCodes.Callvirt, keyValuesType.GetMethod("set_Item", new Type[] ...{ typeof(int), typeof(object) }));
                        setPropMethodIL.Emit(OpCodes.Ret);
                        propBuilder.SetSetMethod(setPropMethodBuilder);
                    }
                }
            }
        }

方法调用

public   static   object  CallByName(
       object  target,  string  methodName, CallType callType, 
       params   object [] args)
     ... {
      switch (callType)
      ...{
        case CallType.Get:
          ...{
            PropertyInfo p = target.GetType().GetProperty(methodName);
            return p.GetValue(target, args);
          }
        case CallType.Let:
        case CallType.Set:
          ...{
            PropertyInfo p = target.GetType().GetProperty(methodName);
            object[] index = null;
            args.CopyTo(index, 1);
            p.SetValue(target, args[0], index);
            return null;
          }
        case CallType.Method:
          ...{
            MethodInfo m = target.GetType().GetMethod(methodName);
            return m.Invoke(target, args);
          }
      }
      return null;
    }

获取父类或嵌套类的上级

private   static   object  CreateBusinessObject( object  criteria)
     ... {
      Type businessType;
      if (criteria.GetType().IsSubclassOf(typeof(CriteriaBase))) //判断其父类
      ...{
        // get the type of the actual business object
        // from CriteriaBase 
        businessType = ((CriteriaBase)criteria).ObjectType;
      }
      else
      ...{
        // get the type of the actual business object
        // based on the nested class scheme in the book
        businessType = criteria.GetType().DeclaringType;  //获取当前嵌套类的上一层类的类别
      }

      // create an instance of the business object
      return Activator.CreateInstance(businessType, true);
    }

递归向上寻找方法

public   static  MethodInfo FindMethod(Type objType,  string  method, Type[] types)
     ... {
      MethodInfo info = null;
      do
      ...{
        //find for a strongly typed match
        info = objType.GetMethod(method, oneLevelFlags, null, types, null);
        if (info != null)
          break;  //match found

        objType = objType.BaseType;
      } while (objType != null);

      return info;
    }

  const  BindingFlags allLevelFlags  =
      BindingFlags.FlattenHierarchy  |
      BindingFlags.Instance  |
      BindingFlags.Public  |
      BindingFlags.NonPublic;

     const  BindingFlags oneLevelFlags  =
      BindingFlags.DeclaredOnly  |
      BindingFlags.Instance  |
      BindingFlags.Public  |
      BindingFlags.NonPublic;

根据名字找，和冲突解决

try
         ... { 
          result = objectType.GetMethod(method, allLevelFlags); 
        }
         catch  (AmbiguousMatchException)
         ... {
          MethodInfo[] methods = objectType.GetMethods();
          foreach (MethodInfo m in methods)
            if (m.Name == method && m.GetParameters().Length == parameters.Length)
            ...{
              result = m;
              break;
            }
          if (result == null)
            throw;
        }

/将参数转成需要的类型,供助TypeDescriptor自动获得类型转换器
  

// 通过反射得到类型信息
                type  =   System.Type.GetType(typeName,  false ,  true );
                 if  (type  ==   null )
                 ... {
                    //处理ASP.NET的临时生成类
                    type = BuildManager.GetType(typeName, false, true);
                }
ParameterInfo[] paraInfos  =  method.GetParameters();
  object [] paras  =   new   object [paraInfos.Length];
  // 将参数转成需要的类型,供助TypeDescriptor自动获得类型转换器
aras[i]  =  TypeDescriptor.GetConverter(paraInfos[i].ParameterType).ConvertFromString(parameterValues[i]);

 给接口类创建方法