Attribute.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / clr / src / BCL / System / Attribute.cs / 1458001 / Attribute.cs

                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 

namespace System { 
 
    using System;
    using System.Reflection; 
    using System.Collections.Generic;
    using System.Runtime.InteropServices;
    using System.Globalization;
    using System.Diagnostics.Contracts; 
    using System.Security;
    using System.Security.Permissions; 
 
[Serializable]
[AttributeUsageAttribute(AttributeTargets.All, Inherited = true, AllowMultiple=false)] 
    [ClassInterface(ClassInterfaceType.None)]
    [ComDefaultInterface(typeof(_Attribute))]
[System.Runtime.InteropServices.ComVisible(true)]
    public abstract class Attribute : _Attribute 
    {
        #region Private Statics 
 
        #region PropertyInfo
        private static Attribute[] InternalGetCustomAttributes(PropertyInfo element, Type type, bool inherit) 
        {
            Contract.Requires(type != null);
            Contract.Requires(type.IsSubclassOf(typeof(Attribute)) || type == typeof(Attribute));
 
            // walk up the hierarchy chain
            Attribute[] attributes = (Attribute[])element.GetCustomAttributes(type, inherit); 
 
            if (!inherit)
                return attributes; 

            // create the hashtable that keeps track of inherited types
            Dictionary types = new Dictionary(11);
 
            // create an array list to collect all the requested attibutes
            List attributeList = new List(); 
            CopyToArrayList(attributeList, attributes, types); 

            PropertyInfo baseProp = GetParentDefinition(element); 
            while (baseProp != null)
            {
                attributes = GetCustomAttributes(baseProp, type, false);
                AddAttributesToList(attributeList, attributes, types); 
                baseProp = GetParentDefinition(baseProp);
            } 
            Array array = CreateAttributeArrayHelper(type, attributeList.Count); 
            Array.Copy(attributeList.ToArray(), 0, array, 0, attributeList.Count);
            return (Attribute[])array; 
        }

        private static bool InternalIsDefined(PropertyInfo element, Type attributeType, bool inherit)
        { 
            // walk up the hierarchy chain
            if (element.IsDefined(attributeType, inherit)) 
                return true; 

            if (inherit) 
            {
                AttributeUsageAttribute usage = InternalGetAttributeUsage(attributeType);

                if (!usage.Inherited) 
                    return false;
 
                PropertyInfo baseProp = GetParentDefinition(element); 

                while (baseProp != null) 
                {
                    if (baseProp.IsDefined(attributeType, false))
                        return true;
 
                    baseProp = GetParentDefinition(baseProp);
                } 
            } 

            return false; 
        }

        private static PropertyInfo GetParentDefinition(PropertyInfo property)
        { 
            Contract.Requires(property != null);
 
            // for the current property get the base class of the getter and the setter, they might be different 
            // note that this only works for RuntimeMethodInfo
            MethodInfo propAccessor = property.GetGetMethod(true); 

            if (propAccessor == null)
                propAccessor = property.GetSetMethod(true);
 
            RuntimeMethodInfo rtPropAccessor = propAccessor as RuntimeMethodInfo;
 
            if (rtPropAccessor != null) 
            {
                rtPropAccessor = rtPropAccessor.GetParentDefinition(); 

                if (rtPropAccessor != null)
                    // There is a public overload of Type.GetProperty that takes both a BingingFlags enum and a return type.
                    // However, we cannot use that because it doesn't accept null for "types". 
                    return rtPropAccessor.DeclaringType.GetProperty(
                        property.Name, 
                        BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly, 
                        property.PropertyType);
            } 

            return null;
        }
 
        #endregion
 
        #region EventInfo 
        private static Attribute[] InternalGetCustomAttributes(EventInfo element, Type type, bool inherit)
        { 
            Contract.Requires(element != null);
            Contract.Requires(type != null);
            Contract.Requires(type.IsSubclassOf(typeof(Attribute)) || type == typeof(Attribute));
 
            // walk up the hierarchy chain
            Attribute[] attributes = (Attribute[])element.GetCustomAttributes(type, inherit); 
            if (inherit) 
            {
                // create the hashtable that keeps track of inherited types 
                Dictionary types = new Dictionary(11);
                // create an array list to collect all the requested attibutes
                List attributeList = new List();
                CopyToArrayList(attributeList, attributes, types); 

                EventInfo baseEvent = GetParentDefinition(element); 
                while (baseEvent != null) 
                {
                    attributes = GetCustomAttributes(baseEvent, type, false); 
                    AddAttributesToList(attributeList, attributes, types);
                    baseEvent = GetParentDefinition(baseEvent);
                }
                Array array = CreateAttributeArrayHelper(type, attributeList.Count); 
                Array.Copy(attributeList.ToArray(), 0, array, 0, attributeList.Count);
                return (Attribute[])array; 
            } 
            else
                return attributes; 
        }

        private static EventInfo GetParentDefinition(EventInfo ev)
        { 
            Contract.Requires(ev != null);
 
            // note that this only works for RuntimeMethodInfo 
            MethodInfo add = ev.GetAddMethod(true);
 
            RuntimeMethodInfo rtAdd = add as RuntimeMethodInfo;

            if (rtAdd != null)
            { 
                rtAdd = rtAdd.GetParentDefinition();
                if (rtAdd != null) 
                    return rtAdd.DeclaringType.GetEvent(ev.Name); 
            }
            return null; 
        }

        private static bool InternalIsDefined (EventInfo element, Type attributeType, bool inherit)
        { 
            Contract.Requires(element != null);
 
            // walk up the hierarchy chain 
            if (element.IsDefined(attributeType, inherit))
                return true; 

            if (inherit)
            {
                AttributeUsageAttribute usage = InternalGetAttributeUsage(attributeType); 

                if (!usage.Inherited) 
                    return false; 

                EventInfo baseEvent = GetParentDefinition(element); 

                while (baseEvent != null)
                {
                    if (baseEvent.IsDefined(attributeType, false)) 
                        return true;
                    baseEvent = GetParentDefinition(baseEvent); 
                } 
            }
 
            return false;
        }

        #endregion 

        #region ParameterInfo 
        private static ParameterInfo GetParentDefinition(ParameterInfo param) 
        {
            Contract.Requires(param != null); 

            // note that this only works for RuntimeMethodInfo
            RuntimeMethodInfo rtMethod = param.Member as RuntimeMethodInfo;
 
            if (rtMethod != null)
            { 
                rtMethod = rtMethod.GetParentDefinition(); 

                if (rtMethod != null) 
                {
                    // Find the ParameterInfo on this method
                    ParameterInfo[] parameters = rtMethod.GetParameters();
                    return parameters[param.Position]; // Point to the correct ParameterInfo of the method 
                }
            } 
            return null; 
        }
 
