Esdeveniment
Crea aplicacions intel·ligents
17 de març, 23 - 21 de març, 23
Uneix-te a la sèrie de trobades per crear solucions d'IA escalables basades en casos d'ús del món real amb altres desenvolupadors i experts.
Registreu-vos-hi araAquest navegador ja no s’admet.
Feu l’actualització al Microsoft Edge per aprofitar les característiques més recents, les actualitzacions de seguretat i l’assistència tècnica.
Los atributos proporcionan un método eficaz para asociar metadatos o información declarativa, con código (ensamblados, tipos, métodos, propiedades, etc.). Después de asociar un atributo a una entidad de programa, el atributo se puede consultar en tiempo de ejecución mediante una técnica denominada reflexión.
Los atributos tienen las siguientes propiedades:
Reflection proporciona objetos (de tipo Type) que describen ensamblados, módulos y tipos. Puede usar la reflexión para crear dinámicamente una instancia de un tipo, enlazar el tipo a un objeto existente o obtener el tipo de un objeto existente e invocar sus métodos o acceder a sus campos y propiedades. Si usa atributos en el código, la reflexión le permite acceder a ellos. Para obtener más información, vea atributos de .
Este es un ejemplo sencillo de reflexión mediante el método GetType() , heredado por todos los tipos de la clase base Object
, para obtener el tipo de una variable:
Nota
Asegúrese de agregar using System;
y using System.Reflection;
en la parte superior del archivo .cs.
// Using GetType to obtain type information:
int i = 42;
Type type = i.GetType();
Console.WriteLine(type);
La salida es: System.Int32
.
En el ejemplo siguiente se usa la reflexión para obtener el nombre completo del ensamblado cargado.
// Using Reflection to get information of an Assembly:
Assembly info = typeof(int).Assembly;
Console.WriteLine(info);
La salida es similar a esta: System.Private.CoreLib, Version=7.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e
.
Nota
Las palabras clave de C# protected
y internal
no tienen ningún significado en el lenguaje intermedio (IL) y no se usan en las API de reflexión. Los términos correspondientes en IL son Family y Assembly. Para identificar un método internal
mediante la reflexión, use la propiedad IsAssembly. Para identificar un método protected internal
, use IsFamilyOrAssembly.
Los atributos se pueden colocar en casi cualquier declaración, aunque un atributo específico podría restringir los tipos de declaraciones en las que es válido. En C#, especifique un atributo colocando el nombre del atributo entre corchetes ([]
) encima de la declaración de la entidad a la que se aplica.
En este ejemplo, el atributo SerializableAttribute se usa para aplicar una característica específica a una clase:
[Serializable]
public class SampleClass
{
// Objects of this type can be serialized.
}
Un método con el atributo DllImportAttribute se declara como en el ejemplo siguiente:
[System.Runtime.InteropServices.DllImport("user32.dll")]
extern static void SampleMethod();
Se puede colocar más de un atributo en una declaración, como se muestra en el ejemplo siguiente:
void MethodA([In][Out] ref double x) { }
void MethodB([Out][In] ref double x) { }
void MethodC([In, Out] ref double x) { }
Algunos atributos se pueden especificar más de una vez para una entidad determinada. Un ejemplo de este atributo multiuso es ConditionalAttribute:
[Conditional("DEBUG"), Conditional("TEST1")]
void TraceMethod()
{
// ...
}
Nota
Por convención, todos los nombres de atributo terminan con la palabra "Attribute" para distinguirlos de otros elementos de las bibliotecas de .NET. Sin embargo, no es necesario especificar el sufijo de atributo al usar atributos en el código. Por ejemplo, [DllImport]
equivale a [DllImportAttribute]
, pero DllImportAttribute
es el nombre real del atributo en la biblioteca de clases de .NET.
Muchos atributos tienen parámetros, que pueden ser posicionales, sin nombre o con nombre. Los parámetros posicionales deben especificarse en un orden determinado y no se pueden omitir. Los parámetros con nombre son opcionales y se pueden especificar en cualquier orden. Los parámetros posicionales se especifican primero. Por ejemplo, estos tres atributos son equivalentes:
[DllImport("user32.dll")]
[DllImport("user32.dll", SetLastError=false, ExactSpelling=false)]
[DllImport("user32.dll", ExactSpelling=false, SetLastError=false)]
El primer parámetro, el nombre del archivo DLL, es posicional y siempre viene primero; los demás son nombrados. En este caso, ambos parámetros con nombre tienen como valor predeterminado false, por lo que se pueden omitir. Los parámetros posicionales corresponden a los parámetros del constructor de atributos. Los parámetros con nombre o opcionales corresponden a propiedades o campos del atributo . Consulte la documentación del atributo individual para obtener información sobre los valores de parámetro predeterminados.
Para obtener más información sobre los tipos de parámetros permitidos, consulte la sección Atributos de de la especificación del lenguaje C# .
El destino de un atributo es la entidad a la que se aplica el atributo. Por ejemplo, un atributo puede aplicarse a una clase, a un método determinado o a un ensamblado completo. De forma predeterminada, un atributo se aplica al elemento que lo sigue. Pero también puede identificar explícitamente, por ejemplo, si se aplica un atributo a un método o a su parámetro o a su valor devuelto.
Para identificar explícitamente un destino de atributo, use la sintaxis siguiente:
[target : attribute-list]
La lista de posibles valores de target
se muestra en la tabla siguiente.
Valor del objetivo | Se aplica a |
---|---|
assembly |
Ensamblado completo |
module |
Módulo de ensamblado actual |
field |
Campo de una clase o un struct |
event |
Evento |
method |
Método o descriptores de acceso de propiedad get y set |
param |
Parámetros de método o parámetros de descriptor de acceso de propiedad set |
property |
Propiedad |
return |
Valor devuelto de un método, indexador de propiedad o descriptor de acceso de propiedad get |
type |
Estructura, clase, interfaz, enumeración o delegado |
Especificaría el valor de destino field
para aplicar un atributo al campo de respaldo creado para una propiedad implementada automáticamente.
En el ejemplo siguiente se muestra cómo aplicar atributos a ensamblados y módulos. Para obtener más información, vea Atributos comunes (C#).
using System;
using System.Reflection;
[assembly: AssemblyTitleAttribute("Production assembly 4")]
[module: CLSCompliant(true)]
En el ejemplo siguiente se muestra cómo aplicar atributos a métodos, parámetros de método y valores devueltos de método en C#.
// default: applies to method
[ValidatedContract]
int Method1() { return 0; }
// applies to method
[method: ValidatedContract]
int Method2() { return 0; }
// applies to parameter
int Method3([ValidatedContract] string contract) { return 0; }
// applies to return value
[return: ValidatedContract]
int Method4() { return 0; }
Nota
Independientemente de los destinos en los que se defina ValidatedContract
para que sea válido, el destino return
debe especificarse, incluso si ValidatedContract
se definiera para aplicar solo a los valores devueltos. En otras palabras, el compilador no usará la información AttributeUsage
para resolver destinos de atributo ambiguos. Para obtener más información, vea AttributeUsage.
En la lista siguiente se incluyen algunos de los usos comunes de atributos en el código:
WebMethod
en servicios web para indicar que el método debe llamarse a través del protocolo SOAP. Para obtener más información, consulte WebMethodAttribute.La reflexión es útil en las siguientes situaciones:
Para obtener más información:
Comentaris de .NET
.NET és un projecte de codi obert. Seleccioneu un enllaç per enviar comentaris:
Esdeveniment
Crea aplicacions intel·ligents
17 de març, 23 - 21 de març, 23
Uneix-te a la sèrie de trobades per crear solucions d'IA escalables basades en casos d'ús del món real amb altres desenvolupadors i experts.
Registreu-vos-hi araFormació
Mòdul
Llamar a métodos desde la biblioteca de clases .NET mediante C# - Training
Use la funcionalidad de la biblioteca de clases .NET llamando a métodos que devuelven valores, aceptan parámetros de entrada, etc.
Documentació
Tutorial: Definición y lectura de atributos personalizados. - C#
Aprenda cómo funcionan los atributos en C#. Los atributos personalizados se definen para agregar metadatos al código. Puede leer esos atributos para obtener información sobre el código en tiempo de ejecución
Creación de atributos personalizados - C#
Aprenda a crear atributos personalizados en C# mediante la definición de una clase de atributo que se derive de la clase de atributos.
Atributos - C# language specification
En este capítulo se tratan los atributos. Los atributos son tipos de metadatos que se pueden aplicar a muchos elementos de programa: clases, estructuras, ensamblados, miembros y argumentos.