The Labs \ Source Viewer \ SSCLI \ System \ Type

  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. ////////////////////////////////////////////////////////////////////////////////
  16. namespace System
  17. {
  18.    
  19.     using System;
  20.     using System.Reflection;
  21.     using System.Reflection.Emit;
  22.     using System.Reflection.Cache;
  23.     using System.Threading;
  24.     using System.Runtime.Remoting;
  25.     using System.Runtime.InteropServices;
  26.     using System.Runtime.CompilerServices;
  27.     using System.Security.Permissions;
  28.     using System.Collections.Generic;
  29.     using CultureInfo = System.Globalization.CultureInfo;
  30.     using SignatureHelper = System.Reflection.Emit.SignatureHelper;
  31.     using StackCrawlMark = System.Threading.StackCrawlMark;
  32.     using DebuggerStepThroughAttribute = System.Diagnostics.DebuggerStepThroughAttribute;
  33.    
  34.     [Serializable()]
  35.     [ClassInterface(ClassInterfaceType.None)]
  36.     [ComDefaultInterface(typeof(_Type))]
  37.     [System.Runtime.InteropServices.ComVisible(true)]
  38.     public abstract class Type : MemberInfo, _Type, IReflect
  39.     {
  40.         public static readonly MemberFilter FilterAttribute;
  41.         public static readonly MemberFilter FilterName;
  42.         public static readonly MemberFilter FilterNameIgnoreCase;
  43.        
  44.         public static readonly object Missing = System.Reflection.Missing.Value;
  45.        
  46.         public static readonly char Delimiter = '.';
  47.        
  48.         // EmptyTypes is used to indicate that we are looking for someting without any parameters.
  49.         public static readonly Type[] EmptyTypes = new Type[0];
  50.        
  51.         // The Default binder. We create a single one and expose that.
  52.         private static object defaultBinder;
  53.        
  54.         // Because the current compiler doesn't support static delegates
  55.         // the _Filters object is an object that we create to contain all of
  56.         // the filters.
  57.         //private static final Type _filterClass = new RuntimeType();
  58.         static Type()
  59.         {
  60.             __Filters _filterClass = new __Filters();
  61.             FilterAttribute = new MemberFilter(_filterClass.FilterAttribute);
  62.             FilterName = new MemberFilter(_filterClass.FilterName);
  63.             FilterNameIgnoreCase = new MemberFilter(_filterClass.FilterIgnoreCase);
  64.         }
  65.        
  66.         // Prevent from begin created, and allow subclass
  67.         // to create.
  68.         protected Type()
  69.         {
  70.         }
  71.        
  72.        
  73.         // MemberInfo Methods....
  74.         // The Member type Field.
  75.         public override MemberTypes MemberType {
  76.             get { return System.Reflection.MemberTypes.TypeInfo; }
  77.         }
  78.        
  79.         // Return the class that declared this Field.
  80.         public override Type DeclaringType {
  81.             get { return this; }
  82.         }
  83.        
  84.         public virtual MethodBase DeclaringMethod {
  85.             get { return null; }
  86.         }
  87.        
  88.         // Return the class that was used to obtain this field.
  89.         public override Type ReflectedType {
  90.             get { return this; }
  91.         }
  92.        
  93.         ////////////////////////////////////////////////////////////////////////////////
  94.         // This is a static method that returns a Class based upon the name of the class
  95.         // (this name needs to be fully qualified with the package name and is
  96.         // case-sensitive by default).
  97.         ////
  98.        
  99.         // this method is required so Object.GetType is not made virtual by the compiler
  100.         //
  101.         public new Type GetType()
  102.         {
  103.             return base.GetType();
  104.         }
  105.        
  106.         public static Type GetType(string typeName, bool throwOnError, bool ignoreCase)
  107.         {
  108.             unsafe {
  109.                 StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  110.                 return RuntimeType.PrivateGetType(typeName, throwOnError, ignoreCase, ref stackMark);
  111.             }
  112.         }
  113.        
  114.         public static Type GetType(string typeName, bool throwOnError)
  115.         {
  116.             unsafe {
  117.                 StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  118.                 return RuntimeType.PrivateGetType(typeName, throwOnError, false, ref stackMark);
  119.             }
  120.         }
  121.        
  122.         public static Type GetType(string typeName)
  123.         {
  124.             unsafe {
  125.                 StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  126.                 return RuntimeType.PrivateGetType(typeName, false, false, ref stackMark);
  127.             }
  128.         }
  129.        
  130.         public static Type ReflectionOnlyGetType(string typeName, bool throwIfNotFound, bool ignoreCase)
  131.         {
  132.             unsafe {
  133.                 StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  134.                     /*reflectionOnly*/                return RuntimeType.PrivateGetType(typeName, throwIfNotFound, ignoreCase, true, ref stackMark);
  135.             }
  136.         }
  137.        
  138.         public virtual Type MakePointerType()
  139.         {
  140.             throw new NotSupportedException();
  141.         }
  142.         public virtual StructLayoutAttribute StructLayoutAttribute {
  143.             get {
  144.                 throw new NotSupportedException();
  145.             }
  146.         }
  147.         public virtual Type MakeByRefType()
  148.         {
  149.             throw new NotSupportedException();
  150.         }
  151.         public virtual Type MakeArrayType()
  152.         {
  153.             throw new NotSupportedException();
  154.         }
  155.         public virtual Type MakeArrayType(int rank)
  156.         {
  157.             throw new NotSupportedException();
  158.         }
  159.        
  160.        
  161.         internal string SigToString()
  162.         {
  163.             Type elementType = this;
  164.            
  165.             while (elementType.HasElementType)
  166.                 elementType = elementType.GetElementType();
  167.            
  168.             if (elementType.IsNested)
  169.                 return Name;
  170.            
  171.             string sigToString = ToString();
  172.            
  173.             if (elementType.IsPrimitive || elementType == typeof(void) || elementType == typeof(TypedReference))
  174.                 sigToString = sigToString.Substring("System.".Length);
  175.            
  176.             return sigToString;
  177.         }
  178.        
  179.         // GetTypeCode
  180.         // This method will return a TypeCode for the passed
  181.         // type.
  182.         public static TypeCode GetTypeCode(Type type)
  183.         {
  184.             if (type == null)
  185.                 return TypeCode.Empty;
  186.             return type.GetTypeCodeInternal();
  187.         }
  188.        
  189.         internal virtual TypeCode GetTypeCodeInternal()
  190.         {
  191.             Type type = this;
  192.             if (type is SymbolType)
  193.                 return TypeCode.Object;
  194.            
  195.             if (type is TypeBuilder) {
  196.                 TypeBuilder typeBuilder = (TypeBuilder)type;
  197.                 if (typeBuilder.IsEnum == false)
  198.                     return TypeCode.Object;
  199.                
  200.                 // if it is an Enum, just let the underlyingSystemType do the work
  201.             }
  202.            
  203.             if (type != type.UnderlyingSystemType)
  204.                 return Type.GetTypeCode(type.UnderlyingSystemType);
  205.            
  206.             return TypeCode.Object;
  207.         }
  208.        
  209.         // Property representing the GUID associated with a class.
  210.         public abstract Guid GUID {
  211.             get;
  212.         }
  213.        
  214.         // Return the Default binder used by the system.
  215.         public static Binder DefaultBinder {
  216.             get {
  217.                 // Allocate the default binder if it hasn't been allocated yet.
  218.                 if (defaultBinder == null)
  219.                     CreateBinder();
  220.                 return defaultBinder as Binder;
  221.             }
  222.         }
  223.        
  224.         private static void CreateBinder()
  225.         {
  226.             if (defaultBinder == null) {
  227.                 object binder = new DefaultBinder();
  228.                 Interlocked.CompareExchange(ref defaultBinder, binder, null);
  229.             }
  230.         }
  231.        
  232.         // Description of the Binding Process.
  233.         // We must invoke a method that is accessable and for which the provided
  234.         // parameters have the most specific match. A method may be called if
  235.         // 1. The number of parameters in the method declaration equals the number of
  236.         // arguments provided to the invocation
  237.         // 2. The type of each argument can be converted by the binder to the
  238.         // type of the type of the parameter.
  239.         //
  240.         // The binder will find all of the matching methods. These method are found based
  241.         // upon the type of binding requested (MethodInvoke, Get/Set Properties). The set
  242.         // of methods is filtered by the name, number of arguments and a set of search modifiers
  243.         // defined in the Binder.
  244.         //
  245.         // After the method is selected, it will be invoked. Accessability is checked
  246.         // at that point. The search may be control which set of methods are searched based
  247.         // upon the accessibility attribute associated with the method.
  248.         //
  249.         // The BindToMethod method is responsible for selecting the method to be invoked.
  250.         // For the default binder, the most specific method will be selected.
  251.         //
  252.         // This will invoke a specific member...
  253.        
  254.         public abstract object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters);
  255.        
  256.         [DebuggerStepThroughAttribute()]
  257.         [Diagnostics.DebuggerHidden()]
  258.         public object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, CultureInfo culture)
  259.         {
  260.             return InvokeMember(name, invokeAttr, binder, target, args, null, culture, null);
  261.         }
  262.        
  263.         [DebuggerStepThroughAttribute()]
  264.         [Diagnostics.DebuggerHidden()]
  265.         public object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args)
  266.         {
  267.             return InvokeMember(name, invokeAttr, binder, target, args, null, null, null);
  268.         }
  269.        
  270.        
  271.         // Module Property associated with a class.
  272.         public abstract new Module Module {
  273.             get;
  274.         }
  275.        
  276.         // Assembly Property associated with a class.
  277.         public abstract Assembly Assembly {
  278.             get;
  279.         }
  280.        
  281.         // A class handle is a unique integer value associated with
  282.         // each class. The handle is unique during the process life time.
  283.         public virtual extern RuntimeTypeHandle TypeHandle {
  284.             [MethodImplAttribute(MethodImplOptions.InternalCall)]
  285.             get;
  286.         }
  287.        
  288.         internal virtual RuntimeTypeHandle GetTypeHandleInternal()
  289.         {
  290.             return TypeHandle;
  291.         }
  292.        
  293.         [MethodImpl(MethodImplOptions.InternalCall)]
  294.         public static extern RuntimeTypeHandle GetTypeHandle(object o);
  295.        
  296.         // Given a class handle, this will return the class for that handle.
  297.         [MethodImpl(MethodImplOptions.InternalCall)]
  298.         public static extern Type GetTypeFromHandle(RuntimeTypeHandle handle);
  299.        
  300.         // Return the fully qualified name. The name does contain the namespace.
  301.         public abstract string FullName {
  302.             get;
  303.         }
  304.        
  305.         // Return the name space of the class.
  306.         public abstract string Namespace {
  307.             get;
  308.         }
  309.        
  310.        
  311.         public abstract string AssemblyQualifiedName {
  312.             get;
  313.         }
  314.        
  315.        
  316.         public virtual int GetArrayRank()
  317.         {
  318.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride"));
  319.         }
  320.        
  321.         // Returns the base class for a class. If this is an interface or has
  322.         // no base class null is returned. Object is the only Type that does not
  323.         // have a base class.
  324.         public abstract Type BaseType {
  325.             get;
  326.         }
  327.        
  328.        
  329.         // GetConstructor
  330.         // This method will search for the specified constructor. For constructors,
  331.         // unlike everything else, the default is to not look for static methods. The
  332.         // reason is that we don't typically expose the class initializer.
  333.         [System.Runtime.InteropServices.ComVisible(true)]
  334.         public ConstructorInfo GetConstructor(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
  335.         {
  336.             // Must provide some types (Type[0] for nothing)
  337.             if (types == null)
  338.                 throw new ArgumentNullException("types");
  339.             for (int i = 0; i < types.Length; i++)
  340.                 if (types[i] == null)
  341.                     throw new ArgumentNullException("types");
  342.             return GetConstructorImpl(bindingAttr, binder, callConvention, types, modifiers);
  343.         }
  344.        
  345.         [System.Runtime.InteropServices.ComVisible(true)]
  346.         public ConstructorInfo GetConstructor(BindingFlags bindingAttr, Binder binder, Type[] types, ParameterModifier[] modifiers)
  347.         {
  348.             if (types == null)
  349.                 throw new ArgumentNullException("types");
  350.             for (int i = 0; i < types.Length; i++)
  351.                 if (types[i] == null)
  352.                     throw new ArgumentNullException("types");
  353.             return GetConstructorImpl(bindingAttr, binder, CallingConventions.Any, types, modifiers);
  354.         }
  355.        
  356.         [System.Runtime.InteropServices.ComVisible(true)]
  357.         public ConstructorInfo GetConstructor(Type[] types)
  358.         {
  359.            
  360.            
  361.            
  362.            
  363.             // The arguments are checked in the called version of GetConstructor.
  364.             return GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, types, null);
  365.         }
  366.        
  367.         protected abstract ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers);
  368.        
  369.         // GetConstructors()
  370.         // This routine will return an array of all constructors supported by the class.
  371.         // Unlike everything else, the default is to not look for static methods. The
  372.         // reason is that we don't typically expose the class initializer.
  373.         [System.Runtime.InteropServices.ComVisible(true)]
  374.         public ConstructorInfo[] GetConstructors()
  375.         {
  376.             return GetConstructors(BindingFlags.Public | BindingFlags.Instance);
  377.         }
  378.        
  379.         [System.Runtime.InteropServices.ComVisible(true)]
  380.         public abstract ConstructorInfo[] GetConstructors(BindingFlags bindingAttr);
  381.        
  382.         [System.Runtime.InteropServices.ComVisible(true)]
  383.         public ConstructorInfo TypeInitializer {
  384.             get { return GetConstructorImpl(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, CallingConventions.Any, Type.EmptyTypes, null); }
  385.         }
  386.        
  387.         // Return a method based upon the passed criteria. The name of the method
  388.         // must be provided, and exception is thrown if it is not. The bindingAttr
  389.         // parameter indicates if non-public methods should be searched. The types
  390.         // array indicates the types of the parameters being looked for.
  391.         public MethodInfo GetMethod(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
  392.         {
  393.             if (name == null)
  394.                 throw new ArgumentNullException("name");
  395.             if (types == null)
  396.                 throw new ArgumentNullException("types");
  397.             for (int i = 0; i < types.Length; i++)
  398.                 if (types[i] == null)
  399.                     throw new ArgumentNullException("types");
  400.             return GetMethodImpl(name, bindingAttr, binder, callConvention, types, modifiers);
  401.         }
  402.        
  403.         public MethodInfo GetMethod(string name, BindingFlags bindingAttr, Binder binder, Type[] types, ParameterModifier[] modifiers)
  404.         {
  405.             if (name == null)
  406.                 throw new ArgumentNullException("name");
  407.             if (types == null)
  408.                 throw new ArgumentNullException("types");
  409.             for (int i = 0; i < types.Length; i++)
  410.                 if (types[i] == null)
  411.                     throw new ArgumentNullException("types");
  412.             return GetMethodImpl(name, bindingAttr, binder, CallingConventions.Any, types, modifiers);
  413.         }
  414.        
  415.         public MethodInfo GetMethod(string name, Type[] types, ParameterModifier[] modifiers)
  416.         {
  417.             if (name == null)
  418.                 throw new ArgumentNullException("name");
  419.             if (types == null)
  420.                 throw new ArgumentNullException("types");
  421.             for (int i = 0; i < types.Length; i++)
  422.                 if (types[i] == null)
  423.                     throw new ArgumentNullException("types");
  424.             return GetMethodImpl(name, Type.DefaultLookup, null, CallingConventions.Any, types, modifiers);
  425.         }
  426.        
  427.         public MethodInfo GetMethod(string name, Type[] types)
  428.         {
  429.             if (name == null)
  430.                 throw new ArgumentNullException("name");
  431.             if (types == null)
  432.                 throw new ArgumentNullException("types");
  433.             for (int i = 0; i < types.Length; i++)
  434.                 if (types[i] == null)
  435.                     throw new ArgumentNullException("types");
  436.             return GetMethodImpl(name, Type.DefaultLookup, null, CallingConventions.Any, types, null);
  437.         }
  438.        
  439.         public MethodInfo GetMethod(string name, BindingFlags bindingAttr)
  440.         {
  441.             if (name == null)
  442.                 throw new ArgumentNullException("name");
  443.             return GetMethodImpl(name, bindingAttr, null, CallingConventions.Any, null, null);
  444.         }
  445.        
  446.         public MethodInfo GetMethod(string name)
  447.         {
  448.             if (name == null)
  449.                 throw new ArgumentNullException("name");
  450.             return GetMethodImpl(name, Type.DefaultLookup, null, CallingConventions.Any, null, null);
  451.         }
  452.        
  453.         protected abstract MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers);
  454.        
  455.         // GetMethods
  456.         // This routine will return all the methods implemented by the class
  457.         public MethodInfo[] GetMethods()
  458.         {
  459.             return GetMethods(Type.DefaultLookup);
  460.         }
  461.        
  462.         public abstract MethodInfo[] GetMethods(BindingFlags bindingAttr);
  463.        
  464.         // GetField
  465.         // Get Field will return a specific field based upon name
  466.         public abstract FieldInfo GetField(string name, BindingFlags bindingAttr);
  467.        
  468.         public FieldInfo GetField(string name)
  469.         {
  470.             return GetField(name, Type.DefaultLookup);
  471.         }
  472.        
  473.         // GetFields
  474.         // Get fields will return a full array of fields implemented by a class
  475.         public FieldInfo[] GetFields()
  476.         {
  477.             return GetFields(Type.DefaultLookup);
  478.         }
  479.         public abstract FieldInfo[] GetFields(BindingFlags bindingAttr);
  480.        
  481.         // GetInterface
  482.         // This method will return an interface (as a class) based upon
  483.         // the passed in name.
  484.         public Type GetInterface(string name)
  485.         {
  486.             return GetInterface(name, false);
  487.         }
  488.         public abstract Type GetInterface(string name, bool ignoreCase);
  489.        
  490.         // GetInterfaces
  491.         // This method will return all of the interfaces implemented by a
  492.         // class
  493.         public abstract Type[] GetInterfaces();
  494.        
  495.         // FindInterfaces
  496.         // This method will filter the interfaces supported the class
  497.         public virtual Type[] FindInterfaces(TypeFilter filter, object filterCriteria)
  498.         {
  499.             if (filter == null)
  500.                 throw new ArgumentNullException("filter");
  501.             Type[] c = GetInterfaces();
  502.             int cnt = 0;
  503.             for (int i = 0; i < c.Length; i++) {
  504.                 if (!filter(c[i], filterCriteria))
  505.                     c[i] = null;
  506.                 else
  507.                     cnt++;
  508.             }
  509.             if (cnt == c.Length)
  510.                 return c;
  511.            
  512.             Type[] ret = new Type[cnt];
  513.             cnt = 0;
  514.             for (int i = 0; i < c.Length; i++) {
  515.                 if (c[i] != null)
  516.                     ret[cnt++] = c[i];
  517.             }
  518.             return ret;
  519.         }
  520.        
  521.         // GetEvent
  522.         // This method will return a event by name if it is found.
  523.         // null is returned if the event is not found
  524.         public EventInfo GetEvent(string name)
  525.         {
  526.             return GetEvent(name, Type.DefaultLookup);
  527.         }
  528.         public abstract EventInfo GetEvent(string name, BindingFlags bindingAttr);
  529.        
  530.         // GetEvents
  531.         // This method will return an array of EventInfo. If there are not Events
  532.         // an empty array will be returned.
  533.        
  534.         public virtual EventInfo[] GetEvents()
  535.         {
  536.             return GetEvents(Type.DefaultLookup);
  537.         }
  538.         public abstract EventInfo[] GetEvents(BindingFlags bindingAttr);
  539.        
  540.         // Return a property based upon the passed criteria. The nameof the
  541.         // parameter must be provided.
  542.         public PropertyInfo GetProperty(string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)
  543.         {
  544.             if (name == null)
  545.                 throw new ArgumentNullException("name");
  546.             if (types == null)
  547.                 throw new ArgumentNullException("types");
  548.             return GetPropertyImpl(name, bindingAttr, binder, returnType, types, modifiers);
  549.         }
  550.        
  551.         public PropertyInfo GetProperty(string name, Type returnType, Type[] types, ParameterModifier[] modifiers)
  552.         {
  553.             if (name == null)
  554.                 throw new ArgumentNullException("name");
  555.             if (types == null)
  556.                 throw new ArgumentNullException("types");
  557.             return GetPropertyImpl(name, Type.DefaultLookup, null, returnType, types, modifiers);
  558.         }
  559.        
  560.         public PropertyInfo GetProperty(string name, BindingFlags bindingAttr)
  561.         {
  562.             if (name == null)
  563.                 throw new ArgumentNullException("name");
  564.             return GetPropertyImpl(name, bindingAttr, null, null, null, null);
  565.         }
  566.        
  567.         public PropertyInfo GetProperty(string name, Type returnType, Type[] types)
  568.         {
  569.             if (name == null)
  570.                 throw new ArgumentNullException("name");
  571.             if (types == null)
  572.                 throw new ArgumentNullException("types");
  573.             return GetPropertyImpl(name, Type.DefaultLookup, null, returnType, types, null);
  574.         }
  575.        
  576.         public PropertyInfo GetProperty(string name, Type[] types)
  577.         {
  578.             if (name == null)
  579.                 throw new ArgumentNullException("name");
  580.             if (types == null)
  581.                 throw new ArgumentNullException("types");
  582.             return GetPropertyImpl(name, Type.DefaultLookup, null, null, types, null);
  583.         }
  584.        
  585.         public PropertyInfo GetProperty(string name, Type returnType)
  586.         {
  587.             if (name == null)
  588.                 throw new ArgumentNullException("name");
  589.             if (returnType == null)
  590.                 throw new ArgumentNullException("returnType");
  591.             return GetPropertyImpl(name, Type.DefaultLookup, null, returnType, null, null);
  592.         }
  593.        
  594.         public PropertyInfo GetProperty(string name)
  595.         {
  596.             if (name == null)
  597.                 throw new ArgumentNullException("name");
  598.             return GetPropertyImpl(name, Type.DefaultLookup, null, null, null, null);
  599.         }
  600.        
  601.         protected abstract PropertyInfo GetPropertyImpl(string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers);
  602.        
  603.         // GetProperties
  604.         // This method will return an array of all of the properties defined
  605.         // for a Type.
  606.         public abstract PropertyInfo[] GetProperties(BindingFlags bindingAttr);
  607.         public PropertyInfo[] GetProperties()
  608.         {
  609.             return GetProperties(Type.DefaultLookup);
  610.         }
  611.        
  612.         // GetNestedTypes()
  613.         // This set of method will return any nested types that are found inside
  614.         // of the type.
  615.         public Type[] GetNestedTypes()
  616.         {
  617.             return GetNestedTypes(Type.DefaultLookup);
  618.         }
  619.        
  620.         public abstract Type[] GetNestedTypes(BindingFlags bindingAttr);
  621.        
  622.         // GetNestedType()
  623.         public Type GetNestedType(string name)
  624.         {
  625.             return GetNestedType(name, Type.DefaultLookup);
  626.         }
  627.        
  628.         public abstract Type GetNestedType(string name, BindingFlags bindingAttr);
  629.        
  630.         // GetMember
  631.         // This method will return all of the members which match the specified string
  632.         // passed into the method
  633.         public MemberInfo[] GetMember(string name)
  634.         {
  635.             return GetMember(name, Type.DefaultLookup);
  636.         }
  637.        
  638.        
  639.        
  640.         public virtual MemberInfo[] GetMember(string name, BindingFlags bindingAttr)
  641.         {
  642.             return GetMember(name, MemberTypes.All, bindingAttr);
  643.         }
  644.        
  645.        
  646.         public virtual MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
  647.         {
  648.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride"));
  649.         }
  650.        
  651.         // GetMembers
  652.         // This will return a Member array of all of the members of a class
  653.         public MemberInfo[] GetMembers()
  654.         {
  655.             return GetMembers(Type.DefaultLookup);
  656.         }
  657.         public abstract MemberInfo[] GetMembers(BindingFlags bindingAttr);
  658.        
  659.         // GetDefaultMembers
  660.         // This will return a MemberInfo that has been marked with the
  661.         // DefaultMemberAttribute
  662.         public virtual MemberInfo[] GetDefaultMembers()
  663.         {
  664.             // See if we have cached the default member name
  665.             string defaultMember = (string)this.Cache[CacheObjType.DefaultMember];
  666.            
  667.             if (defaultMember == null) {
  668.                 // Get all of the custom attributes
  669.                
  670.                 CustomAttributeData attr = null;
  671.                
  672.                 for (Type t = this; t != null; t = t.BaseType) {
  673.                     IList<CustomAttributeData> attrs = CustomAttributeData.GetCustomAttributes(t);
  674.                     for (int i = 0; i < attrs.Count; i++) {
  675.                         if (attrs[i].Constructor.DeclaringType == typeof(DefaultMemberAttribute)) {
  676.                             attr = attrs[i];
  677.                             break;
  678.                         }
  679.                     }
  680.                    
  681.                     if (attr != null)
  682.                         break;
  683.                 }
  684.                
  685.                 if (attr == null)
  686.                     return new MemberInfo[0];
  687.                 defaultMember = attr.ConstructorArguments[0].Value as string;
  688.                 this.Cache[CacheObjType.DefaultMember] = defaultMember;
  689.             }
  690.            
  691.             MemberInfo[] members = GetMember(defaultMember);
  692.             if (members == null)
  693.                 members = new MemberInfo[0];
  694.             return members;
  695.         }
  696.        
  697.         internal virtual string GetDefaultMemberName()
  698.         {
  699.             // See if we have cached the default member name
  700.             string defaultMember = (string)this.Cache[CacheObjType.DefaultMember];
  701.            
  702.             if (defaultMember == null) {
  703.                 object[] attrs = GetCustomAttributes(typeof(DefaultMemberAttribute), true);
  704.                 // We assume that there is only one DefaultMemberAttribute (Allow multiple = false)
  705.                 if (attrs.Length > 1)
  706.                     throw new ExecutionEngineException(Environment.GetResourceString("ExecutionEngine_InvalidAttribute"));
  707.                 if (attrs.Length == 0)
  708.                     return null;
  709.                 defaultMember = ((DefaultMemberAttribute)attrs[0]).MemberName;
  710.                 this.Cache[CacheObjType.DefaultMember] = defaultMember;
  711.             }
  712.             return defaultMember;
  713.         }
  714.        
  715.         // FindMembers
  716.         // This will return a filtered version of the member information
  717.         public virtual MemberInfo[] FindMembers(MemberTypes memberType, BindingFlags bindingAttr, MemberFilter filter, object filterCriteria)
  718.         {
  719.             // Define the work arrays
  720.             MethodInfo[] m = null;
  721.             ConstructorInfo[] c = null;
  722.             FieldInfo[] f = null;
  723.             PropertyInfo[] p = null;
  724.             EventInfo[] e = null;
  725.             Type[] t = null;
  726.            
  727.             int i = 0;
  728.             int cnt = 0;
  729.             // Total Matchs
  730.             // Check the methods
  731.             if ((memberType & System.Reflection.MemberTypes.Method) != 0) {
  732.                 m = GetMethods(bindingAttr);
  733.                 if (filter != null) {
  734.                     for (i = 0; i < m.Length; i++)
  735.                         if (!filter(m[i], filterCriteria))
  736.                             m[i] = null;
  737.                         else
  738.                             cnt++;
  739.                 }
  740.                 else {
  741.                     cnt += m.Length;
  742.                 }
  743.             }
  744.            
  745.             // Check the constructors
  746.             if ((memberType & System.Reflection.MemberTypes.Constructor) != 0) {
  747.                 c = GetConstructors(bindingAttr);
  748.                 if (filter != null) {
  749.                     for (i = 0; i < c.Length; i++)
  750.                         if (!filter(c[i], filterCriteria))
  751.                             c[i] = null;
  752.                         else
  753.                             cnt++;
  754.                 }
  755.                 else {
  756.                     cnt += c.Length;
  757.                 }
  758.             }
  759.            
  760.             // Check the fields
  761.             if ((memberType & System.Reflection.MemberTypes.Field) != 0) {
  762.                 f = GetFields(bindingAttr);
  763.                 if (filter != null) {
  764.                     for (i = 0; i < f.Length; i++)
  765.                         if (!filter(f[i], filterCriteria))
  766.                             f[i] = null;
  767.                         else
  768.                             cnt++;
  769.                 }
  770.                 else {
  771.                     cnt += f.Length;
  772.                 }
  773.             }
  774.            
  775.             // Check the Properties
  776.             if ((memberType & System.Reflection.MemberTypes.Property) != 0) {
  777.                 p = GetProperties(bindingAttr);
  778.                 if (filter != null) {
  779.                     for (i = 0; i < p.Length; i++)
  780.                         if (!filter(p[i], filterCriteria))
  781.                             p[i] = null;
  782.                         else
  783.                             cnt++;
  784.                 }
  785.                 else {
  786.                     cnt += p.Length;
  787.                 }
  788.             }
  789.            
  790.             // Check the Events
  791.             if ((memberType & System.Reflection.MemberTypes.Event) != 0) {
  792.                 e = GetEvents();
  793.                 if (filter != null) {
  794.                     for (i = 0; i < e.Length; i++)
  795.                         if (!filter(e[i], filterCriteria))
  796.                             e[i] = null;
  797.                         else
  798.                             cnt++;
  799.                 }
  800.                 else {
  801.                     cnt += e.Length;
  802.                 }
  803.             }
  804.            
  805.             // Check the Types
  806.             if ((memberType & System.Reflection.MemberTypes.NestedType) != 0) {
  807.                 t = GetNestedTypes(bindingAttr);
  808.                 if (filter != null) {
  809.                     for (i = 0; i < t.Length; i++)
  810.                         if (!filter(t[i], filterCriteria))
  811.                             t[i] = null;
  812.                         else
  813.                             cnt++;
  814.                 }
  815.                 else {
  816.                     cnt += t.Length;
  817.                 }
  818.             }
  819.            
  820.             // Allocate the Member Info
  821.             MemberInfo[] ret = new MemberInfo[cnt];
  822.            
  823.             // Copy the Methods
  824.             cnt = 0;
  825.             if (m != null) {
  826.                 for (i = 0; i < m.Length; i++)
  827.                     if (m[i] != null)
  828.                         ret[cnt++] = m[i];
  829.             }
  830.            
  831.             // Copy the Constructors
  832.             if (c != null) {
  833.                 for (i = 0; i < c.Length; i++)
  834.                     if (c[i] != null)
  835.                         ret[cnt++] = c[i];
  836.             }
  837.            
  838.             // Copy the Fields
  839.             if (f != null) {
  840.                 for (i = 0; i < f.Length; i++)
  841.                     if (f[i] != null)
  842.                         ret[cnt++] = f[i];
  843.             }
  844.            
  845.             // Copy the Properties
  846.             if (p != null) {
  847.                 for (i = 0; i < p.Length; i++)
  848.                     if (p[i] != null)
  849.                         ret[cnt++] = p[i];
  850.             }
  851.            
  852.             // Copy the Events
  853.             if (e != null) {
  854.                 for (i = 0; i < e.Length; i++)
  855.                     if (e[i] != null)
  856.                         ret[cnt++] = e[i];
  857.             }
  858.            
  859.             // Copy the Types
  860.             if (t != null) {
  861.                 for (i = 0; i < t.Length; i++)
  862.                     if (t[i] != null)
  863.                         ret[cnt++] = t[i];
  864.             }
  865.            
  866.             return ret;
  867.         }
  868.        
  869.         ////////////////////////////////////////////////////////////////////////////////
  870.         //
  871.         // Attributes
  872.         //
  873.         // The attributes are all treated as read-only properties on a class. Most of
  874.         // these boolean properties have flag values defined in this class and act like
  875.         // a bit mask of attributes. There are also a set of boolean properties that
  876.         // relate to the classes relationship to other classes and to the state of the
  877.         // class inside the runtime.
  878.         //
  879.         ////////////////////////////////////////////////////////////////////////////////
  880.        
  881.         public bool IsNested {
  882.             get { return DeclaringType != null; }
  883.         }
  884.         // The attribute property on the Type.
  885.         public TypeAttributes Attributes {
  886.             get { return GetAttributeFlagsImpl(); }
  887.         }
  888.        
  889.         public virtual GenericParameterAttributes GenericParameterAttributes {
  890.             get {
  891.                 throw new NotSupportedException();
  892.             }
  893.         }
  894.        
  895.         public bool IsVisible {
  896.             get { return GetTypeHandleInternal().IsVisible(); }
  897.         }
  898.        
  899.         public bool IsNotPublic {
  900.             get { return ((GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.NotPublic); }
  901.         }
  902.         public bool IsPublic {
  903.             get { return ((GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.Public); }
  904.         }
  905.         public bool IsNestedPublic {
  906.             get { return ((GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.NestedPublic); }
  907.         }
  908.         public bool IsNestedPrivate {
  909.             get { return ((GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.NestedPrivate); }
  910.         }
  911.         public bool IsNestedFamily {
  912.             get { return ((GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.NestedFamily); }
  913.         }
  914.         public bool IsNestedAssembly {
  915.             get { return ((GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.NestedAssembly); }
  916.         }
  917.         public bool IsNestedFamANDAssem {
  918.             get { return ((GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.NestedFamANDAssem); }
  919.         }
  920.         public bool IsNestedFamORAssem {
  921.             get { return ((GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.NestedFamORAssem); }
  922.         }
  923.        
  924.         public bool IsAutoLayout {
  925.             get { return ((GetAttributeFlagsImpl() & TypeAttributes.LayoutMask) == TypeAttributes.AutoLayout); }
  926.         }
  927.         public bool IsLayoutSequential {
  928.             get { return ((GetAttributeFlagsImpl() & TypeAttributes.LayoutMask) == TypeAttributes.SequentialLayout); }
  929.         }
  930.         public bool IsExplicitLayout {
  931.             get { return ((GetAttributeFlagsImpl() & TypeAttributes.LayoutMask) == TypeAttributes.ExplicitLayout); }
  932.         }
  933.        
  934.         public bool IsClass {
  935.             get { return ((GetAttributeFlagsImpl() & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Class && !IsSubclassOf(Type.valueType)); }
  936.         }
  937.         public bool IsInterface {
  938.             get { return ((GetAttributeFlagsImpl() & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Interface); }
  939.         }
  940.         public bool IsValueType {
  941.             get { return IsValueTypeImpl(); }
  942.         }
  943.        
  944.         public bool IsAbstract {
  945.             get { return ((GetAttributeFlagsImpl() & TypeAttributes.Abstract) != 0); }
  946.         }
  947.         public bool IsSealed {
  948.             get { return ((GetAttributeFlagsImpl() & TypeAttributes.Sealed) != 0); }
  949.         }
  950.         public bool IsEnum {
  951.             get { return IsSubclassOf(Type.enumType); }
  952.         }
  953.         public bool IsSpecialName {
  954.             get { return ((GetAttributeFlagsImpl() & TypeAttributes.SpecialName) != 0); }
  955.         }
  956.         public bool IsImport {
  957.             get { return ((GetAttributeFlagsImpl() & TypeAttributes.Import) != 0); }
  958.         }
  959.         public bool IsSerializable {
  960.             get { return (((GetAttributeFlagsImpl() & TypeAttributes.Serializable) != 0) || (this.QuickSerializationCastCheck())); }
  961.         }
  962.         private bool QuickSerializationCastCheck()
  963.         {
  964.             Type c = this.UnderlyingSystemType;
  965.             while (c != null) {
  966.                 if (c == typeof(Enum) || c == typeof(Delegate)) {
  967.                     return true;
  968.                 }
  969.                 c = c.BaseType;
  970.             }
  971.             return false;
  972.         }
  973.        
  974.         public bool IsAnsiClass {
  975.             get { return ((GetAttributeFlagsImpl() & TypeAttributes.StringFormatMask) == TypeAttributes.AnsiClass); }
  976.         }
  977.         public bool IsUnicodeClass {
  978.             get { return ((GetAttributeFlagsImpl() & TypeAttributes.StringFormatMask) == TypeAttributes.UnicodeClass); }
  979.         }
  980.         public bool IsAutoClass {
  981.             get { return ((GetAttributeFlagsImpl() & TypeAttributes.StringFormatMask) == TypeAttributes.AutoClass); }
  982.         }
  983.        
  984.         // These are not backed up by attributes. Instead they are implemented
  985.         // based internally.
  986.         public bool IsArray {
  987.             get { return IsArrayImpl(); }
  988.         }
  989.        
  990.         internal virtual bool IsSzArray {
  991.             get { return false; }
  992.         }
  993.        
  994.         public virtual bool IsGenericType {
  995.             get { return false; }
  996.         }
  997.        
  998.         public virtual bool IsGenericTypeDefinition {
  999.             get { return false; }
  1000.         }
  1001.        
  1002.         public virtual bool IsGenericParameter {
  1003.             get { return false; }
  1004.         }
  1005.        
  1006.         public virtual int GenericParameterPosition {
  1007.             get {
  1008.                 throw new InvalidOperationException(Environment.GetResourceString("Arg_NotGenericParameter"));
  1009.             }
  1010.         }
  1011.        
  1012.         public virtual bool ContainsGenericParameters {
  1013.             get {
  1014.                 if (HasElementType)
  1015.                     return GetRootElementType().ContainsGenericParameters;
  1016.                
  1017.                 if (IsGenericParameter)
  1018.                     return true;
  1019.                
  1020.                 if (!IsGenericType)
  1021.                     return false;
  1022.                
  1023.                 Type[] genericArguments = GetGenericArguments();
  1024.                 for (int i = 0; i < genericArguments.Length; i++) {
  1025.                     if (genericArguments[i].ContainsGenericParameters)
  1026.                         return true;
  1027.                 }
  1028.                
  1029.                 return false;
  1030.             }
  1031.         }
  1032.        
  1033.         public virtual Type[] GetGenericParameterConstraints()
  1034.         {
  1035.             if (!IsGenericParameter)
  1036.                 throw new InvalidOperationException(Environment.GetResourceString("Arg_NotGenericParameter"));
  1037.            
  1038.             throw new InvalidOperationException();
  1039.         }
  1040.        
  1041.         public bool IsByRef {
  1042.             get { return IsByRefImpl(); }
  1043.         }
  1044.         public bool IsPointer {
  1045.             get { return IsPointerImpl(); }
  1046.         }
  1047.         public bool IsPrimitive {
  1048.             get { return IsPrimitiveImpl(); }
  1049.         }
  1050.         public bool IsCOMObject {
  1051.             get { return IsCOMObjectImpl(); }
  1052.         }
  1053.        
  1054.         public bool HasElementType {
  1055.             get { return HasElementTypeImpl(); }
  1056.         }
  1057.        
  1058.         public bool IsContextful {
  1059.             get { return IsContextfulImpl(); }
  1060.         }
  1061.        
  1062.         public bool IsMarshalByRef {
  1063.             get { return IsMarshalByRefImpl(); }
  1064.         }
  1065.        
  1066.         internal bool HasProxyAttribute {
  1067.             get { return HasProxyAttributeImpl(); }
  1068.         }
  1069.        
  1070.         // Protected routine to determine if this class represents a value class
  1071.         protected virtual bool IsValueTypeImpl()
  1072.         {
  1073.             Type type = this;
  1074.             if (type == Type.valueType || type == Type.enumType)
  1075.                 return false;
  1076.             return IsSubclassOf(Type.valueType);
  1077.         }
  1078.        
  1079.         // Protected routine to get the attributes.
  1080.         protected abstract TypeAttributes GetAttributeFlagsImpl();
  1081.        
  1082.         // Protected routine to determine if this class represents an Array
  1083.         protected abstract bool IsArrayImpl();
  1084.        
  1085.         // Protected routine to determine if this class is a ByRef
  1086.         protected abstract bool IsByRefImpl();
  1087.        
  1088.         // Protected routine to determine if this class is a Pointer
  1089.         protected abstract bool IsPointerImpl();
  1090.        
  1091.         // Protected routine to determine if this class represents a primitive type
  1092.         protected abstract bool IsPrimitiveImpl();
  1093.        
  1094.         // Protected routine to determine if this class represents a COM object
  1095.         protected abstract bool IsCOMObjectImpl();
  1096.        
  1097.         public virtual Type MakeGenericType(params Type[] typeArguments)
  1098.         {
  1099.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride"));
  1100.         }
  1101.        
  1102.        
  1103.         // Protected routine to determine if this class is contextful
  1104.         protected virtual bool IsContextfulImpl()
  1105.         {
  1106.             return typeof(ContextBoundObject).IsAssignableFrom(this);
  1107.         }
  1108.        
  1109.        
  1110.         // Protected routine to determine if this class is marshaled by ref
  1111.         protected virtual bool IsMarshalByRefImpl()
  1112.         {
  1113.             return typeof(MarshalByRefObject).IsAssignableFrom(this);
  1114.         }
  1115.        
  1116.         internal virtual bool HasProxyAttributeImpl()
  1117.         {
  1118.             // We will override this in RuntimeType
  1119.             return false;
  1120.         }
  1121.        
  1122.         public abstract Type GetElementType();
  1123.        
  1124.         public virtual Type[] GetGenericArguments()
  1125.         {
  1126.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride"));
  1127.         }
  1128.        
  1129.         public virtual Type GetGenericTypeDefinition()
  1130.         {
  1131.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride"));
  1132.         }
  1133.        
  1134.         protected abstract bool HasElementTypeImpl();
  1135.        
  1136.         internal virtual Type GetRootElementType()
  1137.         {
  1138.             Type rootElementType = this;
  1139.            
  1140.             while (rootElementType.HasElementType)
  1141.                 rootElementType = rootElementType.GetElementType();
  1142.            
  1143.             return rootElementType;
  1144.         }
  1145.        
  1146.        
  1147.         // Return the underlying Type that represents the IReflect Object. For expando object,
  1148.         // this is the (Object) IReflectInstance.GetType(). For Type object it is this.
  1149.         public abstract Type UnderlyingSystemType {
  1150.             get;
  1151.         }
  1152.        
  1153.         // Returns true of this class is a true subclass of c. Everything
  1154.         // else returns false. If this class and c are the same class false is
  1155.         // returned.
  1156.         //
  1157.         [System.Runtime.InteropServices.ComVisible(true)]
  1158.         public virtual bool IsSubclassOf(Type c)
  1159.         {
  1160.             Type p = this;
  1161.             if (p == c)
  1162.                 return false;
  1163.             while (p != null) {
  1164.                 if (p == c)
  1165.                     return true;
  1166.                 p = p.BaseType;
  1167.             }
  1168.             return false;
  1169.         }
  1170.        
  1171.         // Returns true if the object passed is assignable to an instance of this class.
  1172.         // Everything else returns false.
  1173.         //
  1174.         public virtual bool IsInstanceOfType(object o)
  1175.         {
  1176.             if (this is RuntimeType)
  1177.                 return IsInstanceOfType(o);
  1178.            
  1179.             if (o == null)
  1180.                 return false;
  1181.            
  1182.             // For transparent proxies we have to check the cast
  1183.             // using remoting specific facilities.
  1184.             if (RemotingServices.IsTransparentProxy(o)) {
  1185.                 return (null != RemotingServices.CheckCast(o, this));
  1186.             }
  1187.            
  1188.             if (IsInterface && o.GetType().IsCOMObject) {
  1189.                 if (this is RuntimeType)
  1190.                     return ((RuntimeType)this).SupportsInterface(o);
  1191.             }
  1192.            
  1193.             return IsAssignableFrom(o.GetType());
  1194.         }
  1195.        
  1196.         // Returns true if an instance of Type c may be assigned
  1197.         // to an instance of this class. Return false otherwise.
  1198.         //
  1199.         public virtual bool IsAssignableFrom(Type c)
  1200.         {
  1201.             if (c == null)
  1202.                 return false;
  1203.            
  1204.             try {
  1205.                 RuntimeType fromType = c.UnderlyingSystemType as RuntimeType;
  1206.                 RuntimeType toType = this.UnderlyingSystemType as RuntimeType;
  1207.                 if (fromType == null || toType == null) {
  1208.                     // special case for TypeBuilder
  1209.                     TypeBuilder fromTypeBuilder = c as TypeBuilder;
  1210.                     if (fromTypeBuilder == null) {
  1211.                         return false;
  1212.                     }
  1213.                    
  1214.                     if (TypeBuilder.IsTypeEqual(this, c))
  1215.                         return true;
  1216.                    
  1217.                     // If fromTypeBuilder is a subclass of this class, then c can be cast to this type.
  1218.                     if (fromTypeBuilder.IsSubclassOf(this))
  1219.                         return true;
  1220.                    
  1221.                     if (this.IsInterface == false) {
  1222.                         return false;
  1223.                     }
  1224.                    
  1225.                     // now is This type a base type on one of the interface impl?
  1226.                     Type[] interfaces = fromTypeBuilder.GetInterfaces();
  1227.                     for (int i = 0; i < interfaces.Length; i++) {
  1228.                         if (TypeBuilder.IsTypeEqual(interfaces[i], this))
  1229.                             return true;
  1230.                         if (interfaces[i].IsSubclassOf(this))
  1231.                             return true;
  1232.                     }
  1233.                     return false;
  1234.                 }
  1235.                 bool b = RuntimeType.CanCastTo(fromType, toType);
  1236.                 return b;
  1237.             }
  1238.             catch (ArgumentException) {
  1239.             }
  1240.            
  1241.             // Check for interfaces
  1242.             if (IsInterface) {
  1243.                 Type[] ifaces = c.GetInterfaces();
  1244.                 for (int i = 0; i < ifaces.Length; i++)
  1245.                     if (this == ifaces[i])
  1246.                         return true;
  1247.             }
  1248.             else if (IsGenericParameter) {
  1249.                 Type[] constraints = GetGenericParameterConstraints();
  1250.                 for (int i = 0; i < constraints.Length; i++)
  1251.                     if (!constraints[i].IsAssignableFrom(c))
  1252.                         return false;
  1253.                
  1254.                 return true;
  1255.             }
  1256.             // Check the class relationship
  1257.             else {
  1258.                 while (c != null) {
  1259.                     if (c == this)
  1260.                         return true;
  1261.                     c = c.BaseType;
  1262.                 }
  1263.             }
  1264.             return false;
  1265.         }
  1266.        
  1267.         // ToString
  1268.         // Print the String Representation of the Type
  1269.         public override string ToString()
  1270.         {
  1271.             return "Type: " + Name;
  1272.         }
  1273.        
  1274.         // This method will return an array of classes based upon the array of
  1275.         // types.
  1276.         public static Type[] GetTypeArray(object[] args)
  1277.         {
  1278.             if (args == null)
  1279.                 throw new ArgumentNullException("args");
  1280.             Type[] cls = new Type[args.Length];
  1281.             for (int i = 0; i < cls.Length; i++) {
  1282.                 if (args[i] == null)
  1283.                     throw new ArgumentNullException();
  1284.                 cls[i] = args[i].GetType();
  1285.             }
  1286.             return cls;
  1287.         }
  1288.        
  1289.         public override bool Equals(object o)
  1290.         {
  1291.             if (o == null)
  1292.                 return false;
  1293.             if (!(o is Type))
  1294.                 return false;
  1295.             return (this.UnderlyingSystemType == ((Type)o).UnderlyingSystemType);
  1296.         }
  1297.        
  1298.         public bool Equals(Type o)
  1299.         {
  1300.             if (o == null)
  1301.                 return false;
  1302.             return (this.UnderlyingSystemType == o.UnderlyingSystemType);
  1303.         }
  1304.        
  1305.         public override int GetHashCode()
  1306.         {
  1307.             Type SystemType = UnderlyingSystemType;
  1308.             if (SystemType != this)
  1309.                 return SystemType.GetHashCode();
  1310.             return base.GetHashCode();
  1311.         }
  1312.        
  1313.        
  1314.         // GetInterfaceMap
  1315.         // This method will return an interface mapping for the interface
  1316.         // requested. It will throw an argument exception if the Type doesn't
  1317.         // implemenet the interface.
  1318.         [System.Runtime.InteropServices.ComVisible(true)]
  1319.         public virtual InterfaceMapping GetInterfaceMap(Type interfaceType)
  1320.         {
  1321.             throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride"));
  1322.         }
  1323.        
  1324.        
  1325.         // This is used by Remoting
  1326.         static internal Type ResolveTypeRelativeTo(string typeName, int offset, int count, Type serverType)
  1327.         {
  1328.             Type type = ResolveTypeRelativeToBaseTypes(typeName, offset, count, serverType);
  1329.             if (type == null) {
  1330.                 // compare against the interface list
  1331.                 // GetInterfaces() returns a complete list of interfaces this type supports
  1332.                 Type[] interfaces = serverType.GetInterfaces();
  1333.                 foreach (Type iface in interfaces) {
  1334.                     string ifaceTypeName = iface.FullName;
  1335.                     if (ifaceTypeName.Length == count) {
  1336.                         if (String.CompareOrdinal(typeName, offset, ifaceTypeName, 0, count) == 0) {
  1337.                             return iface;
  1338.                         }
  1339.                     }
  1340.                 }
  1341.             }
  1342.            
  1343.             return type;
  1344.         }
  1345.         // ResolveTypeRelativeTo
  1346.         // This is used by Remoting
  1347.         static internal Type ResolveTypeRelativeToBaseTypes(string typeName, int offset, int count, Type serverType)
  1348.         {
  1349.             // typeName is excepted to contain the full type name
  1350.             // offset is the start of the full type name within typeName
  1351.             // count us the number of characters in the full type name
  1352.             // serverType is the type of the server object
  1353.            
  1354.             if ((typeName == null) || (serverType == null))
  1355.                 return null;
  1356.            
  1357.             string serverTypeName = serverType.FullName;
  1358.             if (serverTypeName.Length == count) {
  1359.                 if (String.CompareOrdinal(typeName, offset, serverTypeName, 0, count) == 0) {
  1360.                     return serverType;
  1361.                 }
  1362.             }
  1363.            
  1364.             return ResolveTypeRelativeToBaseTypes(typeName, offset, count, serverType.BaseType);
  1365.         }
  1366.         // ResolveTypeRelativeTo
  1367.         void _Type.GetTypeInfoCount(out uint pcTInfo)
  1368.         {
  1369.             throw new NotImplementedException();
  1370.         }
  1371.        
  1372.         void _Type.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
  1373.         {
  1374.             throw new NotImplementedException();
  1375.         }
  1376.        
  1377.         void _Type.GetIDsOfNames(        [In()]
  1378. ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
  1379.         {
  1380.             throw new NotImplementedException();
  1381.         }
  1382.        
  1383.         void _Type.Invoke(uint dispIdMember,         [In()]
  1384. ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
  1385.         {
  1386.             throw new NotImplementedException();
  1387.         }
  1388.        
  1389.         // private convenience data
  1390.         private const BindingFlags DefaultLookup = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public;
  1391.         private static readonly Type valueType = typeof(System.ValueType);
  1392.         private static readonly Type enumType = typeof(System.Enum);
  1393.         private static readonly Type objectType = typeof(object);
  1394.        
  1395.     }
  1396. }

Developer Fusion