        private static Attribute[] InternalParamGetCustomAttributes(ParameterInfo param, Type type, bool inherit)
        {
            Contract.Requires(param != null);
 
            // For ParameterInfo's we need to make sure that we chain through all the MethodInfo's in the inheritance chain that
            // have this ParameterInfo defined. .We pick up all the CustomAttributes for the starting ParameterInfo. We need to pick up only attributes 
            // that are marked inherited from the remainder of the MethodInfo's in the inheritance chain. 
            // For MethodInfo's on an interface we do not do an inheritance walk so the default ParameterInfo attributes are returned.
            // For MethodInfo's on a class we walk up the inheritance chain but do not look at the MethodInfo's on the interfaces that the 
            // class inherits from and return the respective ParameterInfo attributes

            List disAllowMultiple = new List();
            Object [] objAttr; 

            if (type == null) 
                type = typeof(Attribute); 

            objAttr = param.GetCustomAttributes(type, false); 

            for (int i =0;i < objAttr.Length;i++)
            {
                Type objType = objAttr[i].GetType(); 
                AttributeUsageAttribute attribUsage = InternalGetAttributeUsage(objType);
                if (attribUsage.AllowMultiple == false) 
                    disAllowMultiple.Add(objType); 
            }
 
            // Get all the attributes that have Attribute as the base class
            Attribute [] ret = null;
            if (objAttr.Length == 0)
                ret = CreateAttributeArrayHelper(type,0); 
            else
                ret = (Attribute[])objAttr; 
 
            if (param.Member.DeclaringType == null) // This is an interface so we are done.
                return ret; 

            if (!inherit)
                return ret;
 
            ParameterInfo baseParam = GetParentDefinition(param);
 
            while (baseParam != null) 
            {
                objAttr = baseParam.GetCustomAttributes(type, false); 

                int count = 0;
                for (int i =0;i < objAttr.Length;i++)
                { 
                    Type objType = objAttr[i].GetType();
                    AttributeUsageAttribute attribUsage = InternalGetAttributeUsage(objType); 
 
                    if ((attribUsage.Inherited) && (disAllowMultiple.Contains(objType) == false))
                    { 
                        if (attribUsage.AllowMultiple == false)
                            disAllowMultiple.Add(objType);
                        count++;
                    } 
                    else
                        objAttr[i] = null; 
                } 

                // Get all the attributes that have Attribute as the base class 
                Attribute [] attributes = CreateAttributeArrayHelper(type,count);

                count = 0;
                for (int i =0;i < objAttr.Length;i++) 
                {
                    if (objAttr[i] != null) 
                    { 
                        attributes[count] = (Attribute)objAttr[i];
                        count++; 
                    }
                }

                Attribute [] temp = ret; 
                ret = CreateAttributeArrayHelper(type,temp.Length + count);
                Array.Copy(temp,ret,temp.Length); 
 
                int offset = temp.Length;
 
                for (int i =0;i < attributes.Length;i++)
                    ret[offset + i] = attributes[i];

                baseParam = GetParentDefinition(baseParam); 
            }
 
            return ret; 
        }
 
        private static bool InternalParamIsDefined(ParameterInfo param, Type type, bool inherit)
        {
            Contract.Requires(param != null);
            Contract.Requires(type != null); 

            // For ParameterInfo's we need to make sure that we chain through all the MethodInfo's in the inheritance chain. 
            // We pick up all the CustomAttributes for the starting ParameterInfo. We need to pick up only attributes 
            // that are marked inherited from the remainder of the ParameterInfo's in the inheritance chain.
            // For MethodInfo's on an interface we do not do an inheritance walk. For ParameterInfo's on a 
            // Class we walk up the inheritance chain but do not look at the MethodInfo's on the interfaces that the class inherits from.

            if (param.IsDefined(type, false))
                return true; 

            if (param.Member.DeclaringType == null || !inherit) // This is an interface so we are done. 
                return false; 

            ParameterInfo baseParam = GetParentDefinition(param); 

            while (baseParam != null)
            {
                Object[] objAttr = baseParam.GetCustomAttributes(type, false); 

                for (int i =0; i < objAttr.Length; i++) 
                { 
                    Type objType = objAttr[i].GetType();
                    AttributeUsageAttribute attribUsage = InternalGetAttributeUsage(objType); 

                    if ((objAttr[i] is Attribute) && (attribUsage.Inherited))
                        return true;
                } 

                baseParam = GetParentDefinition(baseParam); 
            } 

            return false; 
        }

        #endregion
 
        #region Utility
        private static void CopyToArrayList(List attributeList,Attribute[] attributes,Dictionary types) 
        { 
            for (int i = 0; i < attributes.Length; i++)
            { 
                attributeList.Add(attributes[i]);

                Type attrType = attributes[i].GetType();
 
                if (!types.ContainsKey(attrType))
                    types[attrType] = InternalGetAttributeUsage(attrType); 
            } 
        }
 
        private static void AddAttributesToList(List attributeList, Attribute[] attributes, Dictionary types)
        {
            for (int i = 0; i < attributes.Length; i++)
            { 
                Type attrType = attributes[i].GetType();
                AttributeUsageAttribute usage = null; 
                types.TryGetValue(attrType, out usage); 

                if (usage == null) 
                {
                    // the type has never been seen before if it's inheritable add it to the list
                    usage = InternalGetAttributeUsage(attrType);
                    types[attrType] = usage; 

                    if (usage.Inherited) 
                        attributeList.Add(attributes[i]); 
                }
                else if (usage.Inherited && usage.AllowMultiple) 
                {
                    // we saw this type already add it only if it is inheritable and it does allow multiple
                    attributeList.Add(attributes[i]);
                } 
            }
        } 
 
        private static AttributeUsageAttribute InternalGetAttributeUsage(Type type)
        { 
            // Check if the custom attributes is Inheritable
            Object [] obj = type.GetCustomAttributes(typeof(AttributeUsageAttribute), false);

            if (obj.Length == 1) 
                return (AttributeUsageAttribute)obj[0];
 
            if (obj.Length == 0) 
                return AttributeUsageAttribute.Default;
 
            throw new FormatException(
                Environment.GetResourceString("Format_AttributeUsage", type));
        }
 
        [System.Security.SecuritySafeCritical]
        private static Attribute[] CreateAttributeArrayHelper(Type elementType, int elementCount) 
        { 
            return (Attribute[])Array.UnsafeCreateInstance(elementType, elementCount);
        } 
        #endregion

        #endregion
 
        #region Public Statics
 
        #region MemberInfo 
        public static Attribute[] GetCustomAttributes(MemberInfo element, Type type)
        { 
            return GetCustomAttributes(element, type, true);
        }

        public static Attribute[] GetCustomAttributes(MemberInfo element, Type type, bool inherit) 
        {
            if (element == null) 
                throw new ArgumentNullException("element"); 

            if (type == null) 
                throw new ArgumentNullException("type");

            if (!type.IsSubclassOf(typeof(Attribute)) && type != typeof(Attribute))
                throw new ArgumentException(Environment.GetResourceString("Argument_MustHaveAttributeBaseClass")); 
            Contract.EndContractBlock();
 
            switch (element.MemberType) 
            {
                case MemberTypes.Property: 
                    return InternalGetCustomAttributes((PropertyInfo)element, type, inherit);

                case MemberTypes.Event:
                    return InternalGetCustomAttributes((EventInfo)element, type, inherit); 

                default: 
                    return element.GetCustomAttributes(type, inherit) as Attribute[]; 
            }
        } 

        public static Attribute[] GetCustomAttributes(MemberInfo element)
        {
            return GetCustomAttributes(element, true); 
        }
 
