AYUDA .NET

Atributos de C# (Cómo funciona para desarrolladores)

Actualizado 18 de febrero, 2024
Compartir:

En el mundo de la programación en C#, los metadatos desempeñan un papel crucial a la hora de enriquecer la semántica y el comportamiento del código. Atributos C# surgen como potentes herramientas que permiten a los desarrolladores adjuntar metadatos a diversas entidades de su código, lo que determina la forma en que los compiladores, las herramientas y los entornos de ejecución interpretan esas entidades e interactúan con ellas.

En esta completa guía, echaremos un vistazo a los atributos de C#, explorando su sintaxis, aplicaciones y cómo sirven como mecanismo versátil para mejorar la expresividad y funcionalidad del código.

Comprender C# Atributos: A Primer

Atributos, entre corchetes ([])son etiquetas declarativas que se colocan sobre los elementos de código para proporcionar información adicional sobre ellos. Esta información adicional, también conocida como metadatos, no afecta a la funcionalidad básica del código, pero ofrece información valiosa a compiladores, entornos de ejecución y herramientas.

En C#, un atributo de objeto representa metadatos asociados a una entidad de programa, como una clase o un método. Las instancias de atributos, definidas mediante la sintaxis de atributos, mejoran la descripción de una entidad de programa, como por ejemplo utilizando Conditional("DEBUG") para incluir condicionalmente el código.

He aquí un ejemplo básico de utilización de un atributo en C#:

[Serializable]
public class Person
{
    //  Implantación de clases
}
[Serializable]
public class Person
{
    //  Implantación de clases
}
<Serializable>
Public Class Person
	'  Implantación de clases
End Class
VB   C#

En este ejemplo, el atributo Serializable indica que las instancias de la clase Persona pueden serializarse.

Tipos de C# Atributos

Los atributos se aplican a varios elementos del código C#, entre ellos:

  1. Asamblea: Se aplica a toda la asamblea, influyendo en su comportamiento durante la compilación y ejecución.
    [assembly: AssemblyVersion("1.0.0.0")]
    [assembly: AssemblyVersion("1.0.0.0")]
<Assembly: AssemblyVersion("1.0.0.0")>
VB   C#
  1. Módulo: Se aplica a un módulo dentro de un conjunto y proporciona información sobre el propio módulo.
    [module: SomeCustomModuleAttribute]
    [module: SomeCustomModuleAttribute]
IRON VB CONVERTER ERROR developers@ironsoftware.com
VB   C#
  1. Tipo: Se aplica a los tipos, influyendo en su comportamiento o proporcionando información adicional.
    [Serializable]
        public class Person
        {
            //  Implantación de clases
        }
    [Serializable]
        public class Person
        {
            //  Implantación de clases
        }
<Serializable>
Public Class Person
			'  Implantación de clases
End Class
VB   C#
  1. Método: Se aplica a los métodos, alterando su comportamiento o proporcionando información a las herramientas.
    [Obsolete("Use the newMethod instead.")]
        public void DeprecatedMethod()
        {
            //  Aplicación del método
        }
    [Obsolete("Use the newMethod instead.")]
        public void DeprecatedMethod()
        {
            //  Aplicación del método
        }
<Obsolete("Use the newMethod instead.")>
Public Sub DeprecatedMethod()
			'  Aplicación del método
End Sub
VB   C#
  1. Propiedad, campo, evento, etc.: Se aplica a miembros específicos dentro de un tipo, ofreciendo metadatos relevantes para esos miembros.
    public class Example
        {
            [DefaultValue(42)]
            public int Answer { get; set; }
        }
    public class Example
        {
            [DefaultValue(42)]
            public int Answer { get; set; }
        }
Public Class Example
			<DefaultValue(42)>
			Public Property Answer() As Integer
End Class
VB   C#

Creación de atributos personalizados en C#

Aunque C# proporciona numerosos atributos incorporados, los desarrolladores pueden crear atributos personalizados para transmitir información específica sobre su código. Los atributos personalizados se definen creando una clase que herede de System.Attribute:

[AttributeUsage(AttributeTargets.Class 
 AttributeTargets.Method, AllowMultiple = true)]
