C# Reflection.RuntimeModule类代码示例

 private CustomAttributeData(RuntimeModule scope, CustomAttributeRecord caRecord)
 {
     this.m_scope = scope;
     this.m_ctor = (RuntimeConstructorInfo) RuntimeType.GetMethodBase(scope, (int) caRecord.tkCtor);
     ParameterInfo[] parametersNoCopy = this.m_ctor.GetParametersNoCopy();
     this.m_ctorParams = new CustomAttributeCtorParameter[parametersNoCopy.Length];
     for (int i = 0; i < parametersNoCopy.Length; i++)
     {
         this.m_ctorParams[i] = new CustomAttributeCtorParameter(InitCustomAttributeType((RuntimeType) parametersNoCopy[i].ParameterType));
     }
     FieldInfo[] fields = this.m_ctor.DeclaringType.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
     PropertyInfo[] properties = this.m_ctor.DeclaringType.GetProperties(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
     this.m_namedParams = new CustomAttributeNamedParameter[properties.Length + fields.Length];
     for (int j = 0; j < fields.Length; j++)
     {
         this.m_namedParams[j] = new CustomAttributeNamedParameter(fields[j].Name, CustomAttributeEncoding.Field, InitCustomAttributeType((RuntimeType) fields[j].FieldType));
     }
     for (int k = 0; k < properties.Length; k++)
     {
         this.m_namedParams[k + fields.Length] = new CustomAttributeNamedParameter(properties[k].Name, CustomAttributeEncoding.Property, InitCustomAttributeType((RuntimeType) properties[k].PropertyType));
     }
     this.m_members = new MemberInfo[fields.Length + properties.Length];
     fields.CopyTo(this.m_members, 0);
     properties.CopyTo(this.m_members, fields.Length);
     CustomAttributeEncodedArgument.ParseAttributeArguments(caRecord.blob, ref this.m_ctorParams, ref this.m_namedParams, this.m_scope);
 }

		private static void ValidateModulePointer(RuntimeModule module)
		{
			if (module == null)
			{
				throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullModuleHandle"));
			}
		}

 [System.Security.SecurityCritical]  // auto-generated
 internal void GetCallableMethod(RuntimeModule module, DynamicMethod dm) { 
     dm.m_methodHandle = ModuleHandle.GetDynamicMethod(dm, 
                                   module,
                                   m_methodBuilder.Name, 
                                   (byte[])m_scope[m_methodSigToken],
                                   new DynamicResolver(this));
 }

 internal static void ParseAttributeArguments(ConstArray attributeBlob, ref CustomAttributeCtorParameter[] customAttributeCtorParameters, ref CustomAttributeNamedParameter[] customAttributeNamedParameters, RuntimeModule customAttributeModule)
 {
     if (customAttributeModule == null)
     {
         throw new ArgumentNullException("customAttributeModule");
     }
     if ((customAttributeCtorParameters.Length != 0) || (customAttributeNamedParameters.Length != 0))
     {
         ParseAttributeArguments(attributeBlob.Signature, attributeBlob.Length, ref customAttributeCtorParameters, ref customAttributeNamedParameters, (RuntimeAssembly) customAttributeModule.Assembly);
     }
 }

 private extern static void GetTypeByNameUsingCARules(string name, RuntimeModule scope, ObjectHandleOnStack type);

 private extern static IntPtr _GetMetadataImport(RuntimeModule module);

 [System.Security.SecuritySafeCritical]  // auto-generated
 internal static void GetPEKind(RuntimeModule module, out PortableExecutableKinds peKind, out ImageFileMachine machine)
 {
     int lKind, lMachine;
     GetPEKind(module.GetNativeHandle(), out lKind, out lMachine);
     peKind = (PortableExecutableKinds)lKind;
     machine = (ImageFileMachine)lMachine;
 }

 [System.Security.SecuritySafeCritical]  // auto-generated
 internal static RuntimeType GetModuleType(RuntimeModule module)
 {
     RuntimeType type = null;
     GetModuleType(module.GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref type));
     return type;
 }

 [System.Security.SecuritySafeCritical]  // auto-generated
 internal static RuntimeAssembly GetAssembly(RuntimeModule module)
 {
     RuntimeAssembly retAssembly = null;
     GetAssembly(module.GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref retAssembly));
     return retAssembly;
 }

 [System.Security.SecurityCritical]  // auto-generated
 internal static bool ContainsPropertyMatchingHash(RuntimeModule module, int propertyToken, uint hash)
 {
     return _ContainsPropertyMatchingHash(module.GetNativeHandle(), propertyToken, hash);
 }

 private static void ValidateModulePointer(RuntimeModule module)
 {
     // Make sure we have a valid Module to resolve against.
     if (module == null)
         throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullModuleHandle"));
 }

 internal static extern int GetToken(RuntimeModule module);

 internal static extern IRuntimeMethodInfo GetDynamicMethod(DynamicMethod method, RuntimeModule module, string name, byte[] sig, Resolver resolver);

 internal ModuleHandle(RuntimeModule module) 
 {
     m_ptr = module;
 }

 internal static extern void CheckAttributeAccess(RuntimeFieldHandle fieldHandle, RuntimeModule decoratedTarget);