        public static Attribute[] GetCustomAttributes(MemberInfo element, bool inherit) 
        {
            if (element == null) 
                throw new ArgumentNullException("element");
            Contract.EndContractBlock();

            switch (element.MemberType) 
            {
                case MemberTypes.Property: 
                    return InternalGetCustomAttributes((PropertyInfo)element, typeof(Attribute), inherit); 

                case MemberTypes.Event: 
                    return InternalGetCustomAttributes((EventInfo)element, typeof(Attribute), inherit);

                default:
                    return element.GetCustomAttributes(typeof(Attribute), inherit) as Attribute[]; 
            }
        } 
 
        public static bool IsDefined(MemberInfo element, Type attributeType)
        { 
            return IsDefined(element, attributeType, true);
        }

        public static bool IsDefined(MemberInfo element, Type attributeType, bool inherit) 
        {
            // Returns true if a custom attribute subclass of attributeType class/interface with inheritance walk 
            if (element == null) 
                throw new ArgumentNullException("element");
 
            if (attributeType == null)
                throw new ArgumentNullException("attributeType");

            if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute)) 
                throw new ArgumentException(Environment.GetResourceString("Argument_MustHaveAttributeBaseClass"));
            Contract.EndContractBlock(); 
 
            switch(element.MemberType)
            { 
                case MemberTypes.Property:
                    return InternalIsDefined((PropertyInfo)element, attributeType, inherit);

                case MemberTypes.Event: 
                    return InternalIsDefined((EventInfo)element, attributeType, inherit);
 
                default: 
                    return element.IsDefined(attributeType, inherit);
            } 

        }

        public static Attribute GetCustomAttribute(MemberInfo element, Type attributeType) 
        {
            return GetCustomAttribute(element, attributeType, true); 
        } 

        public static Attribute GetCustomAttribute(MemberInfo element, Type attributeType, bool inherit) 
        {
            Attribute[] attrib = GetCustomAttributes(element, attributeType, inherit);

            if (attrib == null || attrib.Length == 0) 
                return null;
 
            if (attrib.Length == 1) 
                return attrib[0];
 
            throw new AmbiguousMatchException(Environment.GetResourceString("RFLCT.AmbigCust"));
        }

        #endregion 

        #region ParameterInfo 
        public static Attribute[] GetCustomAttributes(ParameterInfo element) 
        {
            return GetCustomAttributes(element, true); 
        }

        public static Attribute[] GetCustomAttributes(ParameterInfo element, Type attributeType)
        { 
            return (Attribute[])GetCustomAttributes(element, attributeType, true);
        } 
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        public static Attribute[] GetCustomAttributes(ParameterInfo element, Type attributeType, bool inherit) 
        {
            if (element == null)
                throw new ArgumentNullException("element");
 
            if (attributeType == null)
                throw new ArgumentNullException("attributeType"); 
 
            if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute))
                throw new ArgumentException(Environment.GetResourceString("Argument_MustHaveAttributeBaseClass")); 

            if (element.Member == null)
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidParameterInfo"), "element");
 
            Contract.EndContractBlock();
 
            MemberInfo member = element.Member; 
            if (member.MemberType == MemberTypes.Method && inherit)
                return InternalParamGetCustomAttributes(element, attributeType, inherit) as Attribute[]; 

            return element.GetCustomAttributes(attributeType, inherit) as Attribute[];
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        public static Attribute[] GetCustomAttributes(ParameterInfo element, bool inherit) 
        { 
            if (element == null)
                throw new ArgumentNullException("element"); 

            if (element.Member == null)
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidParameterInfo"), "element");
 
            Contract.EndContractBlock();
 
            MemberInfo member = element.Member; 
            if (member.MemberType == MemberTypes.Method && inherit)
                return InternalParamGetCustomAttributes(element, null, inherit) as Attribute[]; 

            return element.GetCustomAttributes(typeof(Attribute), inherit) as Attribute[];
        }
 
        public static bool IsDefined(ParameterInfo element, Type attributeType)
        { 
            return IsDefined(element, attributeType, true); 
        }
 
        public static bool IsDefined(ParameterInfo element, Type attributeType, bool inherit)
        {
            // Returns true is a custom attribute subclass of attributeType class/interface with inheritance walk
            if (element == null) 
                throw new ArgumentNullException("element");
 
            if (attributeType == null) 
                throw new ArgumentNullException("attributeType");
 
            if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute))
                throw new ArgumentException(Environment.GetResourceString("Argument_MustHaveAttributeBaseClass"));
            Contract.EndContractBlock();
 
            MemberInfo member = element.Member;
 
            switch(member.MemberType) 
            {
                case MemberTypes.Method: // We need to climb up the member hierarchy 
                    return InternalParamIsDefined(element, attributeType, inherit);

                case MemberTypes.Constructor:
                    return element.IsDefined(attributeType, false); 

                case MemberTypes.Property: 
                    return element.IsDefined(attributeType, false); 

                default: 
                    Contract.Assert(false, "Invalid type for ParameterInfo member in Attribute class");
                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidParamInfo"));
            }
        } 

        public static Attribute GetCustomAttribute(ParameterInfo element, Type attributeType) 
        { 
            return GetCustomAttribute(element, attributeType, true);
        } 

        public static Attribute GetCustomAttribute(ParameterInfo element, Type attributeType, bool inherit)
        {
            // Returns an Attribute of base class/inteface attributeType on the ParameterInfo or null if none exists. 
            // throws an AmbiguousMatchException if there are more than one defined.
            Attribute[] attrib = GetCustomAttributes(element, attributeType, inherit); 
 
            if (attrib == null || attrib.Length == 0)
                return null; 

            if (attrib.Length == 0)
                return null;
 
            if (attrib.Length == 1)
                return attrib[0]; 
 
            throw new AmbiguousMatchException(Environment.GetResourceString("RFLCT.AmbigCust"));
        } 

        #endregion

        #region Module 
        public static Attribute[] GetCustomAttributes(Module element, Type attributeType)
        { 
            return GetCustomAttributes (element, attributeType, true); 
        }
 
        public static Attribute[] GetCustomAttributes(Module element)
        {
            return GetCustomAttributes(element, true);
        } 

        public static Attribute[] GetCustomAttributes(Module element, bool inherit) 
        { 
            if (element == null)
                throw new ArgumentNullException("element"); 
            Contract.EndContractBlock();

            return (Attribute[])element.GetCustomAttributes(typeof(Attribute), inherit);
        } 

        public static Attribute[] GetCustomAttributes(Module element, Type attributeType, bool inherit) 
        { 
            if (element == null)
                throw new ArgumentNullException("element"); 

            if (attributeType == null)
                throw new ArgumentNullException("attributeType");
 
            if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute))
                throw new ArgumentException(Environment.GetResourceString("Argument_MustHaveAttributeBaseClass")); 
            Contract.EndContractBlock(); 

            return (Attribute[])element.GetCustomAttributes(attributeType, inherit); 
        }

        public static bool IsDefined(Module element, Type attributeType)
        { 
            return IsDefined(element, attributeType, false);
        } 
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        public static bool IsDefined(Module element, Type attributeType, bool inherit) 
        {
            // Returns true is a custom attribute subclass of attributeType class/interface with no inheritance walk
            if (element == null)
                throw new ArgumentNullException("element"); 

            if (attributeType == null) 
                throw new ArgumentNullException("attributeType"); 

            if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute)) 
                throw new ArgumentException(Environment.GetResourceString("Argument_MustHaveAttributeBaseClass"));
            Contract.EndContractBlock();

            return element.IsDefined(attributeType,false); 
        }
 
        public static Attribute GetCustomAttribute(Module element, Type attributeType) 
        {
            return GetCustomAttribute(element, attributeType, true); 
        }

        public static Attribute GetCustomAttribute(Module element, Type attributeType, bool inherit)
        { 
            // Returns an Attribute of base class/inteface attributeType on the Module or null if none exists.
            // throws an AmbiguousMatchException if there are more than one defined. 
            Attribute[] attrib = GetCustomAttributes(element,attributeType,inherit); 

            if (attrib == null || attrib.Length == 0) 
                return null;

            if (attrib.Length == 1)
                return attrib[0]; 

            throw new AmbiguousMatchException(Environment.GetResourceString("RFLCT.AmbigCust")); 
        } 

        #endregion 

        #region Assembly
        public static Attribute[] GetCustomAttributes(Assembly element, Type attributeType)
        { 
            return GetCustomAttributes(element, attributeType, true);
        } 
 
        public static Attribute[] GetCustomAttributes(Assembly element, Type attributeType, bool inherit)
        { 
            if (element == null)
                throw new ArgumentNullException("element");

            if (attributeType == null) 
                throw new ArgumentNullException("attributeType");
 
            if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute)) 
                throw new ArgumentException(Environment.GetResourceString("Argument_MustHaveAttributeBaseClass"));
            Contract.EndContractBlock(); 

            return (Attribute[])element.GetCustomAttributes(attributeType, inherit);
        }
 
        public static Attribute[] GetCustomAttributes(Assembly element)
        { 
            return GetCustomAttributes(element, true); 
        }
 
        public static Attribute[] GetCustomAttributes(Assembly element, bool inherit)
        {
            if (element == null)
                throw new ArgumentNullException("element"); 
            Contract.EndContractBlock();
 
            return (Attribute[])element.GetCustomAttributes(typeof(Attribute), inherit); 
        }
 
        public static bool IsDefined (Assembly element, Type attributeType)
        {
            return IsDefined (element, attributeType, true);
        } 

        public static bool IsDefined (Assembly element, Type attributeType, bool inherit) 
        { 
            // Returns true is a custom attribute subclass of attributeType class/interface with no inheritance walk
            if (element == null) 
                throw new ArgumentNullException("element");

            if (attributeType == null)
                throw new ArgumentNullException("attributeType"); 

            if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute)) 
                throw new ArgumentException(Environment.GetResourceString("Argument_MustHaveAttributeBaseClass")); 
            Contract.EndContractBlock();
 
            return element.IsDefined(attributeType, false);
        }

        public static Attribute GetCustomAttribute(Assembly element, Type attributeType) 
        {
            return GetCustomAttribute (element, attributeType, true); 
        } 

        public static Attribute GetCustomAttribute(Assembly element, Type attributeType, bool inherit) 
        {
            // Returns an Attribute of base class/inteface attributeType on the Assembly or null if none exists.
            // throws an AmbiguousMatchException if there are more than one defined.
            Attribute[] attrib = GetCustomAttributes(element,attributeType,inherit); 

            if (attrib == null || attrib.Length == 0) 
                return null; 

            if (attrib.Length == 1) 
                return attrib[0];

            throw new AmbiguousMatchException(Environment.GetResourceString("RFLCT.AmbigCust"));
        } 

        #endregion 
 
        #endregion
 
        #region Constructor
        protected Attribute() { }
        #endregion
 
        #region Object Overrides
        [System.Security.SecuritySafeCritical]  // auto-generated 
        public override bool Equals(Object obj) 
        {
            if (obj == null) 
                return false;

            RuntimeType thisType = (RuntimeType)this.GetType();
            RuntimeType thatType = (RuntimeType)obj.GetType(); 

            if (thatType != thisType) 
                return false; 

            Object thisObj = this; 
            Object thisResult, thatResult;

            FieldInfo[] thisFields = thisType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
 
            for (int i = 0; i < thisFields.Length; i++)
            { 
                // Visibility check and consistency check are not necessary. 
                thisResult = ((RtFieldInfo)thisFields[i]).InternalGetValue(thisObj, false, false);
                thatResult = ((RtFieldInfo)thisFields[i]).InternalGetValue(obj, false, false); 

                if (!AreFieldValuesEqual(thisResult, thatResult))
                {
                    return false; 
                }
            } 
 
            return true;
        } 

        // Compares values of custom-attribute fields.
        private static bool AreFieldValuesEqual(Object thisValue, Object thatValue)
        { 
            if (thisValue == null && thatValue == null)
                return true; 
            if (thisValue == null || thatValue == null) 
                return false;
 
            if (thisValue.GetType().IsArray)
            {
                // Ensure both are arrays of the same type.
                if (!thisValue.GetType().Equals(thatValue.GetType())) 
                {
                    return false; 
                } 

                Array thisValueArray = thisValue as Array; 
                Array thatValueArray = thatValue as Array;
                if (thisValueArray.Length != thatValueArray.Length)
                {
                    return false; 
                }
 
                // Attributes can only contain single-dimension arrays, so we don't need to worry about 
                // multidimensional arrays.
                Contract.Assert(thisValueArray.Rank == 1 && thatValueArray.Rank == 1); 
                for (int j = 0; j < thisValueArray.Length; j++)
                {
                    if (!AreFieldValuesEqual(thisValueArray.GetValue(j), thatValueArray.GetValue(j)))
                    { 
                        return false;
                    } 
                } 
            }
            else 
            {
                // An object of type Attribute will cause a stack overflow.
                // However, this should never happen because custom attributes cannot contain values other than
                // constants, single-dimensional arrays and typeof expressions. 
                Contract.Assert(!(thisValue is Attribute));
                if (!thisValue.Equals(thatValue)) 
                    return false; 
            }
 
            return true;
        }

        [System.Security.SecuritySafeCritical]  // auto-generated 
        public override int GetHashCode()
        { 
            Type type = GetType(); 

            FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); 
            Object vThis = null;

            for (int i = 0; i < fields.Length; i++)
            { 
                // Visibility check and consistency check are not necessary.
                Object fieldValue = ((RtFieldInfo)fields[i]).InternalGetValue(this, false, false); 
 
                // The hashcode of an array ignores the contents of the array, so it can produce
                // different hashcodes for arrays with the same contents. 
                // Since we do deep comparisons of arrays in Equals(), this means Equals and GetHashCode will
                // be inconsistent for arrays. Therefore, we ignore hashes of arrays.
                if (fieldValue != null && !fieldValue.GetType().IsArray)
                    vThis = fieldValue; 

                if (vThis != null) 
                    break; 
            }
 
            if (vThis != null)
                return vThis.GetHashCode();

            return type.GetHashCode(); 
        }
        #endregion 
 
        #region Public Virtual Members
        public virtual Object TypeId { get { return GetType(); } } 

        public virtual bool Match(Object obj) { return Equals(obj); }
        #endregion
 
        #region Public Members
        public virtual bool IsDefaultAttribute() { return false; } 
        #endregion 

        void _Attribute.GetTypeInfoCount(out uint pcTInfo) 
        {
            throw new NotImplementedException();
        }
 
        void _Attribute.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
        { 
            throw new NotImplementedException(); 
        }
 
        void _Attribute.GetIDsOfNames([In] ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
        {
            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();
        } 
    }
}


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 

