The Labs \ Source Viewer \ SSCLI \ System.Reflection \ ImageFileMachine

  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. ////////////////////////////////////////////////////////////////////////////////
  16. using System;
  17. using System.Diagnostics.SymbolStore;
  18. using System.Runtime.Remoting;
  19. using System.Runtime.InteropServices;
  20. using System.Runtime.Serialization;
  21. using System.Reflection.Emit;
  22. using System.Collections;
  23. using System.Threading;
  24. using System.Runtime.CompilerServices;
  25. using System.Security.Permissions;
  26. using System.IO;
  27. using System.Globalization;
  28. using System.Runtime.Versioning;
  29. namespace System.Reflection
  30. {
  31.    
  32.     [Serializable(), Flags()]
  33.     [System.Runtime.InteropServices.ComVisible(true)]
  34.     public enum PortableExecutableKinds
  35.     {
  36.         NotAPortableExecutableImage = 0,
  37.        
  38.         ILOnly = 1,
  39.        
  40.         Required32Bit = 2,
  41.        
  42.         PE32Plus = 4,
  43.        
  44.         Unmanaged32Bit = 8
  45.     }
  46.    
  47.     [Serializable()]
  48.     [System.Runtime.InteropServices.ComVisible(true)]
  49.     public enum ImageFileMachine
  50.     {
  51.         I386 = 332,
  52.        
  53.         IA64 = 512,
  54.        
  55.         AMD64 = 34404
  56.     }
  57.    
  58.    
  59.     [Serializable()]
  60.     [ClassInterface(ClassInterfaceType.None)]
  61.     [ComDefaultInterface(typeof(_Module))]
  62.     [System.Runtime.InteropServices.ComVisible(true)]
  63.     public class Module : _Module, ISerializable, ICustomAttributeProvider
  64.     {
  65.         #region FCalls
  66.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  67.         internal extern Type GetTypeInternal(string className, bool ignoreCase, bool throwOnError);
  68.        
  69.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  70.         internal extern IntPtr GetHINSTANCE();
  71.        
  72.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  73.         private extern string InternalGetName();
  74.        
  75.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  76.         internal extern string InternalGetFullyQualifiedName();
  77.        
  78.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  79.         internal extern Type[] GetTypesInternal(ref StackCrawlMark stackMark);
  80.        
  81.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  82.         private extern Assembly GetAssemblyInternal();
  83.        
  84.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  85.         internal extern int InternalGetTypeToken(string strFullName, Module refedModule, string strRefedModuleFileName, int tkResolution);
  86.        
  87.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  88.         internal extern Type InternalLoadInMemoryTypeByName(string className);
  89.        
  90.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  91.         internal extern int InternalGetMemberRef(Module refedModule, int tr, int defToken);
  92.        
  93.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  94.         internal extern int InternalGetMemberRefFromSignature(int tr, string methodName, byte[] signature, int length);
  95.        
  96.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  97.         private extern int _InternalGetMemberRefOfMethodInfo(int tr, IntPtr method);
  98.         internal int InternalGetMemberRefOfMethodInfo(int tr, RuntimeMethodHandle method)
  99.         {
  100.             return _InternalGetMemberRefOfMethodInfo(tr, method.Value);
  101.         }
  102.        
  103.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  104.         private extern int _InternalGetMemberRefOfFieldInfo(int tkType, IntPtr interfaceHandle, int tkField);
  105.         internal int InternalGetMemberRefOfFieldInfo(int tkType, RuntimeTypeHandle declaringType, int tkField)
  106.         {
  107.             return _InternalGetMemberRefOfFieldInfo(tkType, declaringType.Value, tkField);
  108.         }
  109.        
  110.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  111.         internal extern int InternalGetTypeSpecTokenWithBytes(byte[] signature, int length);
  112.        
  113.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  114.         internal extern int nativeGetArrayMethodToken(int tkTypeSpec, string methodName, byte[] signature, int sigLength, int baseToken);
  115.        
  116.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  117.         internal extern void InternalSetFieldRVAContent(int fdToken, byte[] data, int length);
  118.        
  119.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  120.         internal extern int InternalGetStringConstant(string str);
  121.        
  122.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  123.         internal extern void InternalPreSavePEFile(int portableExecutableKind, int imageFileMachine);
  124.        
  125.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  126.         private extern void _InternalSavePEFile(string fileName, int entryPoint, int isExe, bool isManifestFile);
  127.         internal void InternalSavePEFile(string fileName, MethodToken entryPoint, int isExe, bool isManifestFile)
  128.         {
  129.             _InternalSavePEFile(fileName, entryPoint.Token, isExe, isManifestFile);
  130.         }
  131.        
  132.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  133.         internal extern void InternalSetResourceCounts(int resCount);
  134.        
  135.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  136.         internal extern void InternalAddResource(string strName, byte[] resBytes, int resByteCount, int tkFile, int attribute, int portableExecutableKind, int imageFileMachine);
  137.        
  138.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  139.         internal extern void InternalSetModuleProps(string strModuleName);
  140.        
  141.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  142.         internal extern bool IsResourceInternal();
  143.        
  144.         #endregion
  145.        
  146.         #region Static Constructor
  147.         static Module()
  148.         {
  149.             __Filters _fltObj;
  150.             _fltObj = new __Filters();
  151.             FilterTypeName = new TypeFilter(_fltObj.FilterTypeName);
  152.             FilterTypeNameIgnoreCase = new TypeFilter(_fltObj.FilterTypeNameIgnoreCase);
  153.         }
  154.         #endregion
  155.        
  156.         #region Public Statics
  157.         public static readonly TypeFilter FilterTypeName;
  158.        
  159.         public static readonly TypeFilter FilterTypeNameIgnoreCase;
  160.        
  161.         public MethodBase ResolveMethod(int metadataToken)
  162.         {
  163.             return ResolveMethod(metadataToken, null, null);
  164.         }
  165.        
  166.         private static RuntimeTypeHandle[] ConvertToTypeHandleArray(Type[] genericArguments)
  167.         {
  168.             if (genericArguments == null)
  169.                 return null;
  170.            
  171.             int size = genericArguments.Length;
  172.             RuntimeTypeHandle[] typeHandleArgs = new RuntimeTypeHandle[size];
  173.             for (int i = 0; i < size; i++) {
  174.                 Type typeArg = genericArguments[i];
  175.                 if (typeArg == null)
  176.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidGenericInstArray"));
  177.                 typeArg = typeArg.UnderlyingSystemType;
  178.                 if (typeArg == null)
  179.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidGenericInstArray"));
  180.                 if (!(typeArg is RuntimeType))
  181.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidGenericInstArray"));
  182.                 typeHandleArgs[i] = typeArg.GetTypeHandleInternal();
  183.             }
  184.             return typeHandleArgs;
  185.         }
  186.        
  187.         public byte[] ResolveSignature(int metadataToken)
  188.         {
  189.             MetadataToken tk = new MetadataToken(metadataToken);
  190.            
  191.             if (!MetadataImport.IsValidToken(tk))
  192.                 throw new ArgumentOutOfRangeException("metadataToken", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidToken", tk, this)));
  193.            
  194.             if (!tk.IsMemberRef && !tk.IsMethodDef && !tk.IsTypeSpec && !tk.IsSignature && !tk.IsFieldDef)
  195.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidToken", tk, this)), "metadataToken");
  196.            
  197.             ConstArray signature;
  198.             if (tk.IsMemberRef)
  199.                 signature = MetadataImport.GetMemberRefProps(metadataToken);
  200.             else
  201.                 signature = MetadataImport.GetSignatureFromToken(metadataToken);
  202.            
  203.             byte[] sig = new byte[signature.Length];
  204.            
  205.             for (int i = 0; i < signature.Length; i++)
  206.                 sig[i] = signature[i];
  207.            
  208.             return sig;
  209.         }
  210.        
  211.         public MethodBase ResolveMethod(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
  212.         {
  213.             MetadataToken tk = new MetadataToken(metadataToken);
  214.            
  215.             if (!MetadataImport.IsValidToken(tk))
  216.                 throw new ArgumentOutOfRangeException("metadataToken", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidToken", tk, this)));
  217.            
  218.             RuntimeTypeHandle[] typeArgs = ConvertToTypeHandleArray(genericTypeArguments);
  219.             RuntimeTypeHandle[] methodArgs = ConvertToTypeHandleArray(genericMethodArguments);
  220.            
  221.             try {
  222.                 if (!tk.IsMethodDef && !tk.IsMethodSpec) {
  223.                     if (!tk.IsMemberRef)
  224.                         throw new ArgumentException("metadataToken", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveMethod", tk, this)));
  225.                    
  226.                     unsafe {
  227.                         ConstArray sig = MetadataImport.GetMemberRefProps(tk);
  228.                        
  229.                         if (*(CorCallingConvention*)sig.Signature.ToPointer() == CorCallingConvention.Field)
  230.                             throw new ArgumentException("metadataToken", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveMethod"), tk, this));
  231.                     }
  232.                 }
  233.                
  234.                 RuntimeMethodHandle methodHandle = GetModuleHandle().ResolveMethodHandle(tk, typeArgs, methodArgs);
  235.                 Type declaringType = methodHandle.GetDeclaringType().GetRuntimeType();
  236.                
  237.                 if (declaringType.IsGenericType || declaringType.IsArray) {
  238.                     MetadataToken tkDeclaringType = new MetadataToken(MetadataImport.GetParentToken(tk));
  239.                    
  240.                     if (tk.IsMethodSpec)
  241.                         tkDeclaringType = new MetadataToken(MetadataImport.GetParentToken(tkDeclaringType));
  242.                    
  243.                     declaringType = ResolveType(tkDeclaringType, genericTypeArguments, genericMethodArguments);
  244.                 }
  245.                
  246.                 return System.RuntimeType.GetMethodBase(declaringType.GetTypeHandleInternal(), methodHandle);
  247.             }
  248.             catch (BadImageFormatException e) {
  249.                 throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), e);
  250.             }
  251.         }
  252.        
  253.         internal FieldInfo ResolveLiteralField(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
  254.         {
  255.             MetadataToken tk = new MetadataToken(metadataToken);
  256.            
  257.             if (!MetadataImport.IsValidToken(tk))
  258.                 throw new ArgumentOutOfRangeException("metadataToken", String.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Argument_InvalidToken", tk, this)));
  259.            
  260.             int tkDeclaringType;
  261.             string fieldName;
  262.            
  263.             fieldName = MetadataImport.GetName(tk).ToString();
  264.             tkDeclaringType = MetadataImport.GetParentToken(tk);
  265.            
  266.             Type declaringType = ResolveType(tkDeclaringType, genericTypeArguments, genericMethodArguments);
  267.            
  268.             declaringType.GetFields();
  269.            
  270.             try {
  271.                 return declaringType.GetField(fieldName, BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
  272.             }
  273.             catch {
  274.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveField"), tk, this), "metadataToken");
  275.             }
  276.         }
  277.        
  278.         public FieldInfo ResolveField(int metadataToken)
  279.         {
  280.             return ResolveField(metadataToken, null, null);
  281.         }
  282.        
  283.         public FieldInfo ResolveField(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
  284.         {
  285.             MetadataToken tk = new MetadataToken(metadataToken);
  286.            
  287.             if (!MetadataImport.IsValidToken(tk))
  288.                 throw new ArgumentOutOfRangeException("metadataToken", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidToken", tk, this)));
  289.            
  290.             RuntimeTypeHandle[] typeArgs = ConvertToTypeHandleArray(genericTypeArguments);
  291.             RuntimeTypeHandle[] methodArgs = ConvertToTypeHandleArray(genericMethodArguments);
  292.            
  293.             try {
  294.                 RuntimeFieldHandle fieldHandle = new RuntimeFieldHandle();
  295.                
  296.                 if (!tk.IsFieldDef) {
  297.                     if (!tk.IsMemberRef)
  298.                         throw new ArgumentException("metadataToken", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveField"), tk, this));
  299.                    
  300.                     unsafe {
  301.                         ConstArray sig = MetadataImport.GetMemberRefProps(tk);
  302.                        
  303.                         if (*(CorCallingConvention*)sig.Signature.ToPointer() != CorCallingConvention.Field)
  304.                             throw new ArgumentException("metadataToken", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveField"), tk, this));
  305.                     }
  306.                    
  307.                     fieldHandle = GetModuleHandle().ResolveFieldHandle(tk, typeArgs, methodArgs);
  308.                 }
  309.                
  310.                 fieldHandle = GetModuleHandle().ResolveFieldHandle(metadataToken, typeArgs, methodArgs);
  311.                 Type declaringType = fieldHandle.GetApproxDeclaringType().GetRuntimeType();
  312.                
  313.                 if (declaringType.IsGenericType || declaringType.IsArray) {
  314.                     int tkDeclaringType = GetModuleHandle().GetMetadataImport().GetParentToken(metadataToken);
  315.                     declaringType = ResolveType(tkDeclaringType, genericTypeArguments, genericMethodArguments);
  316.                 }
  317.                
  318.                 return System.RuntimeType.GetFieldInfo(declaringType.GetTypeHandleInternal(), fieldHandle);
  319.             }
  320.             catch (MissingFieldException) {
  321.                 return ResolveLiteralField(tk, genericTypeArguments, genericMethodArguments);
  322.             }
  323.             catch (BadImageFormatException e) {
  324.                 throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), e);
  325.             }
  326.         }
  327.        
  328.         public Type ResolveType(int metadataToken)
  329.         {
  330.             return ResolveType(metadataToken, null, null);
  331.         }
  332.        
  333.         public Type ResolveType(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
  334.         {
  335.             MetadataToken tk = new MetadataToken(metadataToken);
  336.            
  337.             if (tk.IsGlobalTypeDefToken)
  338.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveModuleType"), tk), "metadataToken");
  339.            
  340.             if (!MetadataImport.IsValidToken(tk))
  341.                 throw new ArgumentOutOfRangeException("metadataToken", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidToken", tk, this)));
  342.            
  343.             if (!tk.IsTypeDef && !tk.IsTypeSpec && !tk.IsTypeRef)
  344.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveType"), tk, this), "metadataToken");
  345.            
  346.             RuntimeTypeHandle[] typeArgs = ConvertToTypeHandleArray(genericTypeArguments);
  347.             RuntimeTypeHandle[] methodArgs = ConvertToTypeHandleArray(genericMethodArguments);
  348.            
  349.             try {
  350.                 Type t = GetModuleHandle().ResolveTypeHandle(metadataToken, typeArgs, methodArgs).GetRuntimeType();
  351.                
  352.                 if (t == null)
  353.                     throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveType"), tk, this), "metadataToken");
  354.                
  355.                 return t;
  356.             }
  357.             catch (BadImageFormatException e) {
  358.                 throw new ArgumentException(Environment.GetResourceString("Argument_BadImageFormatExceptionResolve"), e);
  359.             }
  360.         }
  361.        
  362.         public MemberInfo ResolveMember(int metadataToken)
  363.         {
  364.             return ResolveMember(metadataToken, null, null);
  365.         }
  366.        
  367.         public MemberInfo ResolveMember(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
  368.         {
  369.             MetadataToken tk = new MetadataToken(metadataToken);
  370.            
  371.             if (tk.IsProperty)
  372.                 throw new ArgumentException(Environment.GetResourceString("InvalidOperation_PropertyInfoNotAvailable"));
  373.            
  374.             if (tk.IsEvent)
  375.                 throw new ArgumentException(Environment.GetResourceString("InvalidOperation_EventInfoNotAvailable"));
  376.            
  377.             if (tk.IsMethodSpec || tk.IsMethodDef)
  378.                 return ResolveMethod(metadataToken, genericTypeArguments, genericMethodArguments);
  379.            
  380.             if (tk.IsFieldDef)
  381.                 return ResolveField(metadataToken, genericTypeArguments, genericMethodArguments);
  382.            
  383.             if (tk.IsTypeRef || tk.IsTypeDef || tk.IsTypeSpec)
  384.                 return ResolveType(metadataToken, genericTypeArguments, genericMethodArguments);
  385.            
  386.             if (tk.IsMemberRef) {
  387.                 if (!MetadataImport.IsValidToken(tk))
  388.                     throw new ArgumentOutOfRangeException("metadataToken", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidToken", tk, this)));
  389.                
  390.                 ConstArray sig = MetadataImport.GetMemberRefProps(tk);
  391.                
  392.                 unsafe {
  393.                     if (*(CorCallingConvention*)sig.Signature.ToPointer() == CorCallingConvention.Field) {
  394.                         return ResolveField(tk, genericTypeArguments, genericMethodArguments);
  395.                     }
  396.                     else {
  397.                         return ResolveMethod(tk, genericTypeArguments, genericMethodArguments);
  398.                     }
  399.                 }
  400.             }
  401.            
  402.             throw new ArgumentException("metadataToken", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveMember", tk, this)));
  403.         }
  404.        
  405.         public string ResolveString(int metadataToken)
  406.         {
  407.             MetadataToken tk = new MetadataToken(metadataToken);
  408.             if (!tk.IsString)
  409.                 throw new ArgumentException(String.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Argument_ResolveString"), metadataToken, ToString()));
  410.            
  411.             if (!MetadataImport.IsValidToken(tk))
  412.                 throw new ArgumentOutOfRangeException("metadataToken", String.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Argument_InvalidToken", tk, this)));
  413.            
  414.             string str = MetadataImport.GetUserString(metadataToken);
  415.            
  416.             if (str == null)
  417.                 throw new ArgumentException(String.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Argument_ResolveString"), metadataToken, ToString()));
  418.            
  419.             return str;
  420.         }
  421.        
  422.         public void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
  423.         {
  424.             GetModuleHandle().GetPEKind(out peKind, out machine);
  425.         }
  426.        
  427.         public int MDStreamVersion {
  428.             get { return GetModuleHandle().MDStreamVersion; }
  429.         }
  430.        
  431.         #endregion
  432.        
  433.         #region Literals
  434.         private const BindingFlags DefaultLookup = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public;
  435.         #endregion
  436.        
  437.         #region Data Members
  438.         #pragma warning disable 169
  439.         // If you add any data members, you need to update the native declaration ReflectModuleBaseObject.
  440.         internal ArrayList m_TypeBuilderList;
  441.         internal ISymbolWriter m_iSymWriter;
  442.         internal ModuleBuilderData m_moduleData;
  443.         private RuntimeType m_runtimeType;
  444.         private IntPtr m_pRefClass;
  445.         internal IntPtr m_pData;
  446.         internal IntPtr m_pInternalSymWriter;
  447.         private IntPtr m_pGlobals;
  448.         private IntPtr m_pFields;
  449.         internal MethodToken m_EntryPoint;
  450.         #pragma warning restore 169
  451.         #endregion
  452.        
  453.         #region Constructor
  454.         internal Module()
  455.         {
  456.             // Construct a new module. This returns the default dynamic module.
  457.             // 0 is defined as being a module without an entry point (ie a DLL);
  458.             // This must throw because this dies in ToString() when constructed here...
  459.             throw new NotSupportedException(Environment.GetResourceString(ResId.NotSupported_Constructor));
  460.             //m_EntryPoint=new MethodToken(0);
  461.         }
  462.         #endregion
  463.        
  464.         #region Private Members
  465.         private FieldInfo InternalGetField(string name, BindingFlags bindingAttr)
  466.         {
  467.             if (RuntimeType == null)
  468.                 return null;
  469.            
  470.             return RuntimeType.GetField(name, bindingAttr);
  471.         }
  472.         #endregion
  473.        
  474.         #region Internal Members
  475.         internal virtual bool IsDynamic()
  476.         {
  477.             if (this is ModuleBuilder)
  478.                 return true;
  479.            
  480.             return false;
  481.         }
  482.        
  483.         internal RuntimeType RuntimeType {
  484.             get {
  485.                 unsafe {
  486.                     if (m_runtimeType == null)
  487.                         m_runtimeType = GetModuleHandle().GetModuleTypeHandle().GetRuntimeType() as RuntimeType;
  488.                    
  489.                     return m_runtimeType;
  490.                 }
  491.             }
  492.         }
  493.         #endregion
  494.        
  495.         #region Protected Virtuals
  496.         protected virtual MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
  497.         {
  498.             if (RuntimeType == null)
  499.                 return null;
  500.            
  501.             if (types == null) {
  502.                 return RuntimeType.GetMethod(name, bindingAttr);
  503.             }
  504.             else {
  505.                 return RuntimeType.GetMethod(name, bindingAttr, binder, callConvention, types, modifiers);
  506.             }
  507.         }
  508.        
  509.         internal MetadataImport MetadataImport {
  510.             get {
  511.                 unsafe {
  512.                     return ModuleHandle.GetMetadataImport();
  513.                 }
  514.             }
  515.         }
  516.         #endregion
  517.        
  518.         #region ICustomAttributeProvider Members
  519.         public virtual object[] GetCustomAttributes(bool inherit)
  520.         {
  521.             return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType);
  522.         }
  523.        
  524.         public virtual object[] GetCustomAttributes(Type attributeType, bool inherit)
  525.         {
  526.             if (attributeType == null)
  527.                 throw new ArgumentNullException("attributeType");
  528.            
  529.             RuntimeType attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType;
  530.            
  531.             if (attributeRuntimeType == null)
  532.                 throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"), "attributeType");
  533.            
  534.             return CustomAttribute.GetCustomAttributes(this, attributeRuntimeType);
  535.         }
  536.        
  537.         public virtual bool IsDefined(Type attributeType, bool inherit)
  538.         {
  539.             if (attributeType == null)
  540.                 throw new ArgumentNullException("attributeType");
  541.            
  542.             RuntimeType attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType;
  543.            
  544.             if (attributeRuntimeType == null)
  545.                 throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"), "caType");
  546.            
  547.             return CustomAttribute.IsDefined(this, attributeRuntimeType);
  548.         }
  549.        
  550.         #endregion
  551.        
  552.         #region Public Virtuals
  553.         [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
  554.         public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
  555.         {
  556.             if (info == null) {
  557.                 throw new ArgumentNullException("info");
  558.             }
  559.             UnitySerializationHolder.GetUnitySerializationInfo(info, UnitySerializationHolder.ModuleUnity, this.ScopeName, GetAssemblyInternal());
  560.         }
  561.        
  562.         [System.Runtime.InteropServices.ComVisible(true)]
  563.         public virtual Type GetType(string className, bool ignoreCase)
  564.         {
  565.             return GetType(className, false, ignoreCase);
  566.         }
  567.        
  568.         [System.Runtime.InteropServices.ComVisible(true)]
  569.         public virtual Type GetType(string className)
  570.         {
  571.             return GetType(className, false, false);
  572.         }
  573.        
  574.         [System.Runtime.InteropServices.ComVisible(true)]
  575.         public virtual Type GetType(string className, bool throwOnError, bool ignoreCase)
  576.         {
  577.             return GetTypeInternal(className, throwOnError, ignoreCase);
  578.         }
  579.        
  580.         public virtual string FullyQualifiedName {
  581.             [ResourceExposure(ResourceScope.Machine)]
  582.             [ResourceConsumption(ResourceScope.Machine)]
  583.             get {
  584.                 string fullyQualifiedName = InternalGetFullyQualifiedName();
  585.                
  586.                 if (fullyQualifiedName != null) {
  587.                     bool checkPermission = true;
  588.                     try {
  589.                         Path.GetFullPathInternal(fullyQualifiedName);
  590.                     }
  591.                     catch (ArgumentException) {
  592.                         checkPermission = false;
  593.                     }
  594.                     if (checkPermission) {
  595.                         new FileIOPermission(FileIOPermissionAccess.PathDiscovery, fullyQualifiedName).Demand();
  596.                     }
  597.                 }
  598.                
  599.                 return fullyQualifiedName;
  600.             }
  601.         }
  602.        
  603.         public virtual Type[] FindTypes(TypeFilter filter, object filterCriteria)
  604.         {
  605.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  606.             Type[] c = GetTypesInternal(ref stackMark);
  607.             int cnt = 0;
  608.             for (int i = 0; i < c.Length; i++) {
  609.                 if (filter != null && !filter(c[i], filterCriteria))
  610.                     c[i] = null;
  611.                 else
  612.                     cnt++;
  613.             }
  614.             if (cnt == c.Length)
  615.                 return c;
  616.            
  617.             Type[] ret = new Type[cnt];
  618.             cnt = 0;
  619.             for (int i = 0; i < c.Length; i++) {
  620.                 if (c[i] != null)
  621.                     ret[cnt++] = c[i];
  622.             }
  623.             return ret;
  624.         }
  625.        
  626.         public virtual Type[] GetTypes()
  627.         {
  628.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  629.             return GetTypesInternal(ref stackMark);
  630.         }
  631.        
  632.         #endregion
  633.        
  634.         #region Public Members
  635.        
  636.         public Guid ModuleVersionId {
  637.             get {
  638.                 unsafe {
  639.                     Guid mvid;
  640.                     MetadataImport.GetScopeProps(out mvid);
  641.                     return mvid;
  642.                 }
  643.             }
  644.         }
  645.        
  646.         public int MetadataToken {
  647.             get { return GetModuleHandle().GetToken(); }
  648.         }
  649.        
  650.         public bool IsResource()
  651.         {
  652.             return IsResourceInternal();
  653.         }
  654.        
  655.         public FieldInfo[] GetFields()
  656.         {
  657.             if (RuntimeType == null)
  658.                 return new FieldInfo[0];
  659.            
  660.             return RuntimeType.GetFields();
  661.         }
  662.        
  663.         public FieldInfo[] GetFields(BindingFlags bindingFlags)
  664.         {
  665.             if (RuntimeType == null)
  666.                 return new FieldInfo[0];
  667.            
  668.             return RuntimeType.GetFields(bindingFlags);
  669.         }
  670.        
  671.         public FieldInfo GetField(string name)
  672.         {
  673.             if (name == null)
  674.                 throw new ArgumentNullException("name");
  675.            
  676.             return GetField(name, Module.DefaultLookup);
  677.         }
  678.        
  679.         public FieldInfo GetField(string name, BindingFlags bindingAttr)
  680.         {
  681.             if (name == null)
  682.                 throw new ArgumentNullException("name");
  683.            
  684.             return InternalGetField(name, bindingAttr);
  685.         }
  686.        
  687.         public MethodInfo[] GetMethods()
  688.         {
  689.             if (RuntimeType == null)
  690.                 return new MethodInfo[0];
  691.            
  692.             return RuntimeType.GetMethods();
  693.         }
  694.        
  695.         public MethodInfo[] GetMethods(BindingFlags bindingFlags)
  696.         {
  697.             if (RuntimeType == null)
  698.                 return new MethodInfo[0];
  699.            
  700.             return RuntimeType.GetMethods(bindingFlags);
  701.         }
  702.        
  703.         public MethodInfo GetMethod(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
  704.         {
  705.             if (name == null)
  706.                 throw new ArgumentNullException("name");
  707.            
  708.             if (types == null)
  709.                 throw new ArgumentNullException("types");
  710.            
  711.             for (int i = 0; i < types.Length; i++) {
  712.                 if (types[i] == null)
  713.                     throw new ArgumentNullException("types");
  714.             }
  715.            
  716.             return GetMethodImpl(name, bindingAttr, binder, callConvention, types, modifiers);
  717.            
  718.         }
  719.        
  720.         public MethodInfo GetMethod(string name, Type[] types)
  721.         {
  722.             if (name == null)
  723.                 throw new ArgumentNullException("name");
  724.            
  725.             if (types == null)
  726.                 throw new ArgumentNullException("types");
  727.            
  728.             for (int i = 0; i < types.Length; i++) {
  729.                 if (types[i] == null)
  730.                     throw new ArgumentNullException("types");
  731.             }
  732.            
  733.             return GetMethodImpl(name, Module.DefaultLookup, null, CallingConventions.Any, types, null);
  734.         }
  735.        
  736.         public MethodInfo GetMethod(string name)
  737.         {
  738.             if (name == null)
  739.                 throw new ArgumentNullException("name");
  740.             return GetMethodImpl(name, Module.DefaultLookup, null, CallingConventions.Any, null, null);
  741.         }
  742.        
  743.         public string ScopeName {
  744.             get { return InternalGetName(); }
  745.         }
  746.        
  747.         public string Name {
  748.             [ResourceExposure(ResourceScope.None)]
  749.             [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
  750.             get {
  751.                 string s = InternalGetFullyQualifiedName();
  752.                 int i = s.LastIndexOf(System.IO.Path.DirectorySeparatorChar);
  753.                 if (i == -1)
  754.                     return s;
  755.                
  756.                 return new string(s.ToCharArray(), i + 1, s.Length - i - 1);
  757.             }
  758.         }
  759.        
  760.         public override string ToString()
  761.         {
  762.             return ScopeName;
  763.         }
  764.        
  765.         public Assembly Assembly {
  766.             get { return GetAssemblyInternal(); }
  767.         }
  768.         unsafe public ModuleHandle ModuleHandle {
  769. //TODO: Add this back when the GetPEKind is removed from ModuleHandle
  770. //if (Assembly.ReflectionOnly)
  771. // throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotAllowedInReflectionOnly"));
  772.             get { return new ModuleHandle((void*)m_pData); }
  773.         }
  774.        
  775.         unsafe internal ModuleHandle GetModuleHandle()
  776.         {
  777.             return new ModuleHandle((void*)m_pData);
  778.         }
  779.         #endregion
  780.        
  781.         void _Module.GetTypeInfoCount(out uint pcTInfo)
  782.         {
  783.             throw new NotImplementedException();
  784.         }
  785.        
  786.         void _Module.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
  787.         {
  788.             throw new NotImplementedException();
  789.         }
  790.        
  791.         void _Module.GetIDsOfNames(        [In()]
  792. ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
  793.         {
  794.             throw new NotImplementedException();
  795.         }
  796.        
  797.         void _Module.Invoke(uint dispIdMember,         [In()]
  798. ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
  799.         {
  800.             throw new NotImplementedException();
  801.         }
  802.     }
  803. }

Developer Fusion