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

  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. using System;
  16. using System.Reflection;
  17. using System.Runtime.ConstrainedExecution;
  18. using System.Globalization;
  19. using System.Threading;
  20. using System.Diagnostics;
  21. using System.Security.Permissions;
  22. using System.Collections;
  23. using System.Runtime.CompilerServices;
  24. using System.Security;
  25. using System.Text;
  26. using System.Reflection.Emit;
  27. using System.Runtime.InteropServices;
  28. using RuntimeTypeCache = System.RuntimeType.RuntimeTypeCache;
  29. using CorElementType = System.Reflection.CorElementType;
  30. using System.Runtime.Serialization;
  31. using System.Reflection.Cache;
  32. using MdToken = System.Reflection.MetadataToken;
  33. namespace System.Reflection
  34. {
  35.     [Serializable()]
  36.     [ClassInterface(ClassInterfaceType.None)]
  37.     [ComDefaultInterface(typeof(_MemberInfo))]
  38.     [PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = "FullTrust")]
  39.     [System.Runtime.InteropServices.ComVisible(true)]
  40.     public abstract class MemberInfo : ICustomAttributeProvider, _MemberInfo
  41.     {
  42.         #region Consts
  43.         //
  44.         // Invocation cached flags. Those are used in unmanaged code as well
  45.         // so be careful if you change them
  46.         //
  47.         internal const uint INVOCATION_FLAGS_UNKNOWN = 0;
  48.         internal const uint INVOCATION_FLAGS_INITIALIZED = 1;
  49.         // it's used for both method and field to signify that no access is allowed
  50.         internal const uint INVOCATION_FLAGS_NO_INVOKE = 2;
  51.         internal const uint INVOCATION_FLAGS_NEED_SECURITY = 4;
  52.         internal const uint INVOCATION_FLAGS_NO_CTOR_INVOKE = 8;
  53.         // because field and method are different we can reuse the same bits
  54.         // method
  55.         internal const uint INVOCATION_FLAGS_IS_CTOR = 16;
  56.         internal const uint INVOCATION_FLAGS_RISKY_METHOD = 32;
  57.         internal const uint INVOCATION_FLAGS_SECURITY_IMPOSED = 64;
  58.         internal const uint INVOCATION_FLAGS_IS_DELEGATE_CTOR = 128;
  59.         internal const uint INVOCATION_FLAGS_CONTAINS_STACK_POINTERS = 256;
  60.         // field
  61.         internal const uint INVOCATION_FLAGS_SPECIAL_FIELD = 16;
  62.         internal const uint INVOCATION_FLAGS_FIELD_SPECIAL_CAST = 32;
  63.        
  64.         // temporary flag used for flagging invocation of method vs ctor
  65.         // this flag never appears on the instance m_invocationFlag and is simply
  66.         // passed down from within ConstructorInfo.Invoke()
  67.         internal const uint INVOCATION_FLAGS_CONSTRUCTOR_INVOKE = 268435456;
  68.         #endregion
  69.        
  70.         #region Constructor
  71.         protected MemberInfo()
  72.         {
  73.         }
  74.         #endregion
  75.        
  76.         #region Internal Methods
  77.         internal virtual bool CacheEquals(object o)
  78.         {
  79.             throw new NotImplementedException();
  80.         }
  81.         #endregion
  82.        
  83.         #region Legacy Remoting Cache
  84.         // The size of CachedData is accounted for by BaseObjectWithCachedData in object.h.
  85.         // This member is currently being used by Remoting for caching remoting data. If you
  86.         // need to cache data here, talk to the Remoting team to work out a mechanism, so that
  87.         // both caching systems can happily work together.
  88.         private InternalCache m_cachedData;
  89.        
  90.         internal InternalCache Cache {
  91.             get {
  92.                 // This grabs an internal copy of m_cachedData and uses
  93.                 // that instead of looking at m_cachedData directly because
  94.                 // the cache may get cleared asynchronously. This prevents
  95.                 // us from having to take a lock.
  96.                 InternalCache cache = m_cachedData;
  97.                 if (cache == null) {
  98.                     cache = new InternalCache("MemberInfo");
  99.                     InternalCache ret = Interlocked.CompareExchange(ref m_cachedData, cache, null);
  100.                     if (ret != null)
  101.                         cache = ret;
  102.                     GC.ClearCache += new ClearCacheHandler(OnCacheClear);
  103.                 }
  104.                 return cache;
  105.             }
  106.         }
  107.        
  108.        
  109.         internal void OnCacheClear(object sender, ClearCacheEventArgs cacheEventArgs)
  110.         {
  111.             m_cachedData = null;
  112.         }
  113.         #endregion
  114.        
  115.         #region Public Abstract\Virtual Members
  116.         public abstract MemberTypes MemberType {
  117.             get;
  118.         }
  119.        
  120.         public abstract string Name {
  121.             get;
  122.         }
  123.        
  124.         public abstract Type DeclaringType {
  125.             get;
  126.         }
  127.        
  128.         public abstract Type ReflectedType {
  129.             get;
  130.         }
  131.        
  132.         public abstract object[] GetCustomAttributes(bool inherit);
  133.        
  134.         public abstract object[] GetCustomAttributes(Type attributeType, bool inherit);
  135.        
  136.         public abstract bool IsDefined(Type attributeType, bool inherit);
  137.        
  138.         public virtual int MetadataToken {
  139.             get {
  140.                 throw new InvalidOperationException();
  141.             }
  142.         }
  143.        
  144.         internal virtual int MetadataTokenInternal {
  145.             get { return MetadataToken; }
  146.         }
  147.        
  148.         public virtual Module Module {
  149.             get {
  150.                 if (this is Type)
  151.                     return ((Type)this).Module;
  152.                
  153.                 throw new NotImplementedException();
  154.             }
  155.         }
  156.        
  157.        
  158.         // this method is required so Object.GetType is not made final virtual by the compiler
  159.         Type _MemberInfo.GetType()
  160.         {
  161.             return base.GetType();
  162.         }
  163.         #endregion
  164.        
  165.         void _MemberInfo.GetTypeInfoCount(out uint pcTInfo)
  166.         {
  167.             throw new NotImplementedException();
  168.         }
  169.        
  170.         void _MemberInfo.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
  171.         {
  172.             throw new NotImplementedException();
  173.         }
  174.        
  175.         void _MemberInfo.GetIDsOfNames(        [In()]
  176. ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
  177.         {
  178.             throw new NotImplementedException();
  179.         }
  180.        
  181.         void _MemberInfo.Invoke(uint dispIdMember,         [In()]
  182. ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
  183.         {
  184.             throw new NotImplementedException();
  185.         }
  186.     }
  187.    
  188.    
  189.     [Serializable()]
  190.     [ClassInterface(ClassInterfaceType.None)]
  191.     [ComDefaultInterface(typeof(_MethodBase))]
  192.     [PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = "FullTrust")]
  193.     [System.Runtime.InteropServices.ComVisible(true)]
  194.     public abstract class MethodBase : MemberInfo, _MethodBase
  195.     {
  196.         #region Static Members
  197.         public static MethodBase GetMethodFromHandle(RuntimeMethodHandle handle)
  198.         {
  199.             if (handle.IsNullHandle())
  200.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidHandle"));
  201.            
  202.             MethodBase m = RuntimeType.GetMethodBase(handle);
  203.            
  204.             if (m.DeclaringType != null && m.DeclaringType.IsGenericType)
  205.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_MethodDeclaringTypeGeneric"), m, m.DeclaringType.GetGenericTypeDefinition()));
  206.            
  207.             return m;
  208.         }
  209.        
  210.         [System.Runtime.InteropServices.ComVisible(false)]
  211.         public static MethodBase GetMethodFromHandle(RuntimeMethodHandle handle, RuntimeTypeHandle declaringType)
  212.         {
  213.             if (handle.IsNullHandle())
  214.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidHandle"));
  215.            
  216.             return RuntimeType.GetMethodBase(declaringType, handle);
  217.         }
  218.        
  219.         [DynamicSecurityMethod()]
  220.         // Specify DynamicSecurityMethod attribute to prevent inlining of the caller.
  221.         public static MethodBase GetCurrentMethod()
  222.         {
  223.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  224.             return RuntimeMethodInfo.InternalGetCurrentMethod(ref stackMark);
  225.         }
  226.         #endregion
  227.        
  228.         #region Constructor
  229.         protected MethodBase()
  230.         {
  231.         }
  232.         #endregion
  233.        
  234.         #region Internal Members
  235.         internal virtual bool IsOverloaded {
  236.             get {
  237.                 throw new NotSupportedException(Environment.GetResourceString("InvalidOperation_Method"));
  238.             }
  239.         }
  240.         internal virtual RuntimeMethodHandle GetMethodHandle()
  241.         {
  242.             return MethodHandle;
  243.         }
  244.         #endregion
  245.        
  246.         #region Public Abstract\Virtual Members
  247.         internal virtual Type GetReturnType()
  248.         {
  249.             throw new NotImplementedException();
  250.         }
  251.        
  252.         internal virtual ParameterInfo[] GetParametersNoCopy()
  253.         {
  254.             return GetParameters();
  255.         }
  256.        
  257.         public abstract ParameterInfo[] GetParameters();
  258.        
  259.         public abstract MethodImplAttributes GetMethodImplementationFlags();
  260.        
  261.         public abstract RuntimeMethodHandle MethodHandle {
  262.             get;
  263.         }
  264.        
  265.         public abstract MethodAttributes Attributes {
  266.             get;
  267.         }
  268.        
  269.         public abstract object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture);
  270.        
  271.         public virtual CallingConventions CallingConvention {
  272.             get { return CallingConventions.Standard; }
  273.         }
  274.        
  275.         [System.Runtime.InteropServices.ComVisible(true)]
  276.         public virtual Type[] GetGenericArguments()
  277.         {
  278.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride"));
  279.         }
  280.        
  281.         public virtual bool IsGenericMethodDefinition {
  282.             get { return false; }
  283.         }
  284.        
  285.         public virtual bool ContainsGenericParameters {
  286.             get { return false; }
  287.         }
  288.        
  289.         public virtual bool IsGenericMethod {
  290.             get { return false; }
  291.         }
  292.         #endregion
  293.        
  294.         #region _MethodBase Implementation
  295.         Type _MethodBase.GetType()
  296.         {
  297.             return base.GetType();
  298.         }
  299.         bool _MethodBase.IsPublic {
  300.             get { return IsPublic; }
  301.         }
  302.         bool _MethodBase.IsPrivate {
  303.             get { return IsPrivate; }
  304.         }
  305.         bool _MethodBase.IsFamily {
  306.             get { return IsFamily; }
  307.         }
  308.         bool _MethodBase.IsAssembly {
  309.             get { return IsAssembly; }
  310.         }
  311.         bool _MethodBase.IsFamilyAndAssembly {
  312.             get { return IsFamilyAndAssembly; }
  313.         }
  314.         bool _MethodBase.IsFamilyOrAssembly {
  315.             get { return IsFamilyOrAssembly; }
  316.         }
  317.         bool _MethodBase.IsStatic {
  318.             get { return IsStatic; }
  319.         }
  320.         bool _MethodBase.IsFinal {
  321.             get { return IsFinal; }
  322.         }
  323.         bool _MethodBase.IsVirtual {
  324.             get { return IsVirtual; }
  325.         }
  326.         bool _MethodBase.IsHideBySig {
  327.             get { return IsHideBySig; }
  328.         }
  329.         bool _MethodBase.IsAbstract {
  330.             get { return IsAbstract; }
  331.         }
  332.         bool _MethodBase.IsSpecialName {
  333.             get { return IsSpecialName; }
  334.         }
  335.         bool _MethodBase.IsConstructor {
  336.             get { return IsConstructor; }
  337.         }
  338.         #endregion
  339.        
  340.         #region Public Members
  341.         [DebuggerStepThroughAttribute()]
  342.         [Diagnostics.DebuggerHidden()]
  343.         public object Invoke(object obj, object[] parameters)
  344.         {
  345.             return Invoke(obj, BindingFlags.Default, null, parameters, null);
  346.         }
  347.        
  348.         public bool IsPublic {
  349.             get { return (Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Public; }
  350.         }
  351.        
  352.         public bool IsPrivate {
  353.             get { return (Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Private; }
  354.         }
  355.        
  356.         public bool IsFamily {
  357.             get { return (Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Family; }
  358.         }
  359.        
  360.         public bool IsAssembly {
  361.             get { return (Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Assembly; }
  362.         }
  363.        
  364.         public bool IsFamilyAndAssembly {
  365.             get { return (Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.FamANDAssem; }
  366.         }
  367.        
  368.         public bool IsFamilyOrAssembly {
  369.             get { return (Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.FamORAssem; }
  370.         }
  371.        
  372.         public bool IsStatic {
  373.             get { return (Attributes & MethodAttributes.Static) != 0; }
  374.         }
  375.        
  376.         public bool IsFinal {
  377.             get { return (Attributes & MethodAttributes.Final) != 0; }
  378.         }
  379.         public bool IsVirtual {
  380.             get { return (Attributes & MethodAttributes.Virtual) != 0; }
  381.         }
  382.         public bool IsHideBySig {
  383.             get { return (Attributes & MethodAttributes.HideBySig) != 0; }
  384.         }
  385.        
  386.         public bool IsAbstract {
  387.             get { return (Attributes & MethodAttributes.Abstract) != 0; }
  388.         }
  389.        
  390.         public bool IsSpecialName {
  391.             get { return (Attributes & MethodAttributes.SpecialName) != 0; }
  392.         }
  393.        
  394.         [System.Runtime.InteropServices.ComVisible(true)]
  395.         public bool IsConstructor {
  396.             get { return ((Attributes & MethodAttributes.RTSpecialName) != 0) && Name.Equals(ConstructorInfo.ConstructorName); }
  397.         }
  398.        
  399.         [ReflectionPermissionAttribute(SecurityAction.Demand, Flags = ReflectionPermissionFlag.MemberAccess)]
  400.         public virtual MethodBody GetMethodBody()
  401.         {
  402.             throw new InvalidOperationException();
  403.         }
  404.         #endregion
  405.        
  406.         #region Private Invocation Helpers
  407.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  408.         static internal extern uint GetSpecialSecurityFlags(RuntimeMethodHandle method);
  409.        
  410.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  411.         static internal extern void PerformSecurityCheck(object obj, RuntimeMethodHandle method, IntPtr parent, uint invocationFlags);
  412.         #endregion
  413.        
  414.         #region Internal Methods
  415.         internal virtual Type[] GetParameterTypes()
  416.         {
  417.             ParameterInfo[] paramInfo = GetParametersNoCopy();
  418.             Type[] parameterTypes = null;
  419.            
  420.             parameterTypes = new Type[paramInfo.Length];
  421.             for (int i = 0; i < paramInfo.Length; i++)
  422.                 parameterTypes[i] = paramInfo[i].ParameterType;
  423.            
  424.             return parameterTypes;
  425.         }
  426.        
  427.         internal virtual uint GetOneTimeFlags()
  428.         {
  429.             RuntimeMethodHandle handle = MethodHandle;
  430.            
  431.             uint invocationFlags = 0;
  432.             Type declaringType = DeclaringType;
  433.            
  434.             //
  435.             // first take care of all the NO_INVOKE cases
  436.             if ((ContainsGenericParameters) || (declaringType != null && declaringType.ContainsGenericParameters) || ((CallingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs) || ((Attributes & MethodAttributes.RequireSecObject) == MethodAttributes.RequireSecObject) || (Module.Assembly.GetType() == typeof(AssemblyBuilder) && ((AssemblyBuilder)Module.Assembly).m_assemblyData.m_access == AssemblyBuilderAccess.Save))
  437.                 invocationFlags |= INVOCATION_FLAGS_NO_INVOKE;
  438.            
  439.             //
  440.             // this should be an invocable method, determine the other flags that participate in invocation
  441.             else {
  442.                 invocationFlags |= MethodBase.GetSpecialSecurityFlags(handle);
  443.                
  444.                 if ((invocationFlags & INVOCATION_FLAGS_NEED_SECURITY) == 0) {
  445.                     // determine whether the method needs security
  446.                     if (((Attributes & MethodAttributes.MemberAccessMask) != MethodAttributes.Public) || (declaringType != null && !declaringType.IsVisible))
  447.                         invocationFlags |= INVOCATION_FLAGS_NEED_SECURITY;
  448.                    
  449.                     else if (IsGenericMethod) {
  450.                         Type[] genericArguments = GetGenericArguments();
  451.                        
  452.                         for (int i = 0; i < genericArguments.Length; i++) {
  453.                             if (!genericArguments[i].IsVisible) {
  454.                                 invocationFlags |= INVOCATION_FLAGS_NEED_SECURITY;
  455.                                 break;
  456.                             }
  457.                         }
  458.                     }
  459.                 }
  460.                
  461.             }
  462.            
  463.             invocationFlags |= GetOneTimeSpecificFlags();
  464.            
  465.             invocationFlags |= INVOCATION_FLAGS_INITIALIZED;
  466.             return invocationFlags;
  467.         }
  468.        
  469.         // only ctors have special flags for now
  470.         internal virtual uint GetOneTimeSpecificFlags()
  471.         {
  472.             return 0;
  473.         }
  474.        
  475.         internal object[] CheckArguments(object[] parameters, Binder binder, BindingFlags invokeAttr, CultureInfo culture, Signature sig)
  476.         {
  477.             int actualCount = (parameters != null) ? parameters.Length : 0;
  478.             // copy the arguments in a different array so we detach from any user changes
  479.             object[] copyOfParameters = new object[actualCount];
  480.            
  481.             ParameterInfo[] p = null;
  482.             for (int i = 0; i < actualCount; i++) {
  483.                 object arg = parameters[i];
  484.                 RuntimeTypeHandle argRTH = sig.Arguments[i];
  485.                
  486.                 if (arg == Type.Missing) {
  487.                     if (p == null)
  488.                         p = GetParametersNoCopy();
  489.                     if (p[i].DefaultValue == System.DBNull.Value)
  490.                         throw new ArgumentException(Environment.GetResourceString("Arg_VarMissNull"), "parameters");
  491.                     arg = p[i].DefaultValue;
  492.                 }
  493.                 if (argRTH.IsInstanceOfType(arg))
  494.                     copyOfParameters[i] = arg;
  495.                 else
  496.                     copyOfParameters[i] = argRTH.GetRuntimeType().CheckValue(arg, binder, culture, invokeAttr);
  497.             }
  498.            
  499.             return copyOfParameters;
  500.         }
  501.         #endregion
  502.        
  503.         void _MethodBase.GetTypeInfoCount(out uint pcTInfo)
  504.         {
  505.             throw new NotImplementedException();
  506.         }
  507.        
  508.         void _MethodBase.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
  509.         {
  510.             throw new NotImplementedException();
  511.         }
  512.        
  513.         void _MethodBase.GetIDsOfNames(        [In()]
  514. ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
  515.         {
  516.             throw new NotImplementedException();
  517.         }
  518.        
  519.         void _MethodBase.Invoke(uint dispIdMember,         [In()]
  520. ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
  521.         {
  522.             throw new NotImplementedException();
  523.         }
  524.     }
  525.    
  526.    
  527.     [Serializable()]
  528.     [ClassInterface(ClassInterfaceType.None)]
  529.     [ComDefaultInterface(typeof(_ConstructorInfo))]
  530.     [PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = "FullTrust")]
  531.     [System.Runtime.InteropServices.ComVisible(true)]
  532.     public abstract class ConstructorInfo : MethodBase, _ConstructorInfo
  533.     {
  534.         #region Static Members
  535.         [System.Runtime.InteropServices.ComVisible(true)]
  536.         public static readonly string ConstructorName = ".ctor";
  537.        
  538.         [System.Runtime.InteropServices.ComVisible(true)]
  539.         public static readonly string TypeConstructorName = ".cctor";
  540.         #endregion
  541.        
  542.         #region Constructor
  543.         protected ConstructorInfo()
  544.         {
  545.         }
  546.         #endregion
  547.        
  548.         #region MemberInfo Overrides
  549.         [System.Runtime.InteropServices.ComVisible(true)]
  550.         public override MemberTypes MemberType {
  551.             get { return System.Reflection.MemberTypes.Constructor; }
  552.         }
  553.         #endregion
  554.        
  555.         #region Public Abstract\Virtual Members
  556.         public abstract object Invoke(BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture);
  557.         #endregion
  558.        
  559.         #region Public Members
  560.         internal override Type GetReturnType()
  561.         {
  562.             return DeclaringType;
  563.         }
  564.        
  565.         [DebuggerStepThroughAttribute()]
  566.         [Diagnostics.DebuggerHidden()]
  567.         public object Invoke(object[] parameters)
  568.         {
  569.             return Invoke(BindingFlags.Default, null, parameters, null);
  570.         }
  571.         #endregion
  572.        
  573.         #region COM Interop Support
  574.         Type _ConstructorInfo.GetType()
  575.         {
  576.             return base.GetType();
  577.         }
  578.        
  579.         object _ConstructorInfo.Invoke_2(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
  580.         {
  581.             return Invoke(obj, invokeAttr, binder, parameters, culture);
  582.         }
  583.        
  584.         object _ConstructorInfo.Invoke_3(object obj, object[] parameters)
  585.         {
  586.             return Invoke(obj, parameters);
  587.         }
  588.        
  589.         object _ConstructorInfo.Invoke_4(BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
  590.         {
  591.             return Invoke(invokeAttr, binder, parameters, culture);
  592.         }
  593.        
  594.         object _ConstructorInfo.Invoke_5(object[] parameters)
  595.         {
  596.             return Invoke(parameters);
  597.         }
  598.        
  599.         void _ConstructorInfo.GetTypeInfoCount(out uint pcTInfo)
  600.         {
  601.             throw new NotImplementedException();
  602.         }
  603.        
  604.         void _ConstructorInfo.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
  605.         {
  606.             throw new NotImplementedException();
  607.         }
  608.        
  609.         void _ConstructorInfo.GetIDsOfNames(        [In()]
  610. ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
  611.         {
  612.             throw new NotImplementedException();
  613.         }
  614.        
  615.         void _ConstructorInfo.Invoke(uint dispIdMember,         [In()]
  616. ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
  617.         {
  618.             throw new NotImplementedException();
  619.         }
  620.         #endregion
  621.     }
  622.    
  623.    
  624.     [Serializable()]
  625.     [ClassInterface(ClassInterfaceType.None)]
  626.     [ComDefaultInterface(typeof(_MethodInfo))]
  627.     [PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = "FullTrust")]
  628.     [System.Runtime.InteropServices.ComVisible(true)]
  629.     public abstract class MethodInfo : MethodBase, _MethodInfo
  630.     {
  631.         #region Constructor
  632.         protected MethodInfo()
  633.         {
  634.         }
  635.         #endregion
  636.        
  637.         #region MemberInfo Overrides
  638.         public override MemberTypes MemberType {
  639.             get { return System.Reflection.MemberTypes.Method; }
  640.         }
  641.         #endregion
  642.        
  643.         #region Internal Members
  644.         internal virtual MethodInfo GetParentDefinition()
  645.         {
  646.             return null;
  647.         }
  648.         #endregion
  649.        
  650.         #region Public Abstract\Virtual Members
  651.         public virtual Type ReturnType {
  652.             get { return GetReturnType(); }
  653.         }
  654.         internal override Type GetReturnType()
  655.         {
  656.             return ReturnType;
  657.         }
  658.        
  659.         public virtual ParameterInfo ReturnParameter {
  660.             get {
  661.                 throw new NotImplementedException();
  662.             }
  663.         }
  664.        
  665.         public abstract ICustomAttributeProvider ReturnTypeCustomAttributes {
  666.             get;
  667.         }
  668.        
  669.         public abstract MethodInfo GetBaseDefinition();
  670.        
  671.         [System.Runtime.InteropServices.ComVisible(true)]
  672.         public override Type[] GetGenericArguments()
  673.         {
  674.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride"));
  675.         }
  676.        
  677.         [System.Runtime.InteropServices.ComVisible(true)]
  678.         public virtual MethodInfo GetGenericMethodDefinition()
  679.         {
  680.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride"));
  681.         }
  682.        
  683.         public override bool IsGenericMethodDefinition {
  684.             get { return false; }
  685.         }
  686.        
  687.         public override bool ContainsGenericParameters {
  688.             get { return false; }
  689.         }
  690.        
  691.         public virtual MethodInfo MakeGenericMethod(params Type[] typeArguments)
  692.         {
  693.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride"));
  694.         }
  695.        
  696.         public override bool IsGenericMethod {
  697.             get { return false; }
  698.         }
  699.         #endregion
  700.        
  701.         Type _MethodInfo.GetType()
  702.         {
  703.             return base.GetType();
  704.         }
  705.        
  706.         void _MethodInfo.GetTypeInfoCount(out uint pcTInfo)
  707.         {
  708.             throw new NotImplementedException();
  709.         }
  710.        
  711.         void _MethodInfo.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
  712.         {
  713.             throw new NotImplementedException();
  714.         }
  715.        
  716.         void _MethodInfo.GetIDsOfNames(        [In()]
  717. ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
  718.         {
  719.             throw new NotImplementedException();
  720.         }
  721.        
  722.         void _MethodInfo.Invoke(uint dispIdMember,         [In()]
  723. ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
  724.         {
  725.             throw new NotImplementedException();
  726.         }
  727.     }
  728.    
  729.    
  730.     [Serializable()]
  731.     [ClassInterface(ClassInterfaceType.None)]
  732.     [ComDefaultInterface(typeof(_FieldInfo))]
  733.     [PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = "FullTrust")]
  734.     [System.Runtime.InteropServices.ComVisible(true)]
  735.     public abstract class FieldInfo : MemberInfo, _FieldInfo
  736.     {
  737.         #region Static Members
  738.         public static FieldInfo GetFieldFromHandle(RuntimeFieldHandle handle)
  739.         {
  740.             if (handle.IsNullHandle())
  741.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidHandle"));
  742.            
  743.             FieldInfo f = RuntimeType.GetFieldInfo(handle);
  744.            
  745.             if (f.DeclaringType != null && f.DeclaringType.IsGenericType)
  746.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_FieldDeclaringTypeGeneric"), f.Name, f.DeclaringType.GetGenericTypeDefinition()));
  747.            
  748.             return f;
  749.         }
  750.        
  751.         [System.Runtime.InteropServices.ComVisible(false)]
  752.         public static FieldInfo GetFieldFromHandle(RuntimeFieldHandle handle, RuntimeTypeHandle declaringType)
  753.         {
  754.             if (handle.IsNullHandle())
  755.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidHandle"));
  756.            
  757.             return RuntimeType.GetFieldInfo(declaringType, handle);
  758.         }
  759.         #endregion
  760.        
  761.         #region Constructor
  762.         protected FieldInfo()
  763.         {
  764.         }
  765.         #endregion
  766.        
  767.         #region MemberInfo Overrides
  768.         public override MemberTypes MemberType {
  769.             get { return System.Reflection.MemberTypes.Field; }
  770.         }
  771.         #endregion
  772.        
  773.         #region Public Abstract\Virtual Members
  774.        
  775.         public virtual Type[] GetRequiredCustomModifiers()
  776.         {
  777.             throw new NotImplementedException();
  778.         }
  779.        
  780.         public virtual Type[] GetOptionalCustomModifiers()
  781.         {
  782.             throw new NotImplementedException();
  783.         }
  784.        
  785.         [CLSCompliant(false)]
  786.         public virtual void SetValueDirect(TypedReference obj, object value)
  787.         {
  788.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_AbstractNonCLS"));
  789.         }
  790.        
  791.         [CLSCompliant(false)]
  792.         public virtual object GetValueDirect(TypedReference obj)
  793.         {
  794.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_AbstractNonCLS"));
  795.         }
  796.        
  797.         public abstract RuntimeFieldHandle FieldHandle {
  798.             get;
  799.         }
  800.        
  801.         public abstract Type FieldType {
  802.             get;
  803.         }
  804.        
  805.         public abstract object GetValue(object obj);
  806.         public virtual object GetRawConstantValue()
  807.         {
  808.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_AbstractNonCLS"));
  809.         }
  810.        
  811.         public abstract void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture);
  812.        
  813.         public abstract FieldAttributes Attributes {
  814.             get;
  815.         }
  816.         #endregion
  817.        
  818.         #region Public Members
  819.         [DebuggerStepThroughAttribute()]
  820.         [Diagnostics.DebuggerHidden()]
  821.         public void SetValue(object obj, object value)
  822.         {
  823.             SetValue(obj, value, BindingFlags.Default, Type.DefaultBinder, null);
  824.         }
  825.        
  826.         public bool IsPublic {
  827.             get { return (Attributes & FieldAttributes.FieldAccessMask) == FieldAttributes.Public; }
  828.         }
  829.        
  830.         public bool IsPrivate {
  831.             get { return (Attributes & FieldAttributes.FieldAccessMask) == FieldAttributes.Private; }
  832.         }
  833.        
  834.         public bool IsFamily {
  835.             get { return (Attributes & FieldAttributes.FieldAccessMask) == FieldAttributes.Family; }
  836.         }
  837.        
  838.         public bool IsAssembly {
  839.             get { return (Attributes & FieldAttributes.FieldAccessMask) == FieldAttributes.Assembly; }
  840.         }
  841.        
  842.         public bool IsFamilyAndAssembly {
  843.             get { return (Attributes & FieldAttributes.FieldAccessMask) == FieldAttributes.FamANDAssem; }
  844.         }
  845.        
  846.         public bool IsFamilyOrAssembly {
  847.             get { return (Attributes & FieldAttributes.FieldAccessMask) == FieldAttributes.FamORAssem; }
  848.         }
  849.        
  850.         public bool IsStatic {
  851.             get { return (Attributes & FieldAttributes.Static) != 0; }
  852.         }
  853.        
  854.         public bool IsInitOnly {
  855.             get { return (Attributes & FieldAttributes.InitOnly) != 0; }
  856.         }
  857.        
  858.         public bool IsLiteral {
  859.             get { return (Attributes & FieldAttributes.Literal) != 0; }
  860.         }
  861.        
  862.         public bool IsNotSerialized {
  863.             get { return (Attributes & FieldAttributes.NotSerialized) != 0; }
  864.         }
  865.        
  866.         public bool IsSpecialName {
  867.             get { return (Attributes & FieldAttributes.SpecialName) != 0; }
  868.         }
  869.        
  870.         public bool IsPinvokeImpl {
  871.             get { return (Attributes & FieldAttributes.PinvokeImpl) != 0; }
  872.         }
  873.        
  874.         #endregion
  875.        
  876.         Type _FieldInfo.GetType()
  877.         {
  878.             return base.GetType();
  879.         }
  880.        
  881.         void _FieldInfo.GetTypeInfoCount(out uint pcTInfo)
  882.         {
  883.             throw new NotImplementedException();
  884.         }
  885.        
  886.         void _FieldInfo.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
  887.         {
  888.             throw new NotImplementedException();
  889.         }
  890.        
  891.         void _FieldInfo.GetIDsOfNames(        [In()]
  892. ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
  893.         {
  894.             throw new NotImplementedException();
  895.         }
  896.        
  897.         void _FieldInfo.Invoke(uint dispIdMember,         [In()]
  898. ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
  899.         {
  900.             throw new NotImplementedException();
  901.         }
  902.     }
  903.    
  904.    
  905.     [Serializable()]
  906.     [ClassInterface(ClassInterfaceType.None)]
  907.     [ComDefaultInterface(typeof(_EventInfo))]
  908.     [PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = "FullTrust")]
  909.     [System.Runtime.InteropServices.ComVisible(true)]
  910.     public abstract class EventInfo : MemberInfo, _EventInfo
  911.     {
  912.         #region Constructor
  913.         protected EventInfo()
  914.         {
  915.         }
  916.         #endregion
  917.        
  918.         #region MemberInfo Overrides
  919.         public override MemberTypes MemberType {
  920.             get { return MemberTypes.Event; }
  921.         }
  922.         #endregion
  923.        
  924.         #region Public Abstract\Virtual Members
  925.         public virtual MethodInfo[] GetOtherMethods(bool nonPublic)
  926.         {
  927.             throw new NotImplementedException();
  928.         }
  929.        
  930.         public abstract MethodInfo GetAddMethod(bool nonPublic);
  931.        
  932.         public abstract MethodInfo GetRemoveMethod(bool nonPublic);
  933.        
  934.         public abstract MethodInfo GetRaiseMethod(bool nonPublic);
  935.        
  936.         public abstract EventAttributes Attributes {
  937.             get;
  938.         }
  939.         #endregion
  940.        
  941.         #region Public Members
  942.         public MethodInfo[] GetOtherMethods()
  943.         {
  944.             return GetOtherMethods(false);
  945.         }
  946.        
  947.         public MethodInfo GetAddMethod()
  948.         {
  949.             return GetAddMethod(false);
  950.         }
  951.        
  952.         public MethodInfo GetRemoveMethod()
  953.         {
  954.             return GetRemoveMethod(false);
  955.         }
  956.        
  957.         public MethodInfo GetRaiseMethod()
  958.         {
  959.             return GetRaiseMethod(false);
  960.         }
  961.        
  962.         [DebuggerStepThroughAttribute()]
  963.         [Diagnostics.DebuggerHidden()]
  964.         public void AddEventHandler(object target, Delegate handler)
  965.         {
  966.             MethodInfo addMethod = GetAddMethod();
  967.            
  968.             if (addMethod == null)
  969.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NoPublicAddMethod"));
  970.            
  971.             addMethod.Invoke(target, new object[] {handler});
  972.         }
  973.        
  974.         [DebuggerStepThroughAttribute()]
  975.         [Diagnostics.DebuggerHidden()]
  976.         public void RemoveEventHandler(object target, Delegate handler)
  977.         {
  978.             MethodInfo removeMethod = GetRemoveMethod();
  979.            
  980.             if (removeMethod == null)
  981.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NoPublicRemoveMethod"));
  982.            
  983.             removeMethod.Invoke(target, new object[] {handler});
  984.         }
  985.        
  986.         public Type EventHandlerType {
  987.             get {
  988.                
  989.                
  990.                 MethodInfo m = GetAddMethod(true);
  991.                
  992.                 ParameterInfo[] p = m.GetParametersNoCopy();
  993.                
  994.                 Type del = typeof(Delegate);
  995.                
  996.                 for (int i = 0; i < p.Length; i++) {
  997.                     Type c = p[i].ParameterType;
  998.                    
  999.                     if (c.IsSubclassOf(del))
  1000.                         return c;
  1001.                 }
  1002.                 return null;
  1003.             }
  1004.         }
  1005.        
  1006.         public bool IsSpecialName {
  1007.             get { return (Attributes & EventAttributes.SpecialName) != 0; }
  1008.         }
  1009.        
  1010.         public bool IsMulticast {
  1011.             get {
  1012.                 Type cl = EventHandlerType;
  1013.                 Type mc = typeof(MulticastDelegate);
  1014.                 return mc.IsAssignableFrom(cl);
  1015.             }
  1016.         }
  1017.         #endregion
  1018.        
  1019.         Type _EventInfo.GetType()
  1020.         {
  1021.             return base.GetType();
  1022.         }
  1023.        
  1024.         void _EventInfo.GetTypeInfoCount(out uint pcTInfo)
  1025.         {
  1026.             throw new NotImplementedException();
  1027.         }
  1028.        
  1029.         void _EventInfo.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
  1030.         {
  1031.             throw new NotImplementedException();
  1032.         }
  1033.        
  1034.         void _EventInfo.GetIDsOfNames(        [In()]
  1035. ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
  1036.         {
  1037.             throw new NotImplementedException();
  1038.         }
  1039.        
  1040.         void _EventInfo.Invoke(uint dispIdMember,         [In()]
  1041. ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
  1042.         {
  1043.             throw new NotImplementedException();
  1044.         }
  1045.     }
  1046.    
  1047.    
  1048.     [Serializable()]
  1049.     [ClassInterface(ClassInterfaceType.None)]
  1050.     [ComDefaultInterface(typeof(_PropertyInfo))]
  1051.     [PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = "FullTrust")]
  1052.     [System.Runtime.InteropServices.ComVisible(true)]
  1053.     public abstract class PropertyInfo : MemberInfo, _PropertyInfo
  1054.     {
  1055.         #region Constructor
  1056.         protected PropertyInfo()
  1057.         {
  1058.         }
  1059.         #endregion
  1060.        
  1061.         #region MemberInfo Overrides
  1062.         public override MemberTypes MemberType {
  1063.             get { return System.Reflection.MemberTypes.Property; }
  1064.         }
  1065.         #endregion
  1066.        
  1067.         #region Public Abstract\Virtual Members
  1068.         public virtual object GetConstantValue()
  1069.         {
  1070.             throw new NotImplementedException();
  1071.         }
  1072.        
  1073.         public virtual object GetRawConstantValue()
  1074.         {
  1075.             throw new NotImplementedException();
  1076.         }
  1077.        
  1078.         public abstract Type PropertyType {
  1079.             get;
  1080.         }
  1081.        
  1082.         public abstract void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture);
  1083.        
  1084.         public abstract MethodInfo[] GetAccessors(bool nonPublic);
  1085.        
  1086.         public abstract MethodInfo GetGetMethod(bool nonPublic);
  1087.        
  1088.         public abstract MethodInfo GetSetMethod(bool nonPublic);
  1089.        
  1090.         public abstract ParameterInfo[] GetIndexParameters();
  1091.        
  1092.         public abstract PropertyAttributes Attributes {
  1093.             get;
  1094.         }
  1095.        
  1096.         public abstract bool CanRead {
  1097.             get;
  1098.         }
  1099.        
  1100.         public abstract bool CanWrite {
  1101.             get;
  1102.         }
  1103.        
  1104.         [DebuggerStepThroughAttribute()]
  1105.         [Diagnostics.DebuggerHidden()]
  1106.         public virtual object GetValue(object obj, object[] index)
  1107.         {
  1108.             return GetValue(obj, BindingFlags.Default, null, index, null);
  1109.         }
  1110.        
  1111.         public abstract object GetValue(object obj, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture);
  1112.        
  1113.         [DebuggerStepThroughAttribute()]
  1114.         [Diagnostics.DebuggerHidden()]
  1115.         public virtual void SetValue(object obj, object value, object[] index)
  1116.         {
  1117.             SetValue(obj, value, BindingFlags.Default, null, index, null);
  1118.         }
  1119.         #endregion
  1120.        
  1121.         #region Public Members
  1122.         public virtual Type[] GetRequiredCustomModifiers()
  1123.         {
  1124.             return new Type[0];
  1125.         }
  1126.        
  1127.         public virtual Type[] GetOptionalCustomModifiers()
  1128.         {
  1129.             return new Type[0];
  1130.         }
  1131.        
  1132.         public MethodInfo[] GetAccessors()
  1133.         {
  1134.             return GetAccessors(false);
  1135.         }
  1136.        
  1137.         public MethodInfo GetGetMethod()
  1138.         {
  1139.             return GetGetMethod(false);
  1140.         }
  1141.        
  1142.         public MethodInfo GetSetMethod()
  1143.         {
  1144.             return GetSetMethod(false);
  1145.         }
  1146.        
  1147.         public bool IsSpecialName {
  1148.             get { return (Attributes & PropertyAttributes.SpecialName) != 0; }
  1149.         }
  1150.         #endregion
  1151.        
  1152.         Type _PropertyInfo.GetType()
  1153.         {
  1154.             return base.GetType();
  1155.         }
  1156.        
  1157.         void _PropertyInfo.GetTypeInfoCount(out uint pcTInfo)
  1158.         {
  1159.             throw new NotImplementedException();
  1160.         }
  1161.        
  1162.         void _PropertyInfo.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
  1163.         {
  1164.             throw new NotImplementedException();
  1165.         }
  1166.        
  1167.         void _PropertyInfo.GetIDsOfNames(        [In()]
  1168. ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
  1169.         {
  1170.             throw new NotImplementedException();
  1171.         }
  1172.        
  1173.         void _PropertyInfo.Invoke(uint dispIdMember,         [In()]
  1174. ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
  1175.         {
  1176.             throw new NotImplementedException();
  1177.         }
  1178.     }
  1179.    
  1180. }
  1181. namespace System.Reflection
  1182. {
  1183.     internal enum MemberListType
  1184.     {
  1185.         All,
  1186.         CaseSensitive,
  1187.         CaseInsensitive,
  1188.         HandleToInfo
  1189.     }
  1190.    
  1191.     [Serializable()]
  1192.     internal sealed class RuntimeMethodInfo : MethodInfo, ISerializable
  1193.     {
  1194.         #region Static Members
  1195.         static internal string ConstructParameters(ParameterInfo[] parameters, CallingConventions callingConvention)
  1196.         {
  1197.             Type[] parameterTypes = new Type[parameters.Length];
  1198.            
  1199.             for (int i = 0; i < parameters.Length; i++)
  1200.                 parameterTypes[i] = parameters[i].ParameterType;
  1201.            
  1202.             return ConstructParameters(parameterTypes, callingConvention);
  1203.         }
  1204.        
  1205.         static internal string ConstructParameters(Type[] parameters, CallingConventions callingConvention)
  1206.         {
  1207.             string toString = "";
  1208.             string comma = "";
  1209.            
  1210.             for (int i = 0; i < parameters.Length; i++) {
  1211.                 Type t = parameters[i];
  1212.                
  1213.                 toString += comma;
  1214.                 toString += t.SigToString();
  1215.                 if (t.IsByRef) {
  1216.                     toString = toString.TrimEnd(new char[] {'&'});
  1217.                     toString += " ByRef";
  1218.                 }
  1219.                
  1220.                 comma = ", ";
  1221.             }
  1222.            
  1223.             if ((callingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs) {
  1224.                 toString += comma;
  1225.                 toString += "...";
  1226.             }
  1227.            
  1228.             return toString;
  1229.         }
  1230.        
  1231.         static internal string ConstructName(MethodBase mi)
  1232.         {
  1233.             // Serialization uses ToString to resolve MethodInfo overloads.
  1234.             string toString = null;
  1235.            
  1236.             toString += mi.Name;
  1237.            
  1238.             RuntimeMethodInfo rmi = mi as RuntimeMethodInfo;
  1239.            
  1240.             if (rmi != null && rmi.IsGenericMethod)
  1241.                 toString += rmi.m_handle.ConstructInstantiation();
  1242.            
  1243.             toString += "(" + ConstructParameters(mi.GetParametersNoCopy(), mi.CallingConvention) + ")";
  1244.            
  1245.             return toString;
  1246.         }
  1247.         #endregion
  1248.        
  1249.         #region Private Data Members
  1250.         private RuntimeMethodHandle m_handle;
  1251.         private RuntimeTypeCache m_reflectedTypeCache;
  1252.         private string m_name;
  1253.         private string m_toString;
  1254.         private ParameterInfo[] m_parameters;
  1255.         private ParameterInfo m_returnParameter;
  1256.         private BindingFlags m_bindingFlags;
  1257.         private MethodAttributes m_methodAttributes;
  1258.         private Signature m_signature;
  1259.         private RuntimeType m_declaringType;
  1260.         private uint m_invocationFlags;
  1261.         #endregion
  1262.        
  1263.         #region Constructor
  1264.         internal RuntimeMethodInfo()
  1265.         {
  1266.             // Used for dummy head node during population
  1267.         }
  1268.         internal RuntimeMethodInfo(RuntimeMethodHandle handle, RuntimeTypeHandle declaringTypeHandle, RuntimeTypeCache reflectedTypeCache, MethodAttributes methodAttributes, BindingFlags bindingFlags)
  1269.         {
  1270.             ASSERT.PRECONDITION(!handle.IsNullHandle());
  1271.             ASSERT.PRECONDITION(methodAttributes == handle.GetAttributes());
  1272.            
  1273.             m_toString = null;
  1274.             m_bindingFlags = bindingFlags;
  1275.             m_handle = handle;
  1276.             m_reflectedTypeCache = reflectedTypeCache;
  1277.             m_parameters = null;
  1278.             // Created lazily when GetParameters() is called.
  1279.             m_methodAttributes = methodAttributes;
  1280.             m_declaringType = declaringTypeHandle.GetRuntimeType();
  1281.             ASSERT.POSTCONDITION(!m_handle.IsNullHandle());
  1282.         }
  1283.         #endregion
  1284.        
  1285.         #region Private Methods
  1286.         private RuntimeTypeHandle ReflectedTypeHandle {
  1287.             get { return m_reflectedTypeCache.RuntimeTypeHandle; }
  1288.         }
  1289.        
  1290.         internal ParameterInfo[] FetchNonReturnParameters()
  1291.         {
  1292.             if (m_parameters == null)
  1293.                 m_parameters = ParameterInfo.GetParameters(this, this, Signature);
  1294.            
  1295.             return m_parameters;
  1296.         }
  1297.        
  1298.         internal ParameterInfo FetchReturnParameter()
  1299.         {
  1300.             if (m_returnParameter == null)
  1301.                 m_returnParameter = ParameterInfo.GetReturnParameter(this, this, Signature);
  1302.            
  1303.             return m_returnParameter;
  1304.         }
  1305.        
  1306.         #endregion
  1307.        
  1308.         #region Internal Members
  1309.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  1310.         internal override bool CacheEquals(object o)
  1311.         {
  1312.             RuntimeMethodInfo m = o as RuntimeMethodInfo;
  1313.            
  1314.             if (m == null)
  1315.                 return false;
  1316.            
  1317.             return m.m_handle.Equals(m_handle);
  1318.         }
  1319.        
  1320.         internal Signature Signature {
  1321.             get {
  1322.                 if (m_signature == null)
  1323.                     m_signature = new Signature(m_handle, m_declaringType.GetTypeHandleInternal());
  1324.                
  1325.                 return m_signature;
  1326.             }
  1327.         }
  1328.        
  1329.         internal BindingFlags BindingFlags {
  1330.             get { return m_bindingFlags; }
  1331.         }
  1332.        
  1333.         internal override RuntimeMethodHandle GetMethodHandle()
  1334.         {
  1335.             return m_handle;
  1336.         }
  1337.        
  1338.         internal override MethodInfo GetParentDefinition()
  1339.         {
  1340.             if (!IsVirtual || m_declaringType.IsInterface)
  1341.                 return null;
  1342.            
  1343.             Type parent = m_declaringType.BaseType;
  1344.            
  1345.             if (parent == null)
  1346.                 return null;
  1347.            
  1348.             int slot = m_handle.GetSlot();
  1349.            
  1350.             if (parent.GetTypeHandleInternal().GetNumVtableSlots() <= slot)
  1351.                 return null;
  1352.            
  1353.             return (MethodInfo)RuntimeType.GetMethodBase(parent.GetTypeHandleInternal(), parent.GetTypeHandleInternal().GetMethodAt(slot));
  1354.         }
  1355.        
  1356.         internal override uint GetOneTimeFlags()
  1357.         {
  1358.             uint invocationFlags = 0;
  1359.             if (ReturnType.IsByRef)
  1360.                 invocationFlags = INVOCATION_FLAGS_NO_INVOKE;
  1361.             invocationFlags |= base.GetOneTimeFlags();
  1362.             return invocationFlags;
  1363.         }
  1364.        
  1365.         #endregion
  1366.        
  1367.         #region Object Overrides
  1368.         public override string ToString()
  1369.         {
  1370.             if (m_toString == null)
  1371.                 m_toString = ReturnType.SigToString() + " " + ConstructName(this);
  1372.            
  1373.             return m_toString;
  1374.         }
  1375.        
  1376.         public override int GetHashCode()
  1377.         {
  1378.             return m_handle.GetHashCode();
  1379.         }
  1380.        
  1381.         public override bool Equals(object obj)
  1382.         {
  1383.             if (!IsGenericMethod)
  1384.                 return obj == this;
  1385.            
  1386.             RuntimeMethodInfo mi = obj as RuntimeMethodInfo;
  1387.            
  1388.             RuntimeMethodHandle handle1 = GetMethodHandle().StripMethodInstantiation();
  1389.             RuntimeMethodHandle handle2 = mi.GetMethodHandle().StripMethodInstantiation();
  1390.             if (handle1 != handle2)
  1391.                 return false;
  1392.            
  1393.             if (mi == null || !mi.IsGenericMethod)
  1394.                 return false;
  1395.            
  1396.             Type[] lhs = GetGenericArguments();
  1397.             Type[] rhs = mi.GetGenericArguments();
  1398.            
  1399.             if (lhs.Length != rhs.Length)
  1400.                 return false;
  1401.            
  1402.             for (int i = 0; i < lhs.Length; i++) {
  1403.                 if (lhs[i] != rhs[i])
  1404.                     return false;
  1405.             }
  1406.            
  1407.             return true;
  1408.         }
  1409.         #endregion
  1410.        
  1411.         #region ICustomAttributeProvider
  1412.         public override object[] GetCustomAttributes(bool inherit)
  1413.         {
  1414.             return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType as RuntimeType, inherit);
  1415.         }
  1416.        
  1417.         public override object[] GetCustomAttributes(Type attributeType, bool inherit)
  1418.         {
  1419.             if (attributeType == null)
  1420.                 throw new ArgumentNullException("attributeType");
  1421.            
  1422.             RuntimeType attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType;
  1423.            
  1424.             if (attributeRuntimeType == null)
  1425.                 throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"), "attributeType");
  1426.            
  1427.             return CustomAttribute.GetCustomAttributes(this, attributeRuntimeType, inherit);
  1428.         }
  1429.        
  1430.         public override bool IsDefined(Type attributeType, bool inherit)
  1431.         {
  1432.             if (attributeType == null)
  1433.                 throw new ArgumentNullException("attributeType");
  1434.            
  1435.             RuntimeType attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType;
  1436.            
  1437.             if (attributeRuntimeType == null)
  1438.                 throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"), "attributeType");
  1439.            
  1440.             return CustomAttribute.IsDefined(this, attributeRuntimeType, inherit);
  1441.         }
  1442.         #endregion
  1443.        
  1444.         #region MemberInfo Overrides
  1445.         public override string Name {
  1446.             get {
  1447.                 if (m_name == null)
  1448.                     m_name = m_handle.GetName();
  1449.                
  1450.                 return m_name;
  1451.             }
  1452.         }
  1453.        
  1454.         public override Type DeclaringType {
  1455.             get {
  1456.                 if (m_reflectedTypeCache.IsGlobal)
  1457.                     return null;
  1458.                
  1459.                 return m_declaringType;
  1460.             }
  1461.         }
  1462.        
  1463.         public override Type ReflectedType {
  1464.             get {
  1465.                 if (m_reflectedTypeCache.IsGlobal)
  1466.                     return null;
  1467.                
  1468.                 return m_reflectedTypeCache.RuntimeType;
  1469.             }
  1470.         }
  1471.        
  1472.         public override MemberTypes MemberType {
  1473.             get { return MemberTypes.Method; }
  1474.         }
  1475.         public override int MetadataToken {
  1476.             get { return m_handle.GetMethodDef(); }
  1477.         }
  1478.         public override Module Module {
  1479.             get { return m_declaringType.Module; }
  1480.         }
  1481.         #endregion
  1482.        
  1483.         #region MethodBase Overrides
  1484.         internal override ParameterInfo[] GetParametersNoCopy()
  1485.         {
  1486.             FetchNonReturnParameters();
  1487.            
  1488.             return m_parameters;
  1489.         }
  1490.        
  1491.         public override ParameterInfo[] GetParameters()
  1492.         {
  1493.             FetchNonReturnParameters();
  1494.            
  1495.             if (m_parameters.Length == 0)
  1496.                 return m_parameters;
  1497.            
  1498.             ParameterInfo[] ret = new ParameterInfo[m_parameters.Length];
  1499.            
  1500.             Array.Copy(m_parameters, ret, m_parameters.Length);
  1501.            
  1502.             return ret;
  1503.         }
  1504.        
  1505.         public override MethodImplAttributes GetMethodImplementationFlags()
  1506.         {
  1507.             return m_handle.GetImplAttributes();
  1508.         }
  1509.        
  1510.         internal override bool IsOverloaded {
  1511.             get { return m_reflectedTypeCache.GetMethodList(MemberListType.CaseSensitive, Name).Count > 1; }
  1512.         }
  1513.        
  1514.         public override RuntimeMethodHandle MethodHandle {
  1515.             get {
  1516.                 Type declaringType = DeclaringType;
  1517.                 if ((declaringType == null && Module.Assembly.ReflectionOnly) || declaringType is ReflectionOnlyType)
  1518.                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotAllowedInReflectionOnly"));
  1519.                 return m_handle;
  1520.             }
  1521.         }
  1522.        
  1523.         public override MethodAttributes Attributes {
  1524.             get { return m_methodAttributes; }
  1525.         }
  1526.         public override CallingConventions CallingConvention {
  1527.             get { return Signature.CallingConvention; }
  1528.         }
  1529.        
  1530.         [ReflectionPermissionAttribute(SecurityAction.Demand, Flags = ReflectionPermissionFlag.MemberAccess)]
  1531.         public override MethodBody GetMethodBody()
  1532.         {
  1533.             MethodBody mb = m_handle.GetMethodBody(ReflectedTypeHandle);
  1534.             if (mb != null)
  1535.                 mb.m_methodBase = this;
  1536.             return mb;
  1537.         }
  1538.         #endregion
  1539.        
  1540.         #region Invocation Logic(On MemberBase)
  1541.         private void CheckConsistency(object target)
  1542.         {
  1543.             // only test instance methods
  1544.             if ((m_methodAttributes & MethodAttributes.Static) != MethodAttributes.Static) {
  1545.                 if (!m_declaringType.IsInstanceOfType(target)) {
  1546.                     if (target == null)
  1547.                         throw new TargetException(Environment.GetResourceString("RFLCT.Targ_StatMethReqTarg"));
  1548.                     else
  1549.                         throw new TargetException(Environment.GetResourceString("RFLCT.Targ_ITargMismatch"));
  1550.                 }
  1551.             }
  1552.         }
  1553.        
  1554.         private void ThrowNoInvokeException()
  1555.         {
  1556.             // method is ReflectionOnly
  1557.             Type declaringType = DeclaringType;
  1558.             if ((declaringType == null && Module.Assembly.ReflectionOnly) || declaringType is ReflectionOnlyType)
  1559.                 throw new InvalidOperationException(Environment.GetResourceString("Arg_ReflectionOnlyInvoke"));
  1560.            
  1561.             // method is on a class that contains stack pointers
  1562.             if (DeclaringType.GetRootElementType() == typeof(ArgIterator))
  1563.                 throw new NotSupportedException();
  1564.             else if ((CallingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs)
  1565.                 throw new NotSupportedException();
  1566.             else if (DeclaringType.ContainsGenericParameters || ContainsGenericParameters)
  1567.                 throw new InvalidOperationException(Environment.GetResourceString("Arg_UnboundGenParam"));
  1568.             else if (IsAbstract)
  1569.                 throw new MemberAccessException();
  1570.             else if (ReturnType.IsByRef)
  1571.                
  1572.                 // method is vararg
  1573.                
  1574.                 // method is generic or on a generic class
  1575.                
  1576.                 // method is abstract class
  1577.                
  1578.                 // ByRef return are not allowed in reflection
  1579.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_ByRefReturn"));
  1580.            
  1581.             throw new TargetException();
  1582.         }
  1583.        
  1584.         [DebuggerStepThroughAttribute()]
  1585.         [Diagnostics.DebuggerHidden()]
  1586.         public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
  1587.         {
  1588.             return Invoke(obj, invokeAttr, binder, parameters, culture, false);
  1589.         }
  1590.        
  1591.         [DebuggerStepThroughAttribute()]
  1592.         [Diagnostics.DebuggerHidden()]
  1593.         internal object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture, bool skipVisibilityChecks)
  1594.         {
  1595.             // get the signature
  1596.             int formalCount = Signature.Arguments.Length;
  1597.             int actualCount = (parameters != null) ? parameters.Length : 0;
  1598.            
  1599.             // set one time info for invocation
  1600.             if ((m_invocationFlags & INVOCATION_FLAGS_INITIALIZED) == 0)
  1601.                 m_invocationFlags = GetOneTimeFlags();
  1602.            
  1603.             if ((m_invocationFlags & INVOCATION_FLAGS_NO_INVOKE) != 0)
  1604.                 ThrowNoInvokeException();
  1605.            
  1606.             // check basic method consistency. This call will throw if there are problems in the target/method relationship
  1607.             CheckConsistency(obj);
  1608.            
  1609.             if (formalCount != actualCount)
  1610.                 throw new TargetParameterCountException(Environment.GetResourceString("Arg_ParmCnt"));
  1611.            
  1612.             // Don't allow more than 65535 parameters.
  1613.             if (actualCount > UInt16.MaxValue)
  1614.                 throw new TargetParameterCountException(Environment.GetResourceString("NotSupported_TooManyArgs"));
  1615.            
  1616.             if (!skipVisibilityChecks && (m_invocationFlags & (INVOCATION_FLAGS_RISKY_METHOD | INVOCATION_FLAGS_NEED_SECURITY)) != 0) {
  1617.                 if ((m_invocationFlags & INVOCATION_FLAGS_RISKY_METHOD) != 0)
  1618.                     CodeAccessPermission.DemandInternal(PermissionType.ReflectionMemberAccess);
  1619.                
  1620.                 if ((m_invocationFlags & INVOCATION_FLAGS_NEED_SECURITY) != 0)
  1621.                     PerformSecurityCheck(obj, m_handle, m_declaringType.TypeHandle.Value, m_invocationFlags);
  1622.             }
  1623.            
  1624.             // if we are here we passed all the previous checks. Time to look at the arguments
  1625.             RuntimeTypeHandle declaringTypeHandle = RuntimeTypeHandle.EmptyHandle;
  1626.             if (!m_reflectedTypeCache.IsGlobal)
  1627.                 declaringTypeHandle = m_declaringType.TypeHandle;
  1628.            
  1629.             if (actualCount == 0)
  1630.                 return m_handle.InvokeMethodFast(obj, null, Signature, m_methodAttributes, declaringTypeHandle);
  1631.            
  1632.             object[] arguments = CheckArguments(parameters, binder, invokeAttr, culture, Signature);
  1633.            
  1634.             object retValue = m_handle.InvokeMethodFast(obj, arguments, Signature, m_methodAttributes, declaringTypeHandle);
  1635.            
  1636.             // copy out. This should be made only if ByRef are present.
  1637.             for (int index = 0; index < actualCount; index++)
  1638.                 parameters[index] = arguments[index];
  1639.            
  1640.             return retValue;
  1641.         }
  1642.         #endregion
  1643.        
  1644.         #region MethodInfo Overrides
  1645.         public override Type ReturnType {
  1646.             get { return Signature.ReturnTypeHandle.GetRuntimeType(); }
  1647.         }
  1648.        
  1649.         public override ICustomAttributeProvider ReturnTypeCustomAttributes {
  1650.             get { return ReturnParameter; }
  1651.         }
  1652.        
  1653.         public override ParameterInfo ReturnParameter {
  1654.             get {
  1655.                 FetchReturnParameter();
  1656.                 ASSERT.POSTCONDITION(m_returnParameter != null);
  1657.                 return m_returnParameter as ParameterInfo;
  1658.             }
  1659.         }
  1660.        
  1661.         public override MethodInfo GetBaseDefinition()
  1662.         {
  1663.             if (!IsVirtual || m_declaringType.IsInterface)
  1664.                 return this;
  1665.            
  1666.             int slot = m_handle.GetSlot();
  1667.             RuntimeTypeHandle parent = m_handle.GetDeclaringType();
  1668.             RuntimeMethodHandle baseMethodHandle = RuntimeMethodHandle.EmptyHandle;
  1669.             do {
  1670.                 int cVtblSlots = parent.GetNumVtableSlots();
  1671.                
  1672.                 if (cVtblSlots <= slot)
  1673.                     break;
  1674.                
  1675.                 baseMethodHandle = parent.GetMethodAt(slot);
  1676.                 parent = baseMethodHandle.GetDeclaringType().GetBaseTypeHandle();
  1677.             }
  1678.             while (!parent.IsNullHandle());
  1679.            
  1680.             ASSERT.CONSISTENCY_CHECK((baseMethodHandle.GetAttributes() & MethodAttributes.Virtual) != 0);
  1681.            
  1682.             return (MethodInfo)RuntimeType.GetMethodBase(baseMethodHandle);
  1683.         }
  1684.         #endregion
  1685.        
  1686.         #region Generics
  1687.         public override MethodInfo MakeGenericMethod(params Type[] methodInstantiation)
  1688.         {
  1689.             if (methodInstantiation == null)
  1690.                 throw new ArgumentNullException("methodInstantiation");
  1691.            
  1692.             Type[] methodInstantiationCopy = new Type[methodInstantiation.Length];
  1693.             for (int i = 0; i < methodInstantiation.Length; i++)
  1694.                 methodInstantiationCopy[i] = methodInstantiation[i];
  1695.             methodInstantiation = methodInstantiationCopy;
  1696.            
  1697.             if (!IsGenericMethodDefinition)
  1698.                 throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Arg_NotGenericMethodDefinition"), this));
  1699.            
  1700.             for (int i = 0; i < methodInstantiation.Length; i++) {
  1701.                 if (methodInstantiation[i] == null)
  1702.                     throw new ArgumentNullException();
  1703.                
  1704.                 if (!(methodInstantiation[i] is RuntimeType))
  1705.                     return MethodBuilderInstantiation.MakeGenericMethod(this, methodInstantiation);
  1706.             }
  1707.            
  1708.             Type[] genericParameters = GetGenericArguments();
  1709.            
  1710.             RuntimeType.SanityCheckGenericArguments(methodInstantiation, genericParameters);
  1711.            
  1712.             RuntimeTypeHandle[] typeHandles = new RuntimeTypeHandle[methodInstantiation.Length];
  1713.            
  1714.             for (int i = 0; i < methodInstantiation.Length; i++)
  1715.                 typeHandles[i] = methodInstantiation[i].GetTypeHandleInternal();
  1716.            
  1717.             MethodInfo ret = null;
  1718.            
  1719.             try {
  1720.                 ret = RuntimeType.GetMethodBase(m_reflectedTypeCache.RuntimeTypeHandle, m_handle.GetInstantiatingStub(m_declaringType.GetTypeHandleInternal(), typeHandles)) as MethodInfo;
  1721.             }
  1722.             catch (VerificationException e) {
  1723.                 RuntimeType.ValidateGenericArguments(this, methodInstantiation, e);
  1724.                 throw e;
  1725.             }
  1726.            
  1727.             return ret;
  1728.         }
  1729.        
  1730.         public override Type[] GetGenericArguments()
  1731.         {
  1732.             RuntimeType[] rtypes = null;
  1733.             RuntimeTypeHandle[] types = m_handle.GetMethodInstantiation();
  1734.            
  1735.             if (types != null) {
  1736.                 rtypes = new RuntimeType[types.Length];
  1737.                
  1738.                 for (int i = 0; i < types.Length; i++)
  1739.                     rtypes[i] = types[i].GetRuntimeType();
  1740.             }
  1741.             else {
  1742.                
  1743.                 rtypes = new RuntimeType[0];
  1744.             }
  1745.             return rtypes;
  1746.         }
  1747.        
  1748.         public override MethodInfo GetGenericMethodDefinition()
  1749.         {
  1750.             if (!IsGenericMethod)
  1751.                 throw new InvalidOperationException();
  1752.            
  1753.             return RuntimeType.GetMethodBase(m_declaringType.GetTypeHandleInternal(), m_handle.StripMethodInstantiation()) as MethodInfo;
  1754.         }
  1755.        
  1756.         public override bool IsGenericMethod {
  1757.             get { return m_handle.HasMethodInstantiation(); }
  1758.         }
  1759.        
  1760.         public override bool IsGenericMethodDefinition {
  1761.             get { return m_handle.IsGenericMethodDefinition(); }
  1762.         }
  1763.        
  1764.         public override bool ContainsGenericParameters {
  1765.             get {
  1766.                 if (DeclaringType != null && DeclaringType.ContainsGenericParameters)
  1767.                     return true;
  1768.                
  1769.                 if (!IsGenericMethod)
  1770.                     return false;
  1771.                
  1772.                 Type[] pis = GetGenericArguments();
  1773.                 for (int i = 0; i < pis.Length; i++) {
  1774.                     if (pis[i].ContainsGenericParameters)
  1775.                         return true;
  1776.                 }
  1777.                
  1778.                 return false;
  1779.             }
  1780.         }
  1781.         #endregion
  1782.        
  1783.         #region ISerializable Implementation
  1784.         public void GetObjectData(SerializationInfo info, StreamingContext context)
  1785.         {
  1786.             if (info == null)
  1787.                 throw new ArgumentNullException("info");
  1788.            
  1789.             if (m_reflectedTypeCache.IsGlobal)
  1790.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_GlobalMethodSerialization"));
  1791.            
  1792.             MemberInfoSerializationHolder.GetSerializationInfo(info, Name, ReflectedTypeHandle.GetRuntimeType(), ToString(), MemberTypes.Method, IsGenericMethod & !IsGenericMethodDefinition ? GetGenericArguments() : null);
  1793.         }
  1794.         #endregion
  1795.        
  1796.         #region Legacy Internal
  1797.         static internal MethodBase InternalGetCurrentMethod(ref StackCrawlMark stackMark)
  1798.         {
  1799.             RuntimeMethodHandle method = RuntimeMethodHandle.GetCurrentMethod(ref stackMark);
  1800.            
  1801.             if (method.IsNullHandle())
  1802.                 return null;
  1803.            
  1804.             // If C<Foo>.m<Bar> was called, GetCurrentMethod returns C<object>.m<object>. We cannot
  1805.             // get know that the instantiation used Foo or Bar at that point. So the next best thing
  1806.             // is to return C<T>.m<P> and that's what GetTypicalMethodDefinition will do for us.
  1807.             method = method.GetTypicalMethodDefinition();
  1808.            
  1809.             return RuntimeType.GetMethodBase(method);
  1810.         }
  1811.         #endregion
  1812.     }
  1813.    
  1814.    
  1815.     [Serializable()]
  1816.     internal sealed class RuntimeConstructorInfo : ConstructorInfo, ISerializable
  1817.     {
  1818.         #region Private Data Members
  1819.         private RuntimeMethodHandle m_handle;
  1820.         private RuntimeTypeCache m_reflectedTypeCache;
  1821.         private RuntimeType m_declaringType;
  1822.         private string m_toString;
  1823.         private MethodAttributes m_methodAttributes;
  1824.         private BindingFlags m_bindingFlags;
  1825.         private ParameterInfo[] m_parameters = null;
  1826.         // Created lazily when GetParameters() is called.
  1827.         private uint m_invocationFlags;
  1828.         private Signature m_signature;
  1829.         #endregion
  1830.        
  1831.         #region Constructor
  1832.         internal RuntimeConstructorInfo()
  1833.         {
  1834.             // Used for dummy head node during population
  1835.         }
  1836.         internal RuntimeConstructorInfo(RuntimeMethodHandle handle, RuntimeTypeHandle declaringTypeHandle, RuntimeTypeCache reflectedTypeCache, MethodAttributes methodAttributes, BindingFlags bindingFlags)
  1837.         {
  1838.             ASSERT.POSTCONDITION(methodAttributes == handle.GetAttributes());
  1839.            
  1840.             m_bindingFlags = bindingFlags;
  1841.             m_handle = handle;
  1842.             m_reflectedTypeCache = reflectedTypeCache;
  1843.             m_declaringType = declaringTypeHandle.GetRuntimeType();
  1844.             m_parameters = null;
  1845.             // Created lazily when GetParameters() is called.
  1846.             m_toString = null;
  1847.             m_methodAttributes = methodAttributes;
  1848.         }
  1849.         #endregion
  1850.        
  1851.         #region NonPublic Methods
  1852.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  1853.         internal override bool CacheEquals(object o)
  1854.         {
  1855.             RuntimeConstructorInfo m = o as RuntimeConstructorInfo;
  1856.            
  1857.             if (m == null)
  1858.                 return false;
  1859.            
  1860.             return m.m_handle.Equals(m_handle);
  1861.         }
  1862.        
  1863.         private Signature Signature {
  1864.             get {
  1865.                 if (m_signature == null)
  1866.                     m_signature = new Signature(m_handle, m_declaringType.GetTypeHandleInternal());
  1867.                
  1868.                 return m_signature;
  1869.             }
  1870.         }
  1871.        
  1872.         private RuntimeTypeHandle ReflectedTypeHandle {
  1873.             get { return m_reflectedTypeCache.RuntimeTypeHandle; }
  1874.         }
  1875.        
  1876.         private void CheckConsistency(object target)
  1877.         {
  1878.             if (target == null && IsStatic)
  1879.                 return;
  1880.            
  1881.             if (!m_declaringType.IsInstanceOfType(target)) {
  1882.                 if (target == null)
  1883.                     throw new TargetException(Environment.GetResourceString("RFLCT.Targ_StatMethReqTarg"));
  1884.                
  1885.                 throw new TargetException(Environment.GetResourceString("RFLCT.Targ_ITargMismatch"));
  1886.             }
  1887.         }
  1888.        
  1889.         internal BindingFlags BindingFlags {
  1890.             get { return m_bindingFlags; }
  1891.         }
  1892.        
  1893.         internal override RuntimeMethodHandle GetMethodHandle()
  1894.         {
  1895.             return m_handle;
  1896.         }
  1897.        
  1898.         internal override bool IsOverloaded {
  1899.             get { return m_reflectedTypeCache.GetConstructorList(MemberListType.CaseSensitive, Name).Count > 1; }
  1900.         }
  1901.        
  1902.         internal override uint GetOneTimeSpecificFlags()
  1903.         {
  1904.             uint invocationFlags = INVOCATION_FLAGS_IS_CTOR;
  1905.             // this is a given
  1906.             if ((DeclaringType != null && DeclaringType.IsAbstract) || (IsStatic))
  1907.                 invocationFlags |= INVOCATION_FLAGS_NO_CTOR_INVOKE;
  1908.             else if (DeclaringType == typeof(void))
  1909.                 invocationFlags |= INVOCATION_FLAGS_NO_INVOKE;
  1910.             else if (typeof(Delegate).IsAssignableFrom(DeclaringType))
  1911.                 // Check for attempt to create a delegate class, we demand unmanaged
  1912.                 // code permission for this since it's hard to validate the target address.
  1913.                 invocationFlags |= INVOCATION_FLAGS_IS_DELEGATE_CTOR;
  1914.            
  1915.             return invocationFlags;
  1916.         }
  1917.         #endregion
  1918.        
  1919.         #region Object Overrides
  1920.         public override string ToString()
  1921.         {
  1922.             if (m_toString == null)
  1923.                 m_toString = "Void " + RuntimeMethodInfo.ConstructName(this);
  1924.            
  1925.             return m_toString;
  1926.         }
  1927.         #endregion
  1928.        
  1929.         #region ICustomAttributeProvider
  1930.         public override object[] GetCustomAttributes(bool inherit)
  1931.         {
  1932.             return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType);
  1933.         }
  1934.        
  1935.         public override object[] GetCustomAttributes(Type attributeType, bool inherit)
  1936.         {
  1937.             if (attributeType == null)
  1938.                 throw new ArgumentNullException("attributeType");
  1939.            
  1940.             RuntimeType attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType;
  1941.            
  1942.             if (attributeRuntimeType == null)
  1943.                 throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"), "attributeType");
  1944.            
  1945.             return CustomAttribute.GetCustomAttributes(this, attributeRuntimeType);
  1946.         }
  1947.        
  1948.         public override bool IsDefined(Type attributeType, bool inherit)
  1949.         {
  1950.             if (attributeType == null)
  1951.                 throw new ArgumentNullException("attributeType");
  1952.            
  1953.             RuntimeType attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType;
  1954.            
  1955.             if (attributeRuntimeType == null)
  1956.                 throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"), "attributeType");
  1957.            
  1958.             return CustomAttribute.IsDefined(this, attributeRuntimeType);
  1959.         }
  1960.         #endregion
  1961.        
  1962.         #region MemberInfo Overrides
  1963.         public override string Name {
  1964.             get { return m_handle.GetName(); }
  1965.         }
  1966.         [System.Runtime.InteropServices.ComVisible(true)]
  1967.         public override MemberTypes MemberType {
  1968.             get { return MemberTypes.Constructor; }
  1969.         }
  1970.         public override Type DeclaringType {
  1971.             get { return m_reflectedTypeCache.IsGlobal ? null : m_declaringType; }
  1972.         }
  1973.         public override Type ReflectedType {
  1974.             get { return m_reflectedTypeCache.IsGlobal ? null : m_reflectedTypeCache.RuntimeType; }
  1975.         }
  1976.         public override int MetadataToken {
  1977.             get { return m_handle.GetMethodDef(); }
  1978.         }
  1979.         public override Module Module {
  1980.             get { return m_declaringType.GetTypeHandleInternal().GetModuleHandle().GetModule(); }
  1981.         }
  1982.         #endregion
  1983.        
  1984.         #region MethodBase Overrides
  1985.         internal override Type GetReturnType()
  1986.         {
  1987.             return Signature.ReturnTypeHandle.GetRuntimeType();
  1988.         }
  1989.        
  1990.         internal override ParameterInfo[] GetParametersNoCopy()
  1991.         {
  1992.             if (m_parameters == null)
  1993.                 m_parameters = ParameterInfo.GetParameters(this, this, Signature);
  1994.            
  1995.             return m_parameters;
  1996.         }
  1997.        
  1998.         public override ParameterInfo[] GetParameters()
  1999.         {
  2000.             ParameterInfo[] parameters = GetParametersNoCopy();
  2001.            
  2002.             if (parameters.Length == 0)
  2003.                 return parameters;
  2004.            
  2005.             ParameterInfo[] ret = new ParameterInfo[parameters.Length];
  2006.             Array.Copy(parameters, ret, parameters.Length);
  2007.             return ret;
  2008.         }
  2009.        
  2010.         public override MethodImplAttributes GetMethodImplementationFlags()
  2011.         {
  2012.             return m_handle.GetImplAttributes();
  2013.         }
  2014.        
  2015.         public override RuntimeMethodHandle MethodHandle {
  2016.             get {
  2017.                 Type declaringType = DeclaringType;
  2018.                 if ((declaringType == null && Module.Assembly.ReflectionOnly) || declaringType is ReflectionOnlyType)
  2019.                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotAllowedInReflectionOnly"));
  2020.                 return m_handle;
  2021.             }
  2022.         }
  2023.        
  2024.         public override MethodAttributes Attributes {
  2025.             get { return m_methodAttributes; }
  2026.         }
  2027.        
  2028.         public override CallingConventions CallingConvention {
  2029.             get { return Signature.CallingConvention; }
  2030.         }
  2031.        
  2032.         static internal void CheckCanCreateInstance(Type declaringType, bool isVarArg)
  2033.         {
  2034.             if (declaringType == null)
  2035.                 throw new ArgumentNullException("declaringType");
  2036.            
  2037.             // ctor is ReflectOnly
  2038.             if (declaringType is ReflectionOnlyType)
  2039.                 throw new InvalidOperationException(Environment.GetResourceString("Arg_ReflectionOnlyInvoke"));
  2040.             else if (declaringType.IsInterface)
  2041.                 throw new MemberAccessException(String.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Acc_CreateInterfaceEx"), declaringType));
  2042.             else if (declaringType.IsAbstract)
  2043.                 throw new MemberAccessException(String.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Acc_CreateAbstEx"), declaringType));
  2044.             else if (declaringType.GetRootElementType() == typeof(ArgIterator))
  2045.                 throw new NotSupportedException();
  2046.             else if (isVarArg)
  2047.                 throw new NotSupportedException();
  2048.             else if (declaringType.ContainsGenericParameters)
  2049.                 throw new MemberAccessException(String.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Acc_CreateGenericEx"), declaringType));
  2050.             else if (declaringType == typeof(void))
  2051.                
  2052.                 // ctor is declared on interface class
  2053.                
  2054.                 // ctor is on an abstract class
  2055.                
  2056.                 // ctor is on a class that contains stack pointers
  2057.                
  2058.                 // ctor is vararg
  2059.                
  2060.                 // ctor is generic or on a generic class
  2061.                
  2062.                 // ctor is declared on System.Void
  2063.                 throw new MemberAccessException(Environment.GetResourceString("Access_Void"));
  2064.         }
  2065.        
  2066.         internal void ThrowNoInvokeException()
  2067.         {
  2068.             CheckCanCreateInstance(DeclaringType, (CallingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs);
  2069.            
  2070.             // ctor is .cctor
  2071.             if ((Attributes & MethodAttributes.Static) == MethodAttributes.Static)
  2072.                 throw new MemberAccessException(Environment.GetResourceString("Acc_NotClassInit"));
  2073.            
  2074.             throw new TargetException();
  2075.         }
  2076.        
  2077.         [DebuggerStepThroughAttribute()]
  2078.         [Diagnostics.DebuggerHidden()]
  2079.         public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
  2080.         {
  2081.             // set one time info for invocation
  2082.             if (m_invocationFlags == INVOCATION_FLAGS_UNKNOWN)
  2083.                 m_invocationFlags = GetOneTimeFlags();
  2084.            
  2085.             if ((m_invocationFlags & INVOCATION_FLAGS_NO_INVOKE) != 0)
  2086.                 ThrowNoInvokeException();
  2087.            
  2088.             // check basic method consistency. This call will throw if there are problems in the target/method relationship
  2089.             CheckConsistency(obj);
  2090.            
  2091.             if (obj != null)
  2092.                 new SecurityPermission(SecurityPermissionFlag.SkipVerification).Demand();
  2093.            
  2094.             if ((m_invocationFlags & (INVOCATION_FLAGS_RISKY_METHOD | INVOCATION_FLAGS_NEED_SECURITY)) != 0) {
  2095.                 if ((m_invocationFlags & INVOCATION_FLAGS_RISKY_METHOD) != 0)
  2096.                     CodeAccessPermission.DemandInternal(PermissionType.ReflectionMemberAccess);
  2097.                 if ((m_invocationFlags & INVOCATION_FLAGS_NEED_SECURITY) != 0)
  2098.                     PerformSecurityCheck(obj, m_handle, m_declaringType.TypeHandle.Value, m_invocationFlags);
  2099.             }
  2100.            
  2101.             // get the signature
  2102.             int formalCount = Signature.Arguments.Length;
  2103.             int actualCount = (parameters != null) ? parameters.Length : 0;
  2104.             if (formalCount != actualCount)
  2105.                 throw new TargetParameterCountException(Environment.GetResourceString("Arg_ParmCnt"));
  2106.            
  2107.             // if we are here we passed all the previous checks. Time to look at the arguments
  2108.             if (actualCount > 0) {
  2109.                 object[] arguments = CheckArguments(parameters, binder, invokeAttr, culture, Signature);
  2110.                 object retValue = m_handle.InvokeMethodFast(obj, arguments, Signature, m_methodAttributes, (ReflectedType != null) ? ReflectedType.TypeHandle : RuntimeTypeHandle.EmptyHandle);
  2111.                 // copy out. This should be made only if ByRef are present.
  2112.                 for (int index = 0; index < actualCount; index++)
  2113.                     parameters[index] = arguments[index];
  2114.                 return retValue;
  2115.             }
  2116.             return m_handle.InvokeMethodFast(obj, null, Signature, m_methodAttributes, (DeclaringType != null) ? DeclaringType.TypeHandle : RuntimeTypeHandle.EmptyHandle);
  2117.         }
  2118.        
  2119.        
  2120.         [ReflectionPermissionAttribute(SecurityAction.Demand, Flags = ReflectionPermissionFlag.MemberAccess)]
  2121.         public override MethodBody GetMethodBody()
  2122.         {
  2123.             MethodBody mb = m_handle.GetMethodBody(ReflectedTypeHandle);
  2124.             if (mb != null)
  2125.                 mb.m_methodBase = this;
  2126.             return mb;
  2127.         }
  2128.         #endregion
  2129.        
  2130.         #region ConstructorInfo Overrides
  2131.         [DebuggerStepThroughAttribute()]
  2132.         [Diagnostics.DebuggerHidden()]
  2133.         public override object Invoke(BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
  2134.         {
  2135.             // get the declaring TypeHandle early for consistent exceptions in IntrospectionOnly context
  2136.             RuntimeTypeHandle declaringTypeHandle = m_declaringType.TypeHandle;
  2137.            
  2138.             // set one time info for invocation
  2139.             if (m_invocationFlags == INVOCATION_FLAGS_UNKNOWN)
  2140.                 m_invocationFlags = GetOneTimeFlags();
  2141.            
  2142.             if ((m_invocationFlags & (INVOCATION_FLAGS_NO_INVOKE | INVOCATION_FLAGS_CONTAINS_STACK_POINTERS | INVOCATION_FLAGS_NO_CTOR_INVOKE)) != 0)
  2143.                 ThrowNoInvokeException();
  2144.            
  2145.             if ((m_invocationFlags & (INVOCATION_FLAGS_RISKY_METHOD | INVOCATION_FLAGS_NEED_SECURITY | INVOCATION_FLAGS_IS_DELEGATE_CTOR)) != 0) {
  2146.                 if ((m_invocationFlags & INVOCATION_FLAGS_RISKY_METHOD) != 0)
  2147.                     CodeAccessPermission.DemandInternal(PermissionType.ReflectionMemberAccess);
  2148.                 if ((m_invocationFlags & INVOCATION_FLAGS_NEED_SECURITY) != 0)
  2149.                     PerformSecurityCheck(null, m_handle, m_declaringType.TypeHandle.Value, m_invocationFlags & INVOCATION_FLAGS_CONSTRUCTOR_INVOKE);
  2150.                 if ((m_invocationFlags & INVOCATION_FLAGS_IS_DELEGATE_CTOR) != 0)
  2151.                     new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
  2152.             }
  2153.            
  2154.             // get the signature
  2155.             int formalCount = Signature.Arguments.Length;
  2156.             int actualCount = (parameters != null) ? parameters.Length : 0;
  2157.             if (formalCount != actualCount)
  2158.                 throw new TargetParameterCountException(Environment.GetResourceString("Arg_ParmCnt"));
  2159.            
  2160.             // make sure the class ctor has been run
  2161.             RuntimeHelpers.RunClassConstructor(declaringTypeHandle);
  2162.            
  2163.             // if we are here we passed all the previous checks. Time to look at the arguments
  2164.             if (actualCount > 0) {
  2165.                 object[] arguments = CheckArguments(parameters, binder, invokeAttr, culture, Signature);
  2166.                 object retValue = m_handle.InvokeConstructor(arguments, Signature, declaringTypeHandle);
  2167.                 // copy out. This should be made only if ByRef are present.
  2168.                 for (int index = 0; index < actualCount; index++)
  2169.                     parameters[index] = arguments[index];
  2170.                 return retValue;
  2171.             }
  2172.             return m_handle.InvokeConstructor(null, Signature, declaringTypeHandle);
  2173.         }
  2174.         #endregion
  2175.        
  2176.         #region ISerializable Implementation
  2177.         public void GetObjectData(SerializationInfo info, StreamingContext context)
  2178.         {
  2179.             if (info == null)
  2180.                 throw new ArgumentNullException("info");
  2181.             MemberInfoSerializationHolder.GetSerializationInfo(info, Name, ReflectedTypeHandle.GetRuntimeType(), ToString(), MemberTypes.Constructor);
  2182.         }
  2183.        
  2184.         internal void SerializationInvoke(object target, SerializationInfo info, StreamingContext context)
  2185.         {
  2186.             MethodHandle.SerializationInvoke(target, Signature, info, context);
  2187.         }
  2188.         #endregion
  2189.     }
  2190.    
  2191.    
  2192.     [Serializable()]
  2193.     internal abstract class RuntimeFieldInfo : FieldInfo
  2194.     {
  2195.         #region Private Data Members
  2196.         private BindingFlags m_bindingFlags;
  2197.         protected RuntimeTypeCache m_reflectedTypeCache;
  2198.         protected RuntimeType m_declaringType;
  2199.         #endregion
  2200.        
  2201.         #region Constructor
  2202.         protected RuntimeFieldInfo()
  2203.         {
  2204.             // Used for dummy head node during population
  2205.         }
  2206.         protected RuntimeFieldInfo(RuntimeTypeCache reflectedTypeCache, RuntimeType declaringType, BindingFlags bindingFlags)
  2207.         {
  2208.             m_bindingFlags = bindingFlags;
  2209.             m_declaringType = declaringType;
  2210.             m_reflectedTypeCache = reflectedTypeCache;
  2211.         }
  2212.         #endregion
  2213.        
  2214.         #region NonPublic Members
  2215.         internal BindingFlags BindingFlags {
  2216.             get { return m_bindingFlags; }
  2217.         }
  2218.         private RuntimeTypeHandle ReflectedTypeHandle {
  2219.             get { return m_reflectedTypeCache.RuntimeTypeHandle; }
  2220.         }
  2221.         internal RuntimeTypeHandle DeclaringTypeHandle {
  2222.             get {
  2223.                 Type declaringType = DeclaringType;
  2224.                
  2225.                 if (declaringType == null)
  2226.                     return Module.GetModuleHandle().GetModuleTypeHandle();
  2227.                
  2228.                 return declaringType.GetTypeHandleInternal();
  2229.             }
  2230.         }
  2231.        
  2232.         internal virtual RuntimeFieldHandle GetFieldHandle()
  2233.         {
  2234.             return FieldHandle;
  2235.         }
  2236.        
  2237.         #endregion
  2238.        
  2239.         #region MemberInfo Overrides
  2240.         public override MemberTypes MemberType {
  2241.             get { return MemberTypes.Field; }
  2242.         }
  2243.         public override Type ReflectedType {
  2244.             get { return m_reflectedTypeCache.IsGlobal ? null : m_reflectedTypeCache.RuntimeType; }
  2245.         }
  2246.         public override Type DeclaringType {
  2247.             get { return m_reflectedTypeCache.IsGlobal ? null : m_declaringType; }
  2248.         }
  2249.         #endregion
  2250.        
  2251.         #region Object Overrides
  2252.         unsafe public override string ToString()
  2253.         {
  2254.             return FieldType.SigToString() + " " + Name;
  2255.         }
  2256.         #endregion
  2257.        
  2258.         #region ICustomAttributeProvider
  2259.         public override object[] GetCustomAttributes(bool inherit)
  2260.         {
  2261.             return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType);
  2262.         }
  2263.        
  2264.         public override object[] GetCustomAttributes(Type attributeType, bool inherit)
  2265.         {
  2266.             if (attributeType == null)
  2267.                 throw new ArgumentNullException("attributeType");
  2268.            
  2269.             RuntimeType attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType;
  2270.            
  2271.             if (attributeRuntimeType == null)
  2272.                 throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"), "attributeType");
  2273.            
  2274.             return CustomAttribute.GetCustomAttributes(this, attributeRuntimeType);
  2275.         }
  2276.        
  2277.         public override bool IsDefined(Type attributeType, bool inherit)
  2278.         {
  2279.             if (attributeType == null)
  2280.                 throw new ArgumentNullException("attributeType");
  2281.            
  2282.             RuntimeType attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType;
  2283.            
  2284.             if (attributeRuntimeType == null)
  2285.                 throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"), "attributeType");
  2286.            
  2287.             return CustomAttribute.IsDefined(this, attributeRuntimeType);
  2288.         }
  2289.         #endregion
  2290.        
  2291.         #region FieldInfo Overrides
  2292.         // All implemented on derived classes
  2293.         #endregion
  2294.        
  2295.         #region ISerializable Implementation
  2296.         public void GetObjectData(SerializationInfo info, StreamingContext context)
  2297.         {
  2298.             if (info == null)
  2299.                 throw new ArgumentNullException("info");
  2300.             MemberInfoSerializationHolder.GetSerializationInfo(info, this.Name, this.ReflectedType, this.ToString(), MemberTypes.Field);
  2301.         }
  2302.         #endregion
  2303.     }
  2304.    
  2305.    
  2306.     [Serializable()]
  2307.     unsafe internal sealed class RtFieldInfo : RuntimeFieldInfo, ISerializable
  2308.     {
  2309.         #region FCalls
  2310.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  2311.         private static extern void PerformVisibilityCheckOnField(IntPtr field, object target, IntPtr declaringType, FieldAttributes attr, uint invocationFlags);
  2312.         #endregion
  2313.        
  2314.         #region Private Data Members
  2315.         // agressive caching
  2316.         private RuntimeFieldHandle m_fieldHandle;
  2317.         private FieldAttributes m_fieldAttributes;
  2318.         // lazy caching
  2319.         private string m_name;
  2320.         private RuntimeType m_fieldType;
  2321.         private uint m_invocationFlags;
  2322.         #endregion
  2323.        
  2324.         #region Constructor
  2325.         internal RtFieldInfo()
  2326.         {
  2327.             // Used for dummy head node during population
  2328.         }
  2329.         internal RtFieldInfo(RuntimeFieldHandle handle, RuntimeType declaringType, RuntimeTypeCache reflectedTypeCache, BindingFlags bindingFlags) : base(reflectedTypeCache, declaringType, bindingFlags)
  2330.         {
  2331.             m_fieldHandle = handle;
  2332.             m_fieldAttributes = m_fieldHandle.GetAttributes();
  2333.         }
  2334.         #endregion
  2335.        
  2336.         #region Private Members
  2337.         private void GetOneTimeFlags()
  2338.         {
  2339.             Type declaringType = DeclaringType;
  2340.            
  2341.             // first take care of all the NO_INVOKE cases
  2342.             if (declaringType != null && declaringType.ContainsGenericParameters) {
  2343.                 m_invocationFlags |= INVOCATION_FLAGS_NO_INVOKE;
  2344.             }
  2345.             else if (Module.Assembly.GetType() == typeof(AssemblyBuilder)) {
  2346.                 AssemblyBuilder ab = Module.Assembly as AssemblyBuilder;
  2347.                 if (ab.m_assemblyData.m_access == AssemblyBuilderAccess.Save)
  2348.                     m_invocationFlags |= INVOCATION_FLAGS_NO_INVOKE;
  2349.             }
  2350.             if ((declaringType == null && Module.Assembly.ReflectionOnly) || declaringType is ReflectionOnlyType) {
  2351.                 m_invocationFlags |= INVOCATION_FLAGS_NO_INVOKE;
  2352.             }
  2353.            
  2354.            
  2355.             // this should be an usable field, determine the other flags
  2356.             else {
  2357.                 if ((m_fieldAttributes & FieldAttributes.InitOnly) != (FieldAttributes)0)
  2358.                     m_invocationFlags |= INVOCATION_FLAGS_SPECIAL_FIELD;
  2359.                
  2360.                 if ((m_fieldAttributes & FieldAttributes.HasFieldRVA) != (FieldAttributes)0)
  2361.                     m_invocationFlags |= INVOCATION_FLAGS_SPECIAL_FIELD;
  2362.                
  2363.                 if (((m_fieldAttributes & FieldAttributes.FieldAccessMask) != FieldAttributes.Public) || (declaringType != null && !declaringType.IsVisible))
  2364.                     m_invocationFlags |= INVOCATION_FLAGS_NEED_SECURITY;
  2365.                
  2366.                 // find out if the field type is one of the following: Primitive, Enum or Pointer
  2367.                 Type fieldType = FieldType;
  2368.                 if (fieldType.IsPointer || fieldType.IsEnum || fieldType.IsPrimitive)
  2369.                     m_invocationFlags |= INVOCATION_FLAGS_FIELD_SPECIAL_CAST;
  2370.             }
  2371.            
  2372.             // must be last to avoid threading problems
  2373.             m_invocationFlags |= INVOCATION_FLAGS_INITIALIZED;
  2374.         }
  2375.        
  2376.         private void CheckConsistency(object target)
  2377.         {
  2378.             // only test instance fields
  2379.             if ((m_fieldAttributes & FieldAttributes.Static) != FieldAttributes.Static) {
  2380.                 if (!m_declaringType.IsInstanceOfType(target)) {
  2381.                     if (target == null)
  2382.                         throw new TargetException(Environment.GetResourceString("RFLCT.Targ_StatFldReqTarg"));
  2383.                     else {
  2384.                         throw new ArgumentException(String.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Arg_FieldDeclTarget"), Name, m_declaringType, target.GetType()));
  2385.                     }
  2386.                 }
  2387.             }
  2388.         }
  2389.        
  2390.         #endregion
  2391.        
  2392.         #region Internal Members
  2393.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  2394.         internal override bool CacheEquals(object o)
  2395.         {
  2396.             RtFieldInfo m = o as RtFieldInfo;
  2397.            
  2398.             if (m == null)
  2399.                 return false;
  2400.            
  2401.             return m.m_fieldHandle.Equals(m_fieldHandle);
  2402.         }
  2403.        
  2404.         [DebuggerStepThroughAttribute()]
  2405.         [Diagnostics.DebuggerHidden()]
  2406.         internal void InternalSetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture, bool doVisibilityCheck)
  2407.         {
  2408.             InternalSetValue(obj, value, invokeAttr, binder, culture, doVisibilityCheck, true);
  2409.         }
  2410.        
  2411.         [DebuggerStepThroughAttribute()]
  2412.         [Diagnostics.DebuggerHidden()]
  2413.         internal void InternalSetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture, bool doVisibilityCheck, bool doCheckConsistency)
  2414.         {
  2415.             RuntimeType declaringType = DeclaringType as RuntimeType;
  2416.            
  2417.             if ((m_invocationFlags & INVOCATION_FLAGS_INITIALIZED) == 0)
  2418.                 GetOneTimeFlags();
  2419.            
  2420.             if ((m_invocationFlags & INVOCATION_FLAGS_NO_INVOKE) != 0) {
  2421.                 if (declaringType != null && declaringType.ContainsGenericParameters)
  2422.                     throw new InvalidOperationException(Environment.GetResourceString("Arg_UnboundGenField"));
  2423.                
  2424.                 if ((declaringType == null && Module.Assembly.ReflectionOnly) || declaringType is ReflectionOnlyType)
  2425.                     throw new InvalidOperationException(Environment.GetResourceString("Arg_ReflectionOnlyField"));
  2426.                
  2427.                 throw new FieldAccessException();
  2428.             }
  2429.            
  2430.             if (doCheckConsistency)
  2431.                 CheckConsistency(obj);
  2432.            
  2433.             value = ((RuntimeType)FieldType).CheckValue(value, binder, culture, invokeAttr);
  2434.            
  2435.             if (doVisibilityCheck && (m_invocationFlags & (INVOCATION_FLAGS_SPECIAL_FIELD | INVOCATION_FLAGS_NEED_SECURITY)) != 0)
  2436.                 PerformVisibilityCheckOnField(m_fieldHandle.Value, obj, m_declaringType.TypeHandle.Value, m_fieldAttributes, m_invocationFlags);
  2437.            
  2438.             bool domainInitialized = false;
  2439.             if (declaringType == null) {
  2440.                 m_fieldHandle.SetValue(obj, value, FieldType.TypeHandle, m_fieldAttributes, RuntimeTypeHandle.EmptyHandle, ref domainInitialized);
  2441.             }
  2442.             else {
  2443.                 domainInitialized = declaringType.DomainInitialized;
  2444.                 m_fieldHandle.SetValue(obj, value, FieldType.TypeHandle, m_fieldAttributes, DeclaringType.TypeHandle, ref domainInitialized);
  2445.                 declaringType.DomainInitialized = domainInitialized;
  2446.             }
  2447.            
  2448.         }
  2449.        
  2450.         [DebuggerStepThroughAttribute()]
  2451.         [Diagnostics.DebuggerHidden()]
  2452.         internal object InternalGetValue(object obj, bool doVisibilityCheck)
  2453.         {
  2454.             return InternalGetValue(obj, doVisibilityCheck, true);
  2455.         }
  2456.        
  2457.         [DebuggerStepThroughAttribute()]
  2458.         [Diagnostics.DebuggerHidden()]
  2459.         internal object InternalGetValue(object obj, bool doVisibilityCheck, bool doCheckConsistency)
  2460.         {
  2461.             RuntimeType declaringType = DeclaringType as RuntimeType;
  2462.            
  2463.             if ((m_invocationFlags & INVOCATION_FLAGS_INITIALIZED) == 0)
  2464.                 GetOneTimeFlags();
  2465.            
  2466.             if ((m_invocationFlags & INVOCATION_FLAGS_NO_INVOKE) != 0) {
  2467.                 if (declaringType != null && DeclaringType.ContainsGenericParameters)
  2468.                     throw new InvalidOperationException(Environment.GetResourceString("Arg_UnboundGenField"));
  2469.                
  2470.                 if ((declaringType == null && Module.Assembly.ReflectionOnly) || declaringType is ReflectionOnlyType)
  2471.                     throw new InvalidOperationException(Environment.GetResourceString("Arg_ReflectionOnlyField"));
  2472.                
  2473.                 throw new FieldAccessException();
  2474.             }
  2475.            
  2476.             if (doCheckConsistency)
  2477.                 CheckConsistency(obj);
  2478.            
  2479.             RuntimeTypeHandle fieldType = FieldType.TypeHandle;
  2480.             if (doVisibilityCheck && (m_invocationFlags & INVOCATION_FLAGS_NEED_SECURITY) != 0)
  2481.                 PerformVisibilityCheckOnField(m_fieldHandle.Value, obj, m_declaringType.TypeHandle.Value, m_fieldAttributes, m_invocationFlags & ~INVOCATION_FLAGS_SPECIAL_FIELD);
  2482.            
  2483.             bool domainInitialized = false;
  2484.             if (declaringType == null) {
  2485.                 return m_fieldHandle.GetValue(obj, fieldType, RuntimeTypeHandle.EmptyHandle, ref domainInitialized);
  2486.             }
  2487.             else {
  2488.                 domainInitialized = declaringType.DomainInitialized;
  2489.                 object retVal = m_fieldHandle.GetValue(obj, fieldType, DeclaringType.TypeHandle, ref domainInitialized);
  2490.                 declaringType.DomainInitialized = domainInitialized;
  2491.                 return retVal;
  2492.             }
  2493.         }
  2494.        
  2495.         #endregion
  2496.        
  2497.         #region MemberInfo Overrides
  2498.         public override string Name {
  2499.             get {
  2500.                 if (m_name == null)
  2501.                     m_name = m_fieldHandle.GetName();
  2502.                
  2503.                 return m_name;
  2504.             }
  2505.         }
  2506.        
  2507.         public override int MetadataToken {
  2508.             get { return m_fieldHandle.GetToken(); }
  2509.         }
  2510.         public override Module Module {
  2511.             get { return m_fieldHandle.GetApproxDeclaringType().GetModuleHandle().GetModule(); }
  2512.         }
  2513.         #endregion
  2514.        
  2515.         #region FieldInfo Overrides
  2516.         public override object GetValue(object obj)
  2517.         {
  2518.             return InternalGetValue(obj, true);
  2519.         }
  2520.        
  2521.         public override object GetRawConstantValue()
  2522.         {
  2523.             throw new InvalidOperationException();
  2524.         }
  2525.        
  2526.         [DebuggerStepThroughAttribute()]
  2527.         [Diagnostics.DebuggerHidden()]
  2528.         public override object GetValueDirect(TypedReference obj)
  2529.         {
  2530.             if (obj.IsNull)
  2531.                 throw new ArgumentException(Environment.GetResourceString("Arg_TypedReference_Null"));
  2532.            
  2533.             return m_fieldHandle.GetValueDirect(FieldType.TypeHandle, obj, (DeclaringType == null) ? RuntimeTypeHandle.EmptyHandle : DeclaringType.TypeHandle);
  2534.         }
  2535.        
  2536.         [DebuggerStepThroughAttribute()]
  2537.         [Diagnostics.DebuggerHidden()]
  2538.         public override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
  2539.         {
  2540.             InternalSetValue(obj, value, invokeAttr, binder, culture, true);
  2541.         }
  2542.        
  2543.         [DebuggerStepThroughAttribute()]
  2544.         [Diagnostics.DebuggerHidden()]
  2545.         public override void SetValueDirect(TypedReference obj, object value)
  2546.         {
  2547.             if (obj.IsNull)
  2548.                 throw new ArgumentException(Environment.GetResourceString("Arg_TypedReference_Null"));
  2549.            
  2550.             m_fieldHandle.SetValueDirect(FieldType.TypeHandle, obj, value, (DeclaringType == null) ? RuntimeTypeHandle.EmptyHandle : DeclaringType.TypeHandle);
  2551.         }
  2552.        
  2553.         public override RuntimeFieldHandle FieldHandle {
  2554.             get {
  2555.                 Type declaringType = DeclaringType;
  2556.                 if ((declaringType == null && Module.Assembly.ReflectionOnly) || declaringType is ReflectionOnlyType)
  2557.                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotAllowedInReflectionOnly"));
  2558.                 return m_fieldHandle;
  2559.             }
  2560.         }
  2561.        
  2562.         internal override RuntimeFieldHandle GetFieldHandle()
  2563.         {
  2564.             return m_fieldHandle;
  2565.         }
  2566.        
  2567.         public override FieldAttributes Attributes {
  2568.             get { return m_fieldAttributes; }
  2569.         }
  2570.        
  2571.         public override Type FieldType {
  2572.             get {
  2573.                 if (m_fieldType == null)
  2574.                     m_fieldType = new Signature(m_fieldHandle, DeclaringTypeHandle).FieldTypeHandle.GetRuntimeType();
  2575.                
  2576.                 return m_fieldType;
  2577.             }
  2578.         }
  2579.        
  2580.         public override Type[] GetRequiredCustomModifiers()
  2581.         {
  2582.             return new Signature(m_fieldHandle, DeclaringTypeHandle).GetCustomModifiers(1, true);
  2583.         }
  2584.        
  2585.         public override Type[] GetOptionalCustomModifiers()
  2586.         {
  2587.             return new Signature(m_fieldHandle, DeclaringTypeHandle).GetCustomModifiers(1, false);
  2588.         }
  2589.        
  2590.         #endregion
  2591.     }
  2592.    
  2593.    
  2594.     [Serializable()]
  2595.     unsafe internal sealed class MdFieldInfo : RuntimeFieldInfo, ISerializable
  2596.     {
  2597.         #region Private Data Members
  2598.         private int m_tkField;
  2599.         private string m_name;
  2600.         private Type m_fieldType;
  2601.         private FieldAttributes m_fieldAttributes;
  2602.         #endregion
  2603.        
  2604.         #region Constructor
  2605.         internal MdFieldInfo(int tkField, FieldAttributes fieldAttributes, RuntimeTypeHandle declaringTypeHandle, RuntimeTypeCache reflectedTypeCache, BindingFlags bindingFlags) : base(reflectedTypeCache, declaringTypeHandle.GetRuntimeType(), bindingFlags)
  2606.         {
  2607.             m_tkField = tkField;
  2608.             m_name = null;
  2609.             m_fieldAttributes = fieldAttributes;
  2610.         }
  2611.         #endregion
  2612.        
  2613.         #region Internal Members
  2614.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  2615.         internal override bool CacheEquals(object o)
  2616.         {
  2617.             MdFieldInfo m = o as MdFieldInfo;
  2618.            
  2619.             if (m == null)
  2620.                 return false;
  2621.            
  2622.             return m.m_tkField == m_tkField && m_declaringType.GetTypeHandleInternal().GetModuleHandle().Equals(m.m_declaringType.GetTypeHandleInternal().GetModuleHandle());
  2623.         }
  2624.         #endregion
  2625.        
  2626.         #region MemberInfo Overrides
  2627.         public override string Name {
  2628.             get {
  2629.                 if (m_name == null)
  2630.                     m_name = Module.MetadataImport.GetName(m_tkField).ToString();
  2631.                
  2632.                 return m_name;
  2633.             }
  2634.         }
  2635.        
  2636.         public override int MetadataToken {
  2637.             get { return m_tkField; }
  2638.         }
  2639.         public override Module Module {
  2640.             get { return m_declaringType.Module; }
  2641.         }
  2642.         #endregion
  2643.        
  2644.         #region FieldInfo Overrides
  2645.         public override RuntimeFieldHandle FieldHandle {
  2646.             get {
  2647.                 throw new NotSupportedException();
  2648.             }
  2649.         }
  2650.         public override FieldAttributes Attributes {
  2651.             get { return m_fieldAttributes; }
  2652.         }
  2653.        
  2654.         [DebuggerStepThroughAttribute()]
  2655.         [Diagnostics.DebuggerHidden()]
  2656.         public override object GetValueDirect(TypedReference obj)
  2657.         {
  2658.             return GetValue(null);
  2659.         }
  2660.        
  2661.         [DebuggerStepThroughAttribute()]
  2662.         [Diagnostics.DebuggerHidden()]
  2663.         public override void SetValueDirect(TypedReference obj, object value)
  2664.         {
  2665.             throw new FieldAccessException(Environment.GetResourceString("Acc_ReadOnly"));
  2666.         }
  2667.        
  2668.         [DebuggerStepThroughAttribute()]
  2669.         [Diagnostics.DebuggerHidden()]
  2670.         unsafe public override object GetValue(object obj)
  2671.         {
  2672.             return GetValue(false);
  2673.         }
  2674.        
  2675.         unsafe public override object GetRawConstantValue()
  2676.         {
  2677.             return GetValue(true);
  2678.         }
  2679.        
  2680.         unsafe internal object GetValue(bool raw)
  2681.         {
  2682.             // Cannot cache these because they could be user defined non-agile enumerations
  2683.            
  2684.             object value = MdConstant.GetValue(Module.MetadataImport, m_tkField, FieldType.GetTypeHandleInternal(), raw);
  2685.            
  2686.             if (value == DBNull.Value)
  2687.                 throw new NotSupportedException(Environment.GetResourceString("Arg_EnumLitValueNotFound"));
  2688.            
  2689.             return value;
  2690.         }
  2691.        
  2692.         [DebuggerStepThroughAttribute()]
  2693.         [Diagnostics.DebuggerHidden()]
  2694.         public override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
  2695.         {
  2696.             throw new FieldAccessException(Environment.GetResourceString("Acc_ReadOnly"));
  2697.         }
  2698.        
  2699.         public override Type FieldType {
  2700.             get {
  2701.                 if (m_fieldType == null) {
  2702.                     ConstArray fieldMarshal = Module.MetadataImport.GetSigOfFieldDef(m_tkField);
  2703.                    
  2704.                     m_fieldType = new Signature(fieldMarshal.Signature.ToPointer(), (int)fieldMarshal.Length, m_declaringType.GetTypeHandleInternal()).FieldTypeHandle.GetRuntimeType();
  2705.                 }
  2706.                
  2707.                 return m_fieldType;
  2708.             }
  2709.         }
  2710.        
  2711.         public override Type[] GetRequiredCustomModifiers()
  2712.         {
  2713.             return new Type[0];
  2714.         }
  2715.        
  2716.         public override Type[] GetOptionalCustomModifiers()
  2717.         {
  2718.             return new Type[0];
  2719.         }
  2720.        
  2721.         #endregion
  2722.     }
  2723.    
  2724.    
  2725.     static internal class MdConstant
  2726.     {
  2727.         unsafe public static object GetValue(MetadataImport scope, int token, RuntimeTypeHandle fieldTypeHandle, bool raw)
  2728.         {
  2729.             CorElementType corElementType = 0;
  2730.             long buffer = 0;
  2731.             int length;
  2732.            
  2733.             scope.GetDefaultValue(token, out buffer, out length, out corElementType);
  2734.            
  2735.             Type fieldType = Type.GetTypeFromHandle(fieldTypeHandle);
  2736.            
  2737.             if (fieldType.IsEnum && raw == false) {
  2738.                 long defaultValue = 0;
  2739.                
  2740.                 switch (corElementType) {
  2741.                     case CorElementType.Void:
  2742.                         #region Switch
  2743.                         return DBNull.Value;
  2744.                     case CorElementType.Char:
  2745.                        
  2746.                         defaultValue = *(char*)&buffer;
  2747.                         break;
  2748.                     case CorElementType.I1:
  2749.                        
  2750.                         defaultValue = *(sbyte*)&buffer;
  2751.                         break;
  2752.                     case CorElementType.U1:
  2753.                        
  2754.                         defaultValue = *(byte*)&buffer;
  2755.                         break;
  2756.                     case CorElementType.I2:
  2757.                        
  2758.                         defaultValue = *(short*)&buffer;
  2759.                         break;
  2760.                     case CorElementType.U2:
  2761.                        
  2762.                         defaultValue = *(ushort*)&buffer;
  2763.                         break;
  2764.                     case CorElementType.I4:
  2765.                        
  2766.                         defaultValue = *(int*)&buffer;
  2767.                         break;
  2768.                     case CorElementType.U4:
  2769.                        
  2770.                         defaultValue = *(uint*)&buffer;
  2771.                         break;
  2772.                     case CorElementType.I8:
  2773.                        
  2774.                         defaultValue = buffer;
  2775.                         break;
  2776.                     case CorElementType.U8:
  2777.                        
  2778.                         defaultValue = buffer;
  2779.                         break;
  2780.                     default:
  2781.                        
  2782.                         throw new FormatException(Environment.GetResourceString("Arg_BadLiteralFormat"));
  2783.                         break;
  2784.                     #endregion
  2785.                 }
  2786.                
  2787.                 return RuntimeType.CreateEnum(fieldTypeHandle, defaultValue);
  2788.             }
  2789.             else if (fieldType == typeof(DateTime)) {
  2790.                 long defaultValue = 0;
  2791.                
  2792.                 switch (corElementType) {
  2793.                     case CorElementType.Void:
  2794.                         #region Switch
  2795.                         return DBNull.Value;
  2796.                     case CorElementType.I8:
  2797.                        
  2798.                         defaultValue = buffer;
  2799.                         break;
  2800.                     case CorElementType.U8:
  2801.                        
  2802.                         defaultValue = buffer;
  2803.                         break;
  2804.                     default:
  2805.                        
  2806.                         throw new FormatException(Environment.GetResourceString("Arg_BadLiteralFormat"));
  2807.                         break;
  2808.                     #endregion
  2809.                 }
  2810.                
  2811.                 return new DateTime(defaultValue);
  2812.             }
  2813.             else {
  2814.                 switch (corElementType) {
  2815.                     case CorElementType.Void:
  2816.                         #region Switch
  2817.                         return DBNull.Value;
  2818.                     case CorElementType.Char:
  2819.                        
  2820.                         return *(char*)&buffer;
  2821.                     case CorElementType.I1:
  2822.                        
  2823.                         return *(sbyte*)&buffer;
  2824.                     case CorElementType.U1:
  2825.                        
  2826.                         return *(byte*)&buffer;
  2827.                     case CorElementType.I2:
  2828.                        
  2829.                         return *(short*)&buffer;
  2830.                     case CorElementType.U2:
  2831.                        
  2832.                         return *(ushort*)&buffer;
  2833.                     case CorElementType.I4:
  2834.                        
  2835.                         return *(int*)&buffer;
  2836.                     case CorElementType.U4:
  2837.                        
  2838.                         return *(uint*)&buffer;
  2839.                     case CorElementType.I8:
  2840.                        
  2841.                         return buffer;
  2842.                     case CorElementType.U8:
  2843.                        
  2844.                         return (ulong)buffer;
  2845.                     case CorElementType.Boolean:
  2846.                        
  2847.                         return (*(byte*)&buffer != 0);
  2848.                     case CorElementType.R4:
  2849.                        
  2850.                         return *(float*)&buffer;
  2851.                     case CorElementType.R8:
  2852.                        
  2853.                         return *(double*)&buffer;
  2854.                     case CorElementType.String:
  2855.                        
  2856.                         return new string((char*)buffer, 0, length / 2);
  2857.                     case CorElementType.Class:
  2858.                        
  2859.                         return null;
  2860.                     default:
  2861.                        
  2862.                         throw new FormatException(Environment.GetResourceString("Arg_BadLiteralFormat"));
  2863.                         break;
  2864.                     #endregion
  2865.                 }
  2866.             }
  2867.         }
  2868.     }
  2869.    
  2870.    
  2871.     static internal class Associates
  2872.     {
  2873.         [Flags()]
  2874.         internal enum Attributes
  2875.         {
  2876.             ComposedOfAllVirtualMethods = 1,
  2877.             ComposedOfAllPrivateMethods = 2,
  2878.             ComposedOfNoPublicMembers = 4,
  2879.             ComposedOfNoStaticMembers = 8
  2880.         }
  2881.        
  2882.         static internal bool IncludeAccessor(MethodInfo associate, bool nonPublic)
  2883.         {
  2884.             if (associate == null)
  2885.                 return false;
  2886.            
  2887.             if (nonPublic)
  2888.                 return true;
  2889.            
  2890.             if (associate.IsPublic)
  2891.                 return true;
  2892.            
  2893.             return false;
  2894.         }
  2895.        
  2896.         unsafe static internal RuntimeMethodInfo AssignAssociates(int tkMethod, RuntimeTypeHandle declaredTypeHandle, RuntimeTypeHandle reflectedTypeHandle)
  2897.         {
  2898.             if (MetadataToken.IsNullToken(tkMethod))
  2899.                 return null;
  2900.            
  2901.             ASSERT.PRECONDITION(!declaredTypeHandle.IsNullHandle());
  2902.             ASSERT.PRECONDITION(!reflectedTypeHandle.IsNullHandle());
  2903.            
  2904.             bool isInherited = !declaredTypeHandle.Equals(reflectedTypeHandle);
  2905.            
  2906.             RuntimeMethodHandle associateMethodHandle = declaredTypeHandle.GetModuleHandle().ResolveMethodHandle(tkMethod, declaredTypeHandle.GetInstantiation(), new RuntimeTypeHandle[0]);
  2907.             //RuntimeMethodHandle associateMethodHandle = declaredTypeHandle.GetMethodFromToken(tkMethod);
  2908.             ASSERT.CONSISTENCY_CHECK(!associateMethodHandle.IsNullHandle(), "Failed to resolve associateRecord methodDef token");
  2909.            
  2910.             MethodAttributes methAttr = associateMethodHandle.GetAttributes();
  2911.             bool isPrivate = (methAttr & MethodAttributes.MemberAccessMask) == MethodAttributes.Private;
  2912.             bool isVirtual = (methAttr & MethodAttributes.Virtual) != 0;
  2913.            
  2914.             if (isInherited) {
  2915.                 // ECMA MethodSemantics: "All methods for a given Property or Event shall have the same accessibility
  2916.                 //(ie the MemberAccessMask subfield of their Flags row) and cannot be CompilerControlled [CLS]"
  2917.                 // Consequently, a property may be composed of public and private methods. If the declared type !=
  2918.                 // the reflected type, the private methods should not be exposed. Note that this implies that the
  2919.                 // identity of a property includes it's reflected type.
  2920.                 if (isPrivate)
  2921.                     return null;
  2922.                
  2923.                 // Note this is the first time the property was encountered walking from the most derived class
  2924.                 // towards the base class. It would seem to follow that any associated methods would not
  2925.                 // be overriden -- but this is not necessarily true. A more derived class may have overriden a
  2926.                 // virtual method associated with a property in a base class without associating the override with
  2927.                 // the same or any property in the derived class.
  2928.                 if (isVirtual) {
  2929.                     bool declaringTypeIsClass = (declaredTypeHandle.GetAttributes() & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Class;
  2930.                    
  2931.                     ASSERT.CONSISTENCY_CHECK(LOGIC.BIJECTION(declaringTypeIsClass, (reflectedTypeHandle.GetAttributes() & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Class));
  2932.                    
  2933.                     // It makes no sense to search for a virtual override of a method declared on an interface.
  2934.                     if (declaringTypeIsClass) {
  2935.                         int slot = associateMethodHandle.GetSlot();
  2936.                        
  2937.                         // Find the override visible from the reflected type
  2938.                         associateMethodHandle = reflectedTypeHandle.GetMethodAt(slot);
  2939.                     }
  2940.                 }
  2941.             }
  2942.            
  2943.             MethodAttributes visibility = methAttr & MethodAttributes.MemberAccessMask;
  2944.             bool isPublic = visibility == MethodAttributes.Public;
  2945.             bool isNonProtectedInternal = visibility == MethodAttributes.Assembly;
  2946.             bool isStatic = (methAttr & MethodAttributes.Static) != 0;
  2947.            
  2948.             RuntimeMethodInfo associateMethod = RuntimeType.GetMethodBase(reflectedTypeHandle, associateMethodHandle) as RuntimeMethodInfo;
  2949.            
  2950.             // suppose a property was mapped to a method not in the derivation hierarchy of the reflectedTypeHandle
  2951.             if (associateMethod == null)
  2952.                 associateMethod = reflectedTypeHandle.GetRuntimeType().Module.ResolveMethod(tkMethod, null, null) as RuntimeMethodInfo;
  2953.            
  2954.             return associateMethod;
  2955.         }
  2956.        
  2957.         unsafe static internal void AssignAssociates(AssociateRecord* associates, int cAssociates, RuntimeTypeHandle declaringTypeHandle, RuntimeTypeHandle reflectedTypeHandle, out RuntimeMethodInfo addOn, out RuntimeMethodInfo removeOn, out RuntimeMethodInfo fireOn, out RuntimeMethodInfo getter, out RuntimeMethodInfo setter, out MethodInfo[] other,
  2958.         out bool composedOfAllPrivateMethods, out BindingFlags bindingFlags)
  2959.         {
  2960.             addOn = removeOn = fireOn = getter = setter = null;
  2961.             other = null;
  2962.            
  2963.             Attributes attributes = Attributes.ComposedOfAllPrivateMethods | Attributes.ComposedOfAllVirtualMethods | Attributes.ComposedOfNoPublicMembers | Attributes.ComposedOfNoStaticMembers;
  2964.            
  2965.             while (reflectedTypeHandle.IsGenericVariable())
  2966.                 reflectedTypeHandle = reflectedTypeHandle.GetRuntimeType().BaseType.GetTypeHandleInternal();
  2967.            
  2968.             bool isInherited = !declaringTypeHandle.Equals(reflectedTypeHandle);
  2969.            
  2970.             ArrayList otherList = new ArrayList();
  2971.            
  2972.             for (int i = 0; i < cAssociates; i++) {
  2973.                 #region Assign each associate
  2974.                 RuntimeMethodInfo associateMethod = AssignAssociates(associates[i].MethodDefToken, declaringTypeHandle, reflectedTypeHandle);
  2975.                
  2976.                 if (associateMethod == null)
  2977.                     continue;
  2978.                
  2979.                 MethodAttributes methAttr = associateMethod.Attributes;
  2980.                 bool isPrivate = (methAttr & MethodAttributes.MemberAccessMask) == MethodAttributes.Private;
  2981.                 bool isVirtual = (methAttr & MethodAttributes.Virtual) != 0;
  2982.                
  2983.                 MethodAttributes visibility = methAttr & MethodAttributes.MemberAccessMask;
  2984.                 bool isPublic = visibility == MethodAttributes.Public;
  2985.                 bool isNonProtectedInternal = visibility == MethodAttributes.Assembly;
  2986.                 bool isStatic = (methAttr & MethodAttributes.Static) != 0;
  2987.                
  2988.                 if (isPublic) {
  2989.                     attributes &= ~Attributes.ComposedOfNoPublicMembers;
  2990.                     attributes &= ~Attributes.ComposedOfAllPrivateMethods;
  2991.                 }
  2992.                 else if (!isPrivate) {
  2993.                     attributes &= ~Attributes.ComposedOfAllPrivateMethods;
  2994.                 }
  2995.                
  2996.                 if (isStatic)
  2997.                     attributes &= ~Attributes.ComposedOfNoStaticMembers;
  2998.                
  2999.                 if (!isVirtual)
  3000.                     attributes &= ~Attributes.ComposedOfAllVirtualMethods;
  3001.                 #endregion
  3002.                
  3003.                 if (associates[i].Semantics == MethodSemanticsAttributes.Setter)
  3004.                     setter = associateMethod;
  3005.                 else if (associates[i].Semantics == MethodSemanticsAttributes.Getter)
  3006.                     getter = associateMethod;
  3007.                 else if (associates[i].Semantics == MethodSemanticsAttributes.Fire)
  3008.                     fireOn = associateMethod;
  3009.                 else if (associates[i].Semantics == MethodSemanticsAttributes.AddOn)
  3010.                     addOn = associateMethod;
  3011.                 else if (associates[i].Semantics == MethodSemanticsAttributes.RemoveOn)
  3012.                     removeOn = associateMethod;
  3013.                 else
  3014.                     otherList.Add(associateMethod);
  3015.             }
  3016.            
  3017.             bool isPseudoPublic = (attributes & Attributes.ComposedOfNoPublicMembers) == 0;
  3018.             bool isPseudoStatic = (attributes & Attributes.ComposedOfNoStaticMembers) == 0;
  3019.             bindingFlags = RuntimeType.FilterPreCalculate(isPseudoPublic, isInherited, isPseudoStatic);
  3020.            
  3021.             composedOfAllPrivateMethods = (attributes & Attributes.ComposedOfAllPrivateMethods) != 0;
  3022.            
  3023.             other = (MethodInfo[])otherList.ToArray(typeof(MethodInfo));
  3024.         }
  3025.     }
  3026.    
  3027.    
  3028.     [Serializable()]
  3029.     unsafe internal sealed class RuntimePropertyInfo : PropertyInfo, ISerializable
  3030.     {
  3031.         #region Private Data Members
  3032.         private int m_token;
  3033.         private string m_name;
  3034.         private void* m_utf8name;
  3035.         private PropertyAttributes m_flags;
  3036.         private RuntimeTypeCache m_reflectedTypeCache;
  3037.         private RuntimeMethodInfo m_getterMethod;
  3038.         private RuntimeMethodInfo m_setterMethod;
  3039.         private MethodInfo[] m_otherMethod;
  3040.         private RuntimeType m_declaringType;
  3041.         private BindingFlags m_bindingFlags;
  3042.         private Signature m_signature;
  3043.         #endregion
  3044.        
  3045.         #region Constructor
  3046.         internal RuntimePropertyInfo(int tkProperty, RuntimeType declaredType, RuntimeTypeCache reflectedTypeCache, out bool isPrivate)
  3047.         {
  3048.             ASSERT.PRECONDITION(declaredType != null);
  3049.             ASSERT.PRECONDITION(reflectedTypeCache != null);
  3050.             ASSERT.PRECONDITION(!reflectedTypeCache.IsGlobal);
  3051.            
  3052.             MetadataImport scope = declaredType.Module.MetadataImport;
  3053.            
  3054.             m_token = tkProperty;
  3055.             m_reflectedTypeCache = reflectedTypeCache;
  3056.             m_declaringType = declaredType;
  3057.            
  3058.             RuntimeTypeHandle declaredTypeHandle = declaredType.GetTypeHandleInternal();
  3059.             RuntimeTypeHandle reflectedTypeHandle = reflectedTypeCache.RuntimeTypeHandle;
  3060.             RuntimeMethodInfo dummy;
  3061.            
  3062.             scope.GetPropertyProps(tkProperty, out m_utf8name, out m_flags, out MetadataArgs.Skip.ConstArray);
  3063.             int cAssociateRecord = scope.GetAssociatesCount(tkProperty);
  3064.             AssociateRecord* associateRecord = stackalloc AssociateRecord[cAssociateRecord];
  3065.             scope.GetAssociates(tkProperty, associateRecord, cAssociateRecord);
  3066.             Associates.AssignAssociates(associateRecord, cAssociateRecord, declaredTypeHandle, reflectedTypeHandle, out dummy, out dummy, out dummy, out m_getterMethod, out m_setterMethod, out m_otherMethod,
  3067.             out isPrivate, out m_bindingFlags);
  3068.         }
  3069.         #endregion
  3070.        
  3071.         #region Internal Members
  3072.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  3073.         internal override bool CacheEquals(object o)
  3074.         {
  3075.             RuntimePropertyInfo m = o as RuntimePropertyInfo;
  3076.            
  3077.             if (m == null)
  3078.                 return false;
  3079.            
  3080.             return m.m_token == m_token && m_declaringType.GetTypeHandleInternal().GetModuleHandle().Equals(m.m_declaringType.GetTypeHandleInternal().GetModuleHandle());
  3081.         }
  3082.        
  3083.         internal Signature Signature {
  3084.             get {
  3085.                 if (m_signature == null) {
  3086.                     ConstArray sig;
  3087.                 }
  3088.             }
  3089.         }
  3090.        
  3091.         void* name;
  3092.     }
  3093. }

Developer Fusion