AYUDA .NET

Objeto Anónimo C# (Cómo Funciona para Desarrolladores)

Publicado en 14 de enero, 2025

Introducción del Objeto Anónimo

Los tipos anónimos en C# proporcionan un mecanismo para encapsular propiedades de solo lectura públicas en un único objeto de tipo anónimo sin definir explícitamente una declaración formal de clase. Es útil para la estructura de objeto único. Son tipos generados por el compilador que derivan directamente de System.Object, encapsulando propiedades de objetos de manera eficiente y sirviendo como contenedores de datos ligeros e inmutables. Estos tipos son clases selladas donde el compilador infiere y genera automáticamente el nombre del tipo, que permanece inaccesible a nivel de código fuente. También descubriremosIronPDFcomo la biblioteca PDF para los proyectos .NET.

Características clave

Los tipos anónimos están estrictamente limitados en sus capacidades:
Las propiedades se implementan automáticamente como propiedades públicas de solo lectura en la definición de propiedad de un tipo anónimo.
Los usuarios no pueden definir explícitamente métodos, eventos u otros miembros de clase como los métodos equals y gethashcode dentro de él.
No se puede inicializar con valores nulos, función anónima o tipos de puntero, garantizando la integridad de los tipos anónimos.

Casos de uso común

Operaciones LINQ

Los objetos de tipo anónimo destacan en las expresiones de consulta LINQ, especialmente en las cláusulas select para objetos de tipo anónimo, donde devuelven de manera eficiente subconjuntos específicos de propiedades de objetos más grandes. Este enfoque optimiza el uso de memoria creando objetos temporales que contienen solo los datos necesarios.

Agrupación de datos temporal

Sirven como contenedores eficientes para estructuras de datos temporales cuando crear una clase formal sería excesivo. Esto es particularmente útil para transformaciones de datos de corta duración o cálculos intermedios.

Encapsulación de Propiedades

El tipo de datos anónimo proporciona una manera sencilla de agrupar propiedades de objetos relacionadas mediante propiedades de solo lectura. El compilador garantiza la seguridad de tipos mientras mantiene una sintaxis concisa para el acceso a propiedades.

Sintaxis y estructura

La creación de tipos anónimos sigue un patrón específico usando la palabra clave var junto con el operador new y la sintaxis del inicializador de objetos. El compilador genera automáticamente un nombre de tipo que permanece inaccesible a nivel del código fuente.

var person = new { FirstName = "Iron", LastName = "Dev", Age = 35 }; // public int age in this anonymous type

var person = new { FirstName = "Iron", LastName = "Dev", Age = 35 }; // public int age in this anonymous type

Private person = New With {
	Key .FirstName = "Iron",
	Key .LastName = "Dev",
	Key .Age = 35
}

Reglas de Inicialización de Propiedades

El compilador impone reglas estrictas para la inicialización de propiedades en tipos anónimos. Todas las propiedades deben ser inicializadas durante la creación del objeto y no se les pueden asignar valores nulos o tipos de puntero. Una vez inicializadas, los valores de las propiedades de un tipo anónimo pueden ser accesados usando la notación estándar de punto, pero no pueden ser modificados después de la inicialización debido a su naturaleza de solo lectura.

Inferencia de tipos y coincidencia

var person1 = new { Name = "Iron", Age = 30 };
var person2 = new { Name = "Dev", Age = 25 };

var person1 = new { Name = "Iron", Age = 30 };
var person2 = new { Name = "Dev", Age = 25 };

Dim person1 = New With {
	Key .Name = "Iron",
	Key .Age = 30
}
Dim person2 = New With {
	Key .Name = "Dev",
	Key .Age = 25
}

El compilador genera información de tipo idéntica para tipos anónimos con nombres de propiedades, tipos y orden coincidentes. Esto permite la compatibilidad de tipos entre instancias que se utilizarán en colecciones o se pasarán como parámetros de método dentro del mismo ensamblado.

Tipos Anónimos Anidados

El tipo de datos anónimo admite estructuras complejas anidadas con propiedades de objeto de tipo anónimo. Es útil para la creación de representaciones de datos jerárquicas:

var student = new {
    Id = 1,
    PersonalInfo = new {
        Name = "James",
        Contact = new {
            Email = "james@email.com",
            Phone = "123-456-7890"
        }
    },
    Grades = new { Math = 95, Science = 88 }
};

