C# Anonymes Objekt (Wie es für Entwickler funktioniert)

Einführung des anonymen Objekts

Anonyme Typen in C# bieten einen Mechanismus, um öffentliche schreibgeschützte Eigenschaften in einem einzigen anonymen Typobjekt zu kapseln, ohne eine formelle Klassendeklaration explizit zu definieren. Es ist nützlich für die Struktur eines einzelnen Objekts. Es handelt sich um vom Compiler generierte Typen, die direkt von System.Object ableiten, Objekteigenschaften effizient kapseln und als leichtgewichtige, unveränderliche Datencontainer dienen. Diese Typen sind versiegelte Klassen, bei denen der Compiler automatisch den Typnamen ableitet und generiert, der auf Quellcode-Ebene unzugänglich bleibt. Wir werden auch entdeckenIronPDFals die PDF-Bibliothek für die .NET-Projekte.

Wichtige Merkmale

• Anonyme Typen sind in ihren Fähigkeiten streng begrenzt:
• Eigenschaften werden automatisch als öffentliche schreibgeschützte Eigenschaften in der Eigenschaftsdefinition eines anonymen Typs implementiert.
• Benutzer können innerhalb davon keine Methoden, Ereignisse oder andere Klassenmitglieder wie equals- und gethashcode-Methoden explizit definieren.
• Kann nicht mit Nullwerten, anonymen Funktionen oder Zeigertypen initialisiert werden, um die Integrität anonymer Typen zu gewährleisten.

Häufige Anwendungsfälle

LINQ-Operationen

Anonyme Datentyp-Objekte glänzen in LINQ-Abfrageausdrücken, insbesondere in Auswahlklauseln für anonyme Typobjekte, wo sie effizient spezifische Eigenschaftsteilmengen aus größeren Objekten zurückgeben. Dieser Ansatz optimiert den Speicherverbrauch, indem temporäre Objekte erstellt werden, die nur die erforderlichen Daten enthalten.

Temporäre Datengruppierung

Sie dienen als effiziente Container für temporäre Datenstrukturen, wenn das Erstellen einer formalen Klasse übertrieben wäre. Dies ist besonders nützlich für kurzlebige Datenumwandlungen oder Zwischenberechnungen.

Eigenschaftskapselung

Der anonyme Datentyp bietet eine saubere Möglichkeit, verwandte Objekteigenschaften mithilfe von schreibgeschützten Eigenschaften zusammenzufassen. Der Compiler stellt die Typsicherheit sicher und bewahrt dabei eine prägnante Syntax für den Zugriff auf Eigenschaften.

Syntax und Struktur

Die Erstellung von anonymen Typen folgt einem spezifischen Muster unter Verwendung des var-Schlüsselworts zusammen mit dem new-Operator und der Objekt-Initialisierer-Syntax. Der Compiler generiert automatisch einen Typnamen, der auf Quellcode-Ebene unzugänglich bleibt.

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
}

Regeln zur Eigenschaftsinitialisierung

Der Compiler erzwingt strenge Regeln für die Initialisierung von Eigenschaften in anonymen Typen. Alle Eigenschaften müssen während der Objekterstellung initialisiert werden und dürfen keine Nullwerte oder Zeigertypen zugewiesen bekommen. Nach der Initialisierung können Eigenschaftswerte eines anonymen Typs mittels standardmäßiger Punktnotation abgerufen werden, sie können jedoch aufgrund ihrer schreibgeschützten Natur nach der Initialisierung nicht mehr geändert werden.

Typinferenz und Abgleich

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
}

Der Compiler erzeugt identische Typinformationen für anonyme Typen mit übereinstimmenden Eigenschaftsnamen, Typen und Reihenfolge. Dies ermöglicht Typkompatibilität zwischen Instanzen, die in Sammlungen verwendet oder als Methodenparameter innerhalb derselben Assembly übergeben werden.

Verschachtelte anonyme Typen

Der anonyme Datentyp unterstützt komplexe verschachtelte Strukturen mit anonymen Objekteigenschaften. Es ist hilfreich für die Erstellung hierarchischer Datenrepräsentationen.

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
	}
}

Sammlungsoperationen

Anonyme Typen sind besonders geeignet für Szenarien, die die Manipulation von Sammlungen und die Transformation von Daten umfassen:

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# PDF-Bibliothek

IronPDFist eine leistungsstarke Bibliothek zum Erstellen, Bearbeiten und Verwalten von PDF-Dokumenten in .NET-Anwendungen. Bei der Arbeit mit C# verwenden Entwickler häufig anonyme Objekte für leichte und ad hoc Datenstrukturen, insbesondere in Szenarien, in denen es nicht notwendig ist, eine komplette Klasse zu erstellen. Diese anonymen Objekte können nahtlos mit IronPDF verwendet werden, umPDF-Dokumente dynamisch erstellen. Es hilft bei der Erstellung einer flexiblen Lösung für schnelle Daten-zu-PDF-Workflows. Hier ist ein Beispiel, um zu veranschaulichen, wie IronPDF mit anonymen Objekten funktioniert:

Beispiel: Verwenden anonymer Objekte, um ein PDF zu füllen

Stellen Sie sich vor, Sie haben eine Liste von Verkaufsdaten, die Sie als Tabelle in einem PDF darstellen möchten. Anstelle einer formalen Klasse können Sie ein anonymes Objekt verwenden, um die Daten schnell für die Darstellung zu formatieren.

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

Schlussfolgerung

Anonyme Typen in C# bieten eine flexible und effiziente Möglichkeit, temporäre Datenstrukturen zu erstellen, ohne dass formale Klassendeklarationen erforderlich sind. Sie sind besonders nützlich bei der Arbeit mit LINQ-Abfragen, Datentransformationen und Bibliotheken wie IronPDF. Die Kombination anonymer Typen mit den PDF-Generierungsfunktionen von IronPDF bietet eine leistungsstarke Lösung zur Erstellung dynamischer, datengetriebener PDFs mit minimalem Programmieraufwand.

IronPDF ermöglicht es Entwicklern, seine Funktionen durch einkostenloser Test, was es einfach macht, seine Möglichkeiten in Ihren .NET-Anwendungen zu erkunden. Kommerzielle Lizenzen beginnen bei 749 $ und gewähren Zugriff auf das vollständige Funktionsset, einschließlich hochleistungsfähiger HTML-zu-PDF-Darstellung, PDF-Bearbeitung und Sicherheitsfunktionen.