[AttributeUsage(AttributeTargets.Class)] 
  public class TestImplementsAttribute : Attribute 
  { 
      public string Name 
      { get; set; } 
  }

private static void TestMutilpeImplements() 
{ 
    var type = typeof(Program); 
    var attrs = type.GetCustomAttributes(typeof(TestImplementsAttribute), false); 
    Console.WriteLine(string.Format("TestImplementsAttribute:({0})",attrs.Length)); 
    foreach (var item in attrs) 
    { 
        Console.WriteLine("  " + item.GetType().FullName); 
    } 
    attrs = type.GetCustomAttributes(typeof(SerializableAttribute), false); 
    Console.WriteLine(string.Format("SerializableAttribute:({0})", attrs.Length)); 
    foreach (var item in attrs) 
    { 
        Console.WriteLine("  " + item.GetType().FullName); 
    }

attrs = type.GetCustomAttributes(typeof(Attribute), false); 
    Console.WriteLine(string.Format("(base type)Attribute:({0})", attrs.Length)); 
    foreach (var item in attrs) 
    { 
        Console.WriteLine("  " + item.GetType().FullName); 
    }

}

internal static unsafe object[] GetCustomAttributes(Module decoratedModule, int decoratedMetadataToken, int pcaCount, RuntimeType attributeFilterType, bool mustBeInheritable, IList derivedAttributes)
{
    if (decoratedModule.Assembly.ReflectionOnly)
    {
        throw new InvalidOperationException(Environment.GetResourceString("Arg_ReflectionOnlyCA"));
    }
    MetadataImport metadataImport = decoratedModule.MetadataImport;
    CustomAttributeRecord[] customAttributeRecords = CustomAttributeData.GetCustomAttributeRecords(decoratedModule, decoratedMetadataToken);
    Type elementType = (((attributeFilterType == null) || attributeFilterType.IsValueType) || attributeFilterType.ContainsGenericParameters) ? typeof(object) : attributeFilterType;
    if ((attributeFilterType == null) && (customAttributeRecords.Length == 0))
    {
        return (Array.CreateInstance(elementType, 0) as object[]);
    }
    object[] attributes = Array.CreateInstance(elementType, customAttributeRecords.Length) as object[];
    int length = 0;
    SecurityContextFrame frame = new SecurityContextFrame();
    frame.Push(decoratedModule.Assembly.InternalAssembly);
    Assembly lastAptcaOkAssembly = null;
    for (int i = 0; i < customAttributeRecords.Length; i++)
    {
        bool flag2;
        bool flag3;
        object obj2 = null;
        CustomAttributeRecord caRecord = customAttributeRecords[i];
        RuntimeMethodHandle ctor = new RuntimeMethodHandle();
        RuntimeType attributeType = null;
        int namedArgs = 0;
        IntPtr signature = caRecord.blob.Signature;
        IntPtr blobEnd = (IntPtr) (((void*) signature) + caRecord.blob.Length);
        if (FilterCustomAttributeRecord(caRecord, metadataImport, ref lastAptcaOkAssembly, decoratedModule, decoratedMetadataToken, attributeFilterType, mustBeInheritable, attributes, derivedAttributes, out attributeType, out ctor, out flag2, out flag3))
        {
            if (!ctor.IsNullHandle())
            {
                ctor.CheckLinktimeDemands(decoratedModule, decoratedMetadataToken);
            }
            RuntimeConstructorInfo.CheckCanCreateInstance(attributeType, flag3);
            if (flag2)
            {
                obj2 = CreateCaObject(decoratedModule, ctor, ref signature, blobEnd, out namedArgs);
            }
            else
            {
                obj2 = attributeType.TypeHandle.CreateCaInstance(ctor);
                if (Marshal.ReadInt16(signature) != 1)
                {
                    throw new CustomAttributeFormatException();
                }
                signature = (IntPtr) (((void*) signature) + 2);
                namedArgs = Marshal.ReadInt16(signature);
                signature = (IntPtr) (((void*) signature) + 2);
            }
            for (int j = 0; j < namedArgs; j++)
            {
                string str;
                bool flag4;
                Type type3;
                object obj3;
                IntPtr ptr1 = caRecord.blob.Signature;
                GetPropertyOrFieldData(decoratedModule, ref signature, blobEnd, out str, out flag4, out type3, out obj3);
                try
                {
                    if (flag4)
                    {
                        if ((type3 == null) && (obj3 != null))
                        {
                            type3 = (obj3.GetType() == typeof(RuntimeType)) ? typeof(Type) : obj3.GetType();
                        }
                        RuntimePropertyInfo property = null;
                        if (type3 == null)
                        {
                            property = attributeType.GetProperty(str) as RuntimePropertyInfo;
                        }
                        else
                        {
                            property = attributeType.GetProperty(str, type3, Type.EmptyTypes) as RuntimePropertyInfo;
                        }
                        RuntimeMethodInfo setMethod = property.GetSetMethod(true) as RuntimeMethodInfo;
                        if (setMethod.IsPublic)
                        {
                            setMethod.MethodHandle.CheckLinktimeDemands(decoratedModule, decoratedMetadataToken);
                            setMethod.Invoke(obj2, BindingFlags.Default, null, new object[] { obj3 }, null, true);
                        }
                    }
                    else
                    {
                        (attributeType.GetField(str) as RtFieldInfo).InternalSetValue(obj2, obj3, BindingFlags.Default, Type.DefaultBinder, null, false);
                    }
                }
                catch (Exception exception)
                {
                    throw new CustomAttributeFormatException(string.Format(CultureInfo.CurrentUICulture, Environment.GetResourceString(flag4 ? "RFLCT.InvalidPropFail" : "RFLCT.InvalidFieldFail"), new object[] { str }), exception);
                }
            }
            if (!signature.Equals(blobEnd))
            {
                throw new CustomAttributeFormatException();
            }
            attributes[length++] = obj2;
        }
    }
    frame.Pop();
    if ((length == customAttributeRecords.Length) && (pcaCount == 0))
    {
        return attributes;
    }
    if (length == 0)
    {
        Array.CreateInstance(elementType, 0);
    }
    object[] destinationArray = Array.CreateInstance(elementType, (int) (length + pcaCount)) as object[];
    Array.Copy(attributes, 0, destinationArray, 0, length);
    return destinationArray;
}