mcs/class/referencesource/mscorlib/system/reflection/typedelegator.cs

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