The Labs \ Source Viewer \ SSCLI \ System \ RuntimeType

  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.Collections.Generic;
  24. using System.Runtime.Serialization;
  25. using System.Runtime.CompilerServices;
  26. using System.Security;
  27. using System.Text;
  28. using System.Reflection.Emit;
  29. using System.Runtime.Remoting;
  30. using System.Runtime.Remoting.Proxies;
  31. using System.Runtime.Remoting.Messaging;
  32. using System.Runtime.Remoting.Activation;
  33. using MdSigCallingConvention = System.Signature.MdSigCallingConvention;
  34. using RuntimeTypeCache = System.RuntimeType.RuntimeTypeCache;
  35. using System.Runtime.InteropServices;
  36. using StackCrawlMark = System.Threading.StackCrawlMark;
  37. using DebuggerStepThroughAttribute = System.Diagnostics.DebuggerStepThroughAttribute;
  38. using MdToken = System.Reflection.MetadataToken;
  39. namespace System
  40. {
  41.     // this is a work around to get the concept of a calli. It's not as fast but it would be interesting to
  42.     // see how it compares to the current implementation.
  43.     // This delegate will disappear at some point in favor of calli
  44.    
  45.     internal delegate void CtorDelegate(object instance);
  46.    
  47.     [Serializable()]
  48.     internal class RuntimeType : Type, ISerializable, ICloneable
  49.     {
  50.         #region Definitions
  51.        
  52.         [Serializable()]
  53.         internal class RuntimeTypeCache
  54.         {
  55.             #region Definitions
  56.             internal enum WhatsCached
  57.             {
  58.                 Nothing = 0,
  59.                 EnclosingType = 1
  60.             }
  61.            
  62.             internal enum CacheType
  63.             {
  64.                 Method,
  65.                 Constructor,
  66.                 Field,
  67.                 Property,
  68.                 Event,
  69.                 Interface,
  70.                 NestedType
  71.             }
  72.            
  73.             // This method is purely an aid for NGen to statically deduce which
  74.             // instantiations to save in the ngen image.
  75.             // Otherwise, the JIT-compiler gets used, which is bad for working-set.
  76.             // Note that IBC can provide this information too.
  77.             // However, this helps in keeping the JIT-compiler out even for
  78.             // test scenarios which do not use IBC.
  79.             // This can be removed after V2, when we implement other schemes
  80.             // of keeping the JIT-compiler out for generic instantiations.
  81.             static internal void Prejitinit_HACK()
  82.             {
  83.                 new MemberInfoCache<RuntimeMethodInfo>(null);
  84.                 new MemberInfoCache<RuntimeConstructorInfo>(null);
  85.                 new MemberInfoCache<RuntimeFieldInfo>(null);
  86.                 new MemberInfoCache<RuntimeType>(null);
  87.                 new MemberInfoCache<RuntimePropertyInfo>(null);
  88.                 new MemberInfoCache<RuntimeEventInfo>(null);
  89.             }
  90.            
  91.             private struct Filter
  92.             {
  93.                 private Utf8String m_name;
  94.                 private MemberListType m_listType;
  95.                
  96.                 unsafe public Filter(byte* pUtf8Name, int cUtf8Name, MemberListType listType)
  97.                 {
  98.                     this.m_name = new Utf8String((void*)pUtf8Name, cUtf8Name);
  99.                     this.m_listType = listType;
  100.                 }
  101.                
  102.                 public bool Match(Utf8String name)
  103.                 {
  104.                     if (m_listType == MemberListType.CaseSensitive)
  105.                         return m_name.Equals(name);
  106.                     else if (m_listType == MemberListType.CaseInsensitive)
  107.                         return m_name.EqualsCaseInsensitive(name);
  108.                     else
  109.                         return true;
  110.                 }
  111.             }
  112.            
  113.             [Serializable()]
  114.             private class MemberInfoCache<T> where T : MemberInfo
  115.             {
  116.                 #region Static Members
  117.                 static MemberInfoCache()
  118.                 {
  119.                     PrepareMemberInfoCache(typeof(MemberInfoCache<T>).TypeHandle);
  120.                 }
  121.                 #endregion
  122.                
  123.                 #region Private Data Members
  124.                 // MemberInfo caches
  125.                 private CerHashtable<string, CerArrayList<T>> m_csMemberInfos;
  126.                 private CerHashtable<string, CerArrayList<T>> m_cisMemberInfos;
  127.                 private CerArrayList<T> m_root;
  128.                 private bool m_cacheComplete;
  129.                
  130.                 // This is the strong reference back to the cache
  131.                 private RuntimeTypeCache m_runtimeTypeCache;
  132.                 #endregion
  133.                
  134.                 #region Constructor
  135.                 internal MemberInfoCache(RuntimeTypeCache runtimeTypeCache)
  136.                 {
  137.                     m_runtimeTypeCache = runtimeTypeCache;
  138.                     m_cacheComplete = false;
  139.                 }
  140.                
  141.                 internal MethodBase AddMethod(RuntimeTypeHandle declaringType, RuntimeMethodHandle method, CacheType cacheType)
  142.                 {
  143.                     object list = null;
  144.                     MethodAttributes methodAttributes = method.GetAttributes();
  145.                     bool isPublic = (methodAttributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Public;
  146.                     bool isStatic = (methodAttributes & MethodAttributes.Static) != 0;
  147.                     bool isInherited = declaringType.Value != ReflectedTypeHandle.Value;
  148.                     BindingFlags bindingFlags = RuntimeType.FilterPreCalculate(isPublic, isInherited, isStatic);
  149.                     switch (cacheType) {
  150.                         case CacheType.Method:
  151.                             List<RuntimeMethodInfo> mlist = new List<RuntimeMethodInfo>(1);
  152.                             mlist.Add(new RuntimeMethodInfo(method, declaringType, m_runtimeTypeCache, methodAttributes, bindingFlags));
  153.                             list = mlist;
  154.                             break;
  155.                         case CacheType.Constructor:
  156.                             List<RuntimeConstructorInfo> clist = new List<RuntimeConstructorInfo>(1);
  157.                             clist.Add(new RuntimeConstructorInfo(method, declaringType, m_runtimeTypeCache, methodAttributes, bindingFlags));
  158.                             list = clist;
  159.                             break;
  160.                     }
  161.                    
  162.                     CerArrayList<T> cerList = new CerArrayList<T>((List<T>)list);
  163.                    
  164.                     Insert(ref cerList, null, MemberListType.HandleToInfo);
  165.                    
  166.                     return (MethodBase)(object)cerList[0];
  167.                 }
  168.                
  169.                 internal FieldInfo AddField(RuntimeFieldHandle field)
  170.                 {
  171.                     // create the runtime field info
  172.                     List<RuntimeFieldInfo> list = new List<RuntimeFieldInfo>(1);
  173.                     FieldAttributes fieldAttributes = field.GetAttributes();
  174.                     bool isPublic = (fieldAttributes & FieldAttributes.FieldAccessMask) == FieldAttributes.Public;
  175.                     bool isStatic = (fieldAttributes & FieldAttributes.Static) != 0;
  176.                     bool isInherited = field.GetApproxDeclaringType().Value != ReflectedTypeHandle.Value;
  177.                     BindingFlags bindingFlags = RuntimeType.FilterPreCalculate(isPublic, isInherited, isStatic);
  178.                     list.Add(new RtFieldInfo(field, ReflectedType, m_runtimeTypeCache, bindingFlags));
  179.                    
  180.                     CerArrayList<T> cerList = new CerArrayList<T>((List<T>)(object)list);
  181.                     Insert(ref cerList, null, MemberListType.HandleToInfo);
  182.                    
  183.                     return (FieldInfo)(object)cerList[0];
  184.                 }
  185.                
  186.                 unsafe private CerArrayList<T> Populate(string name, MemberListType listType, CacheType cacheType)
  187.                 {
  188.                     if (name == null || name.Length == 0 || (cacheType == CacheType.Constructor && name.FirstChar != '.' && name.FirstChar != '*')) {
  189.                         Filter filter = new Filter(null, 0, listType);
  190.                         List<T> list = null;
  191.                        
  192.                         switch (cacheType) {
  193.                             case CacheType.Method:
  194.                                 list = PopulateMethods(filter) as List<T>;
  195.                                 break;
  196.                             case CacheType.Field:
  197.                                 list = PopulateFields(filter) as List<T>;
  198.                                 break;
  199.                             case CacheType.Constructor:
  200.                                 list = PopulateConstructors(filter) as List<T>;
  201.                                 break;
  202.                             case CacheType.Property:
  203.                                 list = PopulateProperties(filter) as List<T>;
  204.                                 break;
  205.                             case CacheType.Event:
  206.                                 list = PopulateEvents(filter) as List<T>;
  207.                                 break;
  208.                             case CacheType.NestedType:
  209.                                 list = PopulateNestedClasses(filter) as List<T>;
  210.                                 break;
  211.                             case CacheType.Interface:
  212.                                 list = PopulateInterfaces(filter) as List<T>;
  213.                                 break;
  214.                         }
  215.                        
  216.                         CerArrayList<T> cerList = new CerArrayList<T>(list);
  217.                        
  218.                         Insert(ref cerList, name, listType);
  219.                        
  220.                         return cerList;
  221.                     }
  222.                     else {
  223.                         fixed (char* pName = name) {
  224.                             int cUtf8Name = Encoding.UTF8.GetByteCount(pName, name.Length);
  225.                             byte* pUtf8Name = stackalloc byte[cUtf8Name];
  226.                             Encoding.UTF8.GetBytes(pName, name.Length, pUtf8Name, cUtf8Name);
  227.                            
  228.                             Filter filter = new Filter(pUtf8Name, cUtf8Name, listType);
  229.                             List<T> list = null;
  230.                            
  231.                             switch (cacheType) {
  232.                                 case CacheType.Method:
  233.                                     list = PopulateMethods(filter) as List<T>;
  234.                                     break;
  235.                                 case CacheType.Field:
  236.                                     list = PopulateFields(filter) as List<T>;
  237.                                     break;
  238.                                 case CacheType.Constructor:
  239.                                     list = PopulateConstructors(filter) as List<T>;
  240.                                     break;
  241.                                 case CacheType.Property:
  242.                                     list = PopulateProperties(filter) as List<T>;
  243.                                     break;
  244.                                 case CacheType.Event:
  245.                                     list = PopulateEvents(filter) as List<T>;
  246.                                     break;
  247.                                 case CacheType.NestedType:
  248.                                     list = PopulateNestedClasses(filter) as List<T>;
  249.                                     break;
  250.                                 case CacheType.Interface:
  251.                                     list = PopulateInterfaces(filter) as List<T>;
  252.                                     break;
  253.                             }
  254.                            
  255.                             CerArrayList<T> cerList = new CerArrayList<T>(list);
  256.                            
  257.                             Insert(ref cerList, name, listType);
  258.                            
  259.                             return cerList;
  260.                         }
  261.                     }
  262.                 }
  263.                
  264.                 // May replace the list with a new one if certain cache
  265.                 // lookups succeed. Also, may modify the contents of the list
  266.                 // after merging these new data structures with cached ones.
  267.                 private void Insert(ref CerArrayList<T> list, string name, MemberListType listType)
  268.                 {
  269.                     bool lockTaken = false;
  270.                     bool preallocationComplete = false;
  271.                    
  272.                     RuntimeHelpers.PrepareConstrainedRegions();
  273.                     try {
  274.                         Monitor.ReliableEnter(this, ref lockTaken);
  275.                        
  276.                         if (listType == MemberListType.CaseSensitive) {
  277.                             if (m_csMemberInfos == null)
  278.                                 m_csMemberInfos = new CerHashtable<string, CerArrayList<T>>();
  279.                             else
  280.                                 m_csMemberInfos.Preallocate(1);
  281.                         }
  282.                         else if (listType == MemberListType.CaseInsensitive) {
  283.                             if (m_cisMemberInfos == null)
  284.                                 m_cisMemberInfos = new CerHashtable<string, CerArrayList<T>>();
  285.                             else
  286.                                 m_cisMemberInfos.Preallocate(1);
  287.                         }
  288.                        
  289.                         if (m_root == null)
  290.                             m_root = new CerArrayList<T>(list.Count);
  291.                         else
  292.                             m_root.Preallocate(list.Count);
  293.                        
  294.                         preallocationComplete = true;
  295.                     }
  296.                     finally {
  297.                         try {
  298.                             if (preallocationComplete) {
  299.                                 if (listType == MemberListType.CaseSensitive) {
  300.                                     // Ensure we always return a list that has
  301.                                     // been merged with the global list.
  302.                                     CerArrayList<T> cachedList = m_csMemberInfos[name];
  303.                                     if (cachedList == null) {
  304.                                         MergeWithGlobalList(list);
  305.                                         m_csMemberInfos[name] = list;
  306.                                     }
  307.                                     else
  308.                                         list = cachedList;
  309.                                 }
  310.                                 else if (listType == MemberListType.CaseInsensitive) {
  311.                                     // Ensure we always return a list that has
  312.                                     // been merged with the global list.
  313.                                     CerArrayList<T> cachedList = m_cisMemberInfos[name];
  314.                                     if (cachedList == null) {
  315.                                         MergeWithGlobalList(list);
  316.                                         m_cisMemberInfos[name] = list;
  317.                                     }
  318.                                     else
  319.                                         list = cachedList;
  320.                                 }
  321.                                 else {
  322.                                     MergeWithGlobalList(list);
  323.                                 }
  324.                                
  325.                                 if (listType == MemberListType.All) {
  326.                                     m_cacheComplete = true;
  327.                                 }
  328.                             }
  329.                         }
  330.                         finally {
  331.                             if (lockTaken) {
  332.                                 Monitor.Exit(this);
  333.                             }
  334.                         }
  335.                     }
  336.                 }
  337.                
  338.                 // Modifies the existing list.
  339.                 [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  340.                 private void MergeWithGlobalList(CerArrayList<T> list)
  341.                 {
  342.                     int cachedCount = m_root.Count;
  343.                    
  344.                     for (int i = 0; i < list.Count; i++) {
  345.                         T newMemberInfo = list[i];
  346.                         T cachedMemberInfo = null;
  347.                        
  348.                         for (int j = 0; j < cachedCount; j++) {
  349.                             cachedMemberInfo = m_root[j];
  350.                            
  351.                             if (newMemberInfo.CacheEquals(cachedMemberInfo)) {
  352.                                 list.Replace(i, cachedMemberInfo);
  353.                                 break;
  354.                             }
  355.                         }
  356.                        
  357.                         if (list[i] != cachedMemberInfo)
  358.                             m_root.Add(newMemberInfo);
  359.                     }
  360.                 }
  361.                 #endregion
  362.                
  363.                 #region Population Logic
  364.                 unsafe private List<RuntimeMethodInfo> PopulateMethods(Filter filter)
  365.                 {
  366.                     List<RuntimeMethodInfo> list = new List<RuntimeMethodInfo>();
  367.                    
  368.                     bool isInterface = (ReflectedTypeHandle.GetAttributes() & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Interface;
  369.                    
  370.                     if (isInterface) {
  371.                         #region IsInterface
  372.                         RuntimeTypeHandle declaringInterfaceHandle = ReflectedTypeHandle;
  373.                         bool mayNeedInstantiatingStub = declaringInterfaceHandle.HasInstantiation() && !declaringInterfaceHandle.IsGenericTypeDefinition();
  374.                         MethodDescChunkHandle chunkHandle = declaringInterfaceHandle.GetMethodDescChunk();
  375.                        
  376.                         while (!chunkHandle.IsNullHandle()) {
  377.                             int methodCount = chunkHandle.GetMethodCount();
  378.                            
  379.                             for (int i = 0; i < methodCount; i++) {
  380.                                 RuntimeMethodHandle methodHandle = chunkHandle.GetMethodAt(i);
  381.                                
  382.                                 if (!filter.Match(methodHandle.GetUtf8Name()))
  383.                                     continue;
  384.                                
  385.                                 #region Loop through all methods on the interface
  386.                                 ASSERT.CONSISTENCY_CHECK(!methodHandle.IsNullHandle());
  387.                                 ASSERT.CONSISTENCY_CHECK(LOGIC.IMPLIES((methodHandle.GetAttributes() & MethodAttributes.RTSpecialName) != 0, methodHandle.GetName().Equals(".ctor") || methodHandle.GetName().Equals(".cctor") || methodHandle.GetName().Equals("IL_STUB")));
  388.                                 ASSERT.CONSISTENCY_CHECK((methodHandle.GetAttributes() & MethodAttributes.Abstract) != 0);
  389.                                 ASSERT.CONSISTENCY_CHECK((methodHandle.GetAttributes() & MethodAttributes.Virtual) != 0);
  390.                                
  391.                                 #region Calculate Binding Flags
  392.                                 MethodAttributes methodAttributes = methodHandle.GetAttributes();
  393.                                 bool isPublic = (methodAttributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Public;
  394.                                 bool isStatic = (methodAttributes & MethodAttributes.Static) != 0;
  395.                                 bool isInherited = false;
  396.                                 BindingFlags bindingFlags = RuntimeType.FilterPreCalculate(isPublic, isInherited, isStatic);
  397.                                 #endregion
  398.                                
  399.                                 if ((methodAttributes & MethodAttributes.RTSpecialName) != 0 || methodHandle.IsILStub())
  400.                                     continue;
  401.                                
  402.                                 // if it is an instantiated type get the InstantiatedMethodDesc if needed
  403.                                 if (mayNeedInstantiatingStub)
  404.                                     methodHandle = methodHandle.GetInstantiatingStubIfNeeded(declaringInterfaceHandle);
  405.                                
  406.                                 RuntimeMethodInfo runtimeMethodInfo = new RuntimeMethodInfo(methodHandle, declaringInterfaceHandle, m_runtimeTypeCache, methodAttributes, bindingFlags);
  407.                                
  408.                                 list.Add(runtimeMethodInfo);
  409.                                 #endregion
  410.                             }
  411.                            
  412.                             chunkHandle = chunkHandle.GetNextMethodDescChunk();
  413.                         }
  414.                         #endregion
  415.                     }
  416.                     else {
  417.                         #region IsClass or GenericParameter
  418.                         RuntimeTypeHandle declaringTypeHandle = ReflectedTypeHandle;
  419.                        
  420.                         while (declaringTypeHandle.IsGenericVariable())
  421.                             declaringTypeHandle = declaringTypeHandle.GetRuntimeType().BaseType.GetTypeHandleInternal();
  422.                        
  423.                         bool* overrides = stackalloc bool[declaringTypeHandle.GetNumVtableSlots()];
  424.                         bool isValueType = declaringTypeHandle.GetRuntimeType().IsValueType;
  425.                        
  426.                         while (!declaringTypeHandle.IsNullHandle()) {
  427.                             bool mayNeedInstantiatingStub = declaringTypeHandle.HasInstantiation() && !declaringTypeHandle.IsGenericTypeDefinition();
  428.                            
  429.                             int vtableSlots = declaringTypeHandle.GetNumVtableSlots();
  430.                             MethodDescChunkHandle chunkHandle = declaringTypeHandle.GetMethodDescChunk();
  431.                            
  432.                             while (!chunkHandle.IsNullHandle()) {
  433.                                 int methodCount = chunkHandle.GetMethodCount();
  434.                                
  435.                                 for (int i = 0; i < methodCount; i++) {
  436.                                     RuntimeMethodHandle methodHandle = chunkHandle.GetMethodAt(i);
  437.                                    
  438.                                     if (!filter.Match(methodHandle.GetUtf8Name()))
  439.                                         continue;
  440.                                    
  441.                                     #region Loop through all methods on the current type
  442.                                     ASSERT.CONSISTENCY_CHECK(!methodHandle.IsNullHandle());
  443.                                    
  444.                                     MethodAttributes methodAttributes = methodHandle.GetAttributes();
  445.                                     MethodAttributes methodAccess = methodAttributes & MethodAttributes.MemberAccessMask;
  446.                                    
  447.                                     #region Continue if this is a constructor
  448.                                     ASSERT.CONSISTENCY_CHECK(LOGIC.IMPLIES((methodHandle.GetAttributes() & MethodAttributes.RTSpecialName) != 0, methodHandle.GetName().Equals(".ctor") || methodHandle.GetName().Equals(".cctor") || methodHandle.GetName().Equals("IL_STUB")));
  449.                                    
  450.                                     if ((methodAttributes & MethodAttributes.RTSpecialName) != 0 || methodHandle.IsILStub())
  451.                                         continue;
  452.                                     #endregion
  453.                                    
  454.                                     #region Continue if this is a private declared on a base type
  455.                                     bool isVirtual = false;
  456.                                     int methodSlot = 0;
  457.                                     if ((methodAttributes & MethodAttributes.Virtual) != 0) {
  458.                                         // only virtual if actually in the vtableslot range, but GetSlot will
  459.                                         // assert if an EnC method, which can't be virtual, so narrow down first
  460.                                         // before calling GetSlot
  461.                                         methodSlot = methodHandle.GetSlot();
  462.                                         isVirtual = (methodSlot < vtableSlots);
  463.                                     }
  464.                                     bool isPrivate = methodAccess == MethodAttributes.Private;
  465.                                     bool isPrivateVirtual = isVirtual & isPrivate;
  466.                                     bool isInherited = declaringTypeHandle.Value != ReflectedTypeHandle.Value;
  467.                                     if (isInherited && isPrivate && !isPrivateVirtual)
  468.                                         continue;
  469.                                     #endregion
  470.                                    
  471.                                     #region Continue if this is a virtual and is already overridden
  472.                                     if (isVirtual) {
  473.                                         ASSERT.CONSISTENCY_CHECK((methodAttributes & MethodAttributes.Abstract) != 0 || (methodAttributes & MethodAttributes.Virtual) != 0 || methodHandle.GetDeclaringType().Value != declaringTypeHandle.Value);
  474.                                        
  475.                                         if (overrides[methodSlot] == true)
  476.                                             continue;
  477.                                        
  478.                                         overrides[methodSlot] = true;
  479.                                     }
  480.                                     else if (isValueType) {
  481.                                         if ((methodAttributes & (MethodAttributes.Virtual | MethodAttributes.Abstract)) != 0)
  482.                                             continue;
  483.                                     }
  484.                                     else {
  485.                                         ASSERT.CONSISTENCY_CHECK((methodAttributes & (MethodAttributes.Virtual | MethodAttributes.Abstract)) == 0);
  486.                                     }
  487.                                     #endregion
  488.                                    
  489.                                     #region Calculate Binding Flags
  490.                                     bool isPublic = methodAccess == MethodAttributes.Public;
  491.                                     bool isStatic = (methodAttributes & MethodAttributes.Static) != 0;
  492.                                     BindingFlags bindingFlags = RuntimeType.FilterPreCalculate(isPublic, isInherited, isStatic);
  493.                                     #endregion
  494.                                    
  495.                                     // if it is an instantiated type get the InstantiatedMethodDesc if needed
  496.                                     if (mayNeedInstantiatingStub)
  497.                                         methodHandle = methodHandle.GetInstantiatingStubIfNeeded(declaringTypeHandle);
  498.                                    
  499.                                     RuntimeMethodInfo runtimeMethodInfo = new RuntimeMethodInfo(methodHandle, declaringTypeHandle, m_runtimeTypeCache, methodAttributes, bindingFlags);
  500.                                    
  501.                                     list.Add(runtimeMethodInfo);
  502.                                     #endregion
  503.                                 }
  504.                                
  505.                                 chunkHandle = chunkHandle.GetNextMethodDescChunk();
  506.                             }
  507.                            
  508.                             declaringTypeHandle = declaringTypeHandle.GetBaseTypeHandle();
  509.                         }
  510.                         #endregion
  511.                     }
  512.                    
  513.                     return list;
  514.                 }
  515.                
  516.                 private List<RuntimeConstructorInfo> PopulateConstructors(Filter filter)
  517.                 {
  518.                     List<RuntimeConstructorInfo> list = new List<RuntimeConstructorInfo>();
  519.                    
  520.                     if (ReflectedType.IsGenericParameter) {
  521.                         return list;
  522.                     }
  523.                    
  524.                     bool mayNeedInstantiatingStub = ReflectedTypeHandle.HasInstantiation() && !ReflectedTypeHandle.IsGenericTypeDefinition();
  525.                    
  526.                     MethodDescChunkHandle chunkHandle = ReflectedTypeHandle.GetMethodDescChunk();
  527.                    
  528.                     while (!chunkHandle.IsNullHandle()) {
  529.                         int methodCount = chunkHandle.GetMethodCount();
  530.                        
  531.                         for (int i = 0; i < methodCount; i++) {
  532.                             RuntimeMethodHandle methodHandle = chunkHandle.GetMethodAt(i);
  533.                            
  534.                             if (!filter.Match(methodHandle.GetUtf8Name()))
  535.                                 continue;
  536.                            
  537.                             MethodAttributes methodAttributes = methodHandle.GetAttributes();
  538.                            
  539.                             ASSERT.CONSISTENCY_CHECK(!methodHandle.IsNullHandle());
  540.                             /*                           
  541.                             ASSERT.CONSISTENCY_CHECK(
  542.                                 LOGIC.IMPLIES((methodAttributes & MethodAttributes.RTSpecialName) != 0,
  543.                                 methodHandle.GetName().Equals(".ctor") ||
  544.                                 methodHandle.GetName().Equals(".cctor") ||
  545.                                 methodHandle.GetName().Equals("IL_STUB")));                         
  546. */                           
  547.                            
  548. if ((methodAttributes & MethodAttributes.RTSpecialName) == 0)
  549.                                 continue;
  550.                            
  551.                             if (methodHandle.GetName().Equals("IL_STUB"))
  552.                                 continue;
  553.                            
  554.                             // Constructors should not be virtual or abstract
  555.                             ASSERT.CONSISTENCY_CHECK((methodAttributes & MethodAttributes.Abstract) == 0 && (methodAttributes & MethodAttributes.Virtual) == 0);
  556.                            
  557.                             #region Calculate Binding Flags
  558.                             bool isPublic = (methodAttributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Public;
  559.                             bool isStatic = (methodAttributes & MethodAttributes.Static) != 0;
  560.                             bool isInherited = false;
  561.                             BindingFlags bindingFlags = RuntimeType.FilterPreCalculate(isPublic, isInherited, isStatic);
  562.                             #endregion
  563.                            
  564.                             // if it is an instantiated type get the InstantiatedMethodDesc if needed
  565.                             if (mayNeedInstantiatingStub)
  566.                                 methodHandle = methodHandle.GetInstantiatingStubIfNeeded(ReflectedTypeHandle);
  567.                            
  568.                             RuntimeConstructorInfo runtimeConstructorInfo = new RuntimeConstructorInfo(methodHandle, ReflectedTypeHandle, m_runtimeTypeCache, methodAttributes, bindingFlags);
  569.                            
  570.                             list.Add(runtimeConstructorInfo);
  571.                         }
  572.                        
  573.                         chunkHandle = chunkHandle.GetNextMethodDescChunk();
  574.                     }
  575.                    
  576.                     return list;
  577.                 }
  578.                
  579.                 unsafe private List<RuntimeFieldInfo> PopulateFields(Filter filter)
  580.                 {
  581.                     List<RuntimeFieldInfo> list = new List<RuntimeFieldInfo>();
  582.                    
  583.                     RuntimeTypeHandle declaringTypeHandle = ReflectedTypeHandle;
  584.                    
  585.                     #region Populate all static, instance and literal fields
  586.                     while (declaringTypeHandle.IsGenericVariable())
  587.                         declaringTypeHandle = declaringTypeHandle.GetRuntimeType().BaseType.GetTypeHandleInternal();
  588.                    
  589.                     while (!declaringTypeHandle.IsNullHandle()) {
  590.                         PopulateRtFields(filter, declaringTypeHandle, list);
  591.                        
  592.                         PopulateLiteralFields(filter, declaringTypeHandle, list);
  593.                        
  594.                         declaringTypeHandle = declaringTypeHandle.GetBaseTypeHandle();
  595.                     }
  596.                     #endregion
  597.                    
  598.                     #region Populate Literal Fields on Interfaces
  599.                     if (ReflectedType.IsGenericParameter) {
  600.                         Type[] interfaces = ReflectedTypeHandle.GetRuntimeType().BaseType.GetInterfaces();
  601.                        
  602.                         for (int i = 0; i < interfaces.Length; i++) {
  603.                             // Populate literal fields defined on any of the interfaces implemented by the declaring type
  604.                             PopulateLiteralFields(filter, interfaces[i].GetTypeHandleInternal(), list);
  605.                             PopulateRtFields(filter, interfaces[i].GetTypeHandleInternal(), list);
  606.                         }
  607.                     }
  608.                     else {
  609.                         RuntimeTypeHandle[] interfaces = ReflectedTypeHandle.GetInterfaces();
  610.                        
  611.                         if (interfaces != null) {
  612.                             for (int i = 0; i < interfaces.Length; i++) {
  613.                                 // Populate literal fields defined on any of the interfaces implemented by the declaring type
  614.                                 PopulateLiteralFields(filter, interfaces[i], list);
  615.                                 PopulateRtFields(filter, interfaces[i], list);
  616.                             }
  617.                         }
  618.                     }
  619.                     #endregion
  620.                    
  621.                     return list;
  622.                 }
  623.                
  624.                 unsafe private void PopulateRtFields(Filter filter, RuntimeTypeHandle declaringTypeHandle, List<RuntimeFieldInfo> list)
  625.                 {
  626.                     int** pResult = stackalloc int*[64];
  627.                     int count = 64;
  628.                    
  629.                     if (!declaringTypeHandle.GetFields(pResult, &count)) {
  630.                         fixed (int** pBigResult = new int*[count]) {
  631.                             declaringTypeHandle.GetFields(pBigResult, &count);
  632.                             PopulateRtFields(filter, pBigResult, count, declaringTypeHandle, list);
  633.                         }
  634.                     }
  635.                     else if (count > 0) {
  636.                         PopulateRtFields(filter, pResult, count, declaringTypeHandle, list);
  637.                     }
  638.                 }
  639.                
  640.                 unsafe private void PopulateRtFields(Filter filter, int** ppFieldHandles, int count, RuntimeTypeHandle declaringTypeHandle, List<RuntimeFieldInfo> list)
  641.                 {
  642.                     ASSERT.PRECONDITION(!declaringTypeHandle.IsNullHandle());
  643.                     ASSERT.PRECONDITION(!ReflectedTypeHandle.IsNullHandle());
  644.                    
  645.                     bool needsStaticFieldForGeneric = declaringTypeHandle.HasInstantiation() && !declaringTypeHandle.ContainsGenericVariables();
  646.                     bool isInherited = !declaringTypeHandle.Equals(ReflectedTypeHandle);
  647.                    
  648.                     for (int i = 0; i < count; i++) {
  649.                         RuntimeFieldHandle runtimeFieldHandle = new RuntimeFieldHandle(ppFieldHandles[i]);
  650.                        
  651.                         if (!filter.Match(runtimeFieldHandle.GetUtf8Name()))
  652.                             continue;
  653.                        
  654.                         ASSERT.CONSISTENCY_CHECK(!runtimeFieldHandle.IsNullHandle());
  655.                        
  656.                         FieldAttributes fieldAttributes = runtimeFieldHandle.GetAttributes();
  657.                         FieldAttributes fieldAccess = fieldAttributes & FieldAttributes.FieldAccessMask;
  658.                        
  659.                         if (isInherited) {
  660.                             if (fieldAccess == FieldAttributes.Private)
  661.                                 continue;
  662.                         }
  663.                        
  664.                         #region Calculate Binding Flags
  665.                         bool isPublic = fieldAccess == FieldAttributes.Public;
  666.                         bool isStatic = (fieldAttributes & FieldAttributes.Static) != 0;
  667.                         BindingFlags bindingFlags = RuntimeType.FilterPreCalculate(isPublic, isInherited, isStatic);
  668.                         #endregion
  669.                        
  670.                         // correct the FieldDesc if needed
  671.                         if (needsStaticFieldForGeneric && isStatic)
  672.                             runtimeFieldHandle = runtimeFieldHandle.GetStaticFieldForGenericType(declaringTypeHandle);
  673.                        
  674.                         RuntimeFieldInfo runtimeFieldInfo = new RtFieldInfo(runtimeFieldHandle, declaringTypeHandle.GetRuntimeType(), m_runtimeTypeCache, bindingFlags);
  675.                        
  676.                         list.Add(runtimeFieldInfo);
  677.                     }
  678.                 }
  679.                
  680.                 unsafe private void PopulateLiteralFields(Filter filter, RuntimeTypeHandle declaringTypeHandle, List<RuntimeFieldInfo> list)
  681.                 {
  682.                     ASSERT.PRECONDITION(!declaringTypeHandle.IsNullHandle());
  683.                     ASSERT.PRECONDITION(!ReflectedTypeHandle.IsNullHandle());
  684.                    
  685.                     int tkDeclaringType = declaringTypeHandle.GetToken();
  686.                    
  687.                     // Our policy is that TypeDescs do not have metadata tokens
  688.                     if (MdToken.IsNullToken(tkDeclaringType))
  689.                         return;
  690.                    
  691.                     MetadataImport scope = declaringTypeHandle.GetModuleHandle().GetMetadataImport();
  692.                     int cFields = scope.EnumFieldsCount(tkDeclaringType);
  693.                     int* tkFields = stackalloc int[cFields];
  694.                     scope.EnumFields(tkDeclaringType, tkFields, cFields);
  695.                    
  696.                     for (int i = 0; i < cFields; i++) {
  697.                         int tkField = tkFields[i];
  698.                         ASSERT.PRECONDITION(MdToken.IsTokenOfType(tkField, MetadataTokenType.FieldDef));
  699.                         ASSERT.PRECONDITION(!MdToken.IsNullToken(tkField));
  700.                        
  701.                         Utf8String name;
  702.                         name = scope.GetName(tkField);
  703.                        
  704.                         if (!filter.Match(name))
  705.                             continue;
  706.                        
  707.                         FieldAttributes fieldAttributes;
  708.                         scope.GetFieldDefProps(tkField, out fieldAttributes);
  709.                        
  710.                         FieldAttributes fieldAccess = fieldAttributes & FieldAttributes.FieldAccessMask;
  711.                        
  712.                         if ((fieldAttributes & FieldAttributes.Literal) != 0) {
  713.                             bool isInherited = !declaringTypeHandle.Equals(ReflectedTypeHandle);
  714.                             if (isInherited) {
  715.                                 bool isPrivate = fieldAccess == FieldAttributes.Private;
  716.                                 if (isPrivate)
  717.                                     continue;
  718.                             }
  719.                            
  720.                             #region Calculate Binding Flags
  721.                             bool isPublic = fieldAccess == FieldAttributes.Public;
  722.                             bool isStatic = (fieldAttributes & FieldAttributes.Static) != 0;
  723.                             BindingFlags bindingFlags = RuntimeType.FilterPreCalculate(isPublic, isInherited, isStatic);
  724.                             #endregion
  725.                            
  726.                             RuntimeFieldInfo runtimeFieldInfo = new MdFieldInfo(tkField, fieldAttributes, declaringTypeHandle, m_runtimeTypeCache, bindingFlags);
  727.                            
  728.                             list.Add(runtimeFieldInfo);
  729.                         }
  730.                     }
  731.                 }
  732.                
  733.                 private static void AddElementTypes(Type template, IList<Type> types)
  734.                 {
  735.                     if (!template.HasElementType)
  736.                         return;
  737.                    
  738.                     AddElementTypes(template.GetElementType(), types);
  739.                    
  740.                     for (int i = 0; i < types.Count; i++) {
  741.                         if (template.IsArray) {
  742.                             if (template.IsSzArray)
  743.                                 types[i] = types[i].MakeArrayType();
  744.                             else
  745.                                 types[i] = types[i].MakeArrayType(template.GetArrayRank());
  746.                         }
  747.                         else if (template.IsPointer) {
  748.                             types[i] = types[i].MakePointerType();
  749.                         }
  750.                     }
  751.                 }
  752.                
  753.                 private List<RuntimeType> PopulateInterfaces(Filter filter)
  754.                 {
  755.                     List<RuntimeType> list = new List<RuntimeType>();
  756.                    
  757.                     RuntimeTypeHandle declaringTypeHandle = ReflectedTypeHandle;
  758.                    
  759.                     if (!declaringTypeHandle.IsGenericVariable()) {
  760.                         RuntimeTypeHandle[] ifaces = ReflectedTypeHandle.GetInterfaces();
  761.                        
  762.                         if (ifaces != null) {
  763.                             for (int i = 0; i < ifaces.Length; i++) {
  764.                                 RuntimeType interfaceType = ifaces[i].GetRuntimeType();
  765.                                
  766.                                 if (!filter.Match(interfaceType.GetTypeHandleInternal().GetUtf8Name()))
  767.                                     continue;
  768.                                
  769.                                 ASSERT.CONSISTENCY_CHECK(interfaceType.IsInterface);
  770.                                 list.Add(interfaceType);
  771.                             }
  772.                         }
  773.                        
  774.                         if (ReflectedType.IsSzArray) {
  775.                             Type arrayType = ReflectedType.GetElementType();
  776.                            
  777.                             if (!arrayType.IsPointer) {
  778.                                 Type iList = typeof(IList<>).MakeGenericType(arrayType);
  779.                                
  780.                                 if (iList.IsAssignableFrom(ReflectedType)) {
  781.                                     if (filter.Match(iList.GetTypeHandleInternal().GetUtf8Name()))
  782.                                         list.Add(iList as RuntimeType);
  783.                                    
  784.                                     Type[] iFaces = iList.GetInterfaces();
  785.                                     for (int j = 0; j < iFaces.Length; j++) {
  786.                                         Type iFace = iFaces[j];
  787.                                         if (iFace.IsGenericType && filter.Match(iFace.GetTypeHandleInternal().GetUtf8Name()))
  788.                                             list.Add(iFaces[j] as RuntimeType);
  789.                                     }
  790.                                 }
  791.                             }
  792.                         }
  793.                     }
  794.                     else {
  795.                         List<RuntimeType> al = new List<RuntimeType>();
  796.                        
  797.                         // Get all constraints
  798.                         Type[] constraints = declaringTypeHandle.GetRuntimeType().GetGenericParameterConstraints();
  799.                        
  800.                         // Populate transitive closure of all interfaces in constraint set
  801.                         for (int i = 0; i < constraints.Length; i++) {
  802.                             Type constraint = constraints[i];
  803.                             if (constraint.IsInterface)
  804.                                 al.Add(constraint as RuntimeType);
  805.                            
  806.                             Type[] temp = constraint.GetInterfaces();
  807.                             for (int j = 0; j < temp.Length; j++)
  808.                                 al.Add(temp[j] as RuntimeType);
  809.                         }
  810.                        
  811.                         // Remove duplicates
  812.                         Hashtable ht = new Hashtable();
  813.                         for (int i = 0; i < al.Count; i++) {
  814.                             Type constraint = al[i] as Type;
  815.                             if (!ht.Contains(constraint))
  816.                                 ht[constraint] = constraint;
  817.                         }
  818.                        
  819.                         Type[] interfaces = new Type[ht.Values.Count];
  820.                         ht.Values.CopyTo(interfaces, 0);
  821.                        
  822.                         // Populate link-list
  823.                         for (int i = 0; i < interfaces.Length; i++) {
  824.                             if (!filter.Match(interfaces[i].GetTypeHandleInternal().GetUtf8Name()))
  825.                                 continue;
  826.                            
  827.                             list.Add(interfaces[i] as RuntimeType);
  828.                         }
  829.                     }
  830.                    
  831.                     return list;
  832.                 }
  833.                
  834.                 unsafe private List<RuntimeType> PopulateNestedClasses(Filter filter)
  835.                 {
  836.                     List<RuntimeType> list = new List<RuntimeType>();
  837.                    
  838.                     RuntimeTypeHandle declaringTypeHandle = ReflectedTypeHandle;
  839.                    
  840.                     if (declaringTypeHandle.IsGenericVariable()) {
  841.                         while (declaringTypeHandle.IsGenericVariable())
  842.                             declaringTypeHandle = declaringTypeHandle.GetRuntimeType().BaseType.GetTypeHandleInternal();
  843.                     }
  844.                    
  845.                     int tkEnclosingType = declaringTypeHandle.GetToken();
  846.                    
  847.                     // For example, TypeDescs do not have metadata tokens
  848.                     if (MdToken.IsNullToken(tkEnclosingType))
  849.                         return list;
  850.                    
  851.                     ModuleHandle moduleHandle = declaringTypeHandle.GetModuleHandle();
  852.                     MetadataImport scope = moduleHandle.GetMetadataImport();
  853.                    
  854.                     int cNestedClasses = scope.EnumNestedTypesCount(tkEnclosingType);
  855.                     int* tkNestedClasses = stackalloc int[cNestedClasses];
  856.                     scope.EnumNestedTypes(tkEnclosingType, tkNestedClasses, cNestedClasses);
  857.                    
  858.                     for (int i = 0; i < cNestedClasses; i++) {
  859.                         RuntimeTypeHandle nestedTypeHandle = new RuntimeTypeHandle();
  860.                        
  861.                         try {
  862.                             nestedTypeHandle = moduleHandle.ResolveTypeHandle(tkNestedClasses[i]);
  863.                         }
  864.                         catch (System.TypeLoadException) {
  865.                             // In a reflection emit scenario, we may have a token for a class which
  866.                             // has not been baked and hence cannot be loaded.
  867.                             continue;
  868.                         }
  869.                        
  870.                         if (!filter.Match(nestedTypeHandle.GetRuntimeType().GetTypeHandleInternal().GetUtf8Name()))
  871.                             continue;
  872.                        
  873.                         list.Add(nestedTypeHandle.GetRuntimeType());
  874.                     }
  875.                    
  876.                     return list;
  877.                 }
  878.                
  879.                 unsafe private List<RuntimeEventInfo> PopulateEvents(Filter filter)
  880.                 {
  881.                     ASSERT.PRECONDITION(!ReflectedTypeHandle.IsNullHandle());
  882.                    
  883.                     Hashtable csEventInfos = new Hashtable();
  884.                    
  885.                     RuntimeTypeHandle declaringTypeHandle = ReflectedTypeHandle;
  886.                     List<RuntimeEventInfo> list = new List<RuntimeEventInfo>();
  887.                    
  888.                     bool isInterface = (declaringTypeHandle.GetAttributes() & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Interface;
  889.                    
  890.                     if (!isInterface) {
  891.                         while (declaringTypeHandle.IsGenericVariable())
  892.                             declaringTypeHandle = declaringTypeHandle.GetRuntimeType().BaseType.GetTypeHandleInternal();
  893.                        
  894.                         // Populate associates off of the class hierarchy
  895.                         while (!declaringTypeHandle.IsNullHandle()) {
  896.                             PopulateEvents(filter, declaringTypeHandle, csEventInfos, list);
  897.                             declaringTypeHandle = declaringTypeHandle.GetBaseTypeHandle();
  898.                         }
  899.                     }
  900.                     else {
  901.                         // Populate associates for this interface
  902.                         PopulateEvents(filter, declaringTypeHandle, csEventInfos, list);
  903.                     }
  904.                    
  905.                     return list;
  906.                 }
  907.                
  908.                 unsafe private void PopulateEvents(Filter filter, RuntimeTypeHandle declaringTypeHandle, Hashtable csEventInfos, List<RuntimeEventInfo> list)
  909.                 {
  910.                     int tkDeclaringType = declaringTypeHandle.GetToken();
  911.                    
  912.                     // Arrays, Pointers, ByRef types and others generated only the fly by the RT do not have tokens.
  913.                     if (MdToken.IsNullToken(tkDeclaringType))
  914.                         return;
  915.                    
  916.                     MetadataImport scope = declaringTypeHandle.GetModuleHandle().GetMetadataImport();
  917.                     int cEvents = scope.EnumEventsCount(tkDeclaringType);
  918.                     int* tkEvents = stackalloc int[cEvents];
  919.                     scope.EnumEvents(tkDeclaringType, tkEvents, cEvents);
  920.                     PopulateEvents(filter, declaringTypeHandle, scope, tkEvents, cEvents, csEventInfos, list);
  921.                 }
  922.                
  923.                 unsafe private void PopulateEvents(Filter filter, RuntimeTypeHandle declaringTypeHandle, MetadataImport scope, int* tkAssociates, int cAssociates, Hashtable csEventInfos, List<RuntimeEventInfo> list)
  924.                 {
  925.                     for (int i = 0; i < cAssociates; i++) {
  926.                         int tkAssociate = tkAssociates[i];
  927.                         bool isPrivate;
  928.                        
  929.                         ASSERT.PRECONDITION(!MdToken.IsNullToken(tkAssociate));
  930.                         ASSERT.PRECONDITION(MdToken.IsTokenOfType(tkAssociate, MetadataTokenType.Event));
  931.                        
  932.                         Utf8String name;
  933.                         name = scope.GetName(tkAssociate);
  934.                        
  935.                         if (!filter.Match(name))
  936.                             continue;
  937.                        
  938.                         RuntimeEventInfo eventInfo = new RuntimeEventInfo(tkAssociate, declaringTypeHandle.GetRuntimeType() as RuntimeType, m_runtimeTypeCache, out isPrivate);
  939.                        
  940.                         #region Remove Inherited Privates
  941.                         if (!declaringTypeHandle.Equals(m_runtimeTypeCache.RuntimeTypeHandle) && isPrivate)
  942.                             continue;
  943.                         #endregion
  944.                        
  945.                         #region Remove Duplicates
  946.                         if (csEventInfos[eventInfo.Name] != null)
  947.                             continue;
  948.                        
  949.                         csEventInfos[eventInfo.Name] = eventInfo;
  950.                         #endregion
  951.                        
  952.                         list.Add(eventInfo);
  953.                     }
  954.                 }
  955.                
  956.                 unsafe private List<RuntimePropertyInfo> PopulateProperties(Filter filter)
  957.                 {
  958.                     ASSERT.PRECONDITION(!ReflectedTypeHandle.IsNullHandle());
  959.                     ASSERT.CONSISTENCY_CHECK(m_csMemberInfos == null);
  960.                    
  961.                     Hashtable csPropertyInfos = new Hashtable();
  962.                    
  963.                     RuntimeTypeHandle declaringTypeHandle = ReflectedTypeHandle;
  964.                     List<RuntimePropertyInfo> list = new List<RuntimePropertyInfo>();
  965.                    
  966.                     bool isInterface = (declaringTypeHandle.GetAttributes() & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Interface;
  967.                    
  968.                     if (!isInterface) {
  969.                         while (declaringTypeHandle.IsGenericVariable())
  970.                             declaringTypeHandle = declaringTypeHandle.GetRuntimeType().BaseType.GetTypeHandleInternal();
  971.                        
  972.                         // Populate associates off of the class hierarchy
  973.                         while (!declaringTypeHandle.IsNullHandle()) {
  974.                             PopulateProperties(filter, declaringTypeHandle, csPropertyInfos, list);
  975.                             declaringTypeHandle = declaringTypeHandle.GetBaseTypeHandle();
  976.                         }
  977.                     }
  978.                     else {
  979.                         // Populate associates for this interface
  980.                         PopulateProperties(filter, declaringTypeHandle, csPropertyInfos, list);
  981.                     }
  982.                    
  983.                     return list;
  984.                 }
  985.                
  986.                 unsafe private void PopulateProperties(Filter filter, RuntimeTypeHandle declaringTypeHandle, Hashtable csPropertyInfos, List<RuntimePropertyInfo> list)
  987.                 {
  988.                     int tkDeclaringType = declaringTypeHandle.GetToken();
  989.                    
  990.                     // Arrays, Pointers, ByRef types and others generated only the fly by the RT do not have tokens.
  991.                     if (MdToken.IsNullToken(tkDeclaringType))
  992.                         return;
  993.                    
  994.                     MetadataImport scope = declaringTypeHandle.GetModuleHandle().GetMetadataImport();
  995.                     int cProperties = scope.EnumPropertiesCount(tkDeclaringType);
  996.                     int* tkProperties = stackalloc int[cProperties];
  997.                     scope.EnumProperties(tkDeclaringType, tkProperties, cProperties);
  998.                     PopulateProperties(filter, declaringTypeHandle, tkProperties, cProperties, csPropertyInfos, list);
  999.                 }
  1000.                
  1001.                 unsafe private void PopulateProperties(Filter filter, RuntimeTypeHandle declaringTypeHandle, int* tkAssociates, int cProperties, Hashtable csPropertyInfos, List<RuntimePropertyInfo> list)
  1002.                 {
  1003.                     for (int i = 0; i < cProperties; i++) {
  1004.                         int tkAssociate = tkAssociates[i];
  1005.                         bool isPrivate;
  1006.                        
  1007.                         ASSERT.PRECONDITION(!MdToken.IsNullToken(tkAssociate));
  1008.                         ASSERT.PRECONDITION(MdToken.IsTokenOfType(tkAssociate, MetadataTokenType.Property));
  1009.                        
  1010.                         Utf8String name;
  1011.                         name = declaringTypeHandle.GetRuntimeType().Module.MetadataImport.GetName(tkAssociate);
  1012.                        
  1013.                         if (!filter.Match(name))
  1014.                             continue;
  1015.                        
  1016.                         RuntimePropertyInfo propertyInfo = new RuntimePropertyInfo(tkAssociate, declaringTypeHandle.GetRuntimeType() as RuntimeType, m_runtimeTypeCache, out isPrivate);
  1017.                        
  1018.                         #region Remove Privates
  1019.                         if (!declaringTypeHandle.Equals(m_runtimeTypeCache.RuntimeTypeHandle) && isPrivate)
  1020.                             continue;
  1021.                         #endregion
  1022.                        
  1023.                         #region Remove Duplicates
  1024.                         List<RuntimePropertyInfo> cache = csPropertyInfos[propertyInfo.Name] as List<RuntimePropertyInfo>;
  1025.                        
  1026.                         if (cache == null) {
  1027.                             cache = new List<RuntimePropertyInfo>();
  1028.                             csPropertyInfos[propertyInfo.Name] = cache;
  1029.                         }
  1030.                         else {
  1031.                             for (int j = 0; j < cache.Count; j++) {
  1032.                                 if (propertyInfo.EqualsSig(cache[j])) {
  1033.                                     cache = null;
  1034.                                     break;
  1035.                                 }
  1036.                             }
  1037.                         }
  1038.                        
  1039.                         if (cache == null)
  1040.                             continue;
  1041.                        
  1042.                         cache.Add(propertyInfo);
  1043.                         #endregion
  1044.                        
  1045.                         list.Add(propertyInfo);
  1046.                     }
  1047.                 }
  1048.                 #endregion
  1049.                
  1050.                 #region NonPrivate Members
  1051.                 internal CerArrayList<T> GetMemberList(MemberListType listType, string name, CacheType cacheType)
  1052.                 {
  1053.                     CerArrayList<T> list = null;
  1054.                    
  1055.                     switch (listType) {
  1056.                         case MemberListType.CaseSensitive:
  1057.                             if (m_csMemberInfos == null) {
  1058.                                 return Populate(name, listType, cacheType);
  1059.                             }
  1060.                             else {
  1061.                                 list = m_csMemberInfos[name];
  1062.                                
  1063.                                 if (list == null)
  1064.                                     return Populate(name, listType, cacheType);
  1065.                                
  1066.                                 return list;
  1067.                             }
  1068.                             break;
  1069.                         case MemberListType.All:
  1070.                            
  1071.                             if (m_cacheComplete)
  1072.                                 return m_root;
  1073.                            
  1074.                             return Populate(null, listType, cacheType);
  1075.                         default:
  1076.                            
  1077.                             if (m_cisMemberInfos == null) {
  1078.                                 return Populate(name, listType, cacheType);
  1079.                             }
  1080.                             else {
  1081.                                 list = m_cisMemberInfos[name];
  1082.                                
  1083.                                 if (list == null)
  1084.                                     return Populate(name, listType, cacheType);
  1085.                                
  1086.                                 return list;
  1087.                             }
  1088.                             break;
  1089.                     }
  1090.                 }
  1091.                
  1092.                 internal RuntimeTypeHandle ReflectedTypeHandle {
  1093.                     get { return m_runtimeTypeCache.RuntimeTypeHandle; }
  1094.                 }
  1095.                 internal RuntimeType ReflectedType {
  1096.                     get { return ReflectedTypeHandle.GetRuntimeType(); }
  1097.                 }
  1098.                 #endregion
  1099.             }
  1100.             #endregion
  1101.            
  1102.             #region Private Data Members
  1103.             private WhatsCached m_whatsCached;
  1104.             private RuntimeTypeHandle m_runtimeTypeHandle;
  1105.             private RuntimeType m_runtimeType;
  1106.             private RuntimeType m_enclosingType;
  1107.             private TypeCode m_typeCode;
  1108.             private string m_name, m_fullname, m_toString, m_namespace;
  1109.             private bool m_isGlobal;
  1110.             private bool m_bIsDomainInitialized;
  1111.             private MemberInfoCache<RuntimeMethodInfo> m_methodInfoCache;
  1112.             private MemberInfoCache<RuntimeConstructorInfo> m_constructorInfoCache;
  1113.             private MemberInfoCache<RuntimeFieldInfo> m_fieldInfoCache;
  1114.             private MemberInfoCache<RuntimeType> m_interfaceCache;
  1115.             private MemberInfoCache<RuntimeType> m_nestedClassesCache;
  1116.             private MemberInfoCache<RuntimePropertyInfo> m_propertyInfoCache;
  1117.             private MemberInfoCache<RuntimeEventInfo> m_eventInfoCache;
  1118.             private CerHashtable<RuntimeMethodInfo, RuntimeMethodInfo> m_methodInstantiations;
  1119.             #endregion
  1120.            
  1121.             #region Constructor
  1122.             internal RuntimeTypeCache(RuntimeType runtimeType)
  1123.             {
  1124.                 m_typeCode = TypeCode.Empty;
  1125.                 m_runtimeType = runtimeType;
  1126.                 m_runtimeTypeHandle = runtimeType.GetTypeHandleInternal();
  1127.                 m_isGlobal = m_runtimeTypeHandle.GetModuleHandle().GetModuleTypeHandle().Equals(m_runtimeTypeHandle);
  1128.             }
  1129.             #endregion
  1130.            
  1131.             #region Private Members
  1132.             private string ConstructName(ref string name, bool nameSpace, bool fullinst, bool assembly)
  1133.             {
  1134.                 if (name == null) {
  1135.                     name = RuntimeTypeHandle.ConstructName(nameSpace, fullinst, assembly);
  1136.                 }
  1137.                 return name;
  1138.             }
  1139.            
  1140.             private CerArrayList<T> GetMemberList<T>(ref MemberInfoCache<T> m_cache, MemberListType listType, string name, CacheType cacheType) where T : MemberInfo
  1141.             {
  1142.                 MemberInfoCache<T> existingCache = GetMemberCache<T>(ref m_cache);
  1143.                 return existingCache.GetMemberList(listType, name, cacheType);
  1144.             }
  1145.            
  1146.             private MemberInfoCache<T> GetMemberCache<T>(ref MemberInfoCache<T> m_cache) where T : MemberInfo
  1147.             {
  1148.                 MemberInfoCache<T> existingCache = m_cache;
  1149.                
  1150.                 if (existingCache == null) {
  1151.                     MemberInfoCache<T> newCache = new MemberInfoCache<T>(this);
  1152.                     existingCache = Interlocked.CompareExchange(ref m_cache, newCache, null);
  1153.                     if (existingCache == null)
  1154.                         existingCache = newCache;
  1155.                 }
  1156.                
  1157.                 return existingCache;
  1158.             }
  1159.             #endregion
  1160.            
  1161.             #region Internal Members
  1162.             internal bool DomainInitialized {
  1163.                 get { return m_bIsDomainInitialized; }
  1164.                 set { m_bIsDomainInitialized = value; }
  1165.             }
  1166.            
  1167.             internal string GetName()
  1168.             {
  1169.                 return ConstructName(ref m_name, false, false, false);
  1170.             }
  1171.            
  1172.             unsafe internal string GetNameSpace()
  1173.             {
  1174.                 // @Optimization - Use ConstructName to populate m_namespace
  1175.                 if (m_namespace == null) {
  1176.                     Type type = m_runtimeType;
  1177.                     type = type.GetRootElementType();
  1178.                    
  1179.                     while (type.IsNested)
  1180.                         type = type.DeclaringType;
  1181.                    
  1182.                     m_namespace = type.GetTypeHandleInternal().GetModuleHandle().GetMetadataImport().GetNamespace(type.MetadataToken).ToString();
  1183.                 }
  1184.                
  1185.                 return m_namespace;
  1186.             }
  1187.            
  1188.             internal string GetToString()
  1189.             {
  1190.                 return ConstructName(ref m_toString, true, false, false);
  1191.             }
  1192.            
  1193.             internal string GetFullName()
  1194.             {
  1195.                 if (!m_runtimeType.IsGenericTypeDefinition && m_runtimeType.ContainsGenericParameters)
  1196.                     return null;
  1197.                
  1198.                 return ConstructName(ref m_fullname, true, true, false);
  1199.             }
  1200.            
  1201.             internal TypeCode TypeCode {
  1202.                 get { return m_typeCode; }
  1203.                 set { m_typeCode = value; }
  1204.             }
  1205.            
  1206.             unsafe internal RuntimeType GetEnclosingType()
  1207.             {
  1208.                 if ((m_whatsCached & WhatsCached.EnclosingType) == 0) {
  1209.                     m_enclosingType = RuntimeTypeHandle.GetDeclaringType().GetRuntimeType();
  1210.                    
  1211.                     m_whatsCached |= WhatsCached.EnclosingType;
  1212.                 }
  1213.                
  1214.                 return m_enclosingType;
  1215.             }
  1216.            
  1217.             internal bool IsGlobal {
  1218.                 [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  1219.                 get { return m_isGlobal; }
  1220.             }
  1221.             internal RuntimeType RuntimeType {
  1222.                 get { return m_runtimeType; }
  1223.             }
  1224.             internal RuntimeTypeHandle RuntimeTypeHandle {
  1225.                 get { return m_runtimeTypeHandle; }
  1226.             }
  1227.             internal void InvalidateCachedNestedType()
  1228.             {
  1229.                 m_nestedClassesCache = null;
  1230.             }
  1231.             #endregion
  1232.            
  1233.             #region Caches Accessors
  1234.             internal MethodInfo GetGenericMethodInfo(RuntimeMethodHandle genericMethod)
  1235.             {
  1236.                 if (m_methodInstantiations == null)
  1237.                     Interlocked.CompareExchange(ref m_methodInstantiations, new CerHashtable<RuntimeMethodInfo, RuntimeMethodInfo>(), null);
  1238.                
  1239.                 RuntimeMethodInfo rmi = new RuntimeMethodInfo(genericMethod, genericMethod.GetDeclaringType(), this, genericMethod.GetAttributes(), (BindingFlags)(-1));
  1240.                
  1241.                 RuntimeMethodInfo crmi = null;
  1242.                
  1243.                 crmi = m_methodInstantiations[rmi];
  1244.                 if (crmi != null)
  1245.                     return crmi;
  1246.                
  1247.                 bool lockTaken = false;
  1248.                 bool preallocationComplete = false;
  1249.                 RuntimeHelpers.PrepareConstrainedRegions();
  1250.                 try {
  1251.                     Monitor.ReliableEnter(this, ref lockTaken);
  1252.                    
  1253.                     crmi = m_methodInstantiations[rmi];
  1254.                     if (crmi != null)
  1255.                         return crmi;
  1256.                    
  1257.                     m_methodInstantiations.Preallocate(1);
  1258.                    
  1259.                     preallocationComplete = true;
  1260.                 }
  1261.                 finally {
  1262.                     if (preallocationComplete) {
  1263.                         m_methodInstantiations[rmi] = rmi;
  1264.                     }
  1265.                    
  1266.                     if (lockTaken) {
  1267.                         Monitor.Exit(this);
  1268.                     }
  1269.                 }
  1270.                
  1271.                 return rmi;
  1272.             }
  1273.            
  1274.             internal CerArrayList<RuntimeMethodInfo> GetMethodList(MemberListType listType, string name)
  1275.             {
  1276.                 return GetMemberList<RuntimeMethodInfo>(ref m_methodInfoCache, listType, name, CacheType.Method);
  1277.             }
  1278.            
  1279.             internal CerArrayList<RuntimeConstructorInfo> GetConstructorList(MemberListType listType, string name)
  1280.             {
  1281.                 return GetMemberList<RuntimeConstructorInfo>(ref m_constructorInfoCache, listType, name, CacheType.Constructor);
  1282.             }
  1283.            
  1284.             internal CerArrayList<RuntimePropertyInfo> GetPropertyList(MemberListType listType, string name)
  1285.             {
  1286.                 return GetMemberList<RuntimePropertyInfo>(ref m_propertyInfoCache, listType, name, CacheType.Property);
  1287.             }
  1288.            
  1289.             internal CerArrayList<RuntimeEventInfo> GetEventList(MemberListType listType, string name)
  1290.             {
  1291.                 return GetMemberList<RuntimeEventInfo>(ref m_eventInfoCache, listType, name, CacheType.Event);
  1292.             }
  1293.            
  1294.             internal CerArrayList<RuntimeFieldInfo> GetFieldList(MemberListType listType, string name)
  1295.             {
  1296.                 return GetMemberList<RuntimeFieldInfo>(ref m_fieldInfoCache, listType, name, CacheType.Field);
  1297.             }
  1298.            
  1299.             internal CerArrayList<RuntimeType> GetInterfaceList(MemberListType listType, string name)
  1300.             {
  1301.                 return GetMemberList<RuntimeType>(ref m_interfaceCache, listType, name, CacheType.Interface);
  1302.             }
  1303.            
  1304.             internal CerArrayList<RuntimeType> GetNestedTypeList(MemberListType listType, string name)
  1305.             {
  1306.                 return GetMemberList<RuntimeType>(ref m_nestedClassesCache, listType, name, CacheType.NestedType);
  1307.             }
  1308.            
  1309.             internal MethodBase GetMethod(RuntimeTypeHandle declaringType, RuntimeMethodHandle method)
  1310.             {
  1311.                 GetMemberCache<RuntimeMethodInfo>(ref m_methodInfoCache);
  1312.                 return m_methodInfoCache.AddMethod(declaringType, method, CacheType.Method);
  1313.             }
  1314.            
  1315.             internal MethodBase GetConstructor(RuntimeTypeHandle declaringType, RuntimeMethodHandle constructor)
  1316.             {
  1317.                 GetMemberCache<RuntimeConstructorInfo>(ref m_constructorInfoCache);
  1318.                 return m_constructorInfoCache.AddMethod(declaringType, constructor, CacheType.Constructor);
  1319.             }
  1320.            
  1321.             internal FieldInfo GetField(RuntimeFieldHandle field)
  1322.             {
  1323.                 GetMemberCache<RuntimeFieldInfo>(ref m_fieldInfoCache);
  1324.                 return m_fieldInfoCache.AddField(field);
  1325.             }
  1326.            
  1327.             #endregion
  1328.         }
  1329.         #endregion
  1330.        
  1331.         #region Static Members
  1332.        
  1333.         #region Internal
  1334.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  1335.         static internal extern void PrepareMemberInfoCache(RuntimeTypeHandle rt);
  1336.        
  1337.         static internal MethodBase GetMethodBase(ModuleHandle scope, int typeMetadataToken)
  1338.         {
  1339.             return GetMethodBase(scope.ResolveMethodHandle(typeMetadataToken));
  1340.         }
  1341.        
  1342.         static internal MethodBase GetMethodBase(Module scope, int typeMetadataToken)
  1343.         {
  1344.             return GetMethodBase(scope.GetModuleHandle(), typeMetadataToken);
  1345.         }
  1346.        
  1347.         static internal MethodBase GetMethodBase(RuntimeMethodHandle methodHandle)
  1348.         {
  1349.             return GetMethodBase(RuntimeTypeHandle.EmptyHandle, methodHandle);
  1350.         }
  1351.        
  1352.         unsafe static internal MethodBase GetMethodBase(RuntimeTypeHandle reflectedTypeHandle, RuntimeMethodHandle methodHandle)
  1353.         {
  1354.             ASSERT.CONSISTENCY_CHECK(!reflectedTypeHandle.IsNullHandle());
  1355.             ASSERT.CONSISTENCY_CHECK(!methodHandle.IsNullHandle());
  1356.            
  1357.             if (methodHandle.IsDynamicMethod()) {
  1358.                 Resolver resolver = methodHandle.GetResolver();
  1359.                
  1360.                 if (resolver != null)
  1361.                     return resolver.GetDynamicMethod();
  1362.                
  1363.                 return null;
  1364.             }
  1365.            
  1366.             // verify the type/method relationship
  1367.             Type declaredType = methodHandle.GetDeclaringType().GetRuntimeType();
  1368.             RuntimeType reflectedType = reflectedTypeHandle.GetRuntimeType();
  1369.            
  1370.             if (reflectedType == null)
  1371.                 reflectedType = declaredType as RuntimeType;
  1372.            
  1373.             if (reflectedType.IsArray) {
  1374.                 MethodBase[] methodBases = reflectedType.GetMember(methodHandle.GetName(), MemberTypes.Constructor | MemberTypes.Method, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) as MethodBase[];
  1375.                
  1376.                 bool loaderAssuredCompatible = false;
  1377.                 for (int i = 0; i < methodBases.Length; i++) {
  1378.                     if (methodBases[0].GetMethodHandle() == methodHandle)
  1379.                         loaderAssuredCompatible = true;
  1380.                 }
  1381.                
  1382.                 if (!loaderAssuredCompatible)
  1383.                     throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveMethodHandle"), reflectedType.ToString(), declaredType.ToString()));
  1384.                
  1385.                 declaredType = reflectedType;
  1386.             }
  1387.             else if (!declaredType.IsAssignableFrom(reflectedType)) {
  1388.                 if (!declaredType.IsGenericType)
  1389.                     throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveMethodHandle"), reflectedType.ToString(), declaredType.ToString()));
  1390.                
  1391.                 // ignoring instantiation is the ReflectedType a subtype of the DeclaringType
  1392.                 Type declaringDefinition = declaredType.GetGenericTypeDefinition();
  1393.                
  1394.                 Type baseType = reflectedType;
  1395.                
  1396.                 while (baseType != null) {
  1397.                     Type baseDefinition = baseType;
  1398.                    
  1399.                     if (baseDefinition.IsGenericType && !baseType.IsGenericTypeDefinition)
  1400.                         baseDefinition = baseDefinition.GetGenericTypeDefinition();
  1401.                    
  1402.                     if (baseDefinition.Equals(declaringDefinition))
  1403.                         break;
  1404.                    
  1405.                     baseType = baseType.BaseType;
  1406.                 }
  1407.                
  1408.                 if (baseType == null) {
  1409.                     // ignoring instantiation is the ReflectedType is not a subtype of the DeclaringType
  1410.                     throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveMethodHandle"), reflectedType.ToString(), declaredType.ToString()));
  1411.                 }
  1412.                
  1413.                 // remap the method to same method on the subclass ReflectedType
  1414.                 declaredType = baseType;
  1415.                
  1416.                 RuntimeTypeHandle[] methodInstantiation = methodHandle.GetMethodInstantiation();
  1417.                
  1418.                 bool bIsGenericMethodDefinition = methodHandle.IsGenericMethodDefinition();
  1419.                
  1420.                 // lookup via v-table slot the RuntimeMethodHandle on the new declaring type
  1421.                 methodHandle = methodHandle.GetMethodFromCanonical(declaredType.GetTypeHandleInternal());
  1422.                
  1423.                 // if the origional methodHandle was the definition than we don't need to rebind generic method arguments
  1424.                 // because all RuntimeMethodHandles retrieved off of the cannonical method table are definitions. That's
  1425.                 // why for everything else we need to rebind the generic method arguments.
  1426.                 if (!bIsGenericMethodDefinition) {
  1427.                     // rebind any generic method arguments
  1428.                     if (methodInstantiation != null)
  1429.                         methodHandle = methodHandle.GetInstantiatingStub(declaredType.GetTypeHandleInternal(), methodInstantiation);
  1430.                     else
  1431.                         methodHandle = methodHandle.GetInstantiatingStubIfNeeded(declaredType.GetTypeHandleInternal());
  1432.                 }
  1433.             }
  1434.            
  1435.             if (methodHandle.IsConstructor())
  1436.                 return reflectedType.Cache.GetConstructor(declaredType.GetTypeHandleInternal(), methodHandle);
  1437.            
  1438.             if (methodHandle.HasMethodInstantiation() && !methodHandle.IsGenericMethodDefinition())
  1439.                 return reflectedType.Cache.GetGenericMethodInfo(methodHandle);
  1440.            
  1441.             return reflectedType.Cache.GetMethod(declaredType.GetTypeHandleInternal(), methodHandle);
  1442.         }
  1443.        
  1444.         internal bool DomainInitialized {
  1445.             get { return Cache.DomainInitialized; }
  1446.             set { Cache.DomainInitialized = value; }
  1447.         }
  1448.        
  1449.         unsafe static internal FieldInfo GetFieldInfo(RuntimeFieldHandle fieldHandle)
  1450.         {
  1451.             return GetFieldInfo(fieldHandle.GetApproxDeclaringType(), fieldHandle);
  1452.         }
  1453.        
  1454.         unsafe static internal FieldInfo GetFieldInfo(RuntimeTypeHandle reflectedTypeHandle, RuntimeFieldHandle fieldHandle)
  1455.         {
  1456.             // verify the type/method relationship
  1457.             if (reflectedTypeHandle.IsNullHandle()) {
  1458.                 reflectedTypeHandle = fieldHandle.GetApproxDeclaringType();
  1459.             }
  1460.             else {
  1461.                 RuntimeTypeHandle declaredTypeHandle = fieldHandle.GetApproxDeclaringType();
  1462.                 if (!reflectedTypeHandle.Equals(declaredTypeHandle)) {
  1463.                     if (!fieldHandle.AcquiresContextFromThis() || !declaredTypeHandle.GetCanonicalHandle().Equals(reflectedTypeHandle.GetCanonicalHandle())) {
  1464.                         throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_ResolveFieldHandle"), reflectedTypeHandle.GetRuntimeType().ToString(), declaredTypeHandle.GetRuntimeType().ToString()));
  1465.                     }
  1466.                 }
  1467.             }
  1468.            
  1469.             return reflectedTypeHandle.GetRuntimeType().Cache.GetField(fieldHandle);
  1470.         }
  1471.        
  1472.         // Called internally
  1473.         unsafe static internal PropertyInfo GetPropertyInfo(RuntimeTypeHandle reflectedTypeHandle, int tkProperty)
  1474.         {
  1475.             RuntimePropertyInfo property = null;
  1476.             CerArrayList<RuntimePropertyInfo> candidates = reflectedTypeHandle.GetRuntimeType().Cache.GetPropertyList(MemberListType.All, null);
  1477.            
  1478.             for (int i = 0; i < candidates.Count; i++) {
  1479.                 property = candidates[i];
  1480.                 if (property.MetadataToken == tkProperty)
  1481.                     return property;
  1482.             }
  1483.            
  1484.             ASSERT.UNREACHABLE();
  1485.             throw new SystemException();
  1486.         }
  1487.        
  1488.         private static void ThrowIfTypeNeverValidGenericArgument(Type type)
  1489.         {
  1490.             if (type.IsPointer || type.IsByRef || type == typeof(void))
  1491.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_NeverValidGenericArgument"), type.ToString()));
  1492.         }
  1493.        
  1494.        
  1495.         static internal void SanityCheckGenericArguments(Type[] genericArguments, Type[] genericParamters)
  1496.         {
  1497.             if (genericArguments == null)
  1498.                 throw new ArgumentNullException();
  1499.            
  1500.             for (int i = 0; i < genericArguments.Length; i++) {
  1501.                 if (genericArguments[i] == null)
  1502.                     throw new ArgumentNullException();
  1503.                
  1504.                 ThrowIfTypeNeverValidGenericArgument(genericArguments[i]);
  1505.             }
  1506.            
  1507.             if (genericArguments.Length != genericParamters.Length)
  1508.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_NotEnoughGenArguments", genericArguments.Length, genericParamters.Length)));
  1509.         }
  1510.        
  1511.         static internal void ValidateGenericArguments(MemberInfo definition, Type[] genericArguments, Exception e)
  1512.         {
  1513.             RuntimeTypeHandle[] typeContextHandle = null;
  1514.             RuntimeTypeHandle[] methodContextHandle = null;
  1515.             Type[] genericParamters = null;
  1516.            
  1517.             if (definition is Type) {
  1518.                 Type genericTypeDefinition = (Type)definition;
  1519.                 genericParamters = genericTypeDefinition.GetGenericArguments();
  1520.                 typeContextHandle = new RuntimeTypeHandle[genericArguments.Length];
  1521.                 for (int i = 0; i < genericArguments.Length; i++)
  1522.                     typeContextHandle[i] = genericArguments[i].GetTypeHandleInternal();
  1523.             }
  1524.             else {
  1525.                 MethodInfo genericMethodDefinition = (MethodInfo)definition;
  1526.                 genericParamters = genericMethodDefinition.GetGenericArguments();
  1527.                 methodContextHandle = new RuntimeTypeHandle[genericArguments.Length];
  1528.                 for (int i = 0; i < genericArguments.Length; i++)
  1529.                     methodContextHandle[i] = genericArguments[i].GetTypeHandleInternal();
  1530.                
  1531.                 Type declaringType = genericMethodDefinition.DeclaringType;
  1532.                 if (declaringType != null)
  1533.                     typeContextHandle = declaringType.GetTypeHandleInternal().GetInstantiation();
  1534.             }
  1535.            
  1536.             for (int i = 0; i < genericArguments.Length; i++) {
  1537.                 Type genericArgument = genericArguments[i];
  1538.                 Type genericParameter = genericParamters[i];
  1539.                
  1540.                 if (!genericParameter.GetTypeHandleInternal().SatisfiesConstraints(typeContextHandle, methodContextHandle, genericArgument.GetTypeHandleInternal())) {
  1541.                     throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_GenConstraintViolation"), i.ToString(CultureInfo.CurrentCulture), genericArgument.ToString(), definition.ToString(), genericParameter.ToString()), e);
  1542.                 }
  1543.             }
  1544.         }
  1545.        
  1546.         private static void SplitName(string fullname, out string name, out string ns)
  1547.         {
  1548.             name = null;
  1549.             ns = null;
  1550.            
  1551.             if (fullname == null)
  1552.                 return;
  1553.            
  1554.             // Get namespace
  1555.             int nsDelimiter = fullname.LastIndexOf(".", StringComparison.Ordinal);
  1556.             if (nsDelimiter != -1) {
  1557.                 ns = fullname.Substring(0, nsDelimiter);
  1558.                 int nameLength = fullname.Length - ns.Length - 1;
  1559.                 if (nameLength != 0)
  1560.                     name = fullname.Substring(nsDelimiter + 1, nameLength);
  1561.                 else
  1562.                     name = "";
  1563.                 ASSERT.CONSISTENCY_CHECK(fullname.Equals(ns + "." + name));
  1564.             }
  1565.             else {
  1566.                 name = fullname;
  1567.             }
  1568.            
  1569.         }
  1570.         #endregion
  1571.        
  1572.         #region Filters
  1573.         static internal BindingFlags FilterPreCalculate(bool isPublic, bool isInherited, bool isStatic)
  1574.         {
  1575.             BindingFlags bindingFlags = isPublic ? BindingFlags.Public : BindingFlags.NonPublic;
  1576.            
  1577.             if (isInherited) {
  1578.                 // We arrange things so the DeclaredOnly flag means "include inherited members"
  1579.                 bindingFlags |= BindingFlags.DeclaredOnly;
  1580.                
  1581.                 if (isStatic) {
  1582.                     bindingFlags |= BindingFlags.Static | BindingFlags.FlattenHierarchy;
  1583.                 }
  1584.                 else {
  1585.                     bindingFlags |= BindingFlags.Instance;
  1586.                 }
  1587.             }
  1588.             else {
  1589.                 if (isStatic) {
  1590.                     bindingFlags |= BindingFlags.Static;
  1591.                 }
  1592.                 else {
  1593.                     bindingFlags |= BindingFlags.Instance;
  1594.                 }
  1595.             }
  1596.            
  1597.             return bindingFlags;
  1598.         }
  1599.        
  1600.         private static void FilterHelper(BindingFlags bindingFlags, ref string name, bool allowPrefixLookup, out bool prefixLookup, out bool ignoreCase, out MemberListType listType)
  1601.         {
  1602.             prefixLookup = false;
  1603.             ignoreCase = false;
  1604.            
  1605.             if (name != null) {
  1606.                 if ((bindingFlags & BindingFlags.IgnoreCase) != 0) {
  1607.                     name = name.ToLower(CultureInfo.InvariantCulture);
  1608.                     ignoreCase = true;
  1609.                     listType = MemberListType.CaseInsensitive;
  1610.                 }
  1611.                 else {
  1612.                     listType = MemberListType.CaseSensitive;
  1613.                 }
  1614.                
  1615.                 if (allowPrefixLookup && name.EndsWith("*", StringComparison.Ordinal)) {
  1616.                     name = name.Substring(0, name.Length - 1);
  1617.                     prefixLookup = true;
  1618.                     listType = MemberListType.All;
  1619.                 }
  1620.             }
  1621.             else {
  1622.                 listType = MemberListType.All;
  1623.             }
  1624.         }
  1625.        
  1626.         private static void FilterHelper(BindingFlags bindingFlags, ref string name, out bool ignoreCase, out MemberListType listType)
  1627.         {
  1628.             bool prefixLookup;
  1629.             FilterHelper(bindingFlags, ref name, false, out prefixLookup, out ignoreCase, out listType);
  1630.         }
  1631.        
  1632.         private static bool FilterApplyPrefixLookup(MemberInfo memberInfo, string name, bool ignoreCase)
  1633.         {
  1634.             ASSERT.CONSISTENCY_CHECK(name != null);
  1635.            
  1636.             if (ignoreCase) {
  1637.                 if (!memberInfo.Name.ToLower(CultureInfo.InvariantCulture).StartsWith(name, StringComparison.Ordinal))
  1638.                     return false;
  1639.             }
  1640.             else {
  1641.                 if (!memberInfo.Name.StartsWith(name, StringComparison.Ordinal))
  1642.                     return false;
  1643.             }
  1644.            
  1645.             return true;
  1646.         }
  1647.        
  1648.        
  1649.         private static bool FilterApplyBase(MemberInfo memberInfo, BindingFlags bindingFlags, bool isPublic, bool isNonProtectedInternal, bool isStatic, string name, bool prefixLookup)
  1650.         {
  1651.             #region Preconditions
  1652.             ASSERT.PRECONDITION(memberInfo != null);
  1653.             ASSERT.PRECONDITION(name == null || (bindingFlags & BindingFlags.IgnoreCase) == 0 || (name.ToLower(CultureInfo.InvariantCulture).Equals(name)));
  1654.             #endregion
  1655.            
  1656.             #region Filter by Public & Private
  1657.             if (isPublic) {
  1658.                 if ((bindingFlags & BindingFlags.Public) == 0)
  1659.                     return false;
  1660.             }
  1661.             else {
  1662.                 if ((bindingFlags & BindingFlags.NonPublic) == 0)
  1663.                     return false;
  1664.             }
  1665.             #endregion
  1666.            
  1667.             bool isInherited = memberInfo.DeclaringType != memberInfo.ReflectedType;
  1668.            
  1669.             #region Filter by DeclaredOnly
  1670.             if ((bindingFlags & BindingFlags.DeclaredOnly) != 0 && isInherited)
  1671.                 return false;
  1672.             #endregion
  1673.            
  1674.             #region Filter by Static & Instance
  1675.             if (memberInfo.MemberType != MemberTypes.TypeInfo && memberInfo.MemberType != MemberTypes.NestedType) {
  1676.                 if (isStatic) {
  1677.                     if ((bindingFlags & BindingFlags.FlattenHierarchy) == 0 && isInherited)
  1678.                         return false;
  1679.                    
  1680.                     if ((bindingFlags & BindingFlags.Static) == 0)
  1681.                         return false;
  1682.                 }
  1683.                 else {
  1684.                     if ((bindingFlags & BindingFlags.Instance) == 0)
  1685.                         return false;
  1686.                 }
  1687.             }
  1688.             #endregion
  1689.            
  1690.             #region Filter by name wrt prefixLookup and implicitly by case sensitivity
  1691.             if (prefixLookup == true) {
  1692.                 if (!FilterApplyPrefixLookup(memberInfo, name, (bindingFlags & BindingFlags.IgnoreCase) != 0))
  1693.                     return false;
  1694.             }
  1695.             #endregion
  1696.            
  1697.             #region Asymmetries
  1698.             // @Asymmetry - Internal, inherited, instance, non-protected, non-virtual, non-abstract members returned
  1699.             // iff BindingFlags !DeclaredOnly, Instance and Public are present except for fields
  1700.             // DeclaredOnly not present
  1701.             // Is inherited Member
  1702.             // Is non-protected internal member
  1703.             // BindingFlag.NonPublic present
  1704.             // Is instance member
  1705.             // BindingFlag.Instance present
  1706.             if (((bindingFlags & BindingFlags.DeclaredOnly) == 0) && isInherited && (isNonProtectedInternal) && ((bindingFlags & BindingFlags.NonPublic) != 0) && (!isStatic) && ((bindingFlags & BindingFlags.Instance) != 0)) {
  1707.                 MethodInfo methodInfo = memberInfo as MethodInfo;
  1708.                
  1709.                 if (methodInfo == null)
  1710.                     return false;
  1711.                
  1712.                 if (!methodInfo.IsVirtual && !methodInfo.IsAbstract)
  1713.                     return false;
  1714.             }
  1715.             #endregion
  1716.            
  1717.             return true;
  1718.         }
  1719.        
  1720.        
  1721.         private static bool FilterApplyType(Type type, BindingFlags bindingFlags, string name, bool prefixLookup, string ns)
  1722.         {
  1723.             ASSERT.PRECONDITION(type != null);
  1724.             ASSERT.PRECONDITION(type is RuntimeType);
  1725.            
  1726.             bool isPublic = type.IsNestedPublic || type.IsPublic;
  1727.             bool isStatic = false;
  1728.            
  1729.             if (!RuntimeType.FilterApplyBase(type, bindingFlags, isPublic, type.IsNestedAssembly, isStatic, name, prefixLookup))
  1730.                 return false;
  1731.            
  1732.             if (ns != null && !type.Namespace.Equals(ns))
  1733.                 return false;
  1734.            
  1735.             return true;
  1736.         }
  1737.        
  1738.        
  1739.         private static bool FilterApplyMethodBaseInfo(MethodBase methodBase, BindingFlags bindingFlags, string name, CallingConventions callConv, Type[] argumentTypes, bool prefixLookup)
  1740.         {
  1741.             ASSERT.PRECONDITION(methodBase != null);
  1742.            
  1743.             #region Apply Base Filter
  1744.             bindingFlags ^= BindingFlags.DeclaredOnly;
  1745.             BindingFlags matchFlags;
  1746.            
  1747.             RuntimeMethodInfo methodInfo = methodBase as RuntimeMethodInfo;
  1748.             if (methodInfo == null) {
  1749.                 RuntimeConstructorInfo constructorInfo = methodBase as RuntimeConstructorInfo;
  1750.                 matchFlags = constructorInfo.BindingFlags;
  1751.             }
  1752.             else {
  1753.                 matchFlags = methodInfo.BindingFlags;
  1754.             }
  1755.            
  1756.             if ((bindingFlags & matchFlags) != matchFlags || (prefixLookup && !FilterApplyPrefixLookup(methodBase, name, (bindingFlags & BindingFlags.IgnoreCase) != 0)))
  1757.                 return false;
  1758.             #endregion
  1759.            
  1760.             return FilterApplyMethodBaseInfo(methodBase, bindingFlags, callConv, argumentTypes);
  1761.         }
  1762.        
  1763.        
  1764.         private static bool FilterApplyMethodBaseInfo(MethodBase methodBase, BindingFlags bindingFlags, CallingConventions callConv, Type[] argumentTypes)
  1765.         {
  1766.             #region Check CallingConvention
  1767.             if ((callConv & CallingConventions.Any) == 0) {
  1768.                 if ((callConv & CallingConventions.VarArgs) != 0 && (methodBase.CallingConvention & CallingConventions.VarArgs) == 0)
  1769.                     return false;
  1770.                
  1771.                 if ((callConv & CallingConventions.Standard) != 0 && (methodBase.CallingConvention & CallingConventions.Standard) == 0)
  1772.                     return false;
  1773.             }
  1774.             #endregion
  1775.            
  1776.             #region If argumentTypes supplied
  1777.             if (argumentTypes != null) {
  1778.                 ParameterInfo[] parameterInfos = methodBase.GetParametersNoCopy();
  1779.                
  1780.                 if (argumentTypes.Length != parameterInfos.Length) {
  1781.                     #region Invoke Member, Get\Set & Create Instance specific case
  1782.                     // If the number of supplied arguments differs than the number in the signature AND
  1783.                     // we are not filtering for a dynamic call -- InvokeMethod or CreateInstance -- filter out the method.
  1784.                     if ((bindingFlags & (BindingFlags.InvokeMethod | BindingFlags.CreateInstance | BindingFlags.GetProperty | BindingFlags.SetProperty)) == 0)
  1785.                         return false;
  1786.                    
  1787.                     bool testForParamArray = false;
  1788.                     bool excessSuppliedArguments = argumentTypes.Length > parameterInfos.Length;
  1789.                    
  1790.                     if (excessSuppliedArguments) {
  1791.                         // more supplied arguments than parameters, additional arguments could be vararg
  1792.                         #region Varargs
  1793.                         // If method is not vararg, additional arguments can not be passed as vararg
  1794.                         if ((methodBase.CallingConvention & CallingConventions.VarArgs) == 0) {
  1795.                             testForParamArray = true;
  1796.                         }
  1797.                         else {
  1798.                             // If Binding flags did not include varargs we would have filtered this vararg method.
  1799.                             // This Invariant established during callConv check.
  1800.                             ASSERT.CONSISTENCY_CHECK((callConv & CallingConventions.VarArgs) != 0);
  1801.                         }
  1802.                         #endregion
  1803.                     }
  1804.                     else {
  1805.                         // fewer supplied arguments than parameters, missing arguments could be optional
  1806.                         #region OptionalParamBinding
  1807.                         if ((bindingFlags & BindingFlags.OptionalParamBinding) == 0) {
  1808.                             testForParamArray = true;
  1809.                         }
  1810.                         else {
  1811.                             // From our existing code, our policy here is that if a parameterInfo
  1812.                             // is optional then all subsequent parameterInfos shall be optional.
  1813.                            
  1814.                             // Thus, iff the first parameterInfo is not optional then this MethodInfo is no longer a canidate.
  1815.                             if (!parameterInfos[argumentTypes.Length].IsOptional)
  1816.                                 testForParamArray = true;
  1817.                         }
  1818.                         #endregion
  1819.                     }
  1820.                    
  1821.                     #region ParamArray
  1822.                     if (testForParamArray) {
  1823.                         if (parameterInfos.Length == 0)
  1824.                             return false;
  1825.                        
  1826.                         // The last argument of the signature could be a param array.
  1827.                         bool shortByMoreThanOneSuppliedArgument = argumentTypes.Length < parameterInfos.Length - 1;
  1828.                        
  1829.                         if (shortByMoreThanOneSuppliedArgument)
  1830.                             return false;
  1831.                        
  1832.                         ParameterInfo lastParameter = parameterInfos[parameterInfos.Length - 1];
  1833.                        
  1834.                         if (!lastParameter.ParameterType.IsArray)
  1835.                             return false;
  1836.                        
  1837.                         if (!lastParameter.IsDefined(typeof(ParamArrayAttribute), false))
  1838.                             return false;
  1839.                     }
  1840.                     #endregion
  1841.                    
  1842.                     #endregion
  1843.                 }
  1844.                 else {
  1845.                     #region Exact Binding
  1846.                     if ((bindingFlags & BindingFlags.ExactBinding) != 0) {
  1847.                         // Legacy behavior is to ignore ExactBinding when InvokeMember is specified.
  1848.                         // Why filter by InvokeMember? If the answer is we leave this to the binder then why not leave
  1849.                         // all the rest of this to the binder too? Further, what other semanitc would the binder
  1850.                         // use for BindingFlags.ExactBinding besides this one? Further, why not include CreateInstance
  1851.                         // in this if statement? That's just InvokeMethod with a constructor, right?
  1852.                         if ((bindingFlags & (BindingFlags.InvokeMethod)) == 0) {
  1853.                             for (int i = 0; i < parameterInfos.Length; i++) {
  1854.                                 // a null argument type implies a null arg which is always a perfect match
  1855.                                 if (argumentTypes[i] != null && parameterInfos[i].ParameterType != argumentTypes[i])
  1856.                                     return false;
  1857.                             }
  1858.                         }
  1859.                     }
  1860.                     #endregion
  1861.                 }
  1862.             }
  1863.             #endregion
  1864.            
  1865.             return true;
  1866.         }
  1867.        
  1868.         #endregion
  1869.        
  1870.         #endregion
  1871.        
  1872.         #region Private Data Members
  1873.         private IntPtr m_cache;
  1874.         private RuntimeTypeHandle m_handle;
  1875.        
  1876.         private class TypeCacheQueue
  1877.         {
  1878.             // must be a power of 2 for this to work
  1879.             const int QUEUE_SIZE = 4;
  1880.            
  1881.             object[] liveCache;
  1882.            
  1883.             internal TypeCacheQueue()
  1884.             {
  1885.                 liveCache = new object[QUEUE_SIZE];
  1886.             }
  1887.         }
  1888.         private static TypeCacheQueue s_typeCache = null;
  1889.         #endregion
  1890.        
  1891.         #region Constructor
  1892.         private RuntimeType(RuntimeTypeHandle typeHandle)
  1893.         {
  1894.             m_handle = typeHandle;
  1895.         }
  1896.        
  1897.         internal RuntimeType()
  1898.         {
  1899.         }
  1900.         #endregion
  1901.        
  1902.         #region Private\Internal Members
  1903.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  1904.         internal override bool CacheEquals(object o)
  1905.         {
  1906.             RuntimeType m = o as RuntimeType;
  1907.            
  1908.             if (m == null)
  1909.                 return false;
  1910.            
  1911.             return m.m_handle.Equals(m_handle);
  1912.         }
  1913.        
  1914.         private new RuntimeTypeCache Cache {
  1915.             get {
  1916.                 if (m_cache.IsNull()) {
  1917.                     IntPtr newgcHandle = m_handle.GetGCHandle(GCHandleType.WeakTrackResurrection);
  1918.                     IntPtr gcHandle = Interlocked.CompareExchange(ref m_cache, newgcHandle, (IntPtr)0);
  1919.                     if (!gcHandle.IsNull())
  1920.                         m_handle.FreeGCHandle(newgcHandle);
  1921.                 }
  1922.                
  1923.                 RuntimeTypeCache cache = GCHandle.InternalGet(m_cache) as RuntimeTypeCache;
  1924.                 if (cache == null) {
  1925.                     cache = new RuntimeTypeCache(this);
  1926.                     RuntimeTypeCache existingCache = GCHandle.InternalCompareExchange(m_cache, cache, null, false) as RuntimeTypeCache;
  1927.                     if (existingCache != null)
  1928.                         cache = existingCache;
  1929.                     if (s_typeCache == null)
  1930.                         s_typeCache = new TypeCacheQueue();
  1931.                     //s_typeCache.Add(cache);
  1932.                 }
  1933.                 /*
  1934.                 RuntimeTypeCache cache = m_cache as RuntimeTypeCache;
  1935.                 if (cache == null)
  1936.                 {
  1937.                     cache = new RuntimeTypeCache(TypeHandle);
  1938.                     RuntimeTypeCache existingCache = Interlocked.CompareExchange(ref m_cache, cache, null) as RuntimeTypeCache;
  1939.                     if (existingCache != null)
  1940.                         cache = existingCache;
  1941.                 }
  1942. */               
  1943. ASSERT.CONSISTENCY_CHECK(cache != null);
  1944.                 return cache;
  1945.             }
  1946.         }
  1947.         #endregion
  1948.        
  1949.         #region Type Overrides
  1950.        
  1951.         #region Get XXXInfo Candidates
  1952.         private MethodInfo[] GetMethodCandidates(string name, BindingFlags bindingAttr, CallingConventions callConv, Type[] types, bool allowPrefixLookup)
  1953.         {
  1954.             bool prefixLookup;
  1955.             bool ignoreCase;
  1956.             MemberListType listType;
  1957.             RuntimeType.FilterHelper(bindingAttr, ref name, allowPrefixLookup, out prefixLookup, out ignoreCase, out listType);
  1958.            
  1959.             List<MethodInfo> candidates = new List<MethodInfo>();
  1960.             CerArrayList<RuntimeMethodInfo> cache = Cache.GetMethodList(listType, name);
  1961.            
  1962.             bindingAttr ^= BindingFlags.DeclaredOnly;
  1963.            
  1964.             for (int i = 0; i < cache.Count; i++) {
  1965.                 RuntimeMethodInfo methodInfo = cache[i];
  1966.                 if ((bindingAttr & methodInfo.BindingFlags) == methodInfo.BindingFlags && FilterApplyMethodBaseInfo(methodInfo, bindingAttr, callConv, types) && (!prefixLookup || RuntimeType.FilterApplyPrefixLookup(methodInfo, name, ignoreCase))) {
  1967.                     candidates.Add(methodInfo);
  1968.                 }
  1969.             }
  1970.            
  1971.             return candidates.ToArray();
  1972.         }
  1973.        
  1974.        
  1975.         private ConstructorInfo[] GetConstructorCandidates(string name, BindingFlags bindingAttr, CallingConventions callConv, Type[] types, bool allowPrefixLookup)
  1976.         {
  1977.             bool prefixLookup;
  1978.             bool ignoreCase;
  1979.             MemberListType listType;
  1980.             RuntimeType.FilterHelper(bindingAttr, ref name, allowPrefixLookup, out prefixLookup, out ignoreCase, out listType);
  1981.            
  1982.             List<ConstructorInfo> candidates = new List<ConstructorInfo>();
  1983.             CerArrayList<RuntimeConstructorInfo> cache = Cache.GetConstructorList(listType, name);
  1984.            
  1985.             bindingAttr ^= BindingFlags.DeclaredOnly;
  1986.            
  1987.             for (int i = 0; i < cache.Count; i++) {
  1988.                 RuntimeConstructorInfo constructorInfo = cache[i];
  1989.                 if ((bindingAttr & constructorInfo.BindingFlags) == constructorInfo.BindingFlags && FilterApplyMethodBaseInfo(constructorInfo, bindingAttr, callConv, types) && (!prefixLookup || RuntimeType.FilterApplyPrefixLookup(constructorInfo, name, ignoreCase))) {
  1990.                     candidates.Add(constructorInfo);
  1991.                 }
  1992.             }
  1993.            
  1994.             return candidates.ToArray();
  1995.         }
  1996.        
  1997.        
  1998.         private PropertyInfo[] GetPropertyCandidates(string name, BindingFlags bindingAttr, Type[] types, bool allowPrefixLookup)
  1999.         {
  2000.             bool prefixLookup;
  2001.             bool ignoreCase;
  2002.             MemberListType listType;
  2003.             RuntimeType.FilterHelper(bindingAttr, ref name, allowPrefixLookup, out prefixLookup, out ignoreCase, out listType);
  2004.            
  2005.             List<PropertyInfo> candidates = new List<PropertyInfo>();
  2006.             CerArrayList<RuntimePropertyInfo> cache = Cache.GetPropertyList(listType, name);
  2007.            
  2008.             bindingAttr ^= BindingFlags.DeclaredOnly;
  2009.            
  2010.             for (int i = 0; i < cache.Count; i++) {
  2011.                 RuntimePropertyInfo propertyInfo = cache[i];
  2012.                 if ((bindingAttr & propertyInfo.BindingFlags) == propertyInfo.BindingFlags && (!prefixLookup || RuntimeType.FilterApplyPrefixLookup(propertyInfo, name, ignoreCase)) && (types == null || (propertyInfo.GetIndexParameters().Length == types.Length))) {
  2013.                     candidates.Add(propertyInfo);
  2014.                 }
  2015.             }
  2016.            
  2017.             return candidates.ToArray();
  2018.         }
  2019.        
  2020.        
  2021.         private EventInfo[] GetEventCandidates(string name, BindingFlags bindingAttr, bool allowPrefixLookup)
  2022.         {
  2023.             bool prefixLookup;
  2024.             bool ignoreCase;
  2025.             MemberListType listType;
  2026.             RuntimeType.FilterHelper(bindingAttr, ref name, allowPrefixLookup, out prefixLookup, out ignoreCase, out listType);
  2027.            
  2028.             List<EventInfo> candidates = new List<EventInfo>();
  2029.             CerArrayList<RuntimeEventInfo> cache = Cache.GetEventList(listType, name);
  2030.            
  2031.             bindingAttr ^= BindingFlags.DeclaredOnly;
  2032.            
  2033.             for (int i = 0; i < cache.Count; i++) {
  2034.                 RuntimeEventInfo eventInfo = cache[i];
  2035.                 if ((bindingAttr & eventInfo.BindingFlags) == eventInfo.BindingFlags && (!prefixLookup || RuntimeType.FilterApplyPrefixLookup(eventInfo, name, ignoreCase))) {
  2036.                     candidates.Add(eventInfo);
  2037.                 }
  2038.             }
  2039.            
  2040.             return candidates.ToArray();
  2041.         }
  2042.        
  2043.         private FieldInfo[] GetFieldCandidates(string name, BindingFlags bindingAttr, bool allowPrefixLookup)
  2044.         {
  2045.             bool prefixLookup;
  2046.             bool ignoreCase;
  2047.             MemberListType listType;
  2048.             RuntimeType.FilterHelper(bindingAttr, ref name, allowPrefixLookup, out prefixLookup, out ignoreCase, out listType);
  2049.            
  2050.             List<FieldInfo> candidates = new List<FieldInfo>();
  2051.             CerArrayList<RuntimeFieldInfo> cache = Cache.GetFieldList(listType, name);
  2052.            
  2053.             bindingAttr ^= BindingFlags.DeclaredOnly;
  2054.            
  2055.             for (int i = 0; i < cache.Count; i++) {
  2056.                 RuntimeFieldInfo fieldInfo = cache[i];
  2057.                 if ((bindingAttr & fieldInfo.BindingFlags) == fieldInfo.BindingFlags && (!prefixLookup || FilterApplyPrefixLookup(fieldInfo, name, ignoreCase))) {
  2058.                     candidates.Add(fieldInfo);
  2059.                 }
  2060.             }
  2061.            
  2062.             return candidates.ToArray();
  2063.         }
  2064.        
  2065.         private Type[] GetNestedTypeCandidates(string fullname, BindingFlags bindingAttr, bool allowPrefixLookup)
  2066.         {
  2067.             bool prefixLookup;
  2068.             bool ignoreCase;
  2069.             bindingAttr &= ~BindingFlags.Static;
  2070.             string name;
  2071.             string ns;
  2072.             MemberListType listType;
  2073.             SplitName(fullname, out name, out ns);
  2074.             RuntimeType.FilterHelper(bindingAttr, ref name, allowPrefixLookup, out prefixLookup, out ignoreCase, out listType);
  2075.            
  2076.             List<Type> candidates = new List<Type>();
  2077.             CerArrayList<RuntimeType> cache = Cache.GetNestedTypeList(listType, name);
  2078.            
  2079.             for (int i = 0; i < cache.Count; i++) {
  2080.                 RuntimeType nestedClass = cache[i];
  2081.                 if (RuntimeType.FilterApplyType(nestedClass, bindingAttr, name, prefixLookup, ns)) {
  2082.                     candidates.Add(nestedClass);
  2083.                 }
  2084.             }
  2085.            
  2086.             return candidates.ToArray();
  2087.         }
  2088.         #endregion
  2089.        
  2090.         #region Get All XXXInfos
  2091.         public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
  2092.         {
  2093.             return GetMethodCandidates(null, bindingAttr, CallingConventions.Any, null, false);
  2094.         }
  2095.        
  2096.         [System.Runtime.InteropServices.ComVisible(true)]
  2097.         public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
  2098.         {
  2099.             return GetConstructorCandidates(null, bindingAttr, CallingConventions.Any, null, false);
  2100.         }
  2101.        
  2102.         public override PropertyInfo[] GetProperties(BindingFlags bindingAttr)
  2103.         {
  2104.             return GetPropertyCandidates(null, bindingAttr, null, false);
  2105.         }
  2106.        
  2107.         public override EventInfo[] GetEvents(BindingFlags bindingAttr)
  2108.         {
  2109.             return GetEventCandidates(null, bindingAttr, false);
  2110.         }
  2111.        
  2112.         public override FieldInfo[] GetFields(BindingFlags bindingAttr)
  2113.         {
  2114.             return GetFieldCandidates(null, bindingAttr, false);
  2115.         }
  2116.        
  2117.         public override Type[] GetInterfaces()
  2118.         {
  2119.             CerArrayList<RuntimeType> candidates = this.Cache.GetInterfaceList(MemberListType.All, null);
  2120.             Type[] interfaces = new Type[candidates.Count];
  2121.             for (int i = 0; i < candidates.Count; i++)
  2122.                 FastArrayHandle.SetValueAt(interfaces, i, candidates[i]);
  2123.            
  2124.             return interfaces;
  2125.         }
  2126.        
  2127.         public override Type[] GetNestedTypes(BindingFlags bindingAttr)
  2128.         {
  2129.             return GetNestedTypeCandidates(null, bindingAttr, false);
  2130.         }
  2131.        
  2132.         public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
  2133.         {
  2134.             MethodInfo[] methods = GetMethodCandidates(null, bindingAttr, CallingConventions.Any, null, false);
  2135.             ConstructorInfo[] constructors = GetConstructorCandidates(null, bindingAttr, CallingConventions.Any, null, false);
  2136.             PropertyInfo[] properties = GetPropertyCandidates(null, bindingAttr, null, false);
  2137.             EventInfo[] events = GetEventCandidates(null, bindingAttr, false);
  2138.             FieldInfo[] fields = GetFieldCandidates(null, bindingAttr, false);
  2139.             Type[] nestedTypes = GetNestedTypeCandidates(null, bindingAttr, false);
  2140.             // Interfaces are excluded from the result of GetMembers
  2141.            
  2142.             MemberInfo[] members = new MemberInfo[methods.Length + constructors.Length + properties.Length + events.Length + fields.Length + nestedTypes.Length];
  2143.            
  2144.             int i = 0;
  2145.             Array.Copy(methods, 0, members, i, methods.Length);
  2146.             i += methods.Length;
  2147.             Array.Copy(constructors, 0, members, i, constructors.Length);
  2148.             i += constructors.Length;
  2149.             Array.Copy(properties, 0, members, i, properties.Length);
  2150.             i += properties.Length;
  2151.             Array.Copy(events, 0, members, i, events.Length);
  2152.             i += events.Length;
  2153.             Array.Copy(fields, 0, members, i, fields.Length);
  2154.             i += fields.Length;
  2155.             Array.Copy(nestedTypes, 0, members, i, nestedTypes.Length);
  2156.             i += nestedTypes.Length;
  2157.            
  2158.             ASSERT.POSTCONDITION(i == members.Length);
  2159.             return members;
  2160.         }
  2161.        
  2162.         public override InterfaceMapping GetInterfaceMap(Type ifaceType)
  2163.         {
  2164.             if (IsGenericParameter)
  2165.                 throw new InvalidOperationException(Environment.GetResourceString("Arg_GenericParameter"));
  2166.            
  2167.             if (ifaceType == null)
  2168.                 throw new ArgumentNullException("ifaceType");
  2169.            
  2170.             if (!(ifaceType is RuntimeType))
  2171.                 throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeType"), "ifaceType");
  2172.            
  2173.             RuntimeType ifaceRtType = ifaceType as RuntimeType;
  2174.             RuntimeTypeHandle ifaceRtTypeHandle = ifaceRtType.GetTypeHandleInternal();
  2175.            
  2176.             int firstIfaceSlot = GetTypeHandleInternal().GetFirstSlotForInterface(ifaceRtType.GetTypeHandleInternal());
  2177.             ASSERT.CONSISTENCY_CHECK(ifaceType.IsInterface);
  2178.             // GetFirstSlotForInterface enforces this invariant
  2179.             ASSERT.CONSISTENCY_CHECK(!IsInterface);
  2180.             // GetFirstSlotForInterface enforces this invariant
  2181.             int ifaceSlotCount = ifaceRtTypeHandle.GetInterfaceMethodSlots();
  2182.             int ifaceStaticMethodCount = 0;
  2183.            
  2184.             // @Optimization - Most interface have the same number of static members.
  2185.            
  2186.             // Filter out static methods
  2187.             for (int i = 0; i < ifaceSlotCount; i++) {
  2188.                 if ((ifaceRtTypeHandle.GetMethodAt(i).GetAttributes() & MethodAttributes.Static) != 0)
  2189.                     ifaceStaticMethodCount++;
  2190.             }
  2191.            
  2192.             int ifaceInstanceMethodCount = ifaceSlotCount - ifaceStaticMethodCount;
  2193.            
  2194.             InterfaceMapping im;
  2195.             im.InterfaceType = ifaceType;
  2196.             im.TargetType = this;
  2197.             im.InterfaceMethods = new MethodInfo[ifaceInstanceMethodCount];
  2198.             im.TargetMethods = new MethodInfo[ifaceInstanceMethodCount];
  2199.            
  2200.             for (int i = 0; i < ifaceSlotCount; i++) {
  2201.                 RuntimeMethodHandle ifaceRtMethodHandle = ifaceRtTypeHandle.GetMethodAt(i);
  2202.                 if ((ifaceRtTypeHandle.GetMethodAt(i).GetAttributes() & MethodAttributes.Static) != 0)
  2203.                     continue;
  2204.                
  2205.                 bool mayNeedInstantiatingStub = ifaceRtTypeHandle.HasInstantiation() && !ifaceRtTypeHandle.IsGenericTypeDefinition();
  2206.                
  2207.                 // if it is an instantiated type get the InstantiatedMethodDesc if needed
  2208.                 if (mayNeedInstantiatingStub)
  2209.                     ifaceRtMethodHandle = ifaceRtMethodHandle.GetInstantiatingStubIfNeeded(ifaceRtTypeHandle);
  2210.                
  2211.                 MethodBase ifaceMethodBase = RuntimeType.GetMethodBase(ifaceRtTypeHandle, ifaceRtMethodHandle);
  2212.                 ASSERT.CONSISTENCY_CHECK(ifaceMethodBase is RuntimeMethodInfo);
  2213.                 im.InterfaceMethods[i] = (MethodInfo)ifaceMethodBase;
  2214.                
  2215.                 // If the slot is -1, then virtual stub dispatch is active.
  2216.                 // Should remove old "firstIfaceSlot + i" code when old behaviour disappears.
  2217.                 int slot;
  2218.                 if (firstIfaceSlot == -1)
  2219.                     slot = GetTypeHandleInternal().GetInterfaceMethodImplementationSlot(ifaceRtTypeHandle, ifaceRtMethodHandle);
  2220.                 else
  2221.                     slot = firstIfaceSlot + i;
  2222.                
  2223.                 if (slot == -1)
  2224.                     continue;
  2225.                
  2226.                
  2227.                 RuntimeTypeHandle classRtTypeHandle = GetTypeHandleInternal();
  2228.                 RuntimeMethodHandle classRtMethodHandle = classRtTypeHandle.GetMethodAt(slot);
  2229.                
  2230.                 mayNeedInstantiatingStub = classRtTypeHandle.HasInstantiation() && !classRtTypeHandle.IsGenericTypeDefinition();
  2231.                
  2232.                 if (mayNeedInstantiatingStub)
  2233.                     classRtMethodHandle = classRtMethodHandle.GetInstantiatingStubIfNeeded(classRtTypeHandle);
  2234.                
  2235.                 MethodBase rtTypeMethodBase = RuntimeType.GetMethodBase(classRtTypeHandle, classRtMethodHandle);
  2236.                 // a class may not implement all the methods of an interface (abstract class) so null is a valid value
  2237.                 ASSERT.CONSISTENCY_CHECK(rtTypeMethodBase == null || rtTypeMethodBase is RuntimeMethodInfo);
  2238.                 im.TargetMethods[i] = (MethodInfo)rtTypeMethodBase;
  2239.             }
  2240.            
  2241.             return im;
  2242.         }
  2243.         #endregion
  2244.        
  2245.         #region Find XXXInfo
  2246.         protected override MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConv, Type[] types, ParameterModifier[] modifiers)
  2247.         {
  2248.             MethodInfo[] candidates = GetMethodCandidates(name, bindingAttr, callConv, types, false);
  2249.            
  2250.             if (candidates.Length == 0)
  2251.                 return null;
  2252.            
  2253.             if (types == null || types.Length == 0) {
  2254.                 if (candidates.Length == 1) {
  2255.                     return candidates[0];
  2256.                 }
  2257.                 else if (types == null) {
  2258.                     for (int j = 1; j < candidates.Length; j++) {
  2259.                         MethodInfo methodInfo = candidates[j];
  2260.                         if (!System.DefaultBinder.CompareMethodSigAndName(methodInfo, candidates[0])) {
  2261.                             throw new AmbiguousMatchException(Environment.GetResourceString("RFLCT.Ambiguous"));
  2262.                         }
  2263.                     }
  2264.                    
  2265.                     // All the methods have the exact same name and sig so return the most derived one.
  2266.                     return System.DefaultBinder.FindMostDerivedNewSlotMeth(candidates, candidates.Length) as MethodInfo;
  2267.                 }
  2268.             }
  2269.            
  2270.             if (binder == null)
  2271.                 binder = DefaultBinder;
  2272.            
  2273.             return binder.SelectMethod(bindingAttr, candidates, types, modifiers) as MethodInfo;
  2274.         }
  2275.        
  2276.        
  2277.         protected override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
  2278.         {
  2279.             ConstructorInfo[] candidates = GetConstructorCandidates(null, bindingAttr, CallingConventions.Any, types, false);
  2280.            
  2281.             if (binder == null)
  2282.                 binder = DefaultBinder;
  2283.            
  2284.             if (candidates.Length == 0)
  2285.                 return null;
  2286.            
  2287.             if (types.Length == 0 && candidates.Length == 1) {
  2288.                 ParameterInfo[] parameters = (candidates[0]).GetParametersNoCopy();
  2289.                 if (parameters == null || parameters.Length == 0) {
  2290.                     return candidates[0];
  2291.                 }
  2292.             }
  2293.            
  2294.             if ((bindingAttr & BindingFlags.ExactBinding) != 0)
  2295.                 return System.DefaultBinder.ExactBinding(candidates, types, modifiers) as ConstructorInfo;
  2296.            
  2297.             return binder.SelectMethod(bindingAttr, candidates, types, modifiers) as ConstructorInfo;
  2298.         }
  2299.        
  2300.        
  2301.         protected override PropertyInfo GetPropertyImpl(string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)
  2302.         {
  2303.             if (name == null)
  2304.                 throw new ArgumentNullException();
  2305.            
  2306.             PropertyInfo[] candidates = GetPropertyCandidates(name, bindingAttr, types, false);
  2307.            
  2308.             if (binder == null)
  2309.                 binder = DefaultBinder;
  2310.            
  2311.             if (candidates.Length == 0)
  2312.                 return null;
  2313.            
  2314.             if (types == null || types.Length == 0) {
  2315.                 // no arguments
  2316.                 if (candidates.Length == 1) {
  2317.                     if (returnType != null && returnType != candidates[0].PropertyType)
  2318.                         return null;
  2319.                    
  2320.                     return candidates[0];
  2321.                 }
  2322.                 else {
  2323.                     if (returnType == null)
  2324.                         // if we are here we have no args or property type to select over and we have more than one property with that name
  2325.                         throw new AmbiguousMatchException(Environment.GetResourceString("RFLCT.Ambiguous"));
  2326.                 }
  2327.             }
  2328.            
  2329.             if ((bindingAttr & BindingFlags.ExactBinding) != 0)
  2330.                 return System.DefaultBinder.ExactPropertyBinding(candidates, returnType, types, modifiers);
  2331.            
  2332.             return binder.SelectProperty(bindingAttr, candidates, returnType, types, modifiers);
  2333.         }
  2334.        
  2335.        
  2336.         public override EventInfo GetEvent(string name, BindingFlags bindingAttr)
  2337.         {
  2338.             if (name == null)
  2339.                 throw new ArgumentNullException();
  2340.            
  2341.             bool ignoreCase;
  2342.             MemberListType listType;
  2343.             RuntimeType.FilterHelper(bindingAttr, ref name, out ignoreCase, out listType);
  2344.            
  2345.             CerArrayList<RuntimeEventInfo> cache = Cache.GetEventList(listType, name);
  2346.             EventInfo match = null;
  2347.            
  2348.             bindingAttr ^= BindingFlags.DeclaredOnly;
  2349.            
  2350.             for (int i = 0; i < cache.Count; i++) {
  2351.                 RuntimeEventInfo eventInfo = cache[i];
  2352.                 if ((bindingAttr & eventInfo.BindingFlags) == eventInfo.BindingFlags) {
  2353.                     if (match != null)
  2354.                         throw new AmbiguousMatchException(Environment.GetResourceString("RFLCT.Ambiguous"));
  2355.                    
  2356.                     match = eventInfo;
  2357.                 }
  2358.             }
  2359.            
  2360.             return match;
  2361.         }
  2362.        
  2363.         public override FieldInfo GetField(string name, BindingFlags bindingAttr)
  2364.         {
  2365.             if (name == null)
  2366.                 throw new ArgumentNullException();
  2367.            
  2368.             bool ignoreCase;
  2369.             MemberListType listType;
  2370.             RuntimeType.FilterHelper(bindingAttr, ref name, out ignoreCase, out listType);
  2371.            
  2372.             CerArrayList<RuntimeFieldInfo> cache = Cache.GetFieldList(listType, name);
  2373.             FieldInfo match = null;
  2374.            
  2375.             bindingAttr ^= BindingFlags.DeclaredOnly;
  2376.             bool multipleStaticFieldMatches = false;
  2377.            
  2378.             for (int i = 0; i < cache.Count; i++) {
  2379.                 RuntimeFieldInfo fieldInfo = cache[i];
  2380.                 if ((bindingAttr & fieldInfo.BindingFlags) == fieldInfo.BindingFlags) {
  2381.                     if (match != null) {
  2382.                         if (fieldInfo.DeclaringType == match.DeclaringType)
  2383.                             throw new AmbiguousMatchException(Environment.GetResourceString("RFLCT.Ambiguous"));
  2384.                        
  2385.                         if ((match.DeclaringType.IsInterface == true) && (fieldInfo.DeclaringType.IsInterface == true))
  2386.                             multipleStaticFieldMatches = true;
  2387.                     }
  2388.                    
  2389.                     if (match == null || fieldInfo.DeclaringType.IsSubclassOf(match.DeclaringType) || match.DeclaringType.IsInterface)
  2390.                         match = fieldInfo;
  2391.                 }
  2392.             }
  2393.            
  2394.             if (multipleStaticFieldMatches && match.DeclaringType.IsInterface)
  2395.                 throw new AmbiguousMatchException(Environment.GetResourceString("RFLCT.Ambiguous"));
  2396.            
  2397.             return match;
  2398.         }
  2399.        
  2400.         public override Type GetInterface(string fullname, bool ignoreCase)
  2401.         {
  2402.             if (fullname == null)
  2403.                 throw new ArgumentNullException();
  2404.            
  2405.             BindingFlags bindingAttr = BindingFlags.Public | BindingFlags.NonPublic;
  2406.            
  2407.             bindingAttr &= ~BindingFlags.Static;
  2408.            
  2409.             if (ignoreCase)
  2410.                 bindingAttr |= BindingFlags.IgnoreCase;
  2411.            
  2412.             string name;
  2413.             string ns;
  2414.             MemberListType listType;
  2415.             SplitName(fullname, out name, out ns);
  2416.             RuntimeType.FilterHelper(bindingAttr, ref name, out ignoreCase, out listType);
  2417.            
  2418.             CerArrayList<RuntimeType> cache = Cache.GetInterfaceList(listType, name);
  2419.            
  2420.             RuntimeType match = null;
  2421.            
  2422.             for (int i = 0; i < cache.Count; i++) {
  2423.                 RuntimeType iface = cache[i];
  2424.                 if (RuntimeType.FilterApplyType(iface, bindingAttr, name, false, ns)) {
  2425.                     if (match != null)
  2426.                         throw new AmbiguousMatchException(Environment.GetResourceString("RFLCT.Ambiguous"));
  2427.                    
  2428.                     match = iface;
  2429.                 }
  2430.             }
  2431.            
  2432.             return match;
  2433.         }
  2434.        
  2435.         public override Type GetNestedType(string fullname, BindingFlags bindingAttr)
  2436.         {
  2437.             if (fullname == null)
  2438.                 throw new ArgumentNullException();
  2439.            
  2440.             bool ignoreCase;
  2441.             bindingAttr &= ~BindingFlags.Static;
  2442.             string name;
  2443.             string ns;
  2444.             MemberListType listType;
  2445.             SplitName(fullname, out name, out ns);
  2446.             RuntimeType.FilterHelper(bindingAttr, ref name, out ignoreCase, out listType);
  2447.            
  2448.             CerArrayList<RuntimeType> cache = Cache.GetNestedTypeList(listType, name);
  2449.            
  2450.             RuntimeType match = null;
  2451.            
  2452.             for (int i = 0; i < cache.Count; i++) {
  2453.                 RuntimeType nestedType = cache[i];
  2454.                 if (RuntimeType.FilterApplyType(nestedType, bindingAttr, name, false, ns)) {
  2455.                     if (match != null)
  2456.                         throw new AmbiguousMatchException(Environment.GetResourceString("RFLCT.Ambiguous"));
  2457.                    
  2458.                     match = nestedType;
  2459.                 }
  2460.             }
  2461.            
  2462.             return match;
  2463.         }
  2464.        
  2465.         public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
  2466.         {
  2467.             if (name == null)
  2468.                 throw new ArgumentNullException();
  2469.            
  2470.             MethodInfo[] methods = new MethodInfo[0];
  2471.             ConstructorInfo[] constructors = new ConstructorInfo[0];
  2472.             PropertyInfo[] properties = new PropertyInfo[0];
  2473.             EventInfo[] events = new EventInfo[0];
  2474.             FieldInfo[] fields = new FieldInfo[0];
  2475.             Type[] nestedTypes = new Type[0];
  2476.            
  2477.             // Methods
  2478.             if ((type & MemberTypes.Method) != 0)
  2479.                 methods = GetMethodCandidates(name, bindingAttr, CallingConventions.Any, null, true);
  2480.            
  2481.             // Constructors
  2482.             if ((type & MemberTypes.Constructor) != 0)
  2483.                 constructors = GetConstructorCandidates(name, bindingAttr, CallingConventions.Any, null, true);
  2484.            
  2485.             // Properties
  2486.             if ((type & MemberTypes.Property) != 0)
  2487.                 properties = GetPropertyCandidates(name, bindingAttr, null, true);
  2488.            
  2489.             // Events
  2490.             if ((type & MemberTypes.Event) != 0)
  2491.                 events = GetEventCandidates(name, bindingAttr, true);
  2492.            
  2493.             // Fields
  2494.             if ((type & MemberTypes.Field) != 0)
  2495.                 fields = GetFieldCandidates(name, bindingAttr, true);
  2496.            
  2497.             // NestedTypes
  2498.             if ((type & (MemberTypes.NestedType | MemberTypes.TypeInfo)) != 0)
  2499.                 nestedTypes = GetNestedTypeCandidates(name, bindingAttr, true);
  2500.            
  2501.             switch (type) {
  2502.                 case MemberTypes.Method | MemberTypes.Constructor:
  2503.                     MethodBase[] compressBaseses = new MethodBase[methods.Length + constructors.Length];
  2504.                     Array.Copy(methods, compressBaseses, methods.Length);
  2505.                     Array.Copy(constructors, 0, compressBaseses, methods.Length, constructors.Length);
  2506.                     return compressBaseses;
  2507.                 case MemberTypes.Method:
  2508.                    
  2509.                     return methods;
  2510.                 case MemberTypes.Constructor:
  2511.                    
  2512.                     return constructors;
  2513.                 case MemberTypes.Field:
  2514.                    
  2515.                     return fields;
  2516.                 case MemberTypes.Property:
  2517.                    
  2518.                     return properties;
  2519.                 case MemberTypes.Event:
  2520.                    
  2521.                     return events;
  2522.                 case MemberTypes.NestedType:
  2523.                    
  2524.                     return nestedTypes;
  2525.                 case MemberTypes.TypeInfo:
  2526.                    
  2527.                     return nestedTypes;
  2528.             }
  2529.            
  2530.             MemberInfo[] compressMembers = new MemberInfo[methods.Length + constructors.Length + properties.Length + events.Length + fields.Length + nestedTypes.Length];
  2531.            
  2532.             int i = 0;
  2533.             if (methods.Length > 0)
  2534.                 Array.Copy(methods, 0, compressMembers, i, methods.Length);
  2535.             i += methods.Length;
  2536.             if (constructors.Length > 0)
  2537.                 Array.Copy(constructors, 0, compressMembers, i, constructors.Length);
  2538.             i += constructors.Length;
  2539.             if (properties.Length > 0)
  2540.                 Array.Copy(properties, 0, compressMembers, i, properties.Length);
  2541.             i += properties.Length;
  2542.             if (events.Length > 0)
  2543.                 Array.Copy(events, 0, compressMembers, i, events.Length);
  2544.             i += events.Length;
  2545.             if (fields.Length > 0)
  2546.                 Array.Copy(fields, 0, compressMembers, i, fields.Length);
  2547.             i += fields.Length;
  2548.             if (nestedTypes.Length > 0)
  2549.                 Array.Copy(nestedTypes, 0, compressMembers, i, nestedTypes.Length);
  2550.             i += nestedTypes.Length;
  2551.            
  2552.             ASSERT.POSTCONDITION(i == compressMembers.Length);
  2553.             return compressMembers;
  2554.         }
  2555.         #endregion
  2556.        
  2557.         #region Identity
  2558.         public override Module Module {
  2559.             get { return GetTypeHandleInternal().GetModuleHandle().GetModule(); }
  2560.         }
  2561.        
  2562.         public override Assembly Assembly {
  2563.             get { return GetTypeHandleInternal().GetAssemblyHandle().GetAssembly(); }
  2564.         }
  2565.        
  2566.         public override RuntimeTypeHandle TypeHandle {
  2567.             get { return m_handle; }
  2568.         }
  2569.        
  2570.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  2571.         internal override RuntimeTypeHandle GetTypeHandleInternal()
  2572.         {
  2573.             return m_handle;
  2574.         }
  2575.        
  2576.         internal override TypeCode GetTypeCodeInternal()
  2577.         {
  2578.             TypeCode typeCode = Cache.TypeCode;
  2579.            
  2580.             if (typeCode != TypeCode.Empty)
  2581.                 return typeCode;
  2582.            
  2583.             CorElementType corElementType = GetTypeHandleInternal().GetCorElementType();
  2584.             switch (corElementType) {
  2585.                 case CorElementType.Boolean:
  2586.                     typeCode = TypeCode.Boolean;
  2587.                     break;
  2588.                 case CorElementType.Char:
  2589.                     typeCode = TypeCode.Char;
  2590.                     break;
  2591.                 case CorElementType.I1:
  2592.                     typeCode = TypeCode.SByte;
  2593.                     break;
  2594.                 case CorElementType.U1:
  2595.                     typeCode = TypeCode.Byte;
  2596.                     break;
  2597.                 case CorElementType.I2:
  2598.                     typeCode = TypeCode.Int16;
  2599.                     break;
  2600.                 case CorElementType.U2:
  2601.                     typeCode = TypeCode.UInt16;
  2602.                     break;
  2603.                 case CorElementType.I4:
  2604.                     typeCode = TypeCode.Int32;
  2605.                     break;
  2606.                 case CorElementType.U4:
  2607.                     typeCode = TypeCode.UInt32;
  2608.                     break;
  2609.                 case CorElementType.I8:
  2610.                     typeCode = TypeCode.Int64;
  2611.                     break;
  2612.                 case CorElementType.U8:
  2613.                     typeCode = TypeCode.UInt64;
  2614.                     break;
  2615.                 case CorElementType.R4:
  2616.                     typeCode = TypeCode.Single;
  2617.                     break;
  2618.                 case CorElementType.R8:
  2619.                     typeCode = TypeCode.Double;
  2620.                     break;
  2621.                 case CorElementType.String:
  2622.                     typeCode = TypeCode.String;
  2623.                     break;
  2624.                 case CorElementType.ValueType:
  2625.                     if (this == Convert.ConvertTypes[(int)TypeCode.Decimal])
  2626.                         typeCode = TypeCode.Decimal;
  2627.                     else if (this == Convert.ConvertTypes[(int)TypeCode.DateTime])
  2628.                         typeCode = TypeCode.DateTime;
  2629.                     else if (this.IsEnum)
  2630.                         typeCode = Type.GetTypeCode(Enum.GetUnderlyingType(this));
  2631.                     else
  2632.                         typeCode = TypeCode.Object;
  2633.                     break;
  2634.                 default:
  2635.                     if (this == Convert.ConvertTypes[(int)TypeCode.DBNull])
  2636.                         typeCode = TypeCode.DBNull;
  2637.                     else if (this == Convert.ConvertTypes[(int)TypeCode.String])
  2638.                         typeCode = TypeCode.String;
  2639.                     else
  2640.                         typeCode = TypeCode.Object;
  2641.                     break;
  2642.             }
  2643.            
  2644.             Cache.TypeCode = typeCode;
  2645.            
  2646.             return typeCode;
  2647.         }
  2648.        
  2649.         public override MethodBase DeclaringMethod {
  2650.             get {
  2651.                 if (!IsGenericParameter)
  2652.                     throw new InvalidOperationException(Environment.GetResourceString("Arg_NotGenericParameter"));
  2653.                
  2654.                 RuntimeMethodHandle declaringMethod = GetTypeHandleInternal().GetDeclaringMethod();
  2655.                
  2656.                 if (declaringMethod.IsNullHandle())
  2657.                     return null;
  2658.                
  2659.                 return GetMethodBase(declaringMethod.GetDeclaringType(), declaringMethod);
  2660.             }
  2661.         }
  2662.         #endregion
  2663.        
  2664.         #region Hierarchy
  2665.         public override bool IsInstanceOfType(object o)
  2666.         {
  2667.             return GetTypeHandleInternal().IsInstanceOfType(o);
  2668.         }
  2669.        
  2670.         [System.Runtime.InteropServices.ComVisible(true)]
  2671.         public override bool IsSubclassOf(Type type)
  2672.         {
  2673.             if (type == null)
  2674.                 throw new ArgumentNullException("type");
  2675.             ASSERT.PRECONDITION(type is RuntimeType);
  2676.            
  2677.             Type baseType = BaseType;
  2678.            
  2679.             while (baseType != null) {
  2680.                 if (baseType == type)
  2681.                     return true;
  2682.                
  2683.                 baseType = baseType.BaseType;
  2684.             }
  2685.            
  2686.             // pretty much everything is a subclass of object, even interfaces
  2687.             // notice that interfaces are really odd because they do not have a BaseType
  2688.             // yet IsSubclassOf(typeof(object)) returns true
  2689.             if (type == typeof(object) && type != this)
  2690.                 return true;
  2691.            
  2692.             return false;
  2693.         }
  2694.        
  2695.         public override Type BaseType {
  2696.             get {
  2697.                 if (IsInterface)
  2698.                     return null;
  2699.                
  2700.                 if (m_handle.IsGenericVariable()) {
  2701.                     Type[] constraints = GetGenericParameterConstraints();
  2702.                    
  2703.                     Type baseType = typeof(object);
  2704.                    
  2705.                     for (int i = 0; i < constraints.Length; i++) {
  2706.                         Type constraint = constraints[i];
  2707.                        
  2708.                         if (constraint.IsInterface)
  2709.                             continue;
  2710.                        
  2711.                         if (constraint.IsGenericParameter) {
  2712.                             GenericParameterAttributes special;
  2713.                             special = constraint.GenericParameterAttributes & GenericParameterAttributes.SpecialConstraintMask;
  2714.                            
  2715.                             if ((special & GenericParameterAttributes.ReferenceTypeConstraint) == 0 && (special & GenericParameterAttributes.NotNullableValueTypeConstraint) == 0)
  2716.                                 continue;
  2717.                         }
  2718.                        
  2719.                         baseType = constraint;
  2720.                     }
  2721.                    
  2722.                     if (baseType == typeof(object)) {
  2723.                         GenericParameterAttributes special;
  2724.                         special = GenericParameterAttributes & GenericParameterAttributes.SpecialConstraintMask;
  2725.                         if ((special & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0)
  2726.                             baseType = typeof(ValueType);
  2727.                     }
  2728.                    
  2729.                     return baseType;
  2730.                 }
  2731.                
  2732.                 return m_handle.GetBaseTypeHandle().GetRuntimeType();
  2733.             }
  2734.         }
  2735.        
  2736.         public override Type UnderlyingSystemType {
  2737. // Origional Comment: Return the underlying Type that represents the IReflect Object.
  2738. // For expando object, this is the (Object) IReflectInstance.GetType(). For Type object it is this.
  2739.             get { return this; }
  2740.         }
  2741.         #endregion
  2742.        
  2743.         #region Name
  2744.         public override string FullName {
  2745.             get { return Cache.GetFullName(); }
  2746.         }
  2747.        
  2748.         public override string AssemblyQualifiedName {
  2749.             get {
  2750.                 if (!IsGenericTypeDefinition && ContainsGenericParameters)
  2751.                     return null;
  2752.                
  2753.                 return Assembly.CreateQualifiedName(this.Assembly.FullName, this.FullName);
  2754.             }
  2755.         }
  2756.        
  2757.         public override string Namespace {
  2758.             get {
  2759.                 string ns = Cache.GetNameSpace();
  2760.                
  2761.                 if (ns == null || ns.Length == 0)
  2762.                     return null;
  2763.                
  2764.                 return ns;
  2765.             }
  2766.         }
  2767.         #endregion
  2768.        
  2769.         #region Attributes
  2770.         protected override TypeAttributes GetAttributeFlagsImpl()
  2771.         {
  2772.             return m_handle.GetAttributes();
  2773.         }
  2774.        
  2775.         public override Guid GUID {
  2776.             get {
  2777.                 Guid result = new Guid();
  2778.                 GetGUID(ref result);
  2779.                 return result;
  2780.             }
  2781.         }
  2782.        
  2783.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  2784.         private extern void GetGUID(ref Guid result);
  2785.        
  2786.         protected override bool IsContextfulImpl()
  2787.         {
  2788.             return GetTypeHandleInternal().IsContextful();
  2789.         }
  2790.        
  2791. /*
  2792.         protected override bool IsMarshalByRefImpl()
  2793.         {
  2794.             return GetTypeHandleInternal().IsMarshalByRef();
  2795.         }
  2796.         */       
  2797.        
  2798.         protected override bool IsByRefImpl()
  2799.         {
  2800.             CorElementType corElemType = GetTypeHandleInternal().GetCorElementType();
  2801.             return (corElemType == CorElementType.ByRef);
  2802.         }
  2803.        
  2804.         protected override bool IsPrimitiveImpl()
  2805.         {
  2806.             CorElementType corElemType = GetTypeHandleInternal().GetCorElementType();
  2807.            
  2808.             return (corElemType >= CorElementType.Boolean && corElemType <= CorElementType.R8) || corElemType == CorElementType.I || corElemType == CorElementType.U;
  2809.         }
  2810.        
  2811.         protected override bool IsPointerImpl()
  2812.         {
  2813.             CorElementType corElemType = GetTypeHandleInternal().GetCorElementType();
  2814.             return (corElemType == CorElementType.Ptr);
  2815.         }
  2816.        
  2817.         protected override bool IsCOMObjectImpl()
  2818.         {
  2819.             return GetTypeHandleInternal().IsComObject(false);
  2820.         }
  2821.        
  2822.         internal override bool HasProxyAttributeImpl()
  2823.         {
  2824.             return GetTypeHandleInternal().HasProxyAttribute();
  2825.         }
  2826.        
  2827.         protected override bool HasElementTypeImpl()
  2828.         {
  2829.             return (IsArray || IsPointer || IsByRef);
  2830.         }
  2831.        
  2832.         public override GenericParameterAttributes GenericParameterAttributes {
  2833.             get {
  2834.                 if (!IsGenericParameter)
  2835.                     throw new InvalidOperationException(Environment.GetResourceString("Arg_NotGenericParameter"));
  2836.                
  2837.                 GenericParameterAttributes attributes;
  2838.                
  2839.                 GetTypeHandleInternal().GetModuleHandle().GetMetadataImport().GetGenericParamProps(MetadataToken, out attributes);
  2840.                
  2841.                 return attributes;
  2842.             }
  2843.         }
  2844.         #endregion
  2845.        
  2846.         #region Arrays
  2847.         internal override bool IsSzArray {
  2848.             get {
  2849.                 CorElementType corElemType = GetTypeHandleInternal().GetCorElementType();
  2850.                 return (corElemType == CorElementType.SzArray);
  2851.             }
  2852.         }
  2853.        
  2854.         protected override bool IsArrayImpl()
  2855.         {
  2856.             CorElementType corElemType = GetTypeHandleInternal().GetCorElementType();
  2857.             return (corElemType == CorElementType.Array || corElemType == CorElementType.SzArray);
  2858.         }
  2859.        
  2860.         public override int GetArrayRank()
  2861.         {
  2862.             if (!IsArrayImpl())
  2863.                 throw new ArgumentException(Environment.GetResourceString("Argument_HasToBeArrayClass"));
  2864.            
  2865.             return GetTypeHandleInternal().GetArrayRank();
  2866.         }
  2867.        
  2868.         public override Type GetElementType()
  2869.         {
  2870.             return GetTypeHandleInternal().GetElementType().GetRuntimeType();
  2871.         }
  2872.         #endregion
  2873.        
  2874.         #region Generics
  2875.         public override Type[] GetGenericArguments()
  2876.         {
  2877.             Type[] rtypes = null;
  2878.             RuntimeTypeHandle[] types = GetRootElementType().GetTypeHandleInternal().GetInstantiation();
  2879.            
  2880.             if (types != null) {
  2881.                 rtypes = new Type[types.Length];
  2882.                
  2883.                 for (int i = 0; i < types.Length; i++)
  2884.                     rtypes[i] = types[i].GetRuntimeType();
  2885.             }
  2886.             else {
  2887.                 rtypes = new Type[0];
  2888.             }
  2889.            
  2890.             return rtypes;
  2891.         }
  2892.        
  2893.         public override Type MakeGenericType(Type[] instantiation)
  2894.         {
  2895.             if (instantiation == null)
  2896.                 throw new ArgumentNullException("instantiation");
  2897.            
  2898.             Type[] instantiationCopy = new Type[instantiation.Length];
  2899.             for (int i = 0; i < instantiation.Length; i++)
  2900.                 instantiationCopy[i] = instantiation[i];
  2901.             instantiation = instantiationCopy;
  2902.            
  2903.             if (!IsGenericTypeDefinition)
  2904.                 throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Arg_NotGenericTypeDefinition"), this));
  2905.            
  2906.             for (int i = 0; i < instantiation.Length; i++) {
  2907.                 if (instantiation[i] == null)
  2908.                     throw new ArgumentNullException();
  2909.                
  2910.                 if (!(instantiation[i] is RuntimeType))
  2911.                     return new TypeBuilderInstantiation(this, instantiation);
  2912.             }
  2913.            
  2914.             Type[] genericParameters = GetGenericArguments();
  2915.            
  2916.             SanityCheckGenericArguments(instantiation, genericParameters);
  2917.            
  2918.             RuntimeTypeHandle[] typeHandles = new RuntimeTypeHandle[instantiation.Length];
  2919.            
  2920.             for (int i = 0; i < instantiation.Length; i++)
  2921.                 typeHandles[i] = instantiation[i].GetTypeHandleInternal();
  2922.            
  2923.             Type ret = null;
  2924.             try {
  2925.                 ret = m_handle.Instantiate(typeHandles).GetRuntimeType();
  2926.             }
  2927.             catch (TypeLoadException e) {
  2928.                 ValidateGenericArguments(this, instantiation, e);
  2929.                 throw e;
  2930.             }
  2931.            
  2932.             return ret;
  2933.         }
  2934.        
  2935.         public override bool IsGenericTypeDefinition {
  2936.             get { return m_handle.IsGenericTypeDefinition(); }
  2937.         }
  2938.        
  2939.         public override bool IsGenericParameter {
  2940.             get { return m_handle.IsGenericVariable(); }
  2941.         }
  2942.        
  2943.         public override int GenericParameterPosition {
  2944.             get {
  2945.                 if (!IsGenericParameter)
  2946.                     throw new InvalidOperationException(Environment.GetResourceString("Arg_NotGenericParameter"));
  2947.                
  2948.                 return m_handle.GetGenericVariableIndex();
  2949.             }
  2950.         }
  2951.        
  2952.         public override Type GetGenericTypeDefinition()
  2953.         {
  2954.             if (!IsGenericType)
  2955.                 throw new InvalidOperationException();
  2956.            
  2957.             return m_handle.GetGenericTypeDefinition().GetRuntimeType();
  2958.         }
  2959.        
  2960.         public override bool IsGenericType {
  2961.             get { return HasElementType ? false : GetTypeHandleInternal().HasInstantiation(); }
  2962.         }
  2963.        
  2964.         public override bool ContainsGenericParameters {
  2965.             get { return GetRootElementType().GetTypeHandleInternal().ContainsGenericVariables(); }
  2966.         }
  2967.        
  2968.         public override Type[] GetGenericParameterConstraints()
  2969.         {
  2970.             if (!IsGenericParameter)
  2971.                 throw new InvalidOperationException(Environment.GetResourceString("Arg_NotGenericParameter"));
  2972.            
  2973.             RuntimeTypeHandle[] constraintHandles = m_handle.GetConstraints();
  2974.             Type[] constraints = new Type[constraintHandles.Length];
  2975.            
  2976.             for (int i = 0; i < constraints.Length; i++)
  2977.                 constraints[i] = constraintHandles[i].GetRuntimeType();
  2978.            
  2979.             return constraints;
  2980.         }
  2981.         #endregion
  2982.        
  2983.         #region Misc
  2984.         public override Type MakePointerType()
  2985.         {
  2986.             return m_handle.MakePointer().GetRuntimeType();
  2987.         }
  2988.         public override Type MakeByRefType()
  2989.         {
  2990.             return m_handle.MakeByRef().GetRuntimeType();
  2991.         }
  2992.         public override Type MakeArrayType()
  2993.         {
  2994.             return m_handle.MakeSZArray().GetRuntimeType();
  2995.         }
  2996.         public override Type MakeArrayType(int rank)
  2997.         {
  2998.             if (rank <= 0)
  2999.                 throw new IndexOutOfRangeException();
  3000.            
  3001.             return m_handle.MakeArray(rank).GetRuntimeType();
  3002.         }
  3003.         public override StructLayoutAttribute StructLayoutAttribute {
  3004.             get { return (StructLayoutAttribute)StructLayoutAttribute.GetCustomAttribute(this); }
  3005.         }
  3006.         #endregion
  3007.        
  3008.         #region Invoke Member
  3009.         private const BindingFlags MemberBindingMask = (BindingFlags)255;
  3010.         private const BindingFlags InvocationMask = (BindingFlags)65280;
  3011.         private const BindingFlags BinderNonCreateInstance = BindingFlags.InvokeMethod | BinderGetSetField | BinderGetSetProperty;
  3012.         private const BindingFlags BinderGetSetProperty = BindingFlags.GetProperty | BindingFlags.SetProperty;
  3013.         private const BindingFlags BinderSetInvokeProperty = BindingFlags.InvokeMethod | BindingFlags.SetProperty;
  3014.         private const BindingFlags BinderGetSetField = BindingFlags.GetField | BindingFlags.SetField;
  3015.         private const BindingFlags BinderSetInvokeField = BindingFlags.SetField | BindingFlags.InvokeMethod;
  3016.         private const BindingFlags BinderNonFieldGetSet = (BindingFlags)16773888;
  3017.         private const BindingFlags ClassicBindingMask = BindingFlags.InvokeMethod | BindingFlags.GetProperty | BindingFlags.SetProperty | BindingFlags.PutDispProperty | BindingFlags.PutRefDispProperty;
  3018.         private static Type s_typedRef = typeof(TypedReference);
  3019.        
  3020.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  3021.         private static extern bool CanValueSpecialCast(IntPtr valueType, IntPtr targetType);
  3022.        
  3023.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  3024.         private static extern object AllocateObjectForByRef(RuntimeTypeHandle type, object value);
  3025.        
  3026.         unsafe internal object CheckValue(object value, Binder binder, CultureInfo culture, BindingFlags invokeAttr)
  3027.         {
  3028.             // this method is used by invocation in reflection to check whether a value can be assigned to type.
  3029.             if (IsInstanceOfType(value))
  3030.                 return value;
  3031.            
  3032.             // if this is a ByRef get the element type and check if it's compatible
  3033.             bool isByRef = IsByRef;
  3034.             if (isByRef) {
  3035.                 Type elementType = GetElementType();
  3036.                 if (elementType.IsInstanceOfType(value) || value == null) {
  3037.                     // need to create an instance of the ByRef if null was provided, but only if primitive, enum or value type
  3038.                     return AllocateObjectForByRef(elementType.TypeHandle, value);
  3039.                 }
  3040.             }
  3041.             else if (value == null)
  3042.                 return value;
  3043.             else if (this == s_typedRef)
  3044.                 // everything works for a typedref
  3045.                 return value;
  3046.            
  3047.             // check the strange ones courtesy of reflection:
  3048.             // - implicit cast between primitives
  3049.             // - enum treated as underlying type
  3050.             // - IntPtr and System.Reflection.Pointer to pointer types
  3051.             bool needsSpecialCast = IsPointer || IsEnum || IsPrimitive;
  3052.             if (needsSpecialCast) {
  3053.                 Type valueType;
  3054.                 Pointer pointer = value as Pointer;
  3055.                 if (pointer != null)
  3056.                     valueType = pointer.GetPointerType();
  3057.                 else
  3058.                     valueType = value.GetType();
  3059.                
  3060.                 if (CanValueSpecialCast(valueType.TypeHandle.Value, TypeHandle.Value)) {
  3061.                     if (pointer != null)
  3062.                         return pointer.GetPointerValue();
  3063.                     else
  3064.                         return value;
  3065.                 }
  3066.             }
  3067.            
  3068.             if ((invokeAttr & BindingFlags.ExactBinding) == BindingFlags.ExactBinding)
  3069.                 throw new ArgumentException(String.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Arg_ObjObjEx"), value.GetType(), this));
  3070.            
  3071.             if (binder != null && binder != Type.DefaultBinder) {
  3072.                 value = binder.ChangeType(value, this, culture);
  3073.                 if (IsInstanceOfType(value))
  3074.                     return value;
  3075.                 // if this is a ByRef get the element type and check if it's compatible
  3076.                 if (isByRef) {
  3077.                     Type elementType = GetElementType();
  3078.                     if (elementType.IsInstanceOfType(value) || value == null)
  3079.                         return AllocateObjectForByRef(elementType.TypeHandle, value);
  3080.                 }
  3081.                 else if (value == null)
  3082.                     return value;
  3083.                 if (needsSpecialCast) {
  3084.                     Type valueType;
  3085.                     Pointer pointer = value as Pointer;
  3086.                     if (pointer != null)
  3087.                         valueType = pointer.GetPointerType();
  3088.                     else
  3089.                         valueType = value.GetType();
  3090.                    
  3091.                     if (CanValueSpecialCast(valueType.TypeHandle.Value, TypeHandle.Value)) {
  3092.                         if (pointer != null)
  3093.                             return pointer.GetPointerValue();
  3094.                         else
  3095.                             return value;
  3096.                     }
  3097.                 }
  3098.             }
  3099.            
  3100.             throw new ArgumentException(String.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString("Arg_ObjObjEx"), value.GetType(), this));
  3101.         }
  3102.        
  3103.         [DebuggerStepThroughAttribute()]
  3104.         [Diagnostics.DebuggerHidden()]
  3105.         public override object InvokeMember(string name, BindingFlags bindingFlags, Binder binder, object target, object[] providedArgs, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParams)
  3106.         {
  3107.             if (IsGenericParameter)
  3108.                 throw new InvalidOperationException(Environment.GetResourceString("Arg_GenericParameter"));
  3109.            
  3110.             #region Preconditions
  3111.             if ((bindingFlags & InvocationMask) == 0)
  3112.                 // "Must specify binding flags describing the invoke operation required."
  3113.                 throw new ArgumentException(Environment.GetResourceString("Arg_NoAccessSpec"), "bindingFlags");
  3114.            
  3115.             // Provide a default binding mask if none is provided
  3116.             if ((bindingFlags & MemberBindingMask) == 0) {
  3117.                 bindingFlags |= BindingFlags.Instance | BindingFlags.Public;
  3118.                
  3119.                 if ((bindingFlags & BindingFlags.CreateInstance) == 0)
  3120.                     bindingFlags |= BindingFlags.Static;
  3121.             }
  3122.            
  3123.             // There must not be more named parameters than provided arguments
  3124.             if (namedParams != null) {
  3125.                 if (providedArgs != null) {
  3126.                     if (namedParams.Length > providedArgs.Length)
  3127.                         // "Named parameter array can not be bigger than argument array."
  3128.                         throw new ArgumentException(Environment.GetResourceString("Arg_NamedParamTooBig"), "namedParams");
  3129.                 }
  3130.                 else {
  3131.                     if (namedParams.Length != 0)
  3132.                         // "Named parameter array can not be bigger than argument array."
  3133.                         throw new ArgumentException(Environment.GetResourceString("Arg_NamedParamTooBig"), "namedParams");
  3134.                 }
  3135.             }
  3136.             #endregion
  3137.            
  3138.             #region COM Interop
  3139.             #endregion
  3140.            
  3141.             #region Check that any named paramters are not null
  3142.             if (namedParams != null && Array.IndexOf(namedParams, null) != -1)
  3143.                 // "Named parameter value must not be null."
  3144.                 throw new ArgumentException(Environment.GetResourceString("Arg_NamedParamNull"), "namedParams");
  3145.             #endregion
  3146.            
  3147.             int argCnt = (providedArgs != null) ? providedArgs.Length : 0;
  3148.            
  3149.             #region Get a Binder
  3150.             if (binder == null)
  3151.                 binder = DefaultBinder;
  3152.            
  3153.             bool bDefaultBinder = (binder == DefaultBinder);
  3154.             #endregion
  3155.            
  3156.             #region Delegate to Activator.CreateInstance
  3157.             if ((bindingFlags & BindingFlags.CreateInstance) != 0) {
  3158.                 if ((bindingFlags & BindingFlags.CreateInstance) != 0 && (bindingFlags & BinderNonCreateInstance) != 0)
  3159.                     // "Can not specify both CreateInstance and another access type."
  3160.                     throw new ArgumentException(Environment.GetResourceString("Arg_CreatInstAccess"), "bindingFlags");
  3161.                
  3162.                 return Activator.CreateInstance(this, bindingFlags, binder, providedArgs, culture);
  3163.             }
  3164.             #endregion
  3165.            
  3166.             // PutDispProperty and\or PutRefDispProperty ==> SetProperty.
  3167.             if ((bindingFlags & (BindingFlags.PutDispProperty | BindingFlags.PutRefDispProperty)) != 0)
  3168.                 bindingFlags |= BindingFlags.SetProperty;
  3169.            
  3170.             #region Name
  3171.             if (name == null)
  3172.                 throw new ArgumentNullException("name");
  3173.            
  3174.             if (name.Length == 0 || name.Equals("[DISPID=0]")) {
  3175.                 name = GetDefaultMemberName();
  3176.                
  3177.                 if (name == null) {
  3178.                     // in InvokeMember we always pretend there is a default member if none is provided and we make it ToString
  3179.                     name = "ToString";
  3180.                 }
  3181.             }
  3182.             #endregion
  3183.            
  3184.             #region GetField or SetField
  3185.             bool IsGetField = (bindingFlags & BindingFlags.GetField) != 0;
  3186.             bool IsSetField = (bindingFlags & BindingFlags.SetField) != 0;
  3187.            
  3188.             if (IsGetField || IsSetField) {
  3189.                 #region Preconditions
  3190.                 if (IsGetField) {
  3191.                     if (IsSetField)
  3192.                         // "Can not specify both Get and Set on a field."
  3193.                         throw new ArgumentException(Environment.GetResourceString("Arg_FldSetGet"), "bindingFlags");
  3194.                    
  3195.                     if ((bindingFlags & BindingFlags.SetProperty) != 0)
  3196.                         // "Can not specify both GetField and SetProperty."
  3197.                         throw new ArgumentException(Environment.GetResourceString("Arg_FldGetPropSet"), "bindingFlags");
  3198.                 }
  3199.                 else {
  3200.                     ASSERT.CONSISTENCY_CHECK(IsSetField);
  3201.                    
  3202.                     if (providedArgs == null)
  3203.                         throw new ArgumentNullException("providedArgs");
  3204.                    
  3205.                     if ((bindingFlags & BindingFlags.GetProperty) != 0)
  3206.                         // "Can not specify both SetField and GetProperty."
  3207.                         throw new ArgumentException(Environment.GetResourceString("Arg_FldSetPropGet"), "bindingFlags");
  3208.                    
  3209.                     if ((bindingFlags & BindingFlags.InvokeMethod) != 0)
  3210.                         // "Can not specify Set on a Field and Invoke on a method."
  3211.                         throw new ArgumentException(Environment.GetResourceString("Arg_FldSetInvoke"), "bindingFlags");
  3212.                 }
  3213.                 #endregion
  3214.                
  3215.                 #region Lookup Field
  3216.                 FieldInfo selFld = null;
  3217.                 FieldInfo[] flds = GetMember(name, MemberTypes.Field, bindingFlags) as FieldInfo[];
  3218.                
  3219.                 ASSERT.CONSISTENCY_CHECK(flds != null);
  3220.                
  3221.                 if (flds.Length == 1) {
  3222.                     selFld = flds[0];
  3223.                 }
  3224.                 else if (flds.Length > 0) {
  3225.                     selFld = binder.BindToField(bindingFlags, flds, IsGetField ? Empty.Value : providedArgs[0], culture);
  3226.                 }
  3227.                 #endregion
  3228.                
  3229.                 if (selFld != null) {
  3230.                     #region Invocation on a field
  3231.                     if (selFld.FieldType.IsArray || selFld.FieldType == typeof(System.Array)) {
  3232.                         #region Invocation of an array Field
  3233.                         int idxCnt;
  3234.                        
  3235.                         if ((bindingFlags & BindingFlags.GetField) != 0) {
  3236.                             idxCnt = argCnt;
  3237.                         }
  3238.                         else {
  3239.                             idxCnt = argCnt - 1;
  3240.                         }
  3241.                        
  3242.                         if (idxCnt > 0) {
  3243.                             // Verify that all of the index values are ints
  3244.                             int[] idx = new int[idxCnt];
  3245.                             for (int i = 0; i < idxCnt; i++) {
  3246.                                 try {
  3247.                                     idx[i] = ((IConvertible)providedArgs[i]).ToInt32(null);
  3248.                                 }
  3249.                                 catch (InvalidCastException) {
  3250.                                     throw new ArgumentException(Environment.GetResourceString("Arg_IndexMustBeInt"));
  3251.                                 }
  3252.                             }
  3253.                            
  3254.                             // Set or get the value...
  3255.                             Array a = (Array)selFld.GetValue(target);
  3256.                            
  3257.                             // Set or get the value in the array
  3258.                             if ((bindingFlags & BindingFlags.GetField) != 0) {
  3259.                                 return a.GetValue(idx);
  3260.                             }
  3261.                             else {
  3262.                                 a.SetValue(providedArgs[idxCnt], idx);
  3263.                                 return null;
  3264.                             }
  3265.                         }
  3266.                         #endregion
  3267.                     }
  3268.                    
  3269.                     if (IsGetField) {
  3270.                         #region Get the field value
  3271.                         if (argCnt != 0)
  3272.                             throw new ArgumentException(Environment.GetResourceString("Arg_FldGetArgErr"), "bindingFlags");
  3273.                        
  3274.                         return selFld.GetValue(target);
  3275.                         #endregion
  3276.                     }
  3277.                     else {
  3278.                         #region Set the field Value
  3279.                         if (argCnt != 1)
  3280.                             throw new ArgumentException(Environment.GetResourceString("Arg_FldSetArgErr"), "bindingFlags");
  3281.                        
  3282.                         selFld.SetValue(target, providedArgs[0], bindingFlags, binder, culture);
  3283.                        
  3284.                         return null;
  3285.                         #endregion
  3286.                     }
  3287.                     #endregion
  3288.                 }
  3289.                
  3290.                 if ((bindingFlags & BinderNonFieldGetSet) == 0)
  3291.                     throw new MissingFieldException(FullName, name);
  3292.             }
  3293.             #endregion
  3294.            
  3295.             #region Caching Logic
  3296.             /*
  3297.             bool useCache = false;
  3298.             // Note that when we add something to the cache, we are careful to ensure
  3299.             // that the actual providedArgs matches the parameters of the method.  Otherwise,
  3300.             // some default argument processing has occurred.  We don't want anyone
  3301.             // else with the same (insufficient) number of actual arguments to get a
  3302.             // cache hit because then they would bypass the default argument processing
  3303.             // and the invocation would fail.
  3304.             if (bDefaultBinder && namedParams == null && argCnt < 6)
  3305.                 useCache = true;
  3306.             if (useCache)
  3307.             {
  3308.                 MethodBase invokeMethod = GetMethodFromCache (name, bindingFlags, argCnt, providedArgs);
  3309.                 if (invokeMethod != null)
  3310.                     return ((MethodInfo) invokeMethod).Invoke(target, bindingFlags, binder, providedArgs, culture);
  3311.             }
  3312.             */           
  3313.             #endregion
  3314.            
  3315.             #region Property PreConditions
  3316.             // @Legacy - This is RTM behavior
  3317. bool isGetProperty = (bindingFlags & BindingFlags.GetProperty) != 0;
  3318.             bool isSetProperty = (bindingFlags & BindingFlags.SetProperty) != 0;
  3319.            
  3320.             if (isGetProperty || isSetProperty) {
  3321.                 #region Preconditions
  3322.                 if (isGetProperty) {
  3323.                     ASSERT.CONSISTENCY_CHECK(!IsSetField);
  3324.                    
  3325.                     if (isSetProperty)
  3326.                         throw new ArgumentException(Environment.GetResourceString("Arg_PropSetGet"), "bindingFlags");
  3327.                 }
  3328.                 else {
  3329.                     ASSERT.CONSISTENCY_CHECK(isSetProperty);
  3330.                    
  3331.                     ASSERT.CONSISTENCY_CHECK(!IsGetField);
  3332.                    
  3333.                     if ((bindingFlags & BindingFlags.InvokeMethod) != 0)
  3334.                         throw new ArgumentException(Environment.GetResourceString("Arg_PropSetInvoke"), "bindingFlags");
  3335.                 }
  3336.                 #endregion
  3337.             }
  3338.             #endregion
  3339.            
  3340.             MethodInfo[] finalists = null;
  3341.             MethodInfo finalist = null;
  3342.            
  3343.             #region BindingFlags.InvokeMethod
  3344.             if ((bindingFlags & BindingFlags.InvokeMethod) != 0) {
  3345.                 #region Lookup Methods
  3346.                 MethodInfo[] semiFinalists = GetMember(name, MemberTypes.Method, bindingFlags) as MethodInfo[];
  3347.                 ArrayList results = null;
  3348.                
  3349.                 for (int i = 0; i < semiFinalists.Length; i++) {
  3350.                     MethodInfo semiFinalist = semiFinalists[i];
  3351.                     ASSERT.CONSISTENCY_CHECK(semiFinalist != null);
  3352.                    
  3353.                     if (!FilterApplyMethodBaseInfo(semiFinalist, bindingFlags, null, CallingConventions.Any, new Type[argCnt], false))
  3354.                         continue;
  3355.                    
  3356.                     if (finalist == null) {
  3357.                         finalist = semiFinalist;
  3358.                     }
  3359.                     else {
  3360.                         if (results == null) {
  3361.                             results = new ArrayList(semiFinalists.Length);
  3362.                             results.Add(finalist);
  3363.                         }
  3364.                        
  3365.                         results.Add(semiFinalist);
  3366.                     }
  3367.                 }
  3368.                
  3369.                 if (results != null) {
  3370.                     ASSERT.CONSISTENCY_CHECK(results.Count > 1);
  3371.                     finalists = new MethodInfo[results.Count];
  3372.                     results.CopyTo(finalists);
  3373.                 }
  3374.                 #endregion
  3375.             }
  3376.             #endregion
  3377.            
  3378.             ASSERT.CONSISTENCY_CHECK(LOGIC.IMPLIES(finalists != null, finalist != null));
  3379.            
  3380.             #region BindingFlags.GetProperty or BindingFlags.SetProperty
  3381.             if (finalist == null && isGetProperty || isSetProperty) {
  3382.                 #region Lookup Property
  3383.                 PropertyInfo[] semiFinalists = GetMember(name, MemberTypes.Property, bindingFlags) as PropertyInfo[];
  3384.                 ArrayList results = null;
  3385.                
  3386.                 for (int i = 0; i < semiFinalists.Length; i++) {
  3387.                     MethodInfo semiFinalist = null;
  3388.                    
  3389.                     if (isSetProperty) {
  3390.                         semiFinalist = semiFinalists[i].GetSetMethod(true);
  3391.                     }
  3392.                     else {
  3393.                         semiFinalist = semiFinalists[i].GetGetMethod(true);
  3394.                     }
  3395.                    
  3396.                     if (semiFinalist == null)
  3397.                         continue;
  3398.                    
  3399.                     if (!FilterApplyMethodBaseInfo(semiFinalist, bindingFlags, null, CallingConventions.Any, new Type[argCnt], false))
  3400.                         continue;
  3401.                    
  3402.                     if (finalist == null) {
  3403.                         finalist = semiFinalist;
  3404.                     }
  3405.                     else {
  3406.                         if (results == null) {
  3407.                             results = new ArrayList(semiFinalists.Length);
  3408.                             results.Add(finalist);
  3409.                         }
  3410.                        
  3411.                         results.Add(semiFinalist);
  3412.                     }
  3413.                 }
  3414.                
  3415.                 if (results != null) {
  3416.                     ASSERT.CONSISTENCY_CHECK(results.Count > 1);
  3417.                     finalists = new MethodInfo[results.Count];
  3418.                     results.CopyTo(finalists);
  3419.                 }
  3420.                 #endregion
  3421.             }
  3422.             #endregion
  3423.            
  3424.             if (finalist != null) {
  3425.                 #region Invoke
  3426.                 if (finalists == null && argCnt == 0 && finalist.GetParametersNoCopy().Length == 0 && (bindingFlags & BindingFlags.OptionalParamBinding) == 0) {
  3427.                     //if (useCache && argCnt == props[0].GetParameters().Length)
  3428.                     // AddMethodToCache(name, bindingFlags, argCnt, providedArgs, props[0]);
  3429.                    
  3430.                     return finalist.Invoke(target, bindingFlags, binder, providedArgs, culture);
  3431.                 }
  3432.                
  3433.                 if (finalists == null)
  3434.                     finalists = new MethodInfo[] {finalist};
  3435.                
  3436.                 if (providedArgs == null)
  3437.                     providedArgs = new object[0];
  3438.                
  3439.                 object state = null;
  3440.                
  3441.                
  3442.                 MethodBase invokeMethod = null;
  3443.                
  3444.                 try {
  3445.                     invokeMethod = binder.BindToMethod(bindingFlags, finalists, ref providedArgs, modifiers, culture, namedParams, out state);
  3446.                 }
  3447.                 catch (MissingMethodException) {
  3448.                 }
  3449.                
  3450.                 if (invokeMethod == null)
  3451.                     throw new MissingMethodException(FullName, name);
  3452.                
  3453.                 //if (useCache && argCnt == invokeMethod.GetParameters().Length)
  3454.                 // AddMethodToCache(name, bindingFlags, argCnt, providedArgs, invokeMethod);
  3455.                
  3456.                 object result = ((MethodInfo)invokeMethod).Invoke(target, bindingFlags, binder, providedArgs, culture);
  3457.                
  3458.                 if (state != null)
  3459.                     binder.ReorderArgumentArray(ref providedArgs, state);
  3460.                
  3461.                 return result;
  3462.                 #endregion
  3463.             }
  3464.            
  3465.             throw new MissingMethodException(FullName, name);
  3466.         }
  3467.         #endregion
  3468.        
  3469.         #endregion
  3470.        
  3471.         #region Object Overrides
  3472.         public override bool Equals(object obj)
  3473.         {
  3474.             // ComObjects are identified by the instance of the Type object and not the TypeHandle.
  3475.             return obj == this;
  3476.         }
  3477.        
  3478.         public override int GetHashCode()
  3479.         {
  3480.             #if WIN32
  3481.             return (int)GetTypeHandleInternal().Value;
  3482.             #else
  3483.             long l = (long)GetTypeHandleInternal().Value;
  3484.             return unchecked((int)l);
  3485.             #endif
  3486.         }
  3487.        
  3488.         public override string ToString()
  3489.         {
  3490.             return Cache.GetToString();
  3491.         }
  3492.         #endregion
  3493.        
  3494.         #region ICloneable
  3495.         public object Clone()
  3496.         {
  3497.             return this;
  3498.         }
  3499.         #endregion
  3500.        
  3501.         #region ISerializable
  3502.         public void GetObjectData(SerializationInfo info, StreamingContext context)
  3503.         {
  3504.             if (info == null)
  3505.                 throw new ArgumentNullException("info");
  3506.            
  3507.             UnitySerializationHolder.GetUnitySerializationInfo(info, this);
  3508.         }
  3509.         #endregion
  3510.        
  3511.         #region ICustomAttributeProvider
  3512.         public override object[] GetCustomAttributes(bool inherit)
  3513.         {
  3514.             return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType, inherit);
  3515.         }
  3516.        
  3517.         public override object[] GetCustomAttributes(Type attributeType, bool inherit)
  3518.         {
  3519.             if (attributeType == null)
  3520.                 throw new ArgumentNullException("attributeType");
  3521.            
  3522.             RuntimeType attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType;
  3523.            
  3524.             if (attributeRuntimeType == null)
  3525.                 throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"), "attributeType");
  3526.            
  3527.             return CustomAttribute.GetCustomAttributes(this, attributeRuntimeType, inherit);
  3528.         }
  3529.        
  3530.         public override bool IsDefined(Type attributeType, bool inherit)
  3531.         {
  3532.             if (attributeType == null)
  3533.                 throw new ArgumentNullException("attributeType");
  3534.            
  3535.             RuntimeType attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType;
  3536.            
  3537.             if (attributeRuntimeType == null)
  3538.                 throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"), "attributeType");
  3539.            
  3540.             return CustomAttribute.IsDefined(this, attributeRuntimeType, inherit);
  3541.         }
  3542.         #endregion
  3543.        
  3544.         #region MemberInfo Overrides
  3545.         public override string Name {
  3546.             get { return Cache.GetName(); }
  3547.         }
  3548.        
  3549.         public override MemberTypes MemberType {
  3550.             get {
  3551.                 if (this.IsPublic || this.IsNotPublic)
  3552.                     return MemberTypes.TypeInfo;
  3553.                 else
  3554.                     return MemberTypes.NestedType;
  3555.             }
  3556.         }
  3557.        
  3558.         public override Type DeclaringType {
  3559.             get { return Cache.GetEnclosingType(); }
  3560.         }
  3561.        
  3562.         public override Type ReflectedType {
  3563.             get { return DeclaringType; }
  3564.         }
  3565.        
  3566.         public override int MetadataToken {
  3567.             get { return m_handle.GetToken(); }
  3568.         }
  3569.         #endregion
  3570.        
  3571.         #region Legacy Internal
  3572.         internal void CreateInstanceCheckThis()
  3573.         {
  3574.             if (this is ReflectionOnlyType)
  3575.                 throw new ArgumentException(Environment.GetResourceString("Arg_ReflectionOnlyInvoke"));
  3576.            
  3577.             if (ContainsGenericParameters)
  3578.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Acc_CreateGenericEx"), this));
  3579.            
  3580.             Type elementType = this.GetRootElementType();
  3581.            
  3582.             if (elementType == typeof(ArgIterator))
  3583.                 throw new NotSupportedException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Acc_CreateArgIterator")));
  3584.            
  3585.             if (elementType == typeof(void))
  3586.                 throw new NotSupportedException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Acc_CreateVoid")));
  3587.         }
  3588.        
  3589.         internal object CreateInstanceImpl(BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes)
  3590.         {
  3591.             CreateInstanceCheckThis();
  3592.            
  3593.             object server = null;
  3594.            
  3595.             try {
  3596.                 try {
  3597.                     // Store the activation attributes in thread local storage.
  3598.                     // These attributes are later picked up by specialized
  3599.                     // activation services like remote activation services to
  3600.                     // influence the activation.
  3601.                     if (null != activationAttributes) {
  3602.                         ActivationServices.PushActivationAttributes(this, activationAttributes);
  3603.                     }
  3604.                    
  3605.                     if (args == null)
  3606.                         args = new object[0];
  3607.                    
  3608.                     int argCnt = args.Length;
  3609.                    
  3610.                     // Without a binder we need to do use the default binder...
  3611.                     if (binder == null)
  3612.                         binder = DefaultBinder;
  3613.                    
  3614.                     // deal with the __COMObject case first. It is very special because from a reflection point of view it has no ctors
  3615.                     // so a call to GetMemberCons would fail
  3616.                     if (argCnt == 0 && (bindingAttr & BindingFlags.Public) != 0 && (bindingAttr & BindingFlags.Instance) != 0 && (IsGenericCOMObjectImpl() || IsSubclassOf(typeof(ValueType)))) {
  3617.                         server = CreateInstanceImpl(((bindingAttr & BindingFlags.NonPublic) != 0) ? false : true);
  3618.                     }
  3619.                     else {
  3620.                         MethodBase[] candidates = GetConstructors(bindingAttr);
  3621.                         ArrayList matches = new ArrayList(candidates.Length);
  3622.                         Type[] argsType = new Type[argCnt];
  3623.                         for (int i = 0; i < argCnt; i++) {
  3624.                             if (args[i] != null) {
  3625.                                 argsType[i] = args[i].GetType();
  3626.                             }
  3627.                         }
  3628.                        
  3629.                        
  3630.                         for (int i = 0; i < candidates.Length; i++) {
  3631.                             MethodBase canidate = candidates[i];
  3632.                            
  3633.                             if (FilterApplyMethodBaseInfo(candidates[i], bindingAttr, null, CallingConventions.Any, argsType, false))
  3634.                                 matches.Add(candidates[i]);
  3635.                         }
  3636.                        
  3637.                         MethodBase[] cons = new MethodBase[matches.Count];
  3638.                         matches.CopyTo(cons);
  3639.                         if (cons != null && cons.Length == 0)
  3640.                             cons = null;
  3641.                        
  3642.                         if (cons == null) {
  3643.                             // Null out activation attributes before throwing exception
  3644.                             if (null != activationAttributes) {
  3645.                                 ActivationServices.PopActivationAttributes(this);
  3646.                                 activationAttributes = null;
  3647.                             }
  3648.                             throw new MissingMethodException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("MissingConstructor_Name"), FullName));
  3649.                         }
  3650.                        
  3651.                         // It would be strange to have an argCnt of 0 and more than
  3652.                         // one constructor.
  3653.                         if (argCnt == 0 && cons.Length == 1 && (bindingAttr & BindingFlags.OptionalParamBinding) == 0)
  3654.                             server = Activator.CreateInstance(this, true);
  3655.                         else {
  3656.                             // MethodBase invokeMethod = binder.BindToMethod(cons,args,null,null,culture);
  3657.                             MethodBase invokeMethod;
  3658.                             object state = null;
  3659.                             try {
  3660.                                 invokeMethod = binder.BindToMethod(bindingAttr, cons, ref args, null, culture, null, out state);
  3661.                             }
  3662.                             catch (MissingMethodException) {
  3663.                                 invokeMethod = null;
  3664.                             }
  3665.                             if (invokeMethod == null) {
  3666.                                 // Null out activation attributes before throwing exception
  3667.                                 if (null != activationAttributes) {
  3668.                                     ActivationServices.PopActivationAttributes(this);
  3669.                                     activationAttributes = null;
  3670.                                 }
  3671.                                 throw new MissingMethodException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("MissingConstructor_Name"), FullName));
  3672.                             }
  3673.                            
  3674.                             // If we're creating a delegate, we're about to call a
  3675.                             // constructor taking an integer to represent a target
  3676.                             // method. Since this is very difficult (and expensive)
  3677.                             // to verify, we're just going to demand UnmanagedCode
  3678.                             // permission before allowing this. Partially trusted
  3679.                             // clients can instead use Delegate.CreateDelegate,
  3680.                             // which allows specification of the target method via
  3681.                             // name or MethodInfo.
  3682.                             //if (isDelegate)
  3683.                             if (typeof(Delegate).IsAssignableFrom(invokeMethod.DeclaringType))
  3684.                                 new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
  3685.                            
  3686.                             server = ((ConstructorInfo)invokeMethod).Invoke(bindingAttr, binder, args, culture);
  3687.                             if (state != null)
  3688.                                 binder.ReorderArgumentArray(ref args, state);
  3689.                         }
  3690.                     }
  3691.                 }
  3692.                 finally {
  3693.                     // Reset the TLS to null
  3694.                     if (null != activationAttributes) {
  3695.                         ActivationServices.PopActivationAttributes(this);
  3696.                         activationAttributes = null;
  3697.                     }
  3698.                 }
  3699.             }
  3700.             catch (Exception) {
  3701.                 throw;
  3702.             }
  3703.            
  3704.             //Console.WriteLine(server);
  3705.             return server;
  3706.         }
  3707.        
  3708.         // the cache entry
  3709.         class ActivatorCacheEntry
  3710.         {
  3711.             // the type to cache
  3712.             internal Type m_type;
  3713.             // the delegate containing the call to the ctor, will be replaced by an IntPtr to feed a calli with
  3714.             internal CtorDelegate m_ctor;
  3715.             internal RuntimeMethodHandle m_hCtorMethodHandle;
  3716.             // Is a security check needed before this constructor is invoked?
  3717.             internal bool m_bNeedSecurityCheck;
  3718.             // Lazy initialization was performed
  3719.             internal bool m_bFullyInitialized;
  3720.            
  3721.             internal ActivatorCacheEntry(Type t, RuntimeMethodHandle rmh, bool bNeedSecurityCheck)
  3722.             {
  3723.                 m_type = t;
  3724.                 m_bNeedSecurityCheck = bNeedSecurityCheck;
  3725.                 m_hCtorMethodHandle = rmh;
  3726.             }
  3727.         }
  3728.        
  3729.         //ActivatorCache
  3730.         class ActivatorCache
  3731.         {
  3732.             const int CACHE_SIZE = 16;
  3733.             int hash_counter;
  3734.             //Counter for wrap around
  3735.             ActivatorCacheEntry[] cache = new ActivatorCacheEntry[CACHE_SIZE];
  3736.            
  3737.             ConstructorInfo delegateCtorInfo;
  3738.             PermissionSet delegateCreatePermissions;
  3739.            
  3740.             private void InitializeDelegateCreator()
  3741.             {
  3742.                 // No synchronization needed here. In the worst case we create extra garbage
  3743.                 PermissionSet ps = new PermissionSet(PermissionState.None);
  3744.                 ps.AddPermission(new ReflectionPermission(ReflectionPermissionFlag.MemberAccess));
  3745.                 ps.AddPermission(new SecurityPermission(SecurityPermissionFlag.UnmanagedCode));
  3746.                 System.Threading.Thread.MemoryBarrier();
  3747.                 delegateCreatePermissions = ps;
  3748.                
  3749.                 ConstructorInfo ctorInfo = typeof(CtorDelegate).GetConstructor(new Type[] {typeof(object), typeof(IntPtr)});
  3750.                 System.Threading.Thread.MemoryBarrier();
  3751.                 delegateCtorInfo = ctorInfo;
  3752.                 // this assignment should be last
  3753.             }
  3754.            
  3755.             private void InitializeCacheEntry(ActivatorCacheEntry ace)
  3756.             {
  3757.                 if (!ace.m_type.IsValueType) {
  3758.                     BCLDebug.Assert(!ace.m_hCtorMethodHandle.Equals(RuntimeMethodHandle.EmptyHandle), "Expected the default ctor method handle for a reference type.");
  3759.                    
  3760.                     if (delegateCtorInfo == null)
  3761.                         InitializeDelegateCreator();
  3762.                     delegateCreatePermissions.Assert();
  3763.                    
  3764.                     // No synchronization needed here. In the worst case we create extra garbage
  3765.                     CtorDelegate ctor = (CtorDelegate)delegateCtorInfo.Invoke(new object[] {null, ace.m_hCtorMethodHandle.GetFunctionPointer()});
  3766.                     System.Threading.Thread.MemoryBarrier();
  3767.                     ace.m_ctor = ctor;
  3768.                 }
  3769.                 ace.m_bFullyInitialized = true;
  3770.             }
  3771.            
  3772.             internal ActivatorCacheEntry GetEntry(Type t)
  3773.             {
  3774.                 int index = hash_counter;
  3775.                 for (int i = 0; i < CACHE_SIZE; i++) {
  3776.                     ActivatorCacheEntry ace = cache[index];
  3777.                     //check for type match..
  3778.                     if (ace != null && (object)ace.m_type == (object)t) {
  3779.                         if (!ace.m_bFullyInitialized)
  3780.                             InitializeCacheEntry(ace);
  3781.                         return ace;
  3782.                     }
  3783.                     index = (index + 1) & (ActivatorCache.CACHE_SIZE - 1);
  3784.                 }
  3785.                 return null;
  3786.             }
  3787.            
  3788.             internal void SetEntry(ActivatorCacheEntry ace)
  3789.             {
  3790.                 // fill the the array backwards to hit the most recently filled entries first in GetEntry
  3791.                 int index = (hash_counter - 1) & (ActivatorCache.CACHE_SIZE - 1);
  3792.                 hash_counter = index;
  3793.                 cache[index] = ace;
  3794.             }
  3795.         }
  3796.        
  3797.         static ActivatorCache s_ActivatorCache;
  3798.        
  3799.         // the slow path of CreateInstanceImpl
  3800.         private object CreateInstanceSlow(bool publicOnly, bool fillCache)
  3801.         {
  3802.             RuntimeMethodHandle runtime_ctor = RuntimeMethodHandle.EmptyHandle;
  3803.             bool bNeedSecurityCheck = true;
  3804.             bool bCanBeCached = false;
  3805.             bool bSecurityCheckOff = false;
  3806.            
  3807.             CreateInstanceCheckThis();
  3808.            
  3809.             if (!fillCache)
  3810.                 bSecurityCheckOff = true;
  3811.            
  3812.             object instance = RuntimeTypeHandle.CreateInstance(this, publicOnly, bSecurityCheckOff, ref bCanBeCached, ref runtime_ctor, ref bNeedSecurityCheck);
  3813.            
  3814.             if (bCanBeCached && fillCache) {
  3815.                 ActivatorCache activatorCache = s_ActivatorCache;
  3816.                 if (activatorCache == null) {
  3817.                     // No synchronization needed here. In the worst case we create extra garbage
  3818.                     activatorCache = new ActivatorCache();
  3819.                     System.Threading.Thread.MemoryBarrier();
  3820.                     s_ActivatorCache = activatorCache;
  3821.                 }
  3822.                
  3823.                 // cache the ctor
  3824.                 ActivatorCacheEntry ace = new ActivatorCacheEntry(this, runtime_ctor, bNeedSecurityCheck);
  3825.                 System.Threading.Thread.MemoryBarrier();
  3826.                 activatorCache.SetEntry(ace);
  3827.             }
  3828.             return instance;
  3829.         }
  3830.        
  3831.         [DebuggerStepThroughAttribute()]
  3832.         [Diagnostics.DebuggerHidden()]
  3833.         internal object CreateInstanceImpl(bool publicOnly)
  3834.         {
  3835.             return CreateInstanceImpl(publicOnly, false, true);
  3836.         }
  3837.        
  3838.         [DebuggerStepThroughAttribute()]
  3839.         [Diagnostics.DebuggerHidden()]
  3840.         internal object CreateInstanceImpl(bool publicOnly, bool skipVisibilityChecks, bool fillCache)
  3841.         {
  3842.             // next line will throw for ReflectionOnly types
  3843.             RuntimeTypeHandle typeHandle = TypeHandle;
  3844.             ActivatorCache activatorCache = s_ActivatorCache;
  3845.             if (activatorCache != null) {
  3846.                 ActivatorCacheEntry ace = activatorCache.GetEntry(this);
  3847.                 if (ace != null) {
  3848.                     if (publicOnly) {
  3849.                         if (ace.m_ctor != null && (ace.m_hCtorMethodHandle.GetAttributes() & MethodAttributes.MemberAccessMask) != MethodAttributes.Public) {
  3850.                             throw new MissingMethodException(Environment.GetResourceString("Arg_NoDefCTor"));
  3851.                         }
  3852.                     }
  3853.                    
  3854.                     // Allocate empty object
  3855.                     object instance = typeHandle.Allocate();
  3856.                     if (ace.m_ctor != null) {
  3857.                         // Perform security checks if needed
  3858.                         if (!skipVisibilityChecks && ace.m_bNeedSecurityCheck) {
  3859.                             MethodBase.PerformSecurityCheck(instance, ace.m_hCtorMethodHandle, TypeHandle.Value, INVOCATION_FLAGS_CONSTRUCTOR_INVOKE);
  3860.                         }
  3861.                         // Call ctor (value types wont have any)
  3862.                         try {
  3863.                             ace.m_ctor(instance);
  3864.                         }
  3865.                         catch (Exception e) {
  3866.                             throw new TargetInvocationException(e);
  3867.                         }
  3868.                     }
  3869.                     return instance;
  3870.                 }
  3871.             }
  3872.             return CreateInstanceSlow(publicOnly, fillCache);
  3873.         }
  3874.        
  3875.         //End
  3876.        
  3877.         internal bool SupportsInterface(object o)
  3878.         {
  3879.             return TypeHandle.SupportsInterface(o);
  3880.         }
  3881.        
  3882.         internal void InvalidateCachedNestedType()
  3883.         {
  3884.             Cache.InvalidateCachedNestedType();
  3885.         }
  3886.        
  3887.         internal bool IsGenericCOMObjectImpl()
  3888.         {
  3889.             return m_handle.IsComObject(true);
  3890.         }
  3891.         #endregion
  3892.        
  3893.         #region Legacy Static Internal
  3894.         static internal bool CanCastTo(RuntimeType fromType, RuntimeType toType)
  3895.         {
  3896.             return fromType.GetTypeHandleInternal().CanCastTo(toType.GetTypeHandleInternal());
  3897.         }
  3898.        
  3899.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  3900.         private static extern object _CreateEnum(IntPtr enumType, long value);
  3901.         static internal object CreateEnum(RuntimeTypeHandle enumType, long value)
  3902.         {
  3903.             return _CreateEnum(enumType.Value, value);
  3904.         }
  3905.        
  3906.        
  3907.         static internal Type PrivateGetType(string typeName, bool throwOnError, bool ignoreCase, ref StackCrawlMark stackMark)
  3908.         {
  3909.             return PrivateGetType(typeName, throwOnError, ignoreCase, false, ref stackMark);
  3910.         }
  3911.        
  3912.         static internal Type PrivateGetType(string typeName, bool throwOnError, bool ignoreCase, bool reflectionOnly, ref StackCrawlMark stackMark)
  3913.         {
  3914.             unsafe {
  3915.                 if (typeName == null)
  3916.                     throw new ArgumentNullException("TypeName");
  3917.                
  3918.                 return RuntimeTypeHandle.GetTypeByName(typeName, throwOnError, ignoreCase, reflectionOnly, ref stackMark).GetRuntimeType();
  3919.             }
  3920.         }
  3921.        
  3922.         #endregion
  3923.        
  3924.         #region COM
  3925.         #endregion
  3926.     }
  3927.    
  3928.     // this is the introspection only type. This type overrides all the functions with runtime semantics
  3929.     // and throws an exception.
  3930.     // The idea behind this type is that it relieves RuntimeType from doing honerous checks about ReflectionOnly
  3931.     // context.
  3932.     // This type should not derive from RuntimeType but it's doing so for convinience.
  3933.     // That should not present a security threat though it is risky as a direct call to one of the base method
  3934.     // method (RuntimeType) and an instance of this type will work around the reason to have this type in the
  3935.     // first place. However given RuntimeType is not public all its methods are protected and require full trust
  3936.     // to be accessed
  3937.     [Serializable()]
  3938.     internal class ReflectionOnlyType : RuntimeType
  3939.     {
  3940.        
  3941.         private ReflectionOnlyType()
  3942.         {
  3943.         }
  3944.        
  3945.         // always throw
  3946.         public override RuntimeTypeHandle TypeHandle {
  3947.             get {
  3948.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotAllowedInReflectionOnly"));
  3949.             }
  3950.         }
  3951.        
  3952.     }
  3953.    
  3954.     namespace Reflection
  3955.     {
  3956.         [Serializable()]
  3957.         internal sealed class CerArrayList<V>
  3958.         {
  3959.             private const int MinSize = 4;
  3960.            
  3961.             private V[] m_array;
  3962.             private int m_count;
  3963.            
  3964.             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  3965.             internal CerArrayList(List<V> list)
  3966.             {
  3967.                 m_array = new V[list.Count];
  3968.                 for (int i = 0; i < list.Count; i++)
  3969.                     m_array[i] = list[i];
  3970.                 m_count = list.Count;
  3971.             }
  3972.            
  3973.             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  3974.             internal CerArrayList(int length)
  3975.             {
  3976.                 if (length < MinSize)
  3977.                     length = MinSize;
  3978.                
  3979.                 m_array = new V[length];
  3980.                 m_count = 0;
  3981.             }
  3982.            
  3983.             internal int Count {
  3984.                 [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  3985.                 get { return m_count; }
  3986.             }
  3987.            
  3988.             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  3989.             internal void Preallocate(int addition)
  3990.             {
  3991.                 if (m_array.Length - m_count > addition)
  3992.                     return;
  3993.                
  3994.                 int newSize = m_array.Length * 2 > m_array.Length + addition ? m_array.Length * 2 : m_array.Length + addition;
  3995.                
  3996.                 V[] newArray = new V[newSize];
  3997.                
  3998.                 for (int i = 0; i < m_count; i++) {
  3999.                     newArray[i] = m_array[i];
  4000.                 }
  4001.                
  4002.                 m_array = newArray;
  4003.             }
  4004.            
  4005.             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  4006.             internal void Add(V value)
  4007.             {
  4008.                 m_array[m_count] = value;
  4009.                 m_count++;
  4010.             }
  4011.            
  4012.             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  4013.             internal void Replace(int index, V value)
  4014.             {
  4015.                 if (index >= m_count)
  4016.                     throw new InvalidOperationException();
  4017.                
  4018.                 m_array[index] = value;
  4019.             }
  4020.            
  4021.             internal V this[int index]
  4022.             {
  4023.                 [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  4024.                 get { return m_array[index]; }
  4025.             }
  4026.         }
  4027.        
  4028.         [Serializable()]
  4029.         internal sealed class CerHashtable<K, V>
  4030.         {
  4031.             private K[] m_key;
  4032.             private V[] m_value;
  4033.             private int m_count;
  4034.            
  4035.             private const int MinSize = 7;
  4036.            
  4037.             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  4038.             internal CerHashtable() : this(MinSize)
  4039.             {
  4040.             }
  4041.            
  4042.             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  4043.             internal CerHashtable(int size)
  4044.             {
  4045.                 size = HashHelpers.GetPrime(size);
  4046.                 m_key = new K[size];
  4047.                 m_value = new V[size];
  4048.             }
  4049.            
  4050.             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  4051.             internal void Preallocate(int count)
  4052.             {
  4053.                 bool tookLock = false;
  4054.                 bool success = false;
  4055.                 K[] newKeys = null;
  4056.                 ;
  4057.                 V[] newValues = null;
  4058.                 RuntimeHelpers.PrepareConstrainedRegions();
  4059.                 try {
  4060.                     Monitor.ReliableEnter(this, ref tookLock);
  4061.                     int newSize = (count + m_count) * 2;
  4062.                    
  4063.                     if (newSize < m_value.Length)
  4064.                         return;
  4065.                    
  4066.                     newSize = HashHelpers.GetPrime(newSize);
  4067.                    
  4068.                     newKeys = new K[newSize];
  4069.                     newValues = new V[newSize];
  4070.                    
  4071.                     for (int i = 0; i < m_key.Length; i++) {
  4072.                         K key = m_key[i];
  4073.                        
  4074.                         if (key != null) {
  4075.                             int dummyCount = 0;
  4076.                             Insert(newKeys, newValues, ref dummyCount, key, m_value[i]);
  4077.                         }
  4078.                     }
  4079.                    
  4080.                     success = true;
  4081.                 }
  4082.                 finally {
  4083.                     if (success) {
  4084.                         m_key = newKeys;
  4085.                         m_value = newValues;
  4086.                     }
  4087.                    
  4088.                     if (tookLock)
  4089.                         Monitor.Exit(this);
  4090.                 }
  4091.             }
  4092.            
  4093.             // Written as a static so we can share this code from Set and
  4094.             // Preallocate, which adjusts the data structure in place.
  4095.             // Returns whether we inserted the item into a new slot or reused
  4096.             // an existing hash table bucket.
  4097.             // Reliability-wise, we don't guarantee that the updates to the key
  4098.             // and value arrays are done atomically within a CER. Either
  4099.             // add your own CER or use temporary copies of this data structure.
  4100.             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  4101.             private static void Insert(K[] keys, V[] values, ref int count, K key, V value)
  4102.             {
  4103.                 int hashcode = key.GetHashCode();
  4104.                 if (hashcode < 0)
  4105.                     hashcode = -hashcode;
  4106.                 int firstIndex = hashcode % keys.Length;
  4107.                 int index = firstIndex;
  4108.                
  4109.                 while (true) {
  4110.                     K hit = keys[index];
  4111.                    
  4112.                     if ((object)hit == null) {
  4113.                         RuntimeHelpers.PrepareConstrainedRegions();
  4114.                         try {
  4115.                         }
  4116.                         finally {
  4117.                             keys[index] = key;
  4118.                             values[index] = value;
  4119.                             count++;
  4120.                         }
  4121.                        
  4122.                         break;
  4123.                     }
  4124.                     // Replace existing item
  4125.                     else if (hit.Equals(key)) {
  4126.                         //BCLDebug.Assert(false, "Key was already in CerHashtable! Potential race (or bug) in the Reflection cache?");
  4127.                         throw new ArgumentException(Environment.GetResourceString("Argument_AddingDuplicate__", hit, key));
  4128.                         // If we wanted to make this more general, do this:
  4129.                         /*
  4130.                         values[index] = value;
  4131.                         usedNewSlot = false;
  4132.                         */                       
  4133.                         //break;
  4134.                     }
  4135.                     else {
  4136.                         index++;
  4137.                         index %= keys.Length;
  4138.                     }
  4139.                 }
  4140.             }
  4141.            
  4142.             internal V this[K key]
  4143.             {
  4144.                 [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  4145.                 get {
  4146.                     bool tookLock = false;
  4147.                    
  4148.                     RuntimeHelpers.PrepareConstrainedRegions();
  4149.                     try {
  4150.                         Monitor.ReliableEnter(this, ref tookLock);
  4151.                        
  4152.                         int hashcode = key.GetHashCode();
  4153.                         if (hashcode < 0)
  4154.                             hashcode = -hashcode;
  4155.                         int firstIndex = hashcode % m_key.Length;
  4156.                         int index = firstIndex;
  4157.                        
  4158.                         while (true) {
  4159.                             K hit = m_key[index];
  4160.                            
  4161.                             if ((object)hit != null) {
  4162.                                 if (hit.Equals(key))
  4163.                                     return m_value[index];
  4164.                                
  4165.                                 index++;
  4166.                                 index %= m_key.Length;
  4167.                             }
  4168.                             else {
  4169.                                 return default(V);
  4170.                             }
  4171.                         }
  4172.                     }
  4173.                     finally {
  4174.                         if (tookLock)
  4175.                             Monitor.Exit(this);
  4176.                     }
  4177.                    
  4178.                 }
  4179.                 [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  4180.                 set {
  4181.                     bool tookLock = false;
  4182.                     RuntimeHelpers.PrepareConstrainedRegions();
  4183.                     try {
  4184.                         Monitor.ReliableEnter(this, ref tookLock);
  4185.                         Insert(m_key, m_value, ref m_count, key, value);
  4186.                     }
  4187.                     finally {
  4188.                         if (tookLock)
  4189.                             Monitor.Exit(this);
  4190.                     }
  4191.                 }
  4192.             }
  4193.         }
  4194.     }
  4195.    
  4196.     #region Library
  4197.     unsafe internal struct Utf8String
  4198.     {
  4199.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  4200.         unsafe private static extern bool EqualsCaseSensitive(void* szLhs, void* szRhs, int cSz);
  4201.        
  4202.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  4203.         unsafe private static extern bool EqualsCaseInsensitive(void* szLhs, void* szRhs, int cSz);
  4204.        
  4205.         private static int GetUtf8StringByteLength(void* pUtf8String)
  4206.         {
  4207.             int len = 0;
  4208.            
  4209.             unsafe {
  4210.                 byte* pItr = (byte*)pUtf8String;
  4211.                
  4212.                 while (*pItr != 0) {
  4213.                     len++;
  4214.                     pItr++;
  4215.                 }
  4216.             }
  4217.            
  4218.             return len;
  4219.         }
  4220.        
  4221.         private void* m_pStringHeap;
  4222.         // This is the raw UTF8 string.
  4223.         private int m_StringHeapByteLength;
  4224.        
  4225.         internal Utf8String(void* pStringHeap)
  4226.         {
  4227.             m_pStringHeap = pStringHeap;
  4228.             if (pStringHeap != null) {
  4229.                 m_StringHeapByteLength = GetUtf8StringByteLength(pStringHeap);
  4230.             }
  4231.             else {
  4232.                 m_StringHeapByteLength = 0;
  4233.             }
  4234.         }
  4235.        
  4236.         unsafe internal Utf8String(void* pUtf8String, int cUtf8String)
  4237.         {
  4238.             m_pStringHeap = pUtf8String;
  4239.             m_StringHeapByteLength = cUtf8String;
  4240.         }
  4241.        
  4242.         unsafe internal bool Equals(Utf8String s)
  4243.         {
  4244.             if (m_pStringHeap == null) {
  4245.                 return s.m_StringHeapByteLength == 0;
  4246.             }
  4247.             if ((s.m_StringHeapByteLength == m_StringHeapByteLength) && (m_StringHeapByteLength != 0)) {
  4248.                 return Utf8String.EqualsCaseSensitive(s.m_pStringHeap, m_pStringHeap, m_StringHeapByteLength);
  4249.             }
  4250.             return false;
  4251.         }
  4252.        
  4253.         unsafe internal bool EqualsCaseInsensitive(Utf8String s)
  4254.         {
  4255.             if (m_pStringHeap == null) {
  4256.                 return s.m_StringHeapByteLength == 0;
  4257.             }
  4258.             if ((s.m_StringHeapByteLength == m_StringHeapByteLength) && (m_StringHeapByteLength != 0)) {
  4259.                 return Utf8String.EqualsCaseInsensitive(s.m_pStringHeap, m_pStringHeap, m_StringHeapByteLength);
  4260.             }
  4261.             return false;
  4262.         }
  4263.        
  4264.         public override string ToString()
  4265.         {
  4266.             unsafe {
  4267.                 byte* buf = stackalloc byte[m_StringHeapByteLength];
  4268.                 byte* pItr = (byte*)m_pStringHeap;
  4269.                
  4270.                 for (int currentPos = 0; currentPos < m_StringHeapByteLength; currentPos++) {
  4271.                     buf[currentPos] = *pItr;
  4272.                     pItr++;
  4273.                 }
  4274.                
  4275.                 if (m_StringHeapByteLength == 0)
  4276.                     return "";
  4277.                
  4278.                 int cResult = Encoding.UTF8.GetCharCount(buf, m_StringHeapByteLength);
  4279.                 char* result = stackalloc char[cResult];
  4280.                 Encoding.UTF8.GetChars(buf, m_StringHeapByteLength, result, cResult);
  4281.                 return new string(result, 0, cResult);
  4282.             }
  4283.         }
  4284.     }
  4285.    
  4286.     internal sealed class ASSERT : Exception
  4287.     {
  4288.         #region FRIEND
  4289.         private static bool AssertIsFriend(Type[] friends, StackTrace st)
  4290.         {
  4291.             Type typeOfCallee = st.GetFrame(1).GetMethod().DeclaringType;
  4292.             Type typeOfCaller = st.GetFrame(2).GetMethod().DeclaringType;
  4293.            
  4294.             bool noFriends = true;
  4295.             foreach (Type friend in friends) {
  4296.                 if (typeOfCaller != friend && typeOfCaller != typeOfCallee)
  4297.                     noFriends = false;
  4298.             }
  4299.            
  4300.             if (noFriends)
  4301.                 Assert(false, Environment.GetResourceString("RtType.InvalidCaller"), st.ToString());
  4302.            
  4303.             return true;
  4304.         }
  4305.         [Conditional("_DEBUG")]
  4306.         static internal void FRIEND(Type[] friends)
  4307.         {
  4308.             StackTrace st = new StackTrace();
  4309.             AssertIsFriend(friends, st);
  4310.         }
  4311.         [Conditional("_DEBUG")]
  4312.         static internal void FRIEND(Type friend)
  4313.         {
  4314.             StackTrace st = new StackTrace();
  4315.             AssertIsFriend(new Type[] {friend}, st);
  4316.         }
  4317.         [Conditional("_DEBUG")]
  4318.         static internal void FRIEND(string ns)
  4319.         {
  4320.             StackTrace st = new StackTrace();
  4321.             string nsOfCallee = st.GetFrame(1).GetMethod().DeclaringType.Namespace;
  4322.             string nsOfCaller = st.GetFrame(2).GetMethod().DeclaringType.Namespace;
  4323.             Assert(nsOfCaller.Equals(nsOfCaller) || nsOfCaller.Equals(ns), Environment.GetResourceString("RtType.InvalidCaller"), st.ToString());
  4324.         }
  4325.         #endregion
  4326.        
  4327.         #region PRECONDITION
  4328.         [Conditional("_DEBUG")]
  4329.         static internal void PRECONDITION(bool condition)
  4330.         {
  4331.             Assert(condition);
  4332.         }
  4333.        
  4334.         [Conditional("_DEBUG")]
  4335.         static internal void PRECONDITION(bool condition, string message)
  4336.         {
  4337.             Assert(condition, message);
  4338.         }
  4339.        
  4340.         [Conditional("_DEBUG")]
  4341.         static internal void PRECONDITION(bool condition, string message, string detailedMessage)
  4342.         {
  4343.             Assert(condition, message, detailedMessage);
  4344.         }
  4345.         #endregion
  4346.        
  4347.         #region POSTCONDITION
  4348.         [Conditional("_DEBUG")]
  4349.         static internal void POSTCONDITION(bool condition)
  4350.         {
  4351.             Assert(condition);
  4352.         }
  4353.        
  4354.         [Conditional("_DEBUG")]
  4355.         static internal void POSTCONDITION(bool condition, string message)
  4356.         {
  4357.             Assert(condition, message);
  4358.         }
  4359.        
  4360.         [Conditional("_DEBUG")]
  4361.         static internal void POSTCONDITION(bool condition, string message, string detailedMessage)
  4362.         {
  4363.             Assert(condition, message, detailedMessage);
  4364.         }
  4365.         #endregion
  4366.        
  4367.         #region CONSISTENCY_CHECK
  4368.         [Conditional("_DEBUG")]
  4369.         static internal void CONSISTENCY_CHECK(bool condition)
  4370.         {
  4371.             Assert(condition);
  4372.         }
  4373.        
  4374.         [Conditional("_DEBUG")]
  4375.         static internal void CONSISTENCY_CHECK(bool condition, string message)
  4376.         {
  4377.             Assert(condition, message);
  4378.         }
  4379.        
  4380.         [Conditional("_DEBUG")]
  4381.         static internal void CONSISTENCY_CHECK(bool condition, string message, string detailedMessage)
  4382.         {
  4383.             Assert(condition, message, detailedMessage);
  4384.         }
  4385.         #endregion
  4386.        
  4387.         #region SIMPLIFYING_ASSUMPTION
  4388.         [Conditional("_DEBUG")]
  4389.         static internal void SIMPLIFYING_ASSUMPTION(bool condition)
  4390.         {
  4391.             Assert(condition);
  4392.         }
  4393.        
  4394.         [Conditional("_DEBUG")]
  4395.         static internal void SIMPLIFYING_ASSUMPTION(bool condition, string message)
  4396.         {
  4397.             Assert(condition, message);
  4398.         }
  4399.        
  4400.         [Conditional("_DEBUG")]
  4401.         static internal void SIMPLIFYING_ASSUMPTION(bool condition, string message, string detailedMessage)
  4402.         {
  4403.             Assert(condition, message, detailedMessage);
  4404.         }
  4405.         #endregion
  4406.        
  4407.         #region UNREACHABLE
  4408.         [Conditional("_DEBUG")]
  4409.         static internal void UNREACHABLE()
  4410.         {
  4411.             Assert();
  4412.         }
  4413.        
  4414.         [Conditional("_DEBUG")]
  4415.         static internal void UNREACHABLE(string message)
  4416.         {
  4417.             Assert(message);
  4418.         }
  4419.        
  4420.         [Conditional("_DEBUG")]
  4421.         static internal void UNREACHABLE(string message, string detailedMessage)
  4422.         {
  4423.             Assert(message, detailedMessage);
  4424.         }
  4425.         #endregion
  4426.        
  4427.         #region NOT_IMPLEMENTED
  4428.         [Conditional("_DEBUG")]
  4429.         static internal void NOT_IMPLEMENTED()
  4430.         {
  4431.             Assert();
  4432.         }
  4433.        
  4434.         [Conditional("_DEBUG")]
  4435.         static internal void NOT_IMPLEMENTED(string message)
  4436.         {
  4437.             Assert(message);
  4438.         }
  4439.        
  4440.         [Conditional("_DEBUG")]
  4441.         static internal void NOT_IMPLEMENTED(string message, string detailedMessage)
  4442.         {
  4443.             Assert(message, detailedMessage);
  4444.         }
  4445.         #endregion
  4446.        
  4447.         #region Private Asserts - Throw before assert so debugger can inspect
  4448.         private static void Assert()
  4449.         {
  4450.             Assert(false, null, null);
  4451.         }
  4452.        
  4453.         private static void Assert(string message)
  4454.         {
  4455.             Assert(false, message, null);
  4456.         }
  4457.        
  4458.         private static void Assert(bool condition)
  4459.         {
  4460.             Assert(condition, null, null);
  4461.         }
  4462.        
  4463.         private static void Assert(bool condition, string message)
  4464.         {
  4465.             Assert(condition, message, null);
  4466.         }
  4467.        
  4468.         private static void Assert(string message, string detailedMessage)
  4469.         {
  4470.             Assert(false, message, detailedMessage);
  4471.         }
  4472.        
  4473.         private static void Assert(bool condition, string message, string detailedMessage)
  4474.         {
  4475.             if (!condition) {
  4476.                 // Console.WriteLine("ASSERT MESSAGE: " + message + ", " + detailedMessage);
  4477.                 // System.Diagnostics.Debug.Assert(condition, message, detailedMessage);
  4478.                 // throw new ASSERT();
  4479.             }
  4480.         }
  4481.         #endregion
  4482.     }
  4483.     static internal class LOGIC
  4484.     {
  4485.         static internal bool IMPLIES(bool p, bool q)
  4486.         {
  4487.             return !p || q;
  4488.         }
  4489.        
  4490.         static internal bool BIJECTION(bool p, bool q)
  4491.         {
  4492.             return IMPLIES(p, q) && IMPLIES(q, p);
  4493.         }
  4494.     }
  4495.     #endregion
  4496. }

Developer Fusion