public class CustomAttribute : Attribute
{
    //  Aplicación de atributos
}
[AttributeUsage(AttributeTargets.Class 
 AttributeTargets.Method, AllowMultiple = true)]
public class CustomAttribute : Attribute
{
    //  Aplicación de atributos
}
<AttributeUsage(AttributeTargets.Class AttributeTargets.Method, AllowMultiple := True)>
Public Class CustomAttribute
	Inherits Attribute

	'  Aplicación de atributos
End Class
VB   C#

En este ejemplo, CustomAttribute puede aplicarse a clases y métodos, y la propiedad AllowMultiple especifica si se permiten múltiples instancias del atributo en un único objetivo. Al crear una clase de atributos personalizados, se añade un sufijo de atributo al nombre de la clase para diferenciarla de las clases normales. El constructor de atributos inicializa estas propiedades, y los parámetros posicionales desempeñan un papel a la hora de pasar valores a estos atributos, proporcionando información estructurada en el código.

Aplicaciones de C# Atributos

1. Documentación del código

Los atributos desempeñan un papel crucial a la hora de documentar el código y proporcionar información adicional a los desarrolladores o las herramientas. Por ejemplo, el [Obsoleto] indica que un elemento concreto ya no debe utilizarse y que los desarrolladores deben migrar a una alternativa.

[Obsolete("This method is obsolete. Use the newMethod instead.")]
public void DeprecatedMethod()
{
    //  Aplicación del método
}
[Obsolete("This method is obsolete. Use the newMethod instead.")]
public void DeprecatedMethod()
{
    //  Aplicación del método
}
<Obsolete("This method is obsolete. Use the newMethod instead.")>
Public Sub DeprecatedMethod()
	'  Aplicación del método
End Sub
VB   C#

2. Serialización y persistencia

Atributos como [Serializable] informan al entorno de ejecución de que las instancias de un tipo pueden serializarse. Esto es crucial cuando se trata de escenarios como la persistencia de datos.

[Serializable]
public class Person
{
    //  Implementación de clases
}
[Serializable]
public class Person
{
    //  Implementación de clases
}
<Serializable>
Public Class Person
	'  Implementación de clases
End Class
VB   C#

3. Análisis de código e integración de herramientas

Los atributos contribuyen a las herramientas de análisis estático y generación de código. Por ejemplo, herramientas como los marcos de pruebas unitarias utilizan atributos como TestMethod para identificar los métodos de prueba.

[TestClass]
public class MyTestClass
{
    [TestMethod]
    public void TestMethod()
    {
        //  Aplicación del método de ensayo
    }
}
[TestClass]
public class MyTestClass
{
    [TestMethod]
    public void TestMethod()
    {
        //  Aplicación del método de ensayo
    }
}
<TestClass>
Public Class MyTestClass
	<TestMethod>
	Public Sub TestMethod()
		'  Aplicación del método de ensayo
	End Sub
End Class
VB   C#

4. Enrutamiento ASP.NET MVC

En ASP.NET MVC, los atributos se utilizan ampliamente para el enrutamiento. El atributo Route permite a los desarrolladores especificar la plantilla de ruta para un método de acción.

[Route("api/[controller]")]
public class SampleController : Controller
{
    [HttpGet]
    [Route("GetSampleData")]
    public IActionResult GetSampleData()
    {
        //  Aplicación del método de acción
    }
}
[Route("api/[controller]")]
public class SampleController : Controller
{
    [HttpGet]
    [Route("GetSampleData")]
    public IActionResult GetSampleData()
    {
        //  Aplicación del método de acción
    }
}
<Route("api/[controller]")>
Public Class SampleController
	Inherits Controller

	<HttpGet>
	<Route("GetSampleData")>
	Public Function GetSampleData() As IActionResult
		'  Aplicación del método de acción
	End Function
End Class
VB   C#

Presentación de IronPDF: Un breve resumen

IronPDF es una biblioteca versátil diseñada para desarrolladores de C# .NET Framework, que ofrece un amplio conjunto de herramientas para la generación y manipulación de PDF. Desde la creación de PDF a partir de HTML hasta la extracción de contenido de documentos existentes, IronPDF simplifica tareas complejas, lo que lo convierte en un valioso activo en el conjunto de herramientas del desarrollador.

