Los atributos en C# son mecanismos que permiten agregar información declarativa a elementos de un programa como tipos, campos, métodos y propiedades. Esta información puede ser consultada en tiempo de ejecución a través de la reflexión. Existen atributos predefinidos y también se pueden definir atributos personalizados mediante clases que heredan de Attribute.

1. Atributos
Un atributo-un término muy sobre usado-en C# es un mecanismo que define palabras como
declaraciones descriptivas, para anotar a elementos de un programa como lo son tipos, campos,
métodos, y propiedades. Estos atributos son usados para extender la Metadata de la entidad
seleccionada. La información que los atributos contienen puede ser devuelta en tiempo de ejecución
desde la Metadata a través del mecanismo Reflexión. Puedes usar números atributos predefinidos que
vienen con el FCL (Framework Class Library), o puedes definir tu propio atributo personalizado.
Extraído de Wiki pedía.
Los Atributos son una ponderosa herramienta para asociar el código, ya sea, Tipos, Métodos,
propiedades con información declarativa, que puede ser consultada en tiempo de ejecución a través de
Reflection.
Existen 2 tipos de atributos. Los disponibles en el Base Class Library de .Net Framework (Built-in
Attributes) y los atributos definidos por el usuario (Custom Atributes).
Estos se utilizan para:
 Especificar que privilegios de seguridad que una clase requiere.
 Agregar Metadata a los programas. Los atributos permiten agregar información de forma
declarativa que puede ser consultada en tiempo de ejecución.
 Declarar habilidades de un objeto. Como si el mismo soporta serialización, etc.
 También se utilizan para describir objetos. Por ejemplo, cuando miramos el código generado
por LinQ para Convertir una entidad en la base de datos en un objeto en .net que se
corresponda con el mismo, podemos observar como él describe mediante atributos dichos
objetos.
[Table(Name = quot;Employeesquot;)]
public class Employees
{
[Column(IsPrimaryKey = true, Name = quot;EmployeeIDquot;, IsDbGenerated =
true)]
public Int32 EmployeeID { get; set; }
[Column(Name = quot;FirstNamequot;, DbType = quot;varchar(10)quot;)]
public string FirstName { get; set; }
[Column(Name = quot;LastNamequot;, DbType = quot;varchar(20)quot;)]
public string LastName { get; set; }
}

2. Utilizando Atributos
Para utilizar un atributos solo debemos especificar mediante corchetes [ ], y dentro de los mismos
especificar el nombre del atributo que vamos a utilizar.
Si miramos el código anterior, en la declaración de la clase incluimos un atributo que nos especifica que
este objeto es una representación de una tabla.
[Table(Name = quot;Employeesquot;)]
public class Employees
Ahora bien, si deseáramos que nuestro objeto sea Serializable, solo debemos agregar el atributo
Serializable.
[Serializable]
[Table(Name = quot;Employeesquot;)]
public class Employees
Dicha acción está indicando al compilador y CLR que la clase anterior es Serializable, es decir, que puede
ser convertida en XML o en binario para ser guardada automáticamente en un flujo de datos, por lo que
su implementación final dentro del código será algo diferente si no hubiera indicado dicho atributo.
Aunque en el .Net Framework existen muchos tipos de atributos, podemos crear tantos atributos como
sean necesarios.
Creando Atributos Personalizados
Para crear un atributo personalizado solo debemos crear una clase que herede de la clase Attribute. Por
convención las clases que se crean que heredan de Attribute, se agregan a su nombre Attribute. Si
creáramos un atributo TipoVehiculo entonces, el nombre a declarar seria TipoVehiculoAttribute, aunque
en el código solo es necesario utilizar su nombre. TipoVehiculo.
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct)]
class TipoVehiculoAttribute : Attribute
{
Boolean _Is4Ruedas;
Boolean _IsHibrido;
String _fabricante;
String _combustible;
public Boolean Is4Ruedas
{

3. get { return _Is4Ruedas; }
set { _Is4Ruedas = value; }
}
public String Fabricante
{
get { return _fabricante; }
set { _fabricante = value; }
}
public Boolean IsHibrido
{
get { return _IsHibrido; }
set { _IsHibrido = value; }
}
public TipoVehiculoAttribute()
: base()
{
}
public TipoVehiculoAttribute(String NombreCombustible)
: base()
{
_combustible = NombreCombustible;
}
}
El nombre de la clase es el nombre del atributo, TipoVehiculo. Se deriva de System.Attribute, por lo
tanto, se trata de una clase de atributo personalizado. Los parámetros del constructor son los
parámetros posicionales del atributo personalizado, en este caso, Nombre de combustible, mientras que
cualquier propiedad o campo público de lectura y escritura es un parámetro con nombre, en este caso,
IsHibrido, Is4Ruedas y Fabricante. Observe el uso del atributo AttributeUsage para validar el atributo
TipoVehículo sólo se utilizara en las declaraciones de class y struct.
Consultar atributos en tiempo de ejecución
El hecho de poder definir atributos personalizados y colocarlos en el código fuente tendría un valor
escaso si no se dispone de un método para recuperar la información y actuar sobre ella. C# tiene un
sistema de reflexión que permite recuperar la información definida con atributos personalizados. Por
ejemplo, a nuestra clase automóvil estamos asignadole nuestro atributos TipoVehiculo y le
especificamos ciertos valores los cuales podrán ser consultamos en tiempo de ejecución.
[TipoVehiculo(quot;Gasolinaquot;, Fabricante = quot;Toyotaquot;, Is4Ruedas = true, IsHibrido
= false)]
public class Automovil
{

4. }
class Program
{
static void Main(string[] args)
{
Automovil MyCarro = new Automovil();
printAttributeInfo(MyCarro.GetType());
Console.ReadKey();
}
private static void printAttributeInfo(Type e)
{
Console.WriteLine(quot;Comenzando Inspección de Atributosquot;);
object[] AtributosInAutomovil = e.GetCustomAttributes(false);
foreach (object a in AtributosInAutomovil)
{
if (a is TipoVehiculoAttribute)
{
TipoVehiculoAttribute Atr = (TipoVehiculoAttribute)a;
Console.WriteLine(quot;Fabricante: quot; + Atr.Fabricante);
Console.WriteLine(quot;4 Ruedas: quot; + Atr.Is4Ruedas);
Console.WriteLine(quot;Es Hibrido: quot; + Atr.IsHibrido);
}
}
}
}
Glosario
Metadata: es toda la información que utiliza el CLR para describir y hacer referencias a tipos y
asemblies. Metadata es independiente del lenguaje y el medio de intercambio para compiladores y
depuradores y ambientes de ejecución.
Reflection: Método utilizado para dinámicamente y en tiempo de ejecución conocer la instancia de un
tipo o crear una nueva, asignar el tipo a un objeto existente. Además de que podemos obtener el tipo
de un objeto e invocar sus métodos o acceder a sus propiedades.
Serializable: en las ciencias de computación, en el contexto de almacenamiento y transmisión de datos,
se conoce como serialización al proceso de convertir un objeto en forma binaria u otro formato (como
XML), para ser almacenada en un medio persistente o transmitida por la web. Lo que permitirá
reconstruir el objeto que fue serializado como si fuera el original.
Autor:
Stanley R. Lara

5. MSP República Dominicana