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

  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. // TypeDelegator
  16. // This class wraps a Type object and delegates all methods to that Type.
  17. namespace System.Reflection
  18. {
  19.    
  20.     using System;
  21.     using System.Runtime.Remoting.Activation;
  22.     using System.Runtime.InteropServices;
  23.     using CultureInfo = System.Globalization.CultureInfo;
  24.    
  25.     [Serializable()]
  26.     [System.Runtime.InteropServices.ComVisible(true)]
  27.     public class TypeDelegator : Type
  28.     {
  29.         protected Type typeImpl;
  30.        
  31.         protected TypeDelegator()
  32.         {
  33.         }
  34.        
  35.         public TypeDelegator(Type delegatingType)
  36.         {
  37.             if (delegatingType == null)
  38.                 throw new ArgumentNullException("delegatingType");
  39.            
  40.             typeImpl = delegatingType;
  41.         }
  42.        
  43.         public override Guid GUID {
  44.             get { return typeImpl.GUID; }
  45.         }
  46.        
  47.         public override int MetadataToken {
  48.             get { return typeImpl.MetadataToken; }
  49.         }
  50.        
  51.         public override object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters)
  52.         {
  53.             return typeImpl.InvokeMember(name, invokeAttr, binder, target, args, modifiers, culture, namedParameters);
  54.         }
  55.        
  56.         public override Module Module {
  57.             get { return typeImpl.Module; }
  58.         }
  59.        
  60.         public override Assembly Assembly {
  61.             get { return typeImpl.Assembly; }
  62.         }
  63.        
  64.         public override RuntimeTypeHandle TypeHandle {
  65.             get { return typeImpl.TypeHandle; }
  66.         }
  67.        
  68.         public override string Name {
  69.             get { return typeImpl.Name; }
  70.         }
  71.        
  72.         public override string FullName {
  73.             get { return typeImpl.FullName; }
  74.         }
  75.        
  76.         public override string Namespace {
  77.             get { return typeImpl.Namespace; }
  78.         }
  79.        
  80.         public override string AssemblyQualifiedName {
  81.             get { return typeImpl.AssemblyQualifiedName; }
  82.         }
  83.        
  84.         public override Type BaseType {
  85.             get { return typeImpl.BaseType; }
  86.         }
  87.        
  88.         protected override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
  89.         {
  90.             return typeImpl.GetConstructor(bindingAttr, binder, callConvention, types, modifiers);
  91.         }
  92.        
  93.         [System.Runtime.InteropServices.ComVisible(true)]
  94.         public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
  95.         {
  96.             return typeImpl.GetConstructors(bindingAttr);
  97.         }
  98.        
  99.         protected override MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
  100.         {
  101.             // This is interesting there are two paths into the impl. One that validates
  102.             // type as non-null and one where type may be null.
  103.             if (types == null)
  104.                 return typeImpl.GetMethod(name, bindingAttr);
  105.             else
  106.                 return typeImpl.GetMethod(name, bindingAttr, binder, callConvention, types, modifiers);
  107.         }
  108.        
  109.         public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
  110.         {
  111.             return typeImpl.GetMethods(bindingAttr);
  112.         }
  113.        
  114.         public override FieldInfo GetField(string name, BindingFlags bindingAttr)
  115.         {
  116.             return typeImpl.GetField(name, bindingAttr);
  117.         }
  118.        
  119.         public override FieldInfo[] GetFields(BindingFlags bindingAttr)
  120.         {
  121.             return typeImpl.GetFields(bindingAttr);
  122.         }
  123.        
  124.         public override Type GetInterface(string name, bool ignoreCase)
  125.         {
  126.             return typeImpl.GetInterface(name, ignoreCase);
  127.         }
  128.        
  129.         public override Type[] GetInterfaces()
  130.         {
  131.             return typeImpl.GetInterfaces();
  132.         }
  133.        
  134.         public override EventInfo GetEvent(string name, BindingFlags bindingAttr)
  135.         {
  136.             return typeImpl.GetEvent(name, bindingAttr);
  137.         }
  138.        
  139.         public override EventInfo[] GetEvents()
  140.         {
  141.             return typeImpl.GetEvents();
  142.         }
  143.        
  144.         protected override PropertyInfo GetPropertyImpl(string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)
  145.         {
  146.             if (returnType == null && types == null)
  147.                 return typeImpl.GetProperty(name, bindingAttr);
  148.             else
  149.                 return typeImpl.GetProperty(name, bindingAttr, binder, returnType, types, modifiers);
  150.         }
  151.        
  152.         public override PropertyInfo[] GetProperties(BindingFlags bindingAttr)
  153.         {
  154.             return typeImpl.GetProperties(bindingAttr);
  155.         }
  156.        
  157.         public override EventInfo[] GetEvents(BindingFlags bindingAttr)
  158.         {
  159.             return typeImpl.GetEvents(bindingAttr);
  160.         }
  161.        
  162.         public override Type[] GetNestedTypes(BindingFlags bindingAttr)
  163.         {
  164.             return typeImpl.GetNestedTypes(bindingAttr);
  165.         }
  166.        
  167.         public override Type GetNestedType(string name, BindingFlags bindingAttr)
  168.         {
  169.             return typeImpl.GetNestedType(name, bindingAttr);
  170.         }
  171.        
  172.         public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
  173.         {
  174.             return typeImpl.GetMember(name, type, bindingAttr);
  175.         }
  176.        
  177.         public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
  178.         {
  179.             return typeImpl.GetMembers(bindingAttr);
  180.         }
  181.        
  182.         protected override TypeAttributes GetAttributeFlagsImpl()
  183.         {
  184.             return typeImpl.Attributes;
  185.         }
  186.        
  187.         protected override bool IsArrayImpl()
  188.         {
  189.             return typeImpl.IsArray;
  190.         }
  191.        
  192.         protected override bool IsPrimitiveImpl()
  193.         {
  194.             return typeImpl.IsPrimitive;
  195.         }
  196.        
  197.         protected override bool IsByRefImpl()
  198.         {
  199.             return typeImpl.IsByRef;
  200.         }
  201.        
  202.         protected override bool IsPointerImpl()
  203.         {
  204.             return typeImpl.IsPointer;
  205.         }
  206.        
  207.         protected override bool IsValueTypeImpl()
  208.         {
  209.             return typeImpl.IsValueType;
  210.         }
  211.        
  212.         protected override bool IsCOMObjectImpl()
  213.         {
  214.             return typeImpl.IsCOMObject;
  215.         }
  216.        
  217.         public override Type GetElementType()
  218.         {
  219.             return typeImpl.GetElementType();
  220.         }
  221.        
  222.         protected override bool HasElementTypeImpl()
  223.         {
  224.             return typeImpl.HasElementType;
  225.         }
  226.        
  227.         public override Type UnderlyingSystemType {
  228.             get { return typeImpl.UnderlyingSystemType; }
  229.         }
  230.        
  231.         // ICustomAttributeProvider
  232.         public override object[] GetCustomAttributes(bool inherit)
  233.         {
  234.             return typeImpl.GetCustomAttributes(inherit);
  235.         }
  236.        
  237.         public override object[] GetCustomAttributes(Type attributeType, bool inherit)
  238.         {
  239.             return typeImpl.GetCustomAttributes(attributeType, inherit);
  240.         }
  241.        
  242.         public override bool IsDefined(Type attributeType, bool inherit)
  243.         {
  244.             return typeImpl.IsDefined(attributeType, inherit);
  245.         }
  246.        
  247.         [System.Runtime.InteropServices.ComVisible(true)]
  248.         public override InterfaceMapping GetInterfaceMap(Type interfaceType)
  249.         {
  250.             return typeImpl.GetInterfaceMap(interfaceType);
  251.         }
  252.     }
  253. }

Developer Fusion