Atributos C# (Cómo funciona para el desarrollador): Figura 1 - Página web de IronPDF

Instalación de IronPDF: Inicio rápido

Para empezar a aprovechar la biblioteca IronPDF en su proyecto C#, puede instalar fácilmente el paquete IronPDF NuGet. Utilice el siguiente comando en la consola del gestor de paquetes:

Install-Package IronPdf

También puede buscar "IronPDF" en el gestor de paquetes NuGet e instalarlo desde allí.

C# Atributos: Una rápida visión general

Los atributos de C# son etiquetas declarativas que proporcionan información adicional sobre entidades de su código, como clases, métodos o propiedades. Permiten a los desarrolladores adjuntar metadatos o definir comportamientos sin alterar la funcionalidad central del código, como se ha mencionado anteriormente. A medida que avancemos en la exploración de la integración de atributos con IronPDF, descubriremos cómo pueden contribuir a un enfoque más matizado de la generación de PDF.

Mejorar la generación de PDF con C# Atributos

1. Personalización de los metadatos de los documentos

Los atributos pueden emplearse para enriquecer los metadatos asociados al documento PDF. IronPDF permite a los desarrolladores personalizar elementos de metadatos como título, autor y asunto. Mediante el uso de atributos, puede inyectar dinámicamente esta información en el PDF generado. El siguiente ejemplo muestra cómo utilizar diferentes clases de atributos con IronPDF:

PdfGenerationWithAttributes obj = new PdfGenerationWithAttributes();
obj.GeneratePdf();
//  Definir el atributo DocumentMetadataAttribute
public class DocumentMetadataAttribute : Attribute
{
    public string Title { get; set; }
    public string Author { get; set; }
    public string Subject { get; set; }
}
[DocumentMetadata(Title = "Custom PDF Title", Author = "John Doe", Subject = "Document Subject")]
public class PdfGenerationWithAttributes
{
    public void GeneratePdf()
    {
        //  Instanciar IronPDF PdfDocument
        var pdfDocument = new PdfDocument("StyledDocument.pdf");
        //  Recuperar DocumentMetadataAttribute usando reflection
        var documentMetadata = typeof(PdfGenerationWithAttributes)
            .GetCustomAttributes(typeof(DocumentMetadataAttribute), false)
            .FirstOrDefault() as DocumentMetadataAttribute;
        //  Establecer valores de metadatos
        pdfDocument.MetaData.Title = documentMetadata?.Title;
        pdfDocument.MetaData.Author = documentMetadata?.Author;
        pdfDocument.MetaData.Subject = documentMetadata?.Subject;
        //  Generar documentos
        pdfDocument.SaveAs("CustomizedDocument.pdf");
    }
}
PdfGenerationWithAttributes obj = new PdfGenerationWithAttributes();
obj.GeneratePdf();
//  Definir el atributo DocumentMetadataAttribute
public class DocumentMetadataAttribute : Attribute
{
    public string Title { get; set; }
    public string Author { get; set; }
    public string Subject { get; set; }
}
[DocumentMetadata(Title = "Custom PDF Title", Author = "John Doe", Subject = "Document Subject")]
public class PdfGenerationWithAttributes
{
    public void GeneratePdf()
    {
        //  Instanciar IronPDF PdfDocument
        var pdfDocument = new PdfDocument("StyledDocument.pdf");
        //  Recuperar DocumentMetadataAttribute usando reflection
        var documentMetadata = typeof(PdfGenerationWithAttributes)
            .GetCustomAttributes(typeof(DocumentMetadataAttribute), false)
            .FirstOrDefault() as DocumentMetadataAttribute;
        //  Establecer valores de metadatos
        pdfDocument.MetaData.Title = documentMetadata?.Title;
        pdfDocument.MetaData.Author = documentMetadata?.Author;
        pdfDocument.MetaData.Subject = documentMetadata?.Subject;
        //  Generar documentos
        pdfDocument.SaveAs("CustomizedDocument.pdf");
    }
}
Private obj As New PdfGenerationWithAttributes()
obj.GeneratePdf()
'  Definir el atributo DocumentMetadataAttribute
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'public class DocumentMetadataAttribute : Attribute
'{
'	public string Title
'	{
'		get;
'		set;
'	}
'	public string Author
'	{
'		get;
'		set;
'	}
'	public string Subject
'	{
'		get;
'		set;
'	}
'}
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'[DocumentMetadata(Title = "Custom PDF Title", Author = "John Doe", Subject = "Document Subject")]
'public class PdfGenerationWithAttributes
'{
'	public void GeneratePdf()
'	{
'		'  Instanciar IronPDF PdfDocument
'		var pdfDocument = New PdfDocument("StyledDocument.pdf");
'		'  Recuperar DocumentMetadataAttribute usando reflection
'		var documentMetadata = TryCast(typeof(PdfGenerationWithAttributes).GetCustomAttributes(typeof(DocumentMetadataAttribute), False).FirstOrDefault(), DocumentMetadataAttribute);
'		'  Establecer valores de metadatos
'		pdfDocument.MetaData.Title = If(documentMetadata Is Nothing, Nothing, documentMetadata.Title);
'		pdfDocument.MetaData.Author = If(documentMetadata Is Nothing, Nothing, documentMetadata.Author);
'		pdfDocument.MetaData.Subject = If(documentMetadata Is Nothing, Nothing, documentMetadata.Subject);
'		'  Generar documentos
'		pdfDocument.SaveAs("CustomizedDocument.pdf");
'	}
'}
VB   C#