namespace System { 
 
    using System;
    using System.Reflection; 
    using System.Collections.Generic;
    using System.Runtime.InteropServices;
    using System.Globalization;
    using System.Diagnostics.Contracts; 
    using System.Security;
    using System.Security.Permissions; 
 
[Serializable]
[AttributeUsageAttribute(AttributeTargets.All, Inherited = true, AllowMultiple=false)] 
    [ClassInterface(ClassInterfaceType.None)]
    [ComDefaultInterface(typeof(_Attribute))]
[System.Runtime.InteropServices.ComVisible(true)]
    public abstract class Attribute : _Attribute 
    {
        #region Private Statics 
 
        #region PropertyInfo
        private static Attribute[] InternalGetCustomAttributes(PropertyInfo element, Type type, bool inherit) 
        {
            Contract.Requires(type != null);
            Contract.Requires(type.IsSubclassOf(typeof(Attribute)) || type == typeof(Attribute));
 
            // walk up the hierarchy chain
            Attribute[] attributes = (Attribute[])element.GetCustomAttributes(type, inherit); 
 
            if (!inherit)
                return attributes; 

            // create the hashtable that keeps track of inherited types
            Dictionary types = new Dictionary(11);
 
            // create an array list to collect all the requested attibutes
            List attributeList = new List(); 
            CopyToArrayList(attributeList, attributes, types); 

            PropertyInfo baseProp = GetParentDefinition(element); 
            while (baseProp != null)
            {
                attributes = GetCustomAttributes(baseProp, type, false);
                AddAttributesToList(attributeList, attributes, types); 
                baseProp = GetParentDefinition(baseProp);
            } 
            Array array = CreateAttributeArrayHelper(type, attributeList.Count); 
            Array.Copy(attributeList.ToArray(), 0, array, 0, attributeList.Count);
            return (Attribute[])array; 
        }

        private static bool InternalIsDefined(PropertyInfo element, Type attributeType, bool inherit)
        { 
            // walk up the hierarchy chain
            if (element.IsDefined(attributeType, inherit)) 
                return true; 

            if (inherit) 
            {
                AttributeUsageAttribute usage = InternalGetAttributeUsage(attributeType);

                if (!usage.Inherited) 
                    return false;
 
                PropertyInfo baseProp = GetParentDefinition(element); 

                while (baseProp != null) 
                {
                    if (baseProp.IsDefined(attributeType, false))
                        return true;
 
                    baseProp = GetParentDefinition(baseProp);
                } 
            } 

            return false; 
        }

        private static PropertyInfo GetParentDefinition(PropertyInfo property)
        { 
            Contract.Requires(property != null);
 
            // for the current property get the base class of the getter and the setter, they might be different 
            // note that this only works for RuntimeMethodInfo
            MethodInfo propAccessor = property.GetGetMethod(true); 

            if (propAccessor == null)
                propAccessor = property.GetSetMethod(true);
 
            RuntimeMethodInfo rtPropAccessor = propAccessor as RuntimeMethodInfo;
 
            if (rtPropAccessor != null) 
            {
                rtPropAccessor = rtPropAccessor.GetParentDefinition(); 

                if (rtPropAccessor != null)
                    // There is a public overload of Type.GetProperty that takes both a BingingFlags enum and a return type.
                    // However, we cannot use that because it doesn't accept null for "types". 
                    return rtPropAccessor.DeclaringType.GetProperty(
                        property.Name, 
                        BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly, 
                        property.PropertyType);
            } 

            return null;
        }
 
        #endregion
 
        #region EventInfo 
        private static Attribute[] InternalGetCustomAttributes(EventInfo element, Type type, bool inherit)
        { 
            Contract.Requires(element != null);
            Contract.Requires(type != null);
            Contract.Requires(type.IsSubclassOf(typeof(Attribute)) || type == typeof(Attribute));
 
            // walk up the hierarchy chain
            Attribute[] attributes = (Attribute[])element.GetCustomAttributes(type, inherit); 
            if (inherit) 
            {
                // create the hashtable that keeps track of inherited types 
                Dictionary types = new Dictionary(11);
                // create an array list to collect all the requested attibutes
                List attributeList = new List();
                CopyToArrayList(attributeList, attributes, types); 

                EventInfo baseEvent = GetParentDefinition(element); 
                while (baseEvent != null) 
                {
                    attributes = GetCustomAttributes(baseEvent, type, false); 
                    AddAttributesToList(attributeList, attributes, types);
                    baseEvent = GetParentDefinition(baseEvent);
                }
                Array array = CreateAttributeArrayHelper(type, attributeList.Count); 
                Array.Copy(attributeList.ToArray(), 0, array, 0, attributeList.Count);
                return (Attribute[])array; 
            } 
            else
                return attributes; 
        }

        private static EventInfo GetParentDefinition(EventInfo ev)
        { 
            Contract.Requires(ev != null);
 
            // note that this only works for RuntimeMethodInfo 
            MethodInfo add = ev.GetAddMethod(true);
 
            RuntimeMethodInfo rtAdd = add as RuntimeMethodInfo;

            if (rtAdd != null)
            { 
                rtAdd = rtAdd.GetParentDefinition();
                if (rtAdd != null) 
                    return rtAdd.DeclaringType.GetEvent(ev.Name); 
            }
            return null; 
        }

        private static bool InternalIsDefined (EventInfo element, Type attributeType, bool inherit)
        { 
            Contract.Requires(element != null);
 
            // walk up the hierarchy chain 
            if (element.IsDefined(attributeType, inherit))
                return true; 

            if (inherit)
            {
                AttributeUsageAttribute usage = InternalGetAttributeUsage(attributeType); 

                if (!usage.Inherited) 
                    return false; 

                EventInfo baseEvent = GetParentDefinition(element); 

                while (baseEvent != null)
                {
                    if (baseEvent.IsDefined(attributeType, false)) 
                        return true;
                    baseEvent = GetParentDefinition(baseEvent); 
                } 
            }
 
            return false;
        }

        #endregion 

        #region ParameterInfo 
        private static ParameterInfo GetParentDefinition(ParameterInfo param) 
        {
            Contract.Requires(param != null); 

            // note that this only works for RuntimeMethodInfo
            RuntimeMethodInfo rtMethod = param.Member as RuntimeMethodInfo;
 
            if (rtMethod != null)
            { 
                rtMethod = rtMethod.GetParentDefinition(); 

                if (rtMethod != null) 
                {
                    // Find the ParameterInfo on this method
                    ParameterInfo[] parameters = rtMethod.GetParameters();
                    return parameters[param.Position]; // Point to the correct ParameterInfo of the method 
                }
            } 
            return null; 
        }
 
