class/corlib/System/Attribute.cs

   1 //
   2 // System.Attribute.cs
   3 //
   4 // Authors:
   5 //   Miguel de Icaza (miguel@ximian.com) - Original
   6 //   Nick D. Drochak II (ndrochak@gol.com) - Implemented most of the guts
   7 //   Gonzalo Paniagua Javier (gonzalo@ximian.com)
   8 //
   9 // (C) 2002, 2003 Ximian, Inc.  http://www.ximian.com
  10 // Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining
  13 // a copy of this software and associated documentation files (the
  14 // "Software"), to deal in the Software without restriction, including
  15 // without limitation the rights to use, copy, modify, merge, publish,
  16 // distribute, sublicense, and/or sell copies of the Software, and to
  17 // permit persons to whom the Software is furnished to do so, subject to
  18 // the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30 //
  31
  32 using System.Collections.Generic;
  33 using System.Reflection;
  34 using System.Runtime.InteropServices;
  35
  36 namespace System
  37 {
  38         [AttributeUsage (AttributeTargets.All)]
  39         [Serializable]
  40         [ComVisible (true)]
  41         [ComDefaultInterface (typeof (_Attribute))]
  42         [ClassInterfaceAttribute (ClassInterfaceType.None)]
  43         public abstract class Attribute : _Attribute {
  44                 protected Attribute ()
  45                 {
  46                 }
  47
  48                 public virtual object TypeId {
  49                         get {
  50                                 // Derived classes should override this default behaviour as appropriate
  51                                 return this.GetType ();
  52                         }
  53                 }
  54
  55                 private static void CheckParameters (object element, Type attributeType)
  56                 {
  57                         // neither parameter is allowed to be null
  58                         if (element == null)
  59                                 throw new ArgumentNullException ("element");
  60
  61                         if (attributeType == null)
  62                                 throw new ArgumentNullException ("attributeType");
  63
  64                         if (!typeof (Attribute).IsAssignableFrom (attributeType))
  65                                 throw new ArgumentException (Locale.GetText (
  66                                         "Type is not derived from System.Attribute."), "attributeType");
  67                 }
  68
  69                 private static Attribute FindAttribute (object[] attributes)
  70                 {
  71                         // if there exists more than one attribute of the given type, throw an exception
  72                         if (attributes.Length > 1) {
  73                                 throw new AmbiguousMatchException (Locale.GetText (
  74                                         "<element> has more than one attribute of type <attribute_type>"));
  75                         }
  76
  77                         if (attributes.Length < 1)
  78                                 return null;
  79
  80                         // tested above for '> 1' and and '< 1', so only '== 1' is left,
  81                         // i.e. we found the attribute
  82                         return (Attribute) attributes[0];
  83                 }
  84
  85                 public static Attribute GetCustomAttribute (ParameterInfo element, Type attributeType)
  86                 {
  87                         return GetCustomAttribute (element, attributeType, true);
  88                 }
  89
  90                 public static Attribute GetCustomAttribute (MemberInfo element, Type attributeType)
  91                 {
  92                         return GetCustomAttribute (element, attributeType, true);
  93                 }
  94
  95                 public static Attribute GetCustomAttribute (Assembly element, Type attributeType)
  96                 {
  97                         return GetCustomAttribute (element, attributeType, true);
  98                 }
  99
 100                 public static Attribute GetCustomAttribute (Module element, Type attributeType)
 101                 {
 102                         return GetCustomAttribute (element, attributeType, true);
 103                 }
 104
 105                 public static Attribute GetCustomAttribute (Module element, Type attributeType, bool inherit)
 106                 {
 107                         // neither parameter is allowed to be null
 108                         CheckParameters (element, attributeType);
 109
 110                         // Module inheritance hierarchies CAN NOT be searched for attributes, so the second
 111                         // parameter of GetCustomAttributes () is IGNORED.
 112                         object[] attributes = element.GetCustomAttributes (attributeType, inherit);
 113
 114                         return FindAttribute (attributes);
 115                 }
 116
 117                 public static Attribute GetCustomAttribute (Assembly element, Type attributeType, bool inherit)
 118                 {
 119                         // neither parameter is allowed to be null
 120                         CheckParameters (element, attributeType);
 121
 122                         // Assembly inheritance hierarchies CAN NOT be searched for attributes, so the second
 123                         // parameter of GetCustomAttributes () is IGNORED.
 124                         object[] attributes = element.GetCustomAttributes (attributeType, inherit);
 125
 126                         return FindAttribute (attributes);
 127                 }
 128
 129                 public static Attribute GetCustomAttribute (ParameterInfo element, Type attributeType, bool inherit)
 130                 {
 131                         // neither parameter is allowed to be null
 132                         CheckParameters (element, attributeType);
 133
 134                         object[] attributes = GetCustomAttributes (element, attributeType, inherit);
 135
 136                         return FindAttribute (attributes);
 137                 }
 138
 139                 public static Attribute GetCustomAttribute (MemberInfo element, Type attributeType, bool inherit)
 140                 {
 141                         // neither parameter is allowed to be null
 142                         CheckParameters (element, attributeType);
 143
 144                         // MemberInfo inheritance hierarchies can be searched for attributes, so the second
 145                         // parameter of GetCustomAttribute () is respected.
 146                         return MonoCustomAttrs.GetCustomAttribute (element, attributeType, inherit);
 147                 }
 148
 149                 public static Attribute[] GetCustomAttributes (Assembly element)
 150                 {
 151                         return GetCustomAttributes (element, true);
 152                 }
 153
 154                 public static Attribute[] GetCustomAttributes (ParameterInfo element)
 155                 {
 156                         return GetCustomAttributes (element, true);
 157                 }
 158
 159                 public static Attribute[] GetCustomAttributes (MemberInfo element)
 160                 {
 161                         return GetCustomAttributes (element, true);
 162                 }
 163
 164                 public static Attribute[] GetCustomAttributes (Module element)
 165                 {
 166                         return GetCustomAttributes (element, true);
 167                 }
 168
 169                 public static Attribute[] GetCustomAttributes (Assembly element, Type attributeType)
 170                 {
 171                         return GetCustomAttributes (element, attributeType, true);
 172                 }
 173
 174                 public static Attribute[] GetCustomAttributes (Module element, Type attributeType)
 175                 {
 176                         return GetCustomAttributes (element, attributeType, true);
 177                 }
 178
 179                 public static Attribute[] GetCustomAttributes (ParameterInfo element, Type attributeType)
 180                 {
 181                         return GetCustomAttributes (element, attributeType, true);
 182                 }
 183
 184                 public static Attribute[] GetCustomAttributes (MemberInfo element, Type type)
 185                 {
 186                         return GetCustomAttributes (element, type, true);
 187                 }
 188
 189                 public static Attribute[] GetCustomAttributes (Assembly element, Type attributeType, bool inherit)
 190                 {
 191                         // element parameter is not allowed to be null
 192                         CheckParameters (element, attributeType);
 193
 194                         return (Attribute []) element.GetCustomAttributes (attributeType, inherit);
 195                 }
 196
 197                 public static Attribute[] GetCustomAttributes (ParameterInfo element, Type attributeType, bool inherit)
 198                 {
 199                         // element parameter is not allowed to be null
 200                         CheckParameters (element, attributeType);
 201
 202                         Attribute [] attributes;
 203                         if (inherit && TryGetParamCustomAttributes (element, attributeType, out attributes))
 204                                 return attributes;
 205
 206                         return (Attribute []) element.GetCustomAttributes (attributeType, inherit);
 207                 }
 208
 209                 public static Attribute[] GetCustomAttributes (Module element, Type attributeType, bool inherit)
 210                 {
 211                         // element parameter is not allowed to be null
 212                         CheckParameters (element, attributeType);
 213
 214                         return (Attribute []) element.GetCustomAttributes (attributeType, inherit);
 215                 }
 216
 217                 public static Attribute[] GetCustomAttributes (MemberInfo element, Type type, bool inherit)
 218                 {
 219                         // element parameter is not allowed to be null
 220                         CheckParameters (element, type);
 221
 222                         // MS ignores the inherit param in PropertyInfo's ICustomAttributeProvider
 223                         // implementation, but not in the Attributes, so directly get the attributes
 224                         // from MonoCustomAttrs instead of going throught the PropertyInfo's
 225                         // ICustomAttributeProvider
 226                         MemberTypes mtype = element.MemberType;
 227                         if (mtype == MemberTypes.Property)
 228                                 return (Attribute []) MonoCustomAttrs.GetCustomAttributes (element, type, inherit);
 229                         return (Attribute []) element.GetCustomAttributes (type, inherit);
 230                 }
 231
 232                 public static Attribute[] GetCustomAttributes (Module element, bool inherit)
 233                 {
 234                         return GetCustomAttributes (element, typeof (Attribute), inherit);
 235                 }
 236
 237                 public static Attribute[] GetCustomAttributes (Assembly element, bool inherit)
 238                 {
 239                         return GetCustomAttributes (element, typeof (Attribute), inherit);
 240                 }
 241
 242                 public static Attribute[] GetCustomAttributes (MemberInfo element, bool inherit)
 243                 {
 244                         return GetCustomAttributes (element, typeof (Attribute), inherit);
 245                 }
 246
 247                 public static Attribute[] GetCustomAttributes (ParameterInfo element, bool inherit)
 248                 {
 249                         // element parameter is not allowed to be null
 250                         CheckParameters (element, typeof (Attribute));
 251
 252                         return GetCustomAttributes (element, typeof (Attribute), inherit);
 253                 }
 254
 255                 public override int GetHashCode ()
 256                 {
 257                         return base.GetHashCode ();
 258                 }
 259
 260                 public virtual bool IsDefaultAttribute ()
 261                 {
 262                         // Derived classes should override this default behaviour as appropriate
 263                         return false;
 264                 }
 265
 266                 public static bool IsDefined (Module element, Type attributeType)
 267                 {
 268                         return IsDefined (element, attributeType, false);
 269                 }
 270
 271                 public static bool IsDefined (ParameterInfo element, Type attributeType)
 272                 {
 273                         return IsDefined (element, attributeType, true);
 274                 }
 275
 276                 public static bool IsDefined (MemberInfo element, Type attributeType)
 277                 {
 278                         return IsDefined (element, attributeType, true);
 279                 }
 280
 281                 public static bool IsDefined (Assembly element, Type attributeType)
 282                 {
 283                         return IsDefined (element, attributeType, true);
 284                 }
 285
 286                 public static bool IsDefined (MemberInfo element, Type attributeType, bool inherit)
 287                 {
 288                         CheckParameters (element, attributeType);
 289
 290                         MemberTypes mtype = element.MemberType;
 291                         if (mtype != MemberTypes.Constructor && mtype != MemberTypes.Event &&
 292                                 mtype != MemberTypes.Field       && mtype != MemberTypes.Method &&
 293                                 mtype != MemberTypes.Property    && mtype != MemberTypes.TypeInfo &&
 294                                 mtype != MemberTypes.NestedType)
 295                                 throw new NotSupportedException (Locale.GetText (
 296                                         "Element is not a constructor, method, property, event, type or field."));
 297                         // MS ignores the inherit param in PropertyInfo's ICustomAttributeProvider
 298                         // implementation, but not in the Attributes, so directly get the attributes
 299                         // from MonoCustomAttrs instead of going throught the PropertyInfo's
 300                         // ICustomAttributeProvider
 301                         if (mtype == MemberTypes.Property)
 302                                 return MonoCustomAttrs.IsDefined (element, attributeType, inherit);
 303                         return ((MemberInfo) element).IsDefined (attributeType, inherit);
 304                 }
 305
 306                 public static bool IsDefined (Assembly element, Type attributeType, bool inherit)
 307                 {
 308                         CheckParameters (element, attributeType);
 309
 310                         return element.IsDefined (attributeType, inherit);
 311                 }
 312
 313                 public static bool IsDefined (Module element, Type attributeType, bool inherit)
 314                 {
 315                         CheckParameters (element, attributeType);
 316
 317                         return element.IsDefined (attributeType, inherit);
 318                 }
 319
 320                 public static bool IsDefined (ParameterInfo element, Type attributeType, bool inherit)
 321                 {
 322                         CheckParameters (element, attributeType);
 323
 324                         if (element.IsDefined (attributeType, inherit))
 325                                 return true;
 326
 327                         if (inherit)
 328                                 return IsDefinedOnParameter (element, attributeType);
 329
 330                         return false;
 331                 }
 332
 333                 static bool IsDefinedOnParameter (ParameterInfo parameter, Type attributeType)
 334                 {
 335                         var member = parameter.Member;
 336                         if (member.MemberType != MemberTypes.Method)
 337                                 return false;
 338
 339                         var method = ((MethodInfo) member).GetBaseMethod ();
 340
 341                         while (true) {
 342                                 var param = method.GetParameters () [parameter.Position];
 343                                 if (param.IsDefined (attributeType, false))
 344                                         return true;
 345
 346                                 var base_method = method.GetBaseMethod ();
 347                                 if (base_method == method)
 348                                         break;
 349
 350                                 method = base_method;
 351                         }
 352
 353                         return false;
 354                 }
 355
 356                 static bool TryGetParamCustomAttributes (ParameterInfo parameter, Type attributeType, out Attribute [] attributes)
 357                 {
 358                         attributes = null;
 359
 360                         if (parameter.Member.MemberType != MemberTypes.Method)
 361                                 return false;
 362
 363                         var method = (MethodInfo) parameter.Member;
 364                         var definition = method.GetBaseDefinition ();
 365
 366                         if (method == definition)
 367                                 return false;
 368
 369                         var types = new List<Type> ();
 370                         var custom_attributes = new List<Attribute> ();
 371
 372                         while (true) {
 373                                 var param = method.GetParameters () [parameter.Position];
 374                                 var param_attributes = (Attribute []) param.GetCustomAttributes (attributeType, false);
 375                                 foreach (var param_attribute in param_attributes) {
 376                                         var param_type = param_attribute.GetType ();
 377                                         if (types.Contains (param_type))
 378                                                 continue;
 379
 380                                         types.Add (param_type);
 381                                         custom_attributes.Add (param_attribute);
 382                                 }
 383
 384                                 var base_method = method.GetBaseMethod ();
 385                                 if (base_method == method)
 386                                         break;
 387
 388                                 method = base_method;
 389                         }
 390
 391                         attributes = (Attribute []) Array.CreateInstance (attributeType, custom_attributes.Count);
 392                         custom_attributes.CopyTo (attributes, 0);
 393
 394                         return true;
 395                 }
 396
 397                 public virtual bool Match (object obj)
 398                 {
 399                         // default action is the same as Equals.
 400                         // Derived classes should override as appropriate
 401                         return this.Equals (obj);
 402                 }
 403
 404                 public override bool Equals (object obj)
 405                 {
 406                         if (obj == null || !(obj is Attribute))
 407                                 return false;
 408
 409                         //
 410                         // This is needed because Attribute.Equals does a deep
 411                         // compare.  Ran into this with vbnc
 412                         //
 413                         return ValueType.DefaultEquals (this, obj);
 414                 }
 415
 416                 void _Attribute.GetIDsOfNames ([In] ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
 417                 {
 418                         throw new NotImplementedException ();
 419                 }
 420
 421                 void _Attribute.GetTypeInfo (uint iTInfo, uint lcid, IntPtr ppTInfo)
 422                 {
 423                         throw new NotImplementedException ();
 424                 }
 425
 426                 void _Attribute.GetTypeInfoCount (out uint pcTInfo)
 427                 {
 428                         throw new NotImplementedException ();
 429                 }
 430
 431                 void _Attribute.Invoke (uint dispIdMember, [In] ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams,
 432                         IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
 433                 {
 434                         throw new NotImplementedException ();
 435                 }
 436         }
 437 }