En este ejemplo, el atributo DocumentMetadataAttribute sirve como atributo personalizado para transmitir información de metadatos, lo que permite una personalización dinámica durante la generación del PDF. El código proporcionado define una clase de atributo personalizada denominada DocumentMetadataAttribute en C#. Los atributos son una forma de añadir metadatos o información declarativa a entidades del programa como clases, métodos o propiedades. Estos atributos se utilizan después para editar los MetaData de un documento PDF mediante reflexión.

Atributos C# (Cómo funciona para el desarrollador): Figura 2 - Visualización de los metadatos del PDF de salida a través de 'Propiedades del documento'

2. Control del diseño del PDF con atributos

Los atributos también pueden utilizarse para controlar el diseño del documento PDF. IronPDF ofrece opciones para configurar el tamaño de página, los márgenes y la orientación. Mediante el uso de atributos, puede parametrizar estos ajustes de diseño en función de requisitos específicos:

[PageLayout(Size = IronPdf.Rendering.PdfPaperSize.A4, MarginTop = 20, MarginBottom = 20, MarginLeft = 10, MarginRight = 10)]
public class PdfGenerationWithLayoutAttributes
{
    public void GeneratePdf()
    {
        //  Instanciar IronPDF PdfDocument
        var pdfDocument = new ChromePdfRenderer();
        //  Recuperar PageLayoutAttribute usando reflection
        var pageLayout = typeof(PdfGenerationWithLayoutAttributes)
            .GetCustomAttributes(typeof(PageLayoutAttribute), false)
            .FirstOrDefault() as PageLayoutAttribute;
        //  Establecer valores de diseño
        pdfDocument.RenderingOptions.PaperSize = pageLayout?.Size;
        pdfDocument.RenderingOptions.MarginTop = pageLayout?.MarginTop ?? 0;
        pdfDocument.RenderingOptions.MarginBottom = pageLayout?.MarginBottom ?? 0;
        pdfDocument.RenderingOptions.MarginLeft = pageLayout?.MarginLeft ?? 0;
        pdfDocument.RenderingOptions.MarginRight = pageLayout?.MarginRight ?? 0;
        //  Generar documentos
        pdfDocument.RenderHtmlAsPdf("<html><body><h1>Hello, IronPDF!</h1></body></html>").SaveAs("CustomLayoutDocument.pdf");
    }
}
[PageLayout(Size = IronPdf.Rendering.PdfPaperSize.A4, MarginTop = 20, MarginBottom = 20, MarginLeft = 10, MarginRight = 10)]
public class PdfGenerationWithLayoutAttributes
{
    public void GeneratePdf()
    {
        //  Instanciar IronPDF PdfDocument
        var pdfDocument = new ChromePdfRenderer();
        //  Recuperar PageLayoutAttribute usando reflection
        var pageLayout = typeof(PdfGenerationWithLayoutAttributes)
            .GetCustomAttributes(typeof(PageLayoutAttribute), false)
            .FirstOrDefault() as PageLayoutAttribute;
        //  Establecer valores de diseño
        pdfDocument.RenderingOptions.PaperSize = pageLayout?.Size;
        pdfDocument.RenderingOptions.MarginTop = pageLayout?.MarginTop ?? 0;
        pdfDocument.RenderingOptions.MarginBottom = pageLayout?.MarginBottom ?? 0;
        pdfDocument.RenderingOptions.MarginLeft = pageLayout?.MarginLeft ?? 0;
        pdfDocument.RenderingOptions.MarginRight = pageLayout?.MarginRight ?? 0;
        //  Generar documentos
        pdfDocument.RenderHtmlAsPdf("<html><body><h1>Hello, IronPDF!</h1></body></html>").SaveAs("CustomLayoutDocument.pdf");
    }
}
<PageLayout(Size := IronPdf.Rendering.PdfPaperSize.A4, MarginTop := 20, MarginBottom := 20, MarginLeft := 10, MarginRight := 10)>
Public Class PdfGenerationWithLayoutAttributes
	Public Sub GeneratePdf()
		'  Instanciar IronPDF PdfDocument
		Dim pdfDocument = New ChromePdfRenderer()
		'  Recuperar PageLayoutAttribute usando reflection
		Dim pageLayout = TryCast(GetType(PdfGenerationWithLayoutAttributes).GetCustomAttributes(GetType(PageLayoutAttribute), False).FirstOrDefault(), PageLayoutAttribute)
		'  Establecer valores de diseño
		pdfDocument.RenderingOptions.PaperSize = pageLayout?.Size
		pdfDocument.RenderingOptions.MarginTop = If(pageLayout?.MarginTop, 0)
		pdfDocument.RenderingOptions.MarginBottom = If(pageLayout?.MarginBottom, 0)
		pdfDocument.RenderingOptions.MarginLeft = If(pageLayout?.MarginLeft, 0)
		pdfDocument.RenderingOptions.MarginRight = If(pageLayout?.MarginRight, 0)
		'  Generar documentos
		pdfDocument.RenderHtmlAsPdf("<html><body><h1>Hello, IronPDF!</h1></body></html>").SaveAs("CustomLayoutDocument.pdf")
	End Sub
End Class
VB   C#

En este ejemplo, el atributo PageLayoutAttribute se utiliza para encapsular la configuración del diseño de página, permitiendo ajustes dinámicos basados en los valores del atributo.

Conclusión

En conclusión, los atributos de C# son un mecanismo inestimable para incrustar metadatos en el código e influir en el modo en que las herramientas, los compiladores y los entornos de ejecución interpretan y procesan ese código. Tanto si utilizan atributos integrados como si crean atributos personalizados, los desarrolladores pueden aprovechar los atributos para mejorar la expresividad del código, permitir la integración de herramientas y modelar el comportamiento de sus aplicaciones.

La integración de atributos C# con IronPDF abre vías para una generación de PDF más matizada y dinámica. Tanto si se trata de personalizar metadatos como de ajustar la configuración del diseño, los atributos proporcionan un enfoque declarativo para mejorar las capacidades de IronPDF. Mientras explora las posibilidades, considere las necesidades específicas de sus tareas de generación de PDF y cómo los atributos pueden contribuir a un proceso más personalizado y eficaz con IronPDF.

IronPDF es gratuito para el desarrollo con algunas limitaciones que puede desbloquear con un licencia para probar la funcionalidad completa de la biblioteca.

< ANTERIOR
C# String.Format (Cómo funciona para desarrolladores)
SIGUIENTE >
C# Delegates (Cómo funciona para los desarrolladores)

¿Listo para empezar? Versión: 2024.6 recién publicada

Comenzar prueba gratuita Descargas totales: 9,541,998
Ver licencias >