        private static Attribute[] InternalParamGetCustomAttributes(ParameterInfo param, Type type, bool inherit)
        {
            Contract.Requires(param != null);
 
            // For ParameterInfo's we need to make sure that we chain through all the MethodInfo's in the inheritance chain that
            // have this ParameterInfo defined. .We pick up all the CustomAttributes for the starting ParameterInfo. We need to pick up only attributes 
            // that are marked inherited from the remainder of the MethodInfo's in the inheritance chain. 
            // For MethodInfo's on an interface we do not do an inheritance walk so the default ParameterInfo attributes are returned.
            // For MethodInfo's on a class we walk up the inheritance chain but do not look at the MethodInfo's on the interfaces that the 
            // class inherits from and return the respective ParameterInfo attributes

            List disAllowMultiple = new List();
            Object [] objAttr; 

            if (type == null) 
                type = typeof(Attribute); 

            objAttr = param.GetCustomAttributes(type, false); 

            for (int i =0;i < objAttr.Length;i++)
            {
                Type objType = objAttr[i].GetType(); 
                AttributeUsageAttribute attribUsage = InternalGetAttributeUsage(objType);
                if (attribUsage.AllowMultiple == false) 
                    disAllowMultiple.Add(objType); 
            }
 
            // Get all the attributes that have Attribute as the base class
            Attribute [] ret = null;
            if (objAttr.Length == 0)
                ret = CreateAttributeArrayHelper(type,0); 
            else
                ret = (Attribute[])objAttr; 
 
            if (param.Member.DeclaringType == null) // This is an interface so we are done.
                return ret; 

            if (!inherit)
                return ret;
 
            ParameterInfo baseParam = GetParentDefinition(param);
 
            while (baseParam != null) 
            {
                objAttr = baseParam.GetCustomAttributes(type, false); 

                int count = 0;
                for (int i =0;i < objAttr.Length;i++)
                { 
                    Type objType = objAttr[i].GetType();
                    AttributeUsageAttribute attribUsage = InternalGetAttributeUsage(objType); 
 
                    if ((attribUsage.Inherited) && (disAllowMultiple.Contains(objType) == false))
                    { 
                        if (attribUsage.AllowMultiple == false)
                            disAllowMultiple.Add(objType);
                        count++;
                    } 
                    else
                        objAttr[i] = null; 
                } 

                // Get all the attributes that have Attribute as the base class 
                Attribute [] attributes = CreateAttributeArrayHelper(type,count);

                count = 0;
                for (int i =0;i < objAttr.Length;i++) 
                {
                    if (objAttr[i] != null) 
                    { 
                        attributes[count] = (Attribute)objAttr[i];
                        count++; 
                    }
                }

                Attribute [] temp = ret; 
                ret = CreateAttributeArrayHelper(type,temp.Length + count);
                Array.Copy(temp,ret,temp.Length); 
 
                int offset = temp.Length;
 
                for (int i =0;i < attributes.Length;i++)
                    ret[offset + i] = attributes[i];

                baseParam = GetParentDefinition(baseParam); 
            }
 
            return ret; 
        }
 
        private static bool InternalParamIsDefined(ParameterInfo param, Type type, bool inherit)
        {
            Contract.Requires(param != null);
            Contract.Requires(type != null); 

            // For ParameterInfo's we need to make sure that we chain through all the MethodInfo's in the inheritance chain. 
            // We pick up all the CustomAttributes for the starting ParameterInfo. We need to pick up only attributes 
            // that are marked inherited from the remainder of the ParameterInfo's in the inheritance chain.
            // For MethodInfo's on an interface we do not do an inheritance walk. For ParameterInfo's on a 
            // Class we walk up the inheritance chain but do not look at the MethodInfo's on the interfaces that the class inherits from.

            if (param.IsDefined(type, false))
                return true; 

            if (param.Member.DeclaringType == null || !inherit) // This is an interface so we are done. 
                return false; 

            ParameterInfo baseParam = GetParentDefinition(param); 

            while (baseParam != null)
            {
                Object[] objAttr = baseParam.GetCustomAttributes(type, false); 

                for (int i =0; i < objAttr.Length; i++) 
                { 
                    Type objType = objAttr[i].GetType();
                    AttributeUsageAttribute attribUsage = InternalGetAttributeUsage(objType); 

                    if ((objAttr[i] is Attribute) && (attribUsage.Inherited))
                        return true;
                } 

                baseParam = GetParentDefinition(baseParam); 
            } 

            return false; 
        }

        #endregion
 
        #region Utility
        private static void CopyToArrayList(List attributeList,Attribute[] attributes,Dictionary types) 
        { 
            for (int i = 0; i < attributes.Length; i++)
            { 
                attributeList.Add(attributes[i]);

                Type attrType = attributes[i].GetType();
 
                if (!types.ContainsKey(attrType))
                    types[attrType] = InternalGetAttributeUsage(attrType); 
            } 
        }
 
        private static void AddAttributesToList(List attributeList, Attribute[] attributes, Dictionary types)
        {
            for (int i = 0; i < attributes.Length; i++)
            { 
                Type attrType = attributes[i].GetType();
                AttributeUsageAttribute usage = null; 
                types.TryGetValue(attrType, out usage); 

                if (usage == null) 
                {
                    // the type has never been seen before if it's inheritable add it to the list
                    usage = InternalGetAttributeUsage(attrType);
                    types[attrType] = usage; 

                    if (usage.Inherited) 
                        attributeList.Add(attributes[i]); 
                }
                else if (usage.Inherited && usage.AllowMultiple) 
                {
                    // we saw this type already add it only if it is inheritable and it does allow multiple
                    attributeList.Add(attributes[i]);
                } 
            }
        } 
 
        private static AttributeUsageAttribute InternalGetAttributeUsage(Type type)
        { 
            // Check if the custom attributes is Inheritable
            Object [] obj = type.GetCustomAttributes(typeof(AttributeUsageAttribute), false);

            if (obj.Length == 1) 
                return (AttributeUsageAttribute)obj[0];
 
            if (obj.Length == 0) 
                return AttributeUsageAttribute.Default;
 
            throw new FormatException(
                Environment.GetResourceString("Format_AttributeUsage", type));
        }
 
        [System.Security.SecuritySafeCritical]
        private static Attribute[] CreateAttributeArrayHelper(Type elementType, int elementCount) 
        { 
            return (Attribute[])Array.UnsafeCreateInstance(elementType, elementCount);
        } 
        #endregion

        #endregion
 
        #region Public Statics
 
        #region MemberInfo 
        public static Attribute[] GetCustomAttributes(MemberInfo element, Type type)
        { 
            return GetCustomAttributes(element, type, true);
        }

        public static Attribute[] GetCustomAttributes(MemberInfo element, Type type, bool inherit) 
        {
            if (element == null) 
                throw new ArgumentNullException("element"); 

            if (type == null) 
                throw new ArgumentNullException("type");

            if (!type.IsSubclassOf(typeof(Attribute)) && type != typeof(Attribute))
                throw new ArgumentException(Environment.GetResourceString("Argument_MustHaveAttributeBaseClass")); 
            Contract.EndContractBlock();
 
            switch (element.MemberType) 
            {
                case MemberTypes.Property: 
                    return InternalGetCustomAttributes((PropertyInfo)element, type, inherit);

                case MemberTypes.Event:
                    return InternalGetCustomAttributes((EventInfo)element, type, inherit); 

                default: 
                    return element.GetCustomAttributes(type, inherit) as Attribute[]; 
            }
        } 

        public static Attribute[] GetCustomAttributes(MemberInfo element)
        {
            return GetCustomAttributes(element, true); 
        }
 
