Files
mono/mcs/class/corlib/System/Attribute.cs
T
xplicit 850dd01678 fixed stackoverflow exception in Attribute.GetHashCode()
MS implementation of Attribute.GetHashCode does not depend on TypeId property, so you can return any value in TypeId and hashcode in MS.NET will be the same.
2013-11-11 20:44:59 +07:00

451 lines
14 KiB
C#

//
// System.Attribute.cs
//
// Authors:
// Miguel de Icaza ([email protected]) - Original
// Nick D. Drochak II ([email protected]) - Implemented most of the guts
// Gonzalo Paniagua Javier ([email protected])
//
// (C) 2002, 2003 Ximian, Inc. http://www.ximian.com
// Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.InteropServices;
namespace System
{
[AttributeUsage (AttributeTargets.All)]
[Serializable]
[ComVisible (true)]
[ComDefaultInterface (typeof (_Attribute))]
[ClassInterfaceAttribute (ClassInterfaceType.None)]
#if MOBILE
public abstract class Attribute {
#else
public abstract class Attribute : _Attribute {
#endif
protected Attribute ()
{
}
public virtual object TypeId {
get {
// Derived classes should override this default behaviour as appropriate
return this.GetType ();
}
}
private static void CheckParameters (object element, Type attributeType)
{
// neither parameter is allowed to be null
if (element == null)
throw new ArgumentNullException ("element");
if (attributeType == null)
throw new ArgumentNullException ("attributeType");
if (!typeof (Attribute).IsAssignableFrom (attributeType))
throw new ArgumentException (Locale.GetText (
"Type is not derived from System.Attribute."), "attributeType");
}
private static Attribute FindAttribute (object[] attributes)
{
// if there exists more than one attribute of the given type, throw an exception
if (attributes.Length > 1) {
throw new AmbiguousMatchException (Locale.GetText (
"<element> has more than one attribute of type <attribute_type>"));
}
if (attributes.Length < 1)
return null;
// tested above for '> 1' and and '< 1', so only '== 1' is left,
// i.e. we found the attribute
return (Attribute) attributes[0];
}
public static Attribute GetCustomAttribute (ParameterInfo element, Type attributeType)
{
return GetCustomAttribute (element, attributeType, true);
}
public static Attribute GetCustomAttribute (MemberInfo element, Type attributeType)
{
return GetCustomAttribute (element, attributeType, true);
}
public static Attribute GetCustomAttribute (Assembly element, Type attributeType)
{
return GetCustomAttribute (element, attributeType, true);
}
public static Attribute GetCustomAttribute (Module element, Type attributeType)
{
return GetCustomAttribute (element, attributeType, true);
}
public static Attribute GetCustomAttribute (Module element, Type attributeType, bool inherit)
{
// neither parameter is allowed to be null
CheckParameters (element, attributeType);
// Module inheritance hierarchies CAN NOT be searched for attributes, so the second
// parameter of GetCustomAttributes () is IGNORED.
object[] attributes = element.GetCustomAttributes (attributeType, inherit);
return FindAttribute (attributes);
}
public static Attribute GetCustomAttribute (Assembly element, Type attributeType, bool inherit)
{
// neither parameter is allowed to be null
CheckParameters (element, attributeType);
// Assembly inheritance hierarchies CAN NOT be searched for attributes, so the second
// parameter of GetCustomAttributes () is IGNORED.
object[] attributes = element.GetCustomAttributes (attributeType, inherit);
return FindAttribute (attributes);
}
public static Attribute GetCustomAttribute (ParameterInfo element, Type attributeType, bool inherit)
{
// neither parameter is allowed to be null
CheckParameters (element, attributeType);
object[] attributes = GetCustomAttributes (element, attributeType, inherit);
return FindAttribute (attributes);
}
public static Attribute GetCustomAttribute (MemberInfo element, Type attributeType, bool inherit)
{
// neither parameter is allowed to be null
CheckParameters (element, attributeType);
// MemberInfo inheritance hierarchies can be searched for attributes, so the second
// parameter of GetCustomAttribute () is respected.
return MonoCustomAttrs.GetCustomAttribute (element, attributeType, inherit);
}
public static Attribute[] GetCustomAttributes (Assembly element)
{
return GetCustomAttributes (element, true);
}
public static Attribute[] GetCustomAttributes (ParameterInfo element)
{
return GetCustomAttributes (element, true);
}
public static Attribute[] GetCustomAttributes (MemberInfo element)
{
return GetCustomAttributes (element, true);
}
public static Attribute[] GetCustomAttributes (Module element)
{
return GetCustomAttributes (element, true);
}
public static Attribute[] GetCustomAttributes (Assembly element, Type attributeType)
{
return GetCustomAttributes (element, attributeType, true);
}
public static Attribute[] GetCustomAttributes (Module element, Type attributeType)
{
return GetCustomAttributes (element, attributeType, true);
}
public static Attribute[] GetCustomAttributes (ParameterInfo element, Type attributeType)
{
return GetCustomAttributes (element, attributeType, true);
}
public static Attribute[] GetCustomAttributes (MemberInfo element, Type type)
{
return GetCustomAttributes (element, type, true);
}
public static Attribute[] GetCustomAttributes (Assembly element, Type attributeType, bool inherit)
{
// element parameter is not allowed to be null
CheckParameters (element, attributeType);
return (Attribute []) element.GetCustomAttributes (attributeType, inherit);
}
public static Attribute[] GetCustomAttributes (ParameterInfo element, Type attributeType, bool inherit)
{
// element parameter is not allowed to be null
CheckParameters (element, attributeType);
Attribute [] attributes;
if (inherit && TryGetParamCustomAttributes (element, attributeType, out attributes))
return attributes;
return (Attribute []) element.GetCustomAttributes (attributeType, inherit);
}
public static Attribute[] GetCustomAttributes (Module element, Type attributeType, bool inherit)
{
// element parameter is not allowed to be null
CheckParameters (element, attributeType);
return (Attribute []) element.GetCustomAttributes (attributeType, inherit);
}
public static Attribute[] GetCustomAttributes (MemberInfo element, Type type, bool inherit)
{
// element parameter is not allowed to be null
CheckParameters (element, type);
// MS ignores the inherit param in PropertyInfo's ICustomAttributeProvider
// implementation, but not in the Attributes, so directly get the attributes
// from MonoCustomAttrs instead of going throught the PropertyInfo's
// ICustomAttributeProvider
MemberTypes mtype = element.MemberType;
if (mtype == MemberTypes.Property)
return (Attribute []) MonoCustomAttrs.GetCustomAttributes (element, type, inherit);
return (Attribute []) element.GetCustomAttributes (type, inherit);
}
public static Attribute[] GetCustomAttributes (Module element, bool inherit)
{
return GetCustomAttributes (element, typeof (Attribute), inherit);
}
public static Attribute[] GetCustomAttributes (Assembly element, bool inherit)
{
return GetCustomAttributes (element, typeof (Attribute), inherit);
}
public static Attribute[] GetCustomAttributes (MemberInfo element, bool inherit)
{
return GetCustomAttributes (element, typeof (Attribute), inherit);
}
public static Attribute[] GetCustomAttributes (ParameterInfo element, bool inherit)
{
// element parameter is not allowed to be null
CheckParameters (element, typeof (Attribute));
return GetCustomAttributes (element, typeof (Attribute), inherit);
}
public override int GetHashCode ()
{
int result = GetType ().GetHashCode ();
FieldInfo[] fields = GetType ().GetFields (BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
foreach (FieldInfo field in fields) {
object value = field.GetValue (this);
result ^= value == null ? 0 : value.GetHashCode ();
}
return result;
}
public virtual bool IsDefaultAttribute ()
{
// Derived classes should override this default behaviour as appropriate
return false;
}
public static bool IsDefined (Module element, Type attributeType)
{
return IsDefined (element, attributeType, false);
}
public static bool IsDefined (ParameterInfo element, Type attributeType)
{
return IsDefined (element, attributeType, true);
}
public static bool IsDefined (MemberInfo element, Type attributeType)
{
return IsDefined (element, attributeType, true);
}
public static bool IsDefined (Assembly element, Type attributeType)
{
return IsDefined (element, attributeType, true);
}
public static bool IsDefined (MemberInfo element, Type attributeType, bool inherit)
{
CheckParameters (element, attributeType);
MemberTypes mtype = element.MemberType;
if (mtype != MemberTypes.Constructor && mtype != MemberTypes.Event &&
mtype != MemberTypes.Field && mtype != MemberTypes.Method &&
mtype != MemberTypes.Property && mtype != MemberTypes.TypeInfo &&
mtype != MemberTypes.NestedType)
throw new NotSupportedException (Locale.GetText (
"Element is not a constructor, method, property, event, type or field."));
// MS ignores the inherit param in PropertyInfo's ICustomAttributeProvider
// implementation, but not in the Attributes, so directly get the attributes
// from MonoCustomAttrs instead of going throught the PropertyInfo's
// ICustomAttributeProvider
if (mtype == MemberTypes.Property)
return MonoCustomAttrs.IsDefined (element, attributeType, inherit);
return ((MemberInfo) element).IsDefined (attributeType, inherit);
}
public static bool IsDefined (Assembly element, Type attributeType, bool inherit)
{
CheckParameters (element, attributeType);
return element.IsDefined (attributeType, inherit);
}
public static bool IsDefined (Module element, Type attributeType, bool inherit)
{
CheckParameters (element, attributeType);
return element.IsDefined (attributeType, inherit);
}
public static bool IsDefined (ParameterInfo element, Type attributeType, bool inherit)
{
CheckParameters (element, attributeType);
if (element.IsDefined (attributeType, inherit))
return true;
if (inherit)
return IsDefinedOnParameter (element, attributeType);
return false;
}
static bool IsDefinedOnParameter (ParameterInfo parameter, Type attributeType)
{
var member = parameter.Member;
if (member.MemberType != MemberTypes.Method)
return false;
var method = ((MethodInfo) member).GetBaseMethod ();
while (true) {
var param = method.GetParametersInternal () [parameter.Position];
if (param.IsDefined (attributeType, false))
return true;
var base_method = method.GetBaseMethod ();
if (base_method == method)
break;
method = base_method;
}
return false;
}
static bool TryGetParamCustomAttributes (ParameterInfo parameter, Type attributeType, out Attribute [] attributes)
{
attributes = null;
if (parameter.Member.MemberType != MemberTypes.Method)
return false;
var method = (MethodInfo) parameter.Member;
var definition = method.GetBaseDefinition ();
if (method == definition)
return false;
var types = new List<Type> ();
var custom_attributes = new List<Attribute> ();
while (true) {
var param = method.GetParametersInternal () [parameter.Position];
var param_attributes = (Attribute []) param.GetCustomAttributes (attributeType, false);
foreach (var param_attribute in param_attributes) {
var param_type = param_attribute.GetType ();
if (types.Contains (param_type))
continue;
types.Add (param_type);
custom_attributes.Add (param_attribute);
}
var base_method = method.GetBaseMethod ();
if (base_method == method)
break;
method = base_method;
}
attributes = (Attribute []) Array.CreateInstance (attributeType, custom_attributes.Count);
custom_attributes.CopyTo (attributes, 0);
return true;
}
public virtual bool Match (object obj)
{
// default action is the same as Equals.
// Derived classes should override as appropriate
return this.Equals (obj);
}
public override bool Equals (object obj)
{
if (obj == null || !(obj is Attribute))
return false;
//
// This is needed because Attribute.Equals does a deep
// compare. Ran into this with vbnc
//
return ValueType.DefaultEquals (this, obj);
}
#if !MOBILE
void _Attribute.GetIDsOfNames ([In] ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
{
throw new NotImplementedException ();
}
void _Attribute.GetTypeInfo (uint iTInfo, uint lcid, IntPtr ppTInfo)
{
throw new NotImplementedException ();
}
void _Attribute.GetTypeInfoCount (out uint pcTInfo)
{
throw new NotImplementedException ();
}
void _Attribute.Invoke (uint dispIdMember, [In] ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams,
IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
{
throw new NotImplementedException ();
}
#endif
}
}