mcs/class/corlib/System/MonoType.cs

   1 //
   2 // System.MonoType
   3 //
   4 // Authors:
   5 //      Sean MacIsaac (macisaac@ximian.com)
   6 //      Paolo Molaro (lupus@ximian.com)
   7 //      Patrik Torstensson (patrik.torstensson@labs2.com)
   8 //      Gonzalo Paniagua (gonzalo@ximian.com)
   9 //
  10 // (c) 2001-2003 Ximian, Inc.
  11 // Copyright (C) 2003-2005 Novell, Inc (http://www.novell.com)
  12 //
  13 // Permission is hereby granted, free of charge, to any person obtaining
  14 // a copy of this software and associated documentation files (the
  15 // "Software"), to deal in the Software without restriction, including
  16 // without limitation the rights to use, copy, modify, merge, publish,
  17 // distribute, sublicense, and/or sell copies of the Software, and to
  18 // permit persons to whom the Software is furnished to do so, subject to
  19 // the following conditions:
  20 //
  21 // The above copyright notice and this permission notice shall be
  22 // included in all copies or substantial portions of the Software.
  23 //
  24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  28 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  29 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  30 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  31 //
  32
  33 using System.Globalization;
  34 using System.Reflection;
  35 using System.Runtime.CompilerServices;
  36 using System.Runtime.Serialization;
  37 using System.Security;
  38
  39 namespace System
  40 {
  41         [Serializable]
  42         internal class MonoType : Type, ISerializable
  43         {
  44
  45                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
  46                 private static extern void type_from_obj (MonoType type, Object obj);
  47
  48                 [MonoTODO]
  49                 internal MonoType (Object obj)
  50                 {
  51                         // this should not be used - lupus
  52                         type_from_obj (this, obj);
  53
  54                         throw new NotImplementedException ();
  55                 }
  56
  57                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
  58                 private static extern TypeAttributes get_attributes (Type type);
  59
  60                 protected override TypeAttributes GetAttributeFlagsImpl ()
  61                 {
  62                         return get_attributes (this);
  63                 }
  64
  65                 protected override ConstructorInfo GetConstructorImpl (BindingFlags bindingAttr,
  66                                                                        Binder binder,
  67                                                                        CallingConventions callConvention,
  68                                                                        Type[] types,
  69                                                                        ParameterModifier[] modifiers)
  70                 {
  71                         if (bindingAttr == BindingFlags.Default)
  72                                 bindingAttr = BindingFlags.Public | BindingFlags.Instance;
  73
  74                         ConstructorInfo[] methods = GetConstructors (bindingAttr);
  75                         ConstructorInfo found = null;
  76                         MethodBase[] match;
  77                         int count = 0;
  78                         foreach (ConstructorInfo m in methods) {
  79                                 // Under MS.NET, Standard|HasThis matches Standard...
  80                                 if (callConvention != CallingConventions.Any && ((m.CallingConvention & callConvention) != callConvention))
  81                                         continue;
  82                                 found = m;
  83                                 count++;
  84                         }
  85                         if (count == 0)
  86                                 return null;
  87                         if (types == null) {
  88                                 if (count > 1)
  89                                         throw new AmbiguousMatchException ();
  90                                 return (ConstructorInfo) CheckMethodSecurity (found);
  91                         }
  92                         match = new MethodBase [count];
  93                         if (count == 1)
  94                                 match [0] = found;
  95                         else {
  96                                 count = 0;
  97                                 foreach (ConstructorInfo m in methods) {
  98                                         if (callConvention != CallingConventions.Any && ((m.CallingConvention & callConvention) != callConvention))
  99                                                 continue;
 100                                         match [count++] = m;
 101                                 }
 102                         }
 103                         if (binder == null)
 104                                 binder = Binder.DefaultBinder;
 105                         return (ConstructorInfo) CheckMethodSecurity (binder.SelectMethod (bindingAttr, match, types, modifiers));
 106                 }
 107
 108                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 109                 internal extern ConstructorInfo[] GetConstructors_internal (BindingFlags bindingAttr, Type reflected_type);
 110
 111                 public override ConstructorInfo[] GetConstructors (BindingFlags bindingAttr)
 112                 {
 113                         return GetConstructors_internal (bindingAttr, this);
 114                 }
 115
 116                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 117                 extern EventInfo InternalGetEvent (string name, BindingFlags bindingAttr);
 118
 119                 public override EventInfo GetEvent (string name, BindingFlags bindingAttr)
 120                 {
 121                         if (name == null)
 122                                 throw new ArgumentNullException ("name");
 123
 124                         return InternalGetEvent (name, bindingAttr);
 125                 }
 126
 127                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 128                 internal extern EventInfo[] GetEvents_internal (BindingFlags bindingAttr, Type reflected_type);
 129
 130                 public override EventInfo[] GetEvents (BindingFlags bindingAttr)
 131                 {
 132                         return GetEvents_internal (bindingAttr, this);
 133                 }
 134
 135                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 136                 public extern override FieldInfo GetField (string name, BindingFlags bindingAttr);
 137
 138                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 139                 internal extern FieldInfo[] GetFields_internal (BindingFlags bindingAttr, Type reflected_type);
 140
 141                 public override FieldInfo[] GetFields (BindingFlags bindingAttr)
 142                 {
 143                         return GetFields_internal (bindingAttr, this);
 144                 }
 145
 146                 public override Type GetInterface (string name, bool ignoreCase)
 147                 {
 148                         if (name == null)
 149                                 throw new ArgumentNullException ();
 150
 151                         Type[] interfaces = GetInterfaces();
 152
 153                         foreach (Type type in interfaces) {
 154                                 if (String.Compare (type.Name, name, ignoreCase, CultureInfo.InvariantCulture) == 0)
 155                                         return type;
 156                                 if (String.Compare (type.FullName, name, ignoreCase, CultureInfo.InvariantCulture) == 0)
 157                                         return type;
 158                         }
 159
 160                         return null;
 161                 }
 162
 163                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 164                 public extern override Type[] GetInterfaces();
 165
 166                 public override MemberInfo[] GetMembers( BindingFlags bindingAttr)
 167                 {
 168                         return FindMembers (MemberTypes.All, bindingAttr, null, null);
 169                 }
 170
 171                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 172                 internal extern MethodInfo [] GetMethodsByName (string name, BindingFlags bindingAttr, bool ignoreCase, Type reflected_type);
 173
 174                 public override MethodInfo [] GetMethods (BindingFlags bindingAttr)
 175                 {
 176                         return GetMethodsByName (null, bindingAttr, false, this);
 177                 }
 178
 179                 protected override MethodInfo GetMethodImpl (string name, BindingFlags bindingAttr,
 180                                                              Binder binder,
 181                                                              CallingConventions callConvention,
 182                                                              Type[] types, ParameterModifier[] modifiers)
 183                 {
 184                         bool ignoreCase = ((bindingAttr & BindingFlags.IgnoreCase) != 0);
 185                         MethodInfo[] methods = GetMethodsByName (name, bindingAttr, ignoreCase, this);
 186                         MethodInfo found = null;
 187                         MethodBase[] match;
 188                         int count = 0;
 189
 190                         foreach (MethodInfo m in methods) {
 191                                 // Under MS.NET, Standard|HasThis matches Standard...
 192                                 if (callConvention != CallingConventions.Any && ((m.CallingConvention & callConvention) != callConvention))
 193                                         continue;
 194                                 found = m;
 195                                 count++;
 196                         }
 197
 198                         if (count == 0)
 199                                 return null;
 200
 201                         if (count == 1 && types == null)
 202                                 return (MethodInfo) CheckMethodSecurity (found);
 203
 204                         match = new MethodBase [count];
 205                         if (count == 1)
 206                                 match [0] = found;
 207                         else {
 208                                 count = 0;
 209                                 foreach (MethodInfo m in methods) {
 210                                         if (callConvention != CallingConventions.Any && ((m.CallingConvention & callConvention) != callConvention))
 211                                                 continue;
 212                                         match [count++] = m;
 213                                 }
 214                         }
 215
 216                         if (types == null)
 217                                 return (MethodInfo) CheckMethodSecurity (Binder.FindMostDerivedMatch (match));
 218
 219                         if (binder == null)
 220                                 binder = Binder.DefaultBinder;
 221
 222                         return (MethodInfo) CheckMethodSecurity (binder.SelectMethod (bindingAttr, match, types, modifiers));
 223                 }
 224
 225                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 226                 extern MethodInfo GetCorrespondingInflatedMethod (MethodInfo generic);
 227
 228                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 229                 extern ConstructorInfo GetCorrespondingInflatedConstructor (ConstructorInfo generic);
 230
 231                 internal override MethodInfo GetMethod (MethodInfo fromNoninstanciated)
 232                 {
 233                         return GetCorrespondingInflatedMethod (fromNoninstanciated);
 234                 }
 235
 236                 internal override ConstructorInfo GetConstructor (ConstructorInfo fromNoninstanciated)
 237                 {
 238                         return GetCorrespondingInflatedConstructor (fromNoninstanciated);
 239                 }
 240
 241                 internal override FieldInfo GetField (FieldInfo fromNoninstanciated)
 242                 {
 243                         return GetField (fromNoninstanciated.Name);
 244                 }
 245
 246                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 247                 public extern override Type GetNestedType (string name, BindingFlags bindingAttr);
 248
 249                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 250                 public extern override Type[] GetNestedTypes (BindingFlags bindingAttr);
 251
 252                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 253                 internal extern PropertyInfo[] GetPropertiesByName (string name, BindingFlags bindingAttr, bool icase, Type reflected_type);
 254
 255                 public override PropertyInfo [] GetProperties (BindingFlags bindingAttr)
 256                 {
 257                         return GetPropertiesByName (null, bindingAttr, false, this);
 258                 }
 259
 260                 protected override PropertyInfo GetPropertyImpl (string name, BindingFlags bindingAttr,
 261                                                                  Binder binder, Type returnType,
 262                                                                  Type[] types,
 263                                                                  ParameterModifier[] modifiers)
 264                 {
 265                         bool ignoreCase = ((bindingAttr & BindingFlags.IgnoreCase) != 0);
 266                         PropertyInfo [] props = GetPropertiesByName (name, bindingAttr, ignoreCase, this);
 267                         int count = props.Length;
 268                         if (count == 0)
 269                                 return null;
 270
 271                         if (count == 1 && (types == null || types.Length == 0))
 272                                 return props [0];
 273
 274                         if (binder == null)
 275                                 binder = Binder.DefaultBinder;
 276
 277                         return binder.SelectProperty (bindingAttr, props, returnType, types, modifiers);
 278                 }
 279
 280                 protected override bool HasElementTypeImpl ()
 281                 {
 282                         return IsArrayImpl() || IsByRefImpl() || IsPointerImpl ();
 283                 }
 284
 285                 protected override bool IsArrayImpl ()
 286                 {
 287                         return Type.IsArrayImpl (this);
 288                 }
 289
 290                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 291                 protected extern override bool IsByRefImpl ();
 292
 293                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 294                 protected extern override bool IsCOMObjectImpl ();
 295
 296                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 297                 protected extern override bool IsPointerImpl ();
 298
 299                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 300                 protected extern override bool IsPrimitiveImpl ();
 301
 302                 protected override bool IsValueTypeImpl ()
 303                 {
 304                         return type_is_subtype_of (this, typeof (System.ValueType), false) &&
 305                                 this != typeof (System.ValueType) &&
 306                                 this != typeof (System.Enum);
 307                 }
 308
 309                 public override object InvokeMember (string name, BindingFlags invokeAttr,
 310                                                      Binder binder, object target, object[] args,
 311                                                      ParameterModifier[] modifiers,
 312                                                      CultureInfo culture, string[] namedParameters)
 313                 {
 314
 315                         if ((invokeAttr & BindingFlags.CreateInstance) != 0) {
 316                                 if ((invokeAttr & (BindingFlags.GetField |
 317                                                 BindingFlags.GetField | BindingFlags.GetProperty |
 318                                                 BindingFlags.SetProperty)) != 0)
 319                                         throw new ArgumentException ("invokeAttr");
 320                         } else if (name == null)
 321                                 throw new ArgumentNullException ("name");
 322                         if ((invokeAttr & BindingFlags.GetField) != 0 && (invokeAttr & BindingFlags.SetField) != 0)
 323                                 throw new ArgumentException ("invokeAttr");
 324                         if ((invokeAttr & BindingFlags.GetProperty) != 0 && (invokeAttr & BindingFlags.SetProperty) != 0)
 325                                 throw new ArgumentException ("invokeAttr");
 326                         if ((invokeAttr & BindingFlags.InvokeMethod) != 0 && (invokeAttr & (BindingFlags.SetProperty|BindingFlags.SetField)) != 0)
 327                                 throw new ArgumentException ("invokeAttr");
 328                         if ((namedParameters != null) && ((args == null) || args.Length < namedParameters.Length))
 329                                 throw new ArgumentException ("namedParameters cannot be more than named arguments in number");
 330
 331                         /* set some defaults if none are provided :-( */
 332                         if ((invokeAttr & (BindingFlags.Public|BindingFlags.NonPublic)) == 0)
 333                                 invokeAttr |= BindingFlags.Public;
 334                         if ((invokeAttr & (BindingFlags.Static|BindingFlags.Instance)) == 0)
 335                                 invokeAttr |= BindingFlags.Static|BindingFlags.Instance;
 336
 337                         if (binder == null)
 338                                 binder = Binder.DefaultBinder;
 339                         if ((invokeAttr & BindingFlags.CreateInstance) != 0) {
 340                                 /* the name is ignored */
 341                                 invokeAttr |= BindingFlags.DeclaredOnly;
 342                                 ConstructorInfo[] ctors = GetConstructors (invokeAttr);
 343                                 object state = null;
 344                                 MethodBase ctor = binder.BindToMethod (invokeAttr, ctors, ref args, modifiers, culture, namedParameters, out state);
 345                                 if (ctor == null) {
 346                                         if (this.IsValueType && args == null)
 347                                                 return Activator.CreateInstanceInternal (this);
 348
 349                                         throw new MissingMethodException ("Constructor on type '" + FullName + "' not found.");
 350                                 }
 351                                 object result = ctor.Invoke (target, invokeAttr, binder, args, culture);
 352                                 binder.ReorderArgumentArray (ref args, state);
 353                                 return result;
 354                         }
 355                         if (name == String.Empty && Attribute.IsDefined (this, typeof (DefaultMemberAttribute))) {
 356                                 DefaultMemberAttribute attr = (DefaultMemberAttribute) Attribute.GetCustomAttribute (this, typeof (DefaultMemberAttribute));
 357                                 name = attr.MemberName;
 358                         }
 359                         bool ignoreCase = (invokeAttr & BindingFlags.IgnoreCase) != 0;
 360                         string throwMissingMethodDescription = null;
 361                         bool throwMissingFieldException = false;
 362
 363                         if ((invokeAttr & BindingFlags.InvokeMethod) != 0) {
 364                                 MethodInfo[] methods = GetMethodsByName (name, invokeAttr, ignoreCase, this);
 365                                 object state = null;
 366                                 MethodBase m = binder.BindToMethod (invokeAttr, methods, ref args, modifiers, culture, namedParameters, out state);
 367                                 if (m == null) {
 368                                         if (methods.Length > 0)
 369                                                 throwMissingMethodDescription = "The best match for method " + name + " has some invalid parameter.";
 370                                         else
 371                                                 throwMissingMethodDescription = "Cannot find method " + name + ".";
 372                                 } else {
 373                                         object result = m.Invoke (target, invokeAttr, binder, args, culture);
 374                                         binder.ReorderArgumentArray (ref args, state);
 375                                         return result;
 376                                 }
 377                         }
 378                         if ((invokeAttr & BindingFlags.GetField) != 0) {
 379                                 FieldInfo f = GetField (name, invokeAttr);
 380                                 if (f != null) {
 381                                         return f.GetValue (target);
 382                                 } else if ((invokeAttr & BindingFlags.GetProperty) == 0) {
 383                                         throwMissingFieldException = true;
 384                                 }
 385                                 /* try GetProperty */
 386                         } else if ((invokeAttr & BindingFlags.SetField) != 0) {
 387                                 if ((args == null) || args.Length != 1)
 388                                         throw new ArgumentException ("invokeAttr");
 389
 390                                 FieldInfo f = GetField (name, invokeAttr);
 391                                 if (f != null) {
 392                                         f.SetValue (target, args [0]);
 393                                         return null;
 394                                 } else if ((invokeAttr & BindingFlags.SetProperty) == 0) {
 395                                         throwMissingFieldException = true;
 396                                 }
 397                                 /* try SetProperty */
 398                         }
 399                         if ((invokeAttr & BindingFlags.GetProperty) != 0) {
 400                                 PropertyInfo[] properties = GetPropertiesByName (name, invokeAttr, ignoreCase, this);
 401                                 object state = null;
 402                                 int i, count = 0;
 403                                 for (i = 0; i < properties.Length; ++i) {
 404                                         if ((properties [i].GetGetMethod (true) != null))
 405                                                 count++;
 406                                 }
 407                                 MethodBase[] smethods = new MethodBase [count];
 408                                 count = 0;
 409                                 for (i = 0; i < properties.Length; ++i) {
 410                                         MethodBase mb = properties [i].GetGetMethod (true);
 411                                         if (mb != null)
 412                                                 smethods [count++] = mb;
 413                                 }
 414                                 MethodBase m = binder.BindToMethod (invokeAttr, smethods, ref args, modifiers, culture, namedParameters, out state);
 415                                 if (m == null) {
 416                                         throwMissingFieldException = true;
 417                                 } else {
 418                                         object result = m.Invoke (target, invokeAttr, binder, args, culture);
 419                                         binder.ReorderArgumentArray (ref args, state);
 420                                         return result;
 421                                 }
 422                         } else if ((invokeAttr & BindingFlags.SetProperty) != 0) {
 423                                 PropertyInfo[] properties = GetPropertiesByName (name, invokeAttr, ignoreCase, this);
 424                                 object state = null;
 425                                 int i, count = 0;
 426                                 for (i = 0; i < properties.Length; ++i) {
 427                                         if (properties [i].GetSetMethod (true) != null)
 428                                                 count++;
 429                                 }
 430                                 MethodBase[] smethods = new MethodBase [count];
 431                                 count = 0;
 432                                 for (i = 0; i < properties.Length; ++i) {
 433                                         MethodBase mb = properties [i].GetSetMethod (true);
 434                                         if (mb != null)
 435                                                 smethods [count++] = mb;
 436                                 }
 437                                 MethodBase m = binder.BindToMethod (invokeAttr, smethods, ref args, modifiers, culture, namedParameters, out state);
 438                                 if (m == null) {
 439                                         throwMissingFieldException = true;
 440                                 } else {
 441                                         object result = m.Invoke (target, invokeAttr, binder, args, culture);
 442                                         binder.ReorderArgumentArray (ref args, state);
 443                                         return result;
 444                                 }
 445                         }
 446                         if (throwMissingMethodDescription != null)
 447                                 throw new MissingMethodException(throwMissingMethodDescription);
 448                         if (throwMissingFieldException)
 449                                 throw new MissingFieldException("Cannot find variable " + name + ".");
 450
 451                         return null;
 452                 }
 453
 454                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 455                 public extern override Type GetElementType ();
 456
 457                 public override Type UnderlyingSystemType {
 458                         get {
 459                                 // This has _nothing_ to do with getting the base type of an enum etc.
 460                                 return this;
 461                         }
 462                 }
 463
 464                 public extern override Assembly Assembly {
 465                         [MethodImplAttribute(MethodImplOptions.InternalCall)]
 466                         get;
 467                 }
 468
 469                 public override string AssemblyQualifiedName {
 470                         get {
 471                                 return getFullName (true, true);
 472                         }
 473                 }
 474
 475                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 476                 private extern string getFullName(bool full_name, bool assembly_qualified);
 477
 478                 public extern override Type BaseType {
 479                         [MethodImplAttribute(MethodImplOptions.InternalCall)]
 480                         get;
 481                 }
 482
 483                 public override string FullName {
 484                         get {
 485                                 return getFullName (true, false);
 486                         }
 487                 }
 488
 489                 public override Guid GUID {
 490                         get {
 491                                 object[] att = GetCustomAttributes(typeof(System.Runtime.InteropServices.GuidAttribute), true);
 492                                 if (att.Length == 0)
 493                                         return Guid.Empty;
 494                                 return new Guid(((System.Runtime.InteropServices.GuidAttribute)att[0]).Value);
 495                         }
 496                 }
 497
 498                 public override bool IsDefined (Type attributeType, bool inherit)
 499                 {
 500                         return MonoCustomAttrs.IsDefined (this, attributeType, inherit);
 501                 }
 502
 503                 public override object[] GetCustomAttributes (bool inherit)
 504                 {
 505                         return MonoCustomAttrs.GetCustomAttributes (this, inherit);
 506                 }
 507
 508                 public override object[] GetCustomAttributes (Type attributeType, bool inherit)
 509                 {
 510                         if (attributeType == null)
 511                         {
 512                                 throw new ArgumentNullException("attributeType");
 513                         }
 514
 515                         return MonoCustomAttrs.GetCustomAttributes (this, attributeType, inherit);
 516                 }
 517
 518                 public override MemberTypes MemberType {
 519                         get {
 520                                 if (DeclaringType != null)
 521                                         return MemberTypes.NestedType;
 522                                 else
 523                                         return MemberTypes.TypeInfo;
 524                         }
 525                 }
 526
 527                 public extern override string Name {
 528                         [MethodImplAttribute(MethodImplOptions.InternalCall)]
 529                         get;
 530                 }
 531
 532                 public extern override string Namespace {
 533                         [MethodImplAttribute(MethodImplOptions.InternalCall)]
 534                         get;
 535                 }
 536
 537                 public extern override Module Module {
 538                         [MethodImplAttribute(MethodImplOptions.InternalCall)]
 539                         get;
 540                 }
 541
 542                 public extern override Type DeclaringType {
 543                         [MethodImplAttribute(MethodImplOptions.InternalCall)]
 544                         get;
 545                 }
 546
 547                 public override Type ReflectedType {
 548                         get {
 549                                 return DeclaringType;
 550                         }
 551                 }
 552
 553                 public override RuntimeTypeHandle TypeHandle {
 554                         get {
 555                                 return _impl;
 556                         }
 557                 }
 558
 559                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 560                 public extern override int GetArrayRank ();
 561
 562                 public void GetObjectData(SerializationInfo info, StreamingContext context)
 563                 {
 564                         UnitySerializationHolder.GetTypeData (this, info, context);
 565                 }
 566
 567                 public override string ToString()
 568                 {
 569                         return getFullName (false, false);
 570                 }
 571
 572 #if NET_2_0 || BOOTSTRAP_NET_2_0
 573                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 574                 public extern override Type [] GetGenericArguments ();
 575
 576                 public override bool ContainsGenericParameters {
 577                         get {
 578                                 if (IsGenericParameter)
 579                                         return true;
 580
 581                                 if (IsGenericType) {
 582                                         foreach (Type arg in GetGenericArguments ())
 583                                                 if (arg.ContainsGenericParameters)
 584                                                         return true;
 585                                 }
 586
 587                                 if (HasElementType)
 588                                         return GetElementType ().ContainsGenericParameters;
 589
 590                                 return false;
 591                         }
 592                 }
 593
 594                 public extern override bool IsGenericParameter {
 595                         [MethodImplAttribute(MethodImplOptions.InternalCall)]
 596                         get;
 597                 }
 598
 599                 public extern override MethodBase DeclaringMethod {
 600                         [MethodImplAttribute(MethodImplOptions.InternalCall)]
 601                         get;
 602                 }
 603 #endif
 604
 605                 private MethodBase CheckMethodSecurity (MethodBase mb)
 606                 {
 607                         if (!SecurityManager.SecurityEnabled || (mb == null))
 608                                 return mb;
 609
 610                         // Sadly we have no way to know which kind of security action this is
 611                         // so we must do it the hard way. Actually this isn't so bad
 612                         // because we can skip the (mb.Attributes & MethodAttributes.HasSecurity)
 613                         // icall required (and do it ourselves)
 614
 615                         // this (unlike the Invoke step) is _and stays_ a LinkDemand (caller)
 616                         return SecurityManager.ReflectedLinkDemandQuery (mb) ? mb : null;
 617                 }
 618         }
 619 }