        public static Attribute[] GetCustomAttributes(MemberInfo element, bool inherit) 
        {
            if (element == null) 
                throw new ArgumentNullException("element");
            Contract.EndContractBlock();

            switch (element.MemberType) 
            {
                case MemberTypes.Property: 
                    return InternalGetCustomAttributes((PropertyInfo)element, typeof(Attribute), inherit); 

                case MemberTypes.Event: 
                    return InternalGetCustomAttributes((EventInfo)element, typeof(Attribute), inherit);

                default:
                    return element.GetCustomAttributes(typeof(Attribute), inherit) as Attribute[]; 
            }
        } 
 
        public static bool IsDefined(MemberInfo element, Type attributeType)
        { 
            return IsDefined(element, attributeType, true);
        }

        public static bool IsDefined(MemberInfo element, Type attributeType, bool inherit) 
        {
            // Returns true if a custom attribute subclass of attributeType class/interface with inheritance walk 
            if (element == null) 
                throw new ArgumentNullException("element");
 
            if (attributeType == null)
                throw new ArgumentNullException("attributeType");

            if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute)) 
                throw new ArgumentException(Environment.GetResourceString("Argument_MustHaveAttributeBaseClass"));
            Contract.EndContractBlock(); 
 
            switch(element.MemberType)
            { 
                case MemberTypes.Property:
                    return InternalIsDefined((PropertyInfo)element, attributeType, inherit);

                case MemberTypes.Event: 
                    return InternalIsDefined((EventInfo)element, attributeType, inherit);
 
                default: 
                    return element.IsDefined(attributeType, inherit);
            } 

        }

        public static Attribute GetCustomAttribute(MemberInfo element, Type attributeType) 
        {
            return GetCustomAttribute(element, attributeType, true); 
        } 

        public static Attribute GetCustomAttribute(MemberInfo element, Type attributeType, bool inherit) 
        {
            Attribute[] attrib = GetCustomAttributes(element, attributeType, inherit);

            if (attrib == null || attrib.Length == 0) 
                return null;
 
            if (attrib.Length == 1) 
                return attrib[0];
 
            throw new AmbiguousMatchException(Environment.GetResourceString("RFLCT.AmbigCust"));
        }

        #endregion 

        #region ParameterInfo 
        public static Attribute[] GetCustomAttributes(ParameterInfo element) 
        {
            return GetCustomAttributes(element, true); 
        }

        public static Attribute[] GetCustomAttributes(ParameterInfo element, Type attributeType)
        { 
            return (Attribute[])GetCustomAttributes(element, attributeType, true);
        } 
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        public static Attribute[] GetCustomAttributes(ParameterInfo element, Type attributeType, bool inherit) 
        {
            if (element == null)
                throw new ArgumentNullException("element");
 
            if (attributeType == null)
                throw new ArgumentNullException("attributeType"); 
 
            if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute))
                throw new ArgumentException(Environment.GetResourceString("Argument_MustHaveAttributeBaseClass")); 

            if (element.Member == null)
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidParameterInfo"), "element");
 
            Contract.EndContractBlock();
 
            MemberInfo member = element.Member; 
            if (member.MemberType == MemberTypes.Method && inherit)
                return InternalParamGetCustomAttributes(element, attributeType, inherit) as Attribute[]; 

            return element.GetCustomAttributes(attributeType, inherit) as Attribute[];
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        public static Attribute[] GetCustomAttributes(ParameterInfo element, bool inherit) 
        { 
            if (element == null)
                throw new ArgumentNullException("element"); 

            if (element.Member == null)
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidParameterInfo"), "element");
 
            Contract.EndContractBlock();
 
            MemberInfo member = element.Member; 
            if (member.MemberType == MemberTypes.Method && inherit)
                return InternalParamGetCustomAttributes(element, null, inherit) as Attribute[]; 

            return element.GetCustomAttributes(typeof(Attribute), inherit) as Attribute[];
        }
 
        public static bool IsDefined(ParameterInfo element, Type attributeType)
        { 
            return IsDefined(element, attributeType, true); 
        }
 
        public static bool IsDefined(ParameterInfo element, Type attributeType, bool inherit)
        {
            // Returns true is a custom attribute subclass of attributeType class/interface with inheritance walk
            if (element == null) 
                throw new ArgumentNullException("element");
 
            if (attributeType == null) 
                throw new ArgumentNullException("attributeType");
 
            if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute))
                throw new ArgumentException(Environment.GetResourceString("Argument_MustHaveAttributeBaseClass"));
            Contract.EndContractBlock();
 
            MemberInfo member = element.Member;
 
            switch(member.MemberType) 
            {
                case MemberTypes.Method: // We need to climb up the member hierarchy 
                    return InternalParamIsDefined(element, attributeType, inherit);

                case MemberTypes.Constructor:
                    return element.IsDefined(attributeType, false); 

                case MemberTypes.Property: 
                    return element.IsDefined(attributeType, false); 

                default: 
                    Contract.Assert(false, "Invalid type for ParameterInfo member in Attribute class");
                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidParamInfo"));
            }
        } 

        public static Attribute GetCustomAttribute(ParameterInfo element, Type attributeType) 
        { 
            return GetCustomAttribute(element, attributeType, true);
        } 

        public static Attribute GetCustomAttribute(ParameterInfo element, Type attributeType, bool inherit)
        {
            // Returns an Attribute of base class/inteface attributeType on the ParameterInfo or null if none exists. 
            // throws an AmbiguousMatchException if there are more than one defined.
            Attribute[] attrib = GetCustomAttributes(element, attributeType, inherit); 
 
            if (attrib == null || attrib.Length == 0)
                return null; 

            if (attrib.Length == 0)
                return null;
 
            if (attrib.Length == 1)
                return attrib[0]; 
 
            throw new AmbiguousMatchException(Environment.GetResourceString("RFLCT.AmbigCust"));
        } 

        #endregion

        #region Module 
        public static Attribute[] GetCustomAttributes(Module element, Type attributeType)
        { 
            return GetCustomAttributes (element, attributeType, true); 
        }
 
        public static Attribute[] GetCustomAttributes(Module element)
        {
            return GetCustomAttributes(element, true);
        } 

        public static Attribute[] GetCustomAttributes(Module element, bool inherit) 
        { 
            if (element == null)
                throw new ArgumentNullException("element"); 
            Contract.EndContractBlock();

            return (Attribute[])element.GetCustomAttributes(typeof(Attribute), inherit);
        } 

        public static Attribute[] GetCustomAttributes(Module element, Type attributeType, bool inherit) 
        { 
            if (element == null)
                throw new ArgumentNullException("element"); 

            if (attributeType == null)
                throw new ArgumentNullException("attributeType");
 
            if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute))
                throw new ArgumentException(Environment.GetResourceString("Argument_MustHaveAttributeBaseClass")); 
            Contract.EndContractBlock(); 

            return (Attribute[])element.GetCustomAttributes(attributeType, inherit); 
        }

        public static bool IsDefined(Module element, Type attributeType)
        { 
            return IsDefined(element, attributeType, false);
        } 
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        public static bool IsDefined(Module element, Type attributeType, bool inherit) 
        {
            // Returns true is a custom attribute subclass of attributeType class/interface with no inheritance walk
            if (element == null)
                throw new ArgumentNullException("element"); 

            if (attributeType == null) 
                throw new ArgumentNullException("attributeType"); 

            if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute)) 
                throw new ArgumentException(Environment.GetResourceString("Argument_MustHaveAttributeBaseClass"));
            Contract.EndContractBlock();

            return element.IsDefined(attributeType,false); 
        }
 
        public static Attribute GetCustomAttribute(Module element, Type attributeType) 
        {
            return GetCustomAttribute(element, attributeType, true); 
        }

        public static Attribute GetCustomAttribute(Module element, Type attributeType, bool inherit)
        { 
            // Returns an Attribute of base class/inteface attributeType on the Module or null if none exists.
            // throws an AmbiguousMatchException if there are more than one defined. 
            Attribute[] attrib = GetCustomAttributes(element,attributeType,inherit); 

            if (attrib == null || attrib.Length == 0) 
                return null;

            if (attrib.Length == 1)
                return attrib[0]; 

            throw new AmbiguousMatchException(Environment.GetResourceString("RFLCT.AmbigCust")); 
        } 

        #endregion 

        #region Assembly
        public static Attribute[] GetCustomAttributes(Assembly element, Type attributeType)
        { 
            return GetCustomAttributes(element, attributeType, true);
        } 
 
        public static Attribute[] GetCustomAttributes(Assembly element, Type attributeType, bool inherit)
        { 
            if (element == null)
                throw new ArgumentNullException("element");

            if (attributeType == null) 
                throw new ArgumentNullException("attributeType");
 
            if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute)) 
                throw new ArgumentException(Environment.GetResourceString("Argument_MustHaveAttributeBaseClass"));
            Contract.EndContractBlock(); 

            return (Attribute[])element.GetCustomAttributes(attributeType, inherit);
        }
 
        public static Attribute[] GetCustomAttributes(Assembly element)
        { 
            return GetCustomAttributes(element, true); 
        }
 
        public static Attribute[] GetCustomAttributes(Assembly element, bool inherit)
        {
            if (element == null)
                throw new ArgumentNullException("element"); 
            Contract.EndContractBlock();
 
            return (Attribute[])element.GetCustomAttributes(typeof(Attribute), inherit); 
        }
 
        public static bool IsDefined (Assembly element, Type attributeType)
        {
            return IsDefined (element, attributeType, true);
        } 

        public static bool IsDefined (Assembly element, Type attributeType, bool inherit) 
        { 
            // Returns true is a custom attribute subclass of attributeType class/interface with no inheritance walk
            if (element == null) 
                throw new ArgumentNullException("element");

            if (attributeType == null)
                throw new ArgumentNullException("attributeType"); 

            if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute)) 
                throw new ArgumentException(Environment.GetResourceString("Argument_MustHaveAttributeBaseClass")); 
            Contract.EndContractBlock();
 
            return element.IsDefined(attributeType, false);
        }

        public static Attribute GetCustomAttribute(Assembly element, Type attributeType) 
        {
            return GetCustomAttribute (element, attributeType, true); 
        } 

        public static Attribute GetCustomAttribute(Assembly element, Type attributeType, bool inherit) 
        {
            // Returns an Attribute of base class/inteface attributeType on the Assembly or null if none exists.
            // throws an AmbiguousMatchException if there are more than one defined.
            Attribute[] attrib = GetCustomAttributes(element,attributeType,inherit); 

            if (attrib == null || attrib.Length == 0) 
                return null; 

            if (attrib.Length == 1) 
                return attrib[0];

            throw new AmbiguousMatchException(Environment.GetResourceString("RFLCT.AmbigCust"));
        } 

        #endregion 
 
        #endregion
 
        #region Constructor
        protected Attribute() { }
        #endregion
 
        #region Object Overrides
        [System.Security.SecuritySafeCritical]  // auto-generated 
        public override bool Equals(Object obj) 
        {
            if (obj == null) 
                return false;

            RuntimeType thisType = (RuntimeType)this.GetType();
            RuntimeType thatType = (RuntimeType)obj.GetType(); 

            if (thatType != thisType) 
                return false; 

            Object thisObj = this; 
            Object thisResult, thatResult;

            FieldInfo[] thisFields = thisType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
 
            for (int i = 0; i < thisFields.Length; i++)
            { 
                // Visibility check and consistency check are not necessary. 
                thisResult = ((RtFieldInfo)thisFields[i]).InternalGetValue(thisObj, false, false);
                thatResult = ((RtFieldInfo)thisFields[i]).InternalGetValue(obj, false, false); 

                if (!AreFieldValuesEqual(thisResult, thatResult))
                {
                    return false; 
                }
            } 
 
            return true;
        } 

        // Compares values of custom-attribute fields.
        private static bool AreFieldValuesEqual(Object thisValue, Object thatValue)
        { 
            if (thisValue == null && thatValue == null)
                return true; 
            if (thisValue == null || thatValue == null) 
                return false;
 
            if (thisValue.GetType().IsArray)
            {
                // Ensure both are arrays of the same type.
                if (!thisValue.GetType().Equals(thatValue.GetType())) 
                {
                    return false; 
                } 

                Array thisValueArray = thisValue as Array; 
                Array thatValueArray = thatValue as Array;
                if (thisValueArray.Length != thatValueArray.Length)
                {
                    return false; 
                }
 
                // Attributes can only contain single-dimension arrays, so we don't need to worry about 
                // multidimensional arrays.
                Contract.Assert(thisValueArray.Rank == 1 && thatValueArray.Rank == 1); 
                for (int j = 0; j < thisValueArray.Length; j++)
                {
                    if (!AreFieldValuesEqual(thisValueArray.GetValue(j), thatValueArray.GetValue(j)))
                    { 
                        return false;
                    } 
                } 
            }
            else 
            {
                // An object of type Attribute will cause a stack overflow.
                // However, this should never happen because custom attributes cannot contain values other than
                // constants, single-dimensional arrays and typeof expressions. 
                Contract.Assert(!(thisValue is Attribute));
                if (!thisValue.Equals(thatValue)) 
                    return false; 
            }
 
            return true;
        }

        [System.Security.SecuritySafeCritical]  // auto-generated 
        public override int GetHashCode()
        { 
            Type type = GetType(); 

            FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); 
            Object vThis = null;

            for (int i = 0; i < fields.Length; i++)
            { 
                // Visibility check and consistency check are not necessary.
                Object fieldValue = ((RtFieldInfo)fields[i]).InternalGetValue(this, false, false); 
 
                // The hashcode of an array ignores the contents of the array, so it can produce
                // different hashcodes for arrays with the same contents. 
                // Since we do deep comparisons of arrays in Equals(), this means Equals and GetHashCode will
                // be inconsistent for arrays. Therefore, we ignore hashes of arrays.
                if (fieldValue != null && !fieldValue.GetType().IsArray)
                    vThis = fieldValue; 

                if (vThis != null) 
                    break; 
            }
 
            if (vThis != null)
                return vThis.GetHashCode();

            return type.GetHashCode(); 
        }
        #endregion 
 
        #region Public Virtual Members
        public virtual Object TypeId { get { return GetType(); } } 

        public virtual bool Match(Object obj) { return Equals(obj); }
        #endregion
 
        #region Public Members
        public virtual bool IsDefaultAttribute() { return false; } 
        #endregion 

        void _Attribute.GetTypeInfoCount(out uint pcTInfo) 
        {
            throw new NotImplementedException();
        }
 
        void _Attribute.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
        { 
            throw new NotImplementedException(); 
        }
 
        void _Attribute.GetIDsOfNames([In] ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
        {
            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();
        } 
    }
}


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK