Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. C# Anonyme Objekte
.NET HILFE

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

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

Einführung von Anonymous Object

Anonyme Typen in C# bieten einen Mechanismus, um öffentliche schreibgeschützte Eigenschaften in einem einzelnen anonymen Typobjekt zu kapseln, ohne eine formale Klassendeklaration explizit festzulegen. Sie sind nützlich für die Erstellung von Einweg-Datenstrukturen. Diese sind vom Compiler generierte Typen, die direkt von System.Object abgeleitet sind und Objekteigenschaften effizient kapseln und als leichte, unveränderliche Datencontainer dienen. Diese Typen sind versiegelte Klassen, bei denen der Compiler den Typnamen automatisch ableitet und generiert, der auf der Quellcodeebene unzugänglich bleibt. Wir werden auch IronPDF als PDF-Bibliothek für .NET-Projekte entdecken.

Wichtige Merkmale

  • Anonyme Typen haben streng begrenzte Fähigkeiten:
  • Eigenschaften werden innerhalb der Eigenschaftendefinition eines anonymen Typs automatisch als öffentliche schreibgeschützte implementiert.
  • Benutzer können innerhalb dieser keine Methoden, Ereignisse oder andere Klassenmitglieder wie Equals oder GetHashCode-Methoden explizit definieren.
  • Können nicht mit Nullwerten, anonymen Funktionen oder Zeigertypen initialisiert werden, um die Integrität anonymer Typen zu gewährleisten.

Gängige Anwendungsfälle

LINQ-Vorgänge

Anonyme Datentyp-Objekte glänzen in LINQ-Abfrageausdrücken, insbesondere in Select-Klauseln für anonyme Typobjekte, in denen sie effizient spezifische Eigenschaftsuntergruppen aus größeren Objekten zurückgeben. Dieser Ansatz optimiert die Speichernutzung durch die Erstellung temporärer Objekte, die nur die notwendigen Daten enthalten.

Temporäre Datengruppierung

Sie dienen als effiziente Container für temporäre Datenstrukturen, wenn die Erstellung einer formalen Klasse überflüssig wäre. Dies ist besonders nützlich für kurzlebige Datentransformationen oder Zwischenberechnungen.

Eigenschaftskapselung

Der anonyme Datentyp bietet eine klare Methode, um verwandte Objekteigenschaften mit schreibgeschützten Eigenschaften zu bündeln. Der Compiler gewährleistet Typsicherheit, während er eine prägnante Syntax für den Eigenschaftszugriff beibehält.

Syntax und Struktur

Die Erstellung anonymer Typen folgt einem bestimmten Muster unter Verwendung des var-Schlüsselworts zusammen mit dem new-Operator und der Objektinitialisierungssyntax. Der Compiler generiert automatisch einen Typnamen, der auf der Quellcodeebene 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
}
$vbLabelText   $csharpLabel

Eigenschaftsinitialisierungsregeln

Der Compiler erzwingt strenge Regeln für die Eigenschaftsinitialisierung in anonymen Typen. Alle Eigenschaften müssen während der Objekterstellung initialisiert werden und können nicht mit Nullwerten oder Zeigertypen zugewiesen werden. Einmal initialisieren, können Eigenschaftswerte mit der Standardpunktnotation abgerufen werden, aber sie können aufgrund ihrer schreibgeschützten Natur nach der Initialisierung nicht geändert werden.

Typ-Inferenz und Matching

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
}
$vbLabelText   $csharpLabel

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

Anonyme verschachtelte Typen

Anonyme Datentypen unterstützen komplexe verschachtelte Strukturen mit anonymen Typ-Objekteigenschaften. Dies 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
	}
}
$vbLabelText   $csharpLabel

Sammlungsoperationen

Anonyme Typen glänzen in Szenarien, die die Manipulation von Sammlungen und Datenumwandlung beinhalten:

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
	}
}
$vbLabelText   $csharpLabel

IronPDF: C# PDF-Bibliothek

IronPDF ist 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 für Szenarien, in denen die Erstellung einer gesamten Klasse nicht notwendig ist. Diese anonymen Objekte können nahtlos mit IronPDF genutzt werden, um dynamisch PDF-Dokumente zu erstellen. Es hilft bei der Erstellung einer flexiblen Lösung für schnelle Daten-zu-PDF-Workflows. Hier ist ein Beispiel zur Veranschaulichung, wie IronPDF mit anonymen Objekten arbeitet:

Beispiel: Verwendung von anonymen Objekten zum Auffüllen einer PDF-Datei

Stellen Sie sich vor, Sie haben eine Liste von Verkaufsdaten, die Sie als Tabelle in einem PDF wiedergeben möchten. Anstatt eine formale Klasse zu erstellen, 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()
    {
        // Set your IronPDF license key here
        License.LicenseKey = "Your-Licence-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()
    {
        // Set your IronPDF license key here
        License.LicenseKey = "Your-Licence-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()
		' Set your IronPDF license key here
		License.LicenseKey = "Your-Licence-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
$vbLabelText   $csharpLabel

C# Anonymous Object (Wie es für Entwickler funktioniert): Abbildung 1 - Konsolenausgabe aus dem obigen Codebeispiel

Abschluss

C# Anonymous Object (Wie es für Entwickler funktioniert): Abbildung 2 - IronPDF Licensing Page

Anonyme Typen in C# bieten eine flexible und effiziente Methode zur Erstellung temporärer Datenstrukturen, ohne die Notwendigkeit für formale Klassendeklarationen. Sie sind besonders nützlich bei der Arbeit mit LINQ-Abfragen, Datenumwandlungen und Bibliotheken wie IronPDF. Die Kombination anonymer Typen mit den PDF-Erstellungsfunktionen von IronPDF bietet eine leistungsstarke Lösung zur Erstellung dynamischer, datengetriebener PDFs mit minimalem Codeaufwand.

IronPDF ermöglicht es Entwicklern, seine Funktionen über eine kostenlose Testversion auszuprobieren, was es einfach macht, seine Möglichkeiten in Ihren .NET-Anwendungen zu erforschen. Kommerzielle Lizenzen beginnen bei $799 und gewähren Zugriff auf das vollständige Funktionsspektrum, einschließlich leistungsstarker HTML-zu-PDF-Konvertierung, PDF-Bearbeitung und Sicherheitsfunktionen.

Häufig gestellte Fragen

Was sind anonyme Typen in C#?

Anonyme Typen in C# bieten einen Mechanismus, um öffentliche schreibgeschützte Eigenschaften in einem einzigen anonymen Typobjekt zu kapseln, ohne eine formale Klassendeklaration explizit zu definieren. Sie sind kompilererstellte Typen, die als leichte, unveränderliche Datencontainer verwendet werden.

Wie kann ich einen anonymen Typ in C# erstellen?

Um einen anonymen Typ in C# zu erstellen, verwendet man das var-Schlüsselwort mit dem new-Operator und einer Objektinitialisierersyntax. Der Compiler generiert automatisch den Typnamen und die Struktur basierend auf den angegebenen Eigenschaften.

Wie funktionieren anonyme Typen mit LINQ-Operationen in C#?

Anonyme Typen glänzen in LINQ-Abfrageausdrücken, insbesondere in den select-Klauseln, indem sie effizient spezifische Eigenschaftsuntergruppen aus größeren Objekten zurückgeben und so den Speicherverbrauch optimieren.

Können anonyme Typen in verschachtelten Strukturen verwendet werden?

Ja, anonyme Typen können in verschachtelten Strukturen verwendet werden. Dies ermöglicht die Erstellung hierarchischer Datenrepräsentationen, bei denen Eigenschaften eines anonymen Typs selbst anonyme Typobjekte sein können.

Wie kann ich anonyme Objekte verwenden, um dynamische PDFs zu erstellen?

Anonyme Objekte können Daten schnell zum Rendern in dynamischen PDFs formatieren. Durch die Kombination mit einer PDF-Bibliothek wie IronPDF können Sie effizient PDFs mit minimalem Code erzeugen.

Was sind die Einschränkungen anonymer Typen in C#?

Anonyme Typen sind auf öffentliche, schreibgeschützte Eigenschaften beschränkt und können keine Methoden, Ereignisse oder explizit definierten Klassenmitglieder haben. Sie können auch nicht mit Nullwerten oder Zeigertypen initialisiert werden.

Was sind die häufigsten Anwendungsfälle für anonyme Typen?

Häufige Anwendungsfälle für anonyme Typen umfassen temporäre Datenzusammenfassung, Kapselung von Eigenschaften und Sammlungsoperationen, bei denen die Erstellung einer formalen Klasse überflüssig wäre.

Wie können PDF-Bibliotheken Daten-zu-PDF-Workflows in .NET-Anwendungen verbessern?

PDF-Bibliotheken bieten robuste Werkzeuge für die Erstellung, Bearbeitung und Verwaltung von PDF-Dokumenten innerhalb von .NET-Anwendungen und erleichtern effiziente Daten-zu-PDF-Workflows und verbessern datengesteuerte Lösungen.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen