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 typesLen = (types != null) ? types.Length : 0;
 189                         int count = 0;
 190
 191                         foreach (MethodInfo m in methods) {
 192                                 // Under MS.NET, Standard|HasThis matches Standard...
 193                                 if (callConvention != CallingConventions.Any && ((m.CallingConvention & callConvention) != callConvention))
 194                                         continue;
 195                                 found = m;
 196                                 count++;
 197                         }
 198
 199                         if (count == 0)
 200                                 return null;
 201
 202                         if (count == 1 && typesLen == 0)
 203                                 return (MethodInfo) CheckMethodSecurity (found);
 204
 205                         match = new MethodBase [count];
 206                         if (count == 1)
 207                                 match [0] = found;
 208                         else {
 209                                 count = 0;
 210                                 foreach (MethodInfo m in methods) {
 211                                         if (callConvention != CallingConventions.Any && ((m.CallingConvention & callConvention) != callConvention))
 212                                                 continue;
 213                                         match [count++] = m;
 214                                 }
 215                         }
 216
 217                         if (types == null)
 218                                 return (MethodInfo) CheckMethodSecurity (Binder.FindMostDerivedMatch (match));
 219
 220                         if (binder == null)
 221                                 binder = Binder.DefaultBinder;
 222
 223                         return (MethodInfo) CheckMethodSecurity (binder.SelectMethod (bindingAttr, match, types, modifiers));
 224                 }
 225
 226                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 227                 extern MethodInfo GetCorrespondingInflatedMethod (MethodInfo generic);
 228
 229                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 230                 extern ConstructorInfo GetCorrespondingInflatedConstructor (ConstructorInfo generic);
 231
 232                 internal override MethodInfo GetMethod (MethodInfo fromNoninstanciated)
 233                 {
 234                         return GetCorrespondingInflatedMethod (fromNoninstanciated);
 235                 }
 236
 237                 internal override ConstructorInfo GetConstructor (ConstructorInfo fromNoninstanciated)
 238                 {
 239                         return GetCorrespondingInflatedConstructor (fromNoninstanciated);
 240                 }
 241
 242                 internal override FieldInfo GetField (FieldInfo fromNoninstanciated)
 243                 {
 244                         return GetField (fromNoninstanciated.Name);
 245                 }
 246
 247                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 248                 public extern override Type GetNestedType (string name, BindingFlags bindingAttr);
 249
 250                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 251                 public extern override Type[] GetNestedTypes (BindingFlags bindingAttr);
 252
 253                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 254                 internal extern PropertyInfo[] GetPropertiesByName (string name, BindingFlags bindingAttr, bool icase, Type reflected_type);
 255
 256                 public override PropertyInfo [] GetProperties (BindingFlags bindingAttr)
 257                 {
 258                         return GetPropertiesByName (null, bindingAttr, false, this);
 259                 }
 260
 261                 protected override PropertyInfo GetPropertyImpl (string name, BindingFlags bindingAttr,
 262                                                                  Binder binder, Type returnType,
 263                                                                  Type[] types,
 264                                                                  ParameterModifier[] modifiers)
 265                 {
 266                         bool ignoreCase = ((bindingAttr & BindingFlags.IgnoreCase) != 0);
 267                         PropertyInfo [] props = GetPropertiesByName (name, bindingAttr, ignoreCase, this);
 268                         int count = props.Length;
 269                         if (count == 0)
 270                                 return null;
 271
 272                         if (count == 1 && (types == null || types.Length == 0))
 273                                 return props [0];
 274
 275                         if (binder == null)
 276                                 binder = Binder.DefaultBinder;
 277
 278                         return binder.SelectProperty (bindingAttr, props, returnType, types, modifiers);
 279                 }
 280
 281                 protected override bool HasElementTypeImpl ()
 282                 {
 283                         return IsArrayImpl() || IsByRefImpl() || IsPointerImpl ();
 284                 }
 285
 286                 protected override bool IsArrayImpl ()
 287                 {
 288                         return Type.IsArrayImpl (this);
 289                 }
 290
 291                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 292                 protected extern override bool IsByRefImpl ();
 293
 294                 protected override bool IsCOMObjectImpl ()
 295                 {
 296                         return false;
 297                 }
 298
 299                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 300                 protected extern override bool IsPointerImpl ();
 301
 302                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 303                 protected extern override bool IsPrimitiveImpl ();
 304
 305                 protected override bool IsValueTypeImpl ()
 306                 {
 307                         return type_is_subtype_of (this, typeof (System.ValueType), false) &&
 308                                 this != typeof (System.ValueType) &&
 309                                 this != typeof (System.Enum);
 310                 }
 311
 312                 public override object InvokeMember (string name, BindingFlags invokeAttr,
 313                                                      Binder binder, object target, object[] args,
 314                                                      ParameterModifier[] modifiers,
 315                                                      CultureInfo culture, string[] namedParameters)
 316                 {
 317
 318                         if ((invokeAttr & BindingFlags.CreateInstance) != 0) {
 319                                 if ((invokeAttr & (BindingFlags.GetField |
 320                                                 BindingFlags.GetField | BindingFlags.GetProperty |
 321                                                 BindingFlags.SetProperty)) != 0)
 322                                         throw new ArgumentException ("invokeAttr");
 323                         } else if (name == null)
 324                                 throw new ArgumentNullException ("name");
 325                         if ((invokeAttr & BindingFlags.GetField) != 0 && (invokeAttr & BindingFlags.SetField) != 0)
 326                                 throw new ArgumentException ("invokeAttr");
 327                         if ((invokeAttr & BindingFlags.GetProperty) != 0 && (invokeAttr & BindingFlags.SetProperty) != 0)
 328                                 throw new ArgumentException ("invokeAttr");
 329                         if ((invokeAttr & BindingFlags.InvokeMethod) != 0 && (invokeAttr & (BindingFlags.SetProperty|BindingFlags.SetField)) != 0)
 330                                 throw new ArgumentException ("invokeAttr");
 331                         if ((invokeAttr & BindingFlags.SetField) != 0 && ((args == null) || args.Length != 1))
 332                                 throw new ArgumentException ("invokeAttr");
 333                         if ((namedParameters != null) && ((args == null) || args.Length < namedParameters.Length))
 334                                 throw new ArgumentException ("namedParameters cannot be more than named arguments in number");
 335
 336                         /* set some defaults if none are provided :-( */
 337                         if ((invokeAttr & (BindingFlags.Public|BindingFlags.NonPublic)) == 0)
 338                                 invokeAttr |= BindingFlags.Public;
 339                         if ((invokeAttr & (BindingFlags.Static|BindingFlags.Instance)) == 0)
 340                                 invokeAttr |= BindingFlags.Static|BindingFlags.Instance;
 341
 342                         if (binder == null)
 343                                 binder = Binder.DefaultBinder;
 344                         if ((invokeAttr & BindingFlags.CreateInstance) != 0) {
 345                                 /* the name is ignored */
 346                                 invokeAttr |= BindingFlags.DeclaredOnly;
 347                                 ConstructorInfo[] ctors = GetConstructors (invokeAttr);
 348                                 object state = null;
 349                                 MethodBase ctor = binder.BindToMethod (invokeAttr, ctors, ref args, modifiers, culture, namedParameters, out state);
 350                                 if (ctor == null) {
 351                                         if (this.IsValueType && args == null)
 352                                                 return Activator.CreateInstanceInternal (this);
 353
 354                                         throw new MissingMethodException ("Constructor on type '" + FullName + "' not found.");
 355                                 }
 356                                 object result = ctor.Invoke (target, invokeAttr, binder, args, culture);
 357                                 binder.ReorderArgumentArray (ref args, state);
 358                                 return result;
 359                         }
 360                         if (name == String.Empty && Attribute.IsDefined (this, typeof (DefaultMemberAttribute))) {
 361                                 DefaultMemberAttribute attr = (DefaultMemberAttribute) Attribute.GetCustomAttribute (this, typeof (DefaultMemberAttribute));
 362                                 name = attr.MemberName;
 363                         }
 364                         bool ignoreCase = (invokeAttr & BindingFlags.IgnoreCase) != 0;
 365                         string throwMissingMethodDescription = null;
 366                         bool throwMissingFieldException = false;
 367
 368                         if ((invokeAttr & BindingFlags.InvokeMethod) != 0) {
 369                                 MethodInfo[] methods = GetMethodsByName (name, invokeAttr, ignoreCase, this);
 370                                 object state = null;
 371                                 MethodBase m = binder.BindToMethod (invokeAttr, methods, ref args, modifiers, culture, namedParameters, out state);
 372                                 if (m == null) {
 373                                         if (methods.Length > 0)
 374                                                 throwMissingMethodDescription = "The best match for method " + name + " has some invalid parameter.";
 375                                         else
 376                                                 throwMissingMethodDescription = "Cannot find method " + name + ".";
 377                                 } else {
 378                                         object result = m.Invoke (target, invokeAttr, binder, args, culture);
 379                                         binder.ReorderArgumentArray (ref args, state);
 380                                         return result;
 381                                 }
 382                         }
 383                         if ((invokeAttr & BindingFlags.GetField) != 0) {
 384                                 FieldInfo f = GetField (name, invokeAttr);
 385                                 if (f != null) {
 386                                         return f.GetValue (target);
 387                                 } else if ((invokeAttr & BindingFlags.GetProperty) == 0) {
 388                                         throwMissingFieldException = true;
 389                                 }
 390                                 /* try GetProperty */
 391                         } else if ((invokeAttr & BindingFlags.SetField) != 0) {
 392                                 FieldInfo f = GetField (name, invokeAttr);
 393                                 if (f != null) {
 394                                         f.SetValue (target, args [0]);
 395                                         return null;
 396                                 } else if ((invokeAttr & BindingFlags.SetProperty) == 0) {
 397                                         throwMissingFieldException = true;
 398                                 }
 399                                 /* try SetProperty */
 400                         }
 401                         if ((invokeAttr & BindingFlags.GetProperty) != 0) {
 402                                 PropertyInfo[] properties = GetPropertiesByName (name, invokeAttr, ignoreCase, this);
 403                                 object state = null;
 404                                 int i, count = 0;
 405                                 for (i = 0; i < properties.Length; ++i) {
 406                                         if ((properties [i].GetGetMethod (true) != null))
 407                                                 count++;
 408                                 }
 409                                 MethodBase[] smethods = new MethodBase [count];
 410                                 count = 0;
 411                                 for (i = 0; i < properties.Length; ++i) {
 412                                         MethodBase mb = properties [i].GetGetMethod (true);
 413                                         if (mb != null)
 414                                                 smethods [count++] = mb;
 415                                 }
 416                                 MethodBase m = binder.BindToMethod (invokeAttr, smethods, ref args, modifiers, culture, namedParameters, out state);
 417                                 if (m == null) {
 418                                         throwMissingFieldException = true;
 419                                 } else {
 420                                         object result = m.Invoke (target, invokeAttr, binder, args, culture);
 421                                         binder.ReorderArgumentArray (ref args, state);
 422                                         return result;
 423                                 }
 424                         } else if ((invokeAttr & BindingFlags.SetProperty) != 0) {
 425                                 PropertyInfo[] properties = GetPropertiesByName (name, invokeAttr, ignoreCase, this);
 426                                 object state = null;
 427                                 int i, count = 0;
 428                                 for (i = 0; i < properties.Length; ++i) {
 429                                         if (properties [i].GetSetMethod (true) != null)
 430                                                 count++;
 431                                 }
 432                                 MethodBase[] smethods = new MethodBase [count];
 433                                 count = 0;
 434                                 for (i = 0; i < properties.Length; ++i) {
 435                                         MethodBase mb = properties [i].GetSetMethod (true);
 436                                         if (mb != null)
 437                                                 smethods [count++] = mb;
 438                                 }
 439                                 MethodBase m = binder.BindToMethod (invokeAttr, smethods, ref args, modifiers, culture, namedParameters, out state);
 440                                 if (m == null) {
 441                                         throwMissingFieldException = true;
 442                                 } else {
 443                                         object result = m.Invoke (target, invokeAttr, binder, args, culture);
 444                                         binder.ReorderArgumentArray (ref args, state);
 445                                         return result;
 446                                 }
 447                         }
 448                         if (throwMissingMethodDescription != null)
 449                                 throw new MissingMethodException(throwMissingMethodDescription);
 450                         if (throwMissingFieldException)
 451                                 throw new MissingFieldException("Cannot find variable " + name + ".");
 452
 453                         return null;
 454                 }
 455
 456                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 457                 public extern override Type GetElementType ();
 458
 459                 public override Type UnderlyingSystemType {
 460                         get {
 461                                 // This has _nothing_ to do with getting the base type of an enum etc.
 462                                 return this;
 463                         }
 464                 }
 465
 466                 public extern override Assembly Assembly {
 467                         [MethodImplAttribute(MethodImplOptions.InternalCall)]
 468                         get;
 469                 }
 470
 471                 public override string AssemblyQualifiedName {
 472                         get {
 473                                 return getFullName (true, true);
 474                         }
 475                 }
 476
 477                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 478                 private extern string getFullName(bool full_name, bool assembly_qualified);
 479
 480                 public extern override Type BaseType {
 481                         [MethodImplAttribute(MethodImplOptions.InternalCall)]
 482                         get;
 483                 }
 484
 485                 public override string FullName {
 486                         get {
 487                                 return getFullName (true, false);
 488                         }
 489                 }
 490
 491                 public override Guid GUID {
 492                         get {
 493                                 object[] att = GetCustomAttributes(typeof(System.Runtime.InteropServices.GuidAttribute), true);
 494                                 if (att.Length == 0)
 495                                         return Guid.Empty;
 496                                 return new Guid(((System.Runtime.InteropServices.GuidAttribute)att[0]).Value);
 497                         }
 498                 }
 499
 500                 public override bool IsDefined (Type attributeType, bool inherit)
 501                 {
 502                         return MonoCustomAttrs.IsDefined (this, attributeType, inherit);
 503                 }
 504
 505                 public override object[] GetCustomAttributes (bool inherit)
 506                 {
 507                         return MonoCustomAttrs.GetCustomAttributes (this, inherit);
 508                 }
 509
 510                 public override object[] GetCustomAttributes (Type attributeType, bool inherit)
 511                 {
 512                         if (attributeType == null)
 513                         {
 514                                 throw new ArgumentNullException("attributeType");
 515                         }
 516
 517                         return MonoCustomAttrs.GetCustomAttributes (this, attributeType, inherit);
 518                 }
 519
 520                 public override MemberTypes MemberType {
 521                         get {
 522                                 if (DeclaringType != null)
 523                                         return MemberTypes.NestedType;
 524                                 else
 525                                         return MemberTypes.TypeInfo;
 526                         }
 527                 }
 528
 529                 public extern override string Name {
 530                         [MethodImplAttribute(MethodImplOptions.InternalCall)]
 531                         get;
 532                 }
 533
 534                 public extern override string Namespace {
 535                         [MethodImplAttribute(MethodImplOptions.InternalCall)]
 536                         get;
 537                 }
 538
 539                 public extern override Module Module {
 540                         [MethodImplAttribute(MethodImplOptions.InternalCall)]
 541                         get;
 542                 }
 543
 544                 public extern override Type DeclaringType {
 545                         [MethodImplAttribute(MethodImplOptions.InternalCall)]
 546                         get;
 547                 }
 548
 549                 public override Type ReflectedType {
 550                         get {
 551                                 return DeclaringType;
 552                         }
 553                 }
 554
 555                 public override RuntimeTypeHandle TypeHandle {
 556                         get {
 557                                 return _impl;
 558                         }
 559                 }
 560
 561                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 562                 public extern override int GetArrayRank ();
 563
 564                 public void GetObjectData(SerializationInfo info, StreamingContext context)
 565                 {
 566                         UnitySerializationHolder.GetTypeData (this, info, context);
 567                 }
 568
 569                 public override string ToString()
 570                 {
 571                         return getFullName (false, false);
 572                 }
 573
 574 #if NET_2_0 || BOOTSTRAP_NET_2_0
 575                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 576                 public extern override Type [] GetGenericArguments ();
 577
 578                 public override bool ContainsGenericParameters {
 579                         get {
 580                                 if (IsGenericParameter)
 581                                         return true;
 582
 583                                 if (IsGenericType) {
 584                                         foreach (Type arg in GetGenericArguments ())
 585                                                 if (arg.ContainsGenericParameters)
 586                                                         return true;
 587                                 }
 588
 589                                 if (HasElementType)
 590                                         return GetElementType ().ContainsGenericParameters;
 591
 592                                 return false;
 593                         }
 594                 }
 595
 596                 public extern override bool IsGenericParameter {
 597                         [MethodImplAttribute(MethodImplOptions.InternalCall)]
 598                         get;
 599                 }
 600
 601                 public extern override MethodBase DeclaringMethod {
 602                         [MethodImplAttribute(MethodImplOptions.InternalCall)]
 603                         get;
 604                 }
 605 #endif
 606
 607                 private MethodBase CheckMethodSecurity (MethodBase mb)
 608                 {
 609                         if (!SecurityManager.SecurityEnabled || (mb == null))
 610                                 return mb;
 611
 612                         // Sadly we have no way to know which kind of security action this is
 613                         // so we must do it the hard way. Actually this isn't so bad
 614                         // because we can skip the (mb.Attributes & MethodAttributes.HasSecurity)
 615                         // icall required (and do it ourselves)
 616
 617                         // this (unlike the Invoke step) is _and stays_ a LinkDemand (caller)
 618                         return SecurityManager.ReflectedLinkDemandQuery (mb) ? mb : null;
 619                 }
 620         }
 621 }