var student = new {
    Id = 1,
    PersonalInfo = new {
        Name = "James",
        Contact = new {
            Email = "james@email.com",
            Phone = "123-456-7890"
        }
    },
    Grades = new { Math = 95, Science = 88 }
};

Dim student = New With {
	Key .Id = 1,
	Key .PersonalInfo = New With {
		Key .Name = "James",
		Key .Contact = New With {
			Key .Email = "james@email.com",
			Key .Phone = "123-456-7890"
		}
	},
	Key .Grades = New With {
		Key .Math = 95,
		Key .Science = 88
	}
}

Operaciones de Colección

Los tipos anónimos destacan en escenarios que implican la manipulación de colecciones y la transformación de datos:

var items = new[] {
    new { ProductId = 1, Name = "Laptop", Price = 1200.00m },
    new { ProductId = 2, Name = "Mouse", Price = 25.99m },
    new { ProductId = 3, Name = "Keyboard", Price = 45.50m }
};

var items = new[] {
    new { ProductId = 1, Name = "Laptop", Price = 1200.00m },
    new { ProductId = 2, Name = "Mouse", Price = 25.99m },
    new { ProductId = 3, Name = "Keyboard", Price = 45.50m }
};

Dim items = {
	New With {
		Key .ProductId = 1,
		Key .Name = "Laptop",
		Key .Price = 1200.00D
	},
	New With {
		Key .ProductId = 2,
		Key .Name = "Mouse",
		Key .Price = 25.99D
	},
	New With {
		Key .ProductId = 3,
		Key .Name = "Keyboard",
		Key .Price = 45.50D
	}
}

IronPDF: C# Biblioteca PDF

IronPDFes una potente biblioteca para generar, editar y gestionar documentos PDF en aplicaciones .NET. Al trabajar con C#, los desarrolladores a menudo utilizan objetos anónimos para estructuras de datos ligeras y ad hoc, especialmente en escenarios donde no es necesario crear una clase completa. Estos objetos anónimos pueden ser utilizados sin problemas con IronPDF para crear documentos PDF dinámicamente. Ayuda a crear una solución flexible para flujos de trabajo de datos a PDF rápidos. Aquí tienes un ejemplo para ilustrar cómo funciona IronPDF con objetos anónimos:

Ejemplo: Uso de Objetos Anónimos para Rellenar un PDF

Imagina que tienes una lista de datos de ventas que deseas presentar como una tabla en un PDF. En lugar de crear una clase formal, puedes usar un objeto anónimo para formatear rápidamente los datos para su representación.

using IronPdf;
using System;
using System.Linq;
class Program
{
    static void Main()
    {
        License.LicenseKey = "Licenes-Key";
        // Sample data using anonymous objects
        var salesData = new[]
        {
            new { Product = "Laptop", Quantity = 2, Price = 1200.50 },
            new { Product = "Smartphone", Quantity = 5, Price = 800.00 },
            new { Product = "Headphones", Quantity = 10, Price = 150.75 }
        };
        // Create an HTML string dynamically using the anonymous object data
        var htmlContent = @"
        <html>
        <head><style>table {border-collapse: collapse;} th, td {border: 1px solid black; padding: 5px;}</style></head>
        <body>
        <h1>Sales Report</h1>
        <table>
            <thead>
                <tr>
                    <th>Product</th>
                    <th>Quantity</th>
                    <th>Price</th>
                </tr>
            </thead>
            <tbody>
                " +
            string.Join("", salesData.Select(item =>
                $"<tr><td>{item.Product}</td><td>{item.Quantity}</td><td>{item.Price:C}</td></tr>")) +
            @"
            </tbody>
        </table>
        </body>
        </html>";
        // Generate the PDF
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        // Save the PDF
        pdf.SaveAs("SalesReport.pdf");
        Console.WriteLine("PDF generated successfully!");
    }
}

using IronPdf;
using System;
using System.Linq;
class Program
{
    static void Main()
    {
        License.LicenseKey = "Licenes-Key";
        // Sample data using anonymous objects
        var salesData = new[]
        {
            new { Product = "Laptop", Quantity = 2, Price = 1200.50 },
            new { Product = "Smartphone", Quantity = 5, Price = 800.00 },
            new { Product = "Headphones", Quantity = 10, Price = 150.75 }
        };
        // Create an HTML string dynamically using the anonymous object data
        var htmlContent = @"
        <html>
        <head><style>table {border-collapse: collapse;} th, td {border: 1px solid black; padding: 5px;}</style></head>
        <body>
        <h1>Sales Report</h1>
        <table>
            <thead>
                <tr>
                    <th>Product</th>
                    <th>Quantity</th>
                    <th>Price</th>
                </tr>
            </thead>
            <tbody>
                " +
            string.Join("", salesData.Select(item =>
                $"<tr><td>{item.Product}</td><td>{item.Quantity}</td><td>{item.Price:C}</td></tr>")) +
            @"
            </tbody>
        </table>
        </body>
        </html>";
        // Generate the PDF
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        // Save the PDF
        pdf.SaveAs("SalesReport.pdf");
        Console.WriteLine("PDF generated successfully!");
    }
}

Imports IronPdf
Imports System
Imports System.Linq
Friend Class Program
	Shared Sub Main()
		License.LicenseKey = "Licenes-Key"
		' Sample data using anonymous objects
		Dim salesData = {
			New With {
				Key .Product = "Laptop",
				Key .Quantity = 2,
				Key .Price = 1200.50
			},
			New With {
				Key .Product = "Smartphone",
				Key .Quantity = 5,
				Key .Price = 800.00
			},
			New With {
				Key .Product = "Headphones",
				Key .Quantity = 10,
				Key .Price = 150.75
			}
		}
		' Create an HTML string dynamically using the anonymous object data
		Dim htmlContent = "
        <html>
        <head><style>table {border-collapse: collapse;} th, td {border: 1px solid black; padding: 5px;}</style></head>
        <body>
        <h1>Sales Report</h1>
        <table>
            <thead>
                <tr>
                    <th>Product</th>
                    <th>Quantity</th>
                    <th>Price</th>
                </tr>
            </thead>
            <tbody>
                " & String.Join("", salesData.Select(Function(item) $"<tr><td>{item.Product}</td><td>{item.Quantity}</td><td>{item.Price:C}</td></tr>")) & "
            </tbody>
        </table>
        </body>
        </html>"
		' Generate the PDF
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
		' Save the PDF
		pdf.SaveAs("SalesReport.pdf")
		Console.WriteLine("PDF generated successfully!")
	End Sub
End Class

Objeto anónimo de C# (Cómo funciona para los desarrolladores): Figura 1 - Salida de consola del ejemplo de código anterior

Conclusión

C# Objeto Anónimo (Cómo Funciona para Desarrolladores): Figura 2 - Página de Licencias de IronPDF

Los tipos anónimos en C# ofrecen una manera flexible y eficiente de crear estructuras de datos temporales sin la necesidad de declaraciones formales de clases. Son particularmente útiles cuando se trabaja con consultas LINQ, transformaciones de datos y bibliotecas como IronPDF. Combinar tipos anónimos con las capacidades de generación de PDF de IronPDF ofrece una potente solución para crear PDFs dinámicos y basados en datos con un mínimo de sobrecarga de código.

IronPDF permite a los desarrolladores probar sus características a través de unprueba gratuita, facilitando la exploración de sus capacidades en tus aplicaciones .NET. Las licencias comerciales comienzan en $749 y otorgan acceso a su conjunto completo de características, incluyendo el renderizado HTML a PDF de alto rendimiento, la edición de PDF y las funciones de seguridad.

Kannapat Udonpant

Ingeniero de software

LinkedIn

Antes de convertirse en ingeniero de software, Kannapat realizó un doctorado en Recursos Medioambientales en la Universidad de Hokkaido (Japón). Mientras cursaba su licenciatura, Kannapat también se convirtió en miembro del Laboratorio de Robótica Vehicular, que forma parte del Departamento de Ingeniería de Bioproducción. En 2022, aprovechó sus conocimientos de C# para unirse al equipo de ingeniería de Iron Software, donde se centra en IronPDF. Kannapat valora su trabajo porque aprende directamente del desarrollador que escribe la mayor parte del código utilizado en IronPDF. Además del aprendizaje entre iguales, Kannapat disfruta del aspecto social de trabajar en Iron Software. Cuando no está escribiendo código o documentación, Kannapat suele jugar con su PS5 o volver a ver The Last of Us.

< ANTERIOR
Parámetro de salida en C# (Cómo funciona: Una guía para desarrolladores)

SIGUIENTE >
C# Parallel Foreach (Cómo Funciona para Desarrolladores)