Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método Attribute.GetCustomAttributes (MemberInfo, Type)

 

Publicado: octubre de 2016

Recupera una matriz de los atributos personalizados aplicados a un miembro de un tipo. Los parámetros especifican el miembro y el tipo del atributo personalizado que se buscará.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

public static Attribute[] GetCustomAttributes(
	MemberInfo element,
	Type type
)

Parámetros

element
Type: System.Reflection.MemberInfo

Un objeto derivado de la MemberInfo clase que describe un constructor, evento, campo, método o propiedad de miembro de una clase.

type
Type: System.Type

El tipo o un tipo base, del atributo personalizado que se buscará.

Valor devuelto

Type: System.Attribute[]

Un Attribute matriz que contiene los atributos personalizados del tipo type aplicado a element, o una matriz vacía si no existe ningún atributo personalizado.

Exception Condition
ArgumentNullException

El valor de element o type es null.

ArgumentException

typeno se deriva de Attribute.

NotSupportedException

elementno es un constructor, método, propiedad, evento, tipo o campo.

TypeLoadException

No se puede cargar un tipo de atributo personalizado.

El valor devuelto contiene los atributos personalizados para sus antecesores element.

System_CAPS_noteNota

A partir de la versión 2.0 de .NET Framework, este método devuelve los atributos de seguridad en métodos, constructores y tipos si los atributos se almacenan en el nuevo formato de metadatos. Los ensamblados compilados con la versión 2.0 o posterior, usan el nuevo formato. Ensamblados dinámicos y los ensamblados compilados con versiones anteriores de .NET Framework usan el formato XML antiguo. Vea emitir atributos de seguridad declarativa.

En el ejemplo de código siguiente se muestra el uso de GetCustomAttribute, teniendo un MemberInfo como un parámetro.

using System;
using System.Reflection;
using System.Security;
using System.Runtime.InteropServices;

namespace CustAttrs4CS
{

    // Define an enumeration of Win32 unmanaged types
    public enum UnmanagedType
    {
        User,
        GDI,
        Kernel,
        Shell,
        Networking,
        Multimedia
    }

    // Define the Unmanaged attribute.
    public class UnmanagedAttribute : Attribute
    {
        // Storage for the UnmanagedType value.
        protected UnmanagedType thisType;

        // Set the unmanaged type in the constructor.
        public UnmanagedAttribute(UnmanagedType type)
        {
            thisType = type;
        }

        // Define a property to get and set the UnmanagedType value.
        public UnmanagedType Win32Type
        {
            get { return thisType; }
            set { thisType = Win32Type; }
        }
    }

    // Create a class for an imported Win32 unmanaged function.
    public class Win32 {
        [DllImport("user32.dll", CharSet = CharSet.Unicode)]
        public static extern int MessageBox(int hWnd, String text,
            String caption, uint type);
    }

    public class AClass {
        // Add some attributes to Win32CallMethod.
        [Obsolete("This method is obsolete. Use managed MsgBox instead.")]
        [Unmanaged(UnmanagedType.User)]
        public void Win32CallMethod()
        {
            Win32.MessageBox(0, "This is an unmanaged call.", "Caution!", 0);
        }
    }

    class DemoClass {
        static void Main(string[] args)
            {
            // Get the AClass type to access its metadata.
            Type clsType = typeof(AClass);
            // Get the type information for Win32CallMethod.
            MethodInfo mInfo = clsType.GetMethod("Win32CallMethod");
            if (mInfo != null)
            {
                // Iterate through all the attributes of the method.
                foreach(Attribute attr in
                    Attribute.GetCustomAttributes(mInfo)) {
                    // Check for the Obsolete attribute.
                    if (attr.GetType() == typeof(ObsoleteAttribute))
                    {
                        Console.WriteLine("Method {0} is obsolete. " +
                            "The message is:",
                            mInfo.Name);
                        Console.WriteLine("  \"{0}\"",
                            ((ObsoleteAttribute)attr).Message);
                    }

                    // Check for the Unmanaged attribute.
                    else if (attr.GetType() == typeof(UnmanagedAttribute))
                    {
                        Console.WriteLine(
                            "This method calls unmanaged code.");
                        Console.WriteLine(
                            String.Format("The Unmanaged attribute type is {0}.",
                                          ((UnmanagedAttribute)attr).Win32Type));
                        AClass myCls = new AClass();
                        myCls.Win32CallMethod();
                    }
                }
            }
        }
    }
}

/*

This code example produces the following results.

First, the compilation yields the warning, "...This method is
obsolete. Use managed MsgBox instead."
Second, execution yields a message box with a title of "Caution!"
and message text of "This is an unmanaged call."
Third, the following text is displayed in the console window:

Method Win32CallMethod is obsolete. The message is:
  "This method is obsolete. Use managed MsgBox instead."
This method calls unmanaged code.
The Unmanaged attribute type is User.

*/

.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Volver al principio
Mostrar: