Was sind Generika in C#?

C#-Generika führen eine Möglichkeit ein, Klassen, Methoden, Schnittstellen und Delegates mit einem Typ-Parameter zu entwerfen. Dies ermöglicht die Erstellung von flexiblen und wiederverwendbaren Code-Komponenten, die Typensicherheit und Leistungsverbesserungen bieten.

Wie funktionieren generische Klassen in C#?

Eine generische Klasse in C# verwendet einen Typ-Parameter, oft als T bezeichnet, der als Platzhalter für den Typ dient, den sie enthält oder auf dem sie arbeitet. Dadurch kann die Klasse mit verschiedenen Datentypen instanziiert werden und dennoch die Typensicherheit beibehalten.

Können Sie ein Beispiel für eine generische Klasse in C# geben?

Ja, ein einfaches Beispiel ist eine Box -Klasse, die einen Wert eines beliebigen Typs speichert. Sie können Instanzen wie Box oder Box erstellen, um verschiedene Datentypen mit derselben Klasse zu speichern.

Was ist eine generische Methode in C#?

Eine generische Methode ist auf Methodenebene mit Typ-Parametern definiert, sodass sie auf verschiedenen Typen arbeiten kann. Sie kann Teil einer nicht-generischen oder einer generischen Klasse sein und bietet Flexibilität im Methodendesign.

Wie können generische Schnittstellen und Delegates in C# verwendet werden?

Generische Schnittstellen und Delegates erlauben die Definition von Verträgen und Rückrufmethoden, die mit beliebigen Typen arbeiten können, und erhöhen die Flexibilität und Wiederverwendbarkeit von Code.

Was sind die Vorteile der Verwendung von generischen Sammlungen in C#?

Generische Sammlungen wie List und Dictionary bieten eine typsichere und effiziente Speicherung für jeden spezifischen Typ, beseitigen die Notwendigkeit für Casting und reduzieren Laufzeitfehler.

Wie kann ich benutzerdefinierte generische Typen in C# erstellen?

Sie können benutzerdefinierte generische Typen erstellen, um Operationen zu kapseln, die über verschiedene Datentypen hinweg gemeinsam sind, aber auf eine typenspezifische Weise behandelt werden, was für den Bau von Bibliotheken oder Dienstprogrammen nützlich ist.

Wie können C#-Generika die PDF-Erstellung in .NET verbessern?

C#-Generika können mit einer PDF-Bibliothek verwendet werden, um flexible und wiederverwendbare Komponenten zu erstellen. Zum Beispiel kann eine PdfOptions -Klasse verwendet werden, um PDF-Erstellungsoptionen zu halten, was die Anpassungsfähigkeit von Generika mit PDF-Aufgaben demonstriert.

Wie kann eine PDF-Bibliothek mit C#-Generika genutzt werden?

Eine PDF-Bibliothek wie IronPDF kann C#-Generika verwenden, um ihre Funktionalität zu verbessern. Zum Beispiel könnte eine generische Methode verwendet werden, um HTML in PDF zu konvertieren, was einen flexiblen Ansatz zur Dokumentenerstellung bietet.

Was sind die Vorteile der Verwendung von C#-Generika?

C#-Generika ermöglichen die Wiederverwendung von Code über verschiedene Datentypen hinweg, gewährleisten die Typüberprüfung zur Kompilierzeit, reduzieren Laufzeitfehler und verbessern die allgemeine Codequalität. Sie ermöglichen das Schreiben von anpassbarem und pflegeleichtem Code.

Die C# PDF-Bibliothek

Explore IronPDF Gratis testen

HTML zu PDF

Online Demo Alle Codebeispiele anzeigen

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

ENTWICKLER-UPDATES

C# Generics (Funktionsweise für Entwickler)

Jacob Mellor

Updated: 19. Juli 2026

C#-Generika führen eine Möglichkeit ein, Klassen, Methoden, Schnittstellen und Delegaten zu entwerfen, bei denen der Datentyp, den sie verwalten, als Parameter angegeben werden kann. Dieses Konzept, bekannt als generischer Typ-Parameter, ermöglicht die Erstellung flexibler und wiederverwendbarer Codekomponenten. Durch die Verwendung von Generika können Sie die Code-Wiederverwendbarkeit, Typsicherheit und Leistung maximieren. - Private: Eigenschaften oder Felder, die private deklariert sind, können nur innerhalb der definierten Klasse zugegriffen werden, zum Beispiel private int age. In diesem Artikel lernen wir die Grundlagen der C#-Generika und IronPDF-Bibliotheksfunktionen zur PDF-Manipulation kennen.

Grundlagen der generischen Klassen

Eine generische Klasse in C# ist ein Bauplan zur Erstellung einer Klasse mit einem Platzhalter für den Typ, den sie enthält oder auf dem sie arbeitet. Dieser Platzhalter, oft mit T bezeichnet, stellt einen Typ-Parameter dar, der angegeben wird, wenn die Klasse instanziiert wird. Wir können generische Klassen mit Typ-Parameter T erstellen, um verschiedene Datentypen zu handhaben. Generische Klassen sind besonders nützlich für Sammlungs-Klassen wie Listen, Warteschlangen und Hashtabellen, da sie jeden Datentyp aufnehmen können, während sie gleichzeitig Typsicherheit gewährleisten und den Bedarf an Typumwandlungen verringern.

Einfaches Beispiel für eine generische Klasse

Betrachten Sie eine generische Klasse namens Box, die entworfen wurde, um einen Wert eines beliebigen Typs zu speichern:

public class Box<t>
{
    private T data;

    public Box(T data)
    {
        this.data = data;
    }

    public T Data
    {
        get { return data; }
    }
}

public class Box<t>
{
    private T data;

    public Box(T data)
    {
        this.data = data;
    }

    public T Data
    {
        get { return data; }
    }
}

Public Class Box(Of T)
    Private data As T

    Public Sub New(data As T)
        Me.data = data
    End Sub

    Public ReadOnly Property Data As T
        Get
            Return data
        End Get
    End Property
End Class

Public Class Box(Of T)
    Private data As T

    Public Sub New(data As T)
        Me.data = data
    End Sub

    Public ReadOnly Property Data As T
        Get
            Return data
        End Get
    End Property
End Class

Um diese Klasse zu verwenden, erstellen Sie eine Instanz, die den tatsächlichen Typ für T angibt:

Box<int> integerBox = new Box<int>(123);
Box<string> stringBox = new Box<string>("Hello");

Box<int> integerBox = new Box<int>(123);
Box<string> stringBox = new Box<string>("Hello");

Dim integerBox As New Box(Of Integer)(123)
Dim stringBox As New Box(Of String)("Hello")

Dim integerBox As New Box(Of Integer)(123)
Dim stringBox As New Box(Of String)("Hello")

Dieser Code veranschaulicht, wie eine einzelne Klasse (Box) sich anpassen kann, um verschiedene Datentypen zu speichern (int, string), und zeigt die Leistungsfähigkeit von Generika für Code-Wiederverwendung und Typsicherheit auf.

Implementierung generischer Methoden

Generische Methoden sind ähnlich wie generische Klassen, werden jedoch mit Typ-Parametern auf der Methodenebene definiert. Dies ermöglicht die Erstellung von Methoden, die auf verschiedenen Typen operieren können, während sie in einer nicht-generischen Klasse oder einer generischen Klasse definiert sind.

Beispiel für eine generische Methode

Hier ist eine Methode, die zwei Elemente in einem Array eines beliebigen Typs vertauscht:

public class Utility
{
    // Swaps two elements by reference using generics
    public static void Swap<t>(ref T lhs, ref T rhs)
    {
        T temp = lhs; // Store lhs in a temporary variable
        lhs = rhs;    // Assign rhs to lhs
        rhs = temp;   // Assign temp (original lhs) to rhs
    }
}

public class Utility
{
    // Swaps two elements by reference using generics
    public static void Swap<t>(ref T lhs, ref T rhs)
    {
        T temp = lhs; // Store lhs in a temporary variable
        lhs = rhs;    // Assign rhs to lhs
        rhs = temp;   // Assign temp (original lhs) to rhs
    }
}

Public Class Utility
    ' Swaps two elements by reference using generics
    Public Shared Sub Swap(Of T)(ByRef lhs As T, ByRef rhs As T)
        Dim temp As T = lhs ' Store lhs in a temporary variable
        lhs = rhs ' Assign rhs to lhs
        rhs = temp ' Assign temp (original lhs) to rhs
    End Sub
End Class

Public Class Utility
    ' Swaps two elements by reference using generics
    Public Shared Sub Swap(Of T)(ByRef lhs As T, ByRef rhs As T)
        Dim temp As T = lhs ' Store lhs in a temporary variable
        lhs = rhs ' Assign rhs to lhs
        rhs = temp ' Assign temp (original lhs) to rhs
    End Sub
End Class

Die Verwendung der obigen Methode kann wie folgt aussehen:

int a = 1, b = 2;
Utility.Swap<int>(ref a, ref b);

string first = "world", second = "hello";
Utility.Swap(ref first, ref second);

int a = 1, b = 2;
Utility.Swap<int>(ref a, ref b);

string first = "world", second = "hello";
Utility.Swap(ref first, ref second);

Dim a As Integer = 1, b As Integer = 2
Utility.Swap(Of Integer)(a, b)

Dim first As String = "world", second As String = "hello"
Utility.Swap(first, second)

Dim a As Integer = 1, b As Integer = 2
Utility.Swap(Of Integer)(a, b)

Dim first As String = "world", second As String = "hello"
Utility.Swap(first, second)

Erforschung von generischen Schnittstellen und Delegaten

Generische Schnittstellen und Delegaten ermöglichen die Definition von Verträgen und Rückrufmethoden, die mit jedem Typ arbeiten können. Die Implementierung einer generischen Schnittstelle oder eines Delegaten in Ihrer Klasse/Methode verbessert Flexibilität und Wiederverwendbarkeit.

Beispiel für eine generische Schnittstelle

Eine generische Repository-Schnittstelle für Datenzugriffsoperationen könnte so aussehen:

public interface IRepository<t>
{
    void Add(T item);
    T GetById(int id);
    IEnumerable<t> GetAll();
}

public interface IRepository<t>
{
    void Add(T item);
    T GetById(int id);
    IEnumerable<t> GetAll();
}

Public Interface IRepository(Of T)
    Sub Add(item As T)
    Function GetById(id As Integer) As T
    Function GetAll() As IEnumerable(Of T)
End Interface

Public Interface IRepository(Of T)
    Sub Add(item As T)
    Function GetById(id As Integer) As T
    Function GetAll() As IEnumerable(Of T)
End Interface

Diese Schnittstelle kann von jeder Klasse implementiert werden, um spezifische Datentypen zu handhaben, was konsistente Datenzugriffsmuster für verschiedene Typen ermöglicht.

Generisches Delegate-Beispiel

Ein generischer Delegat könnte verwendet werden, um einen typsicheren Rückruf zu definieren:

public delegate void Action<t>(T item);

public delegate void Action<t>(T item);

Public Delegate Sub Action(Of T)(item As T)

Public Delegate Sub Action(Of T)(item As T)

Nutzung generischer Sammlungen

Generische Sammlungsklassen, wie List, Dictionary<TKey, TValue> und andere im System.Collections.Generic-Namensraum, bieten typsichere, effiziente Sammlungen zum Speichern und Manipulieren von Daten eines bestimmten Typs. Diese Sammlungen sind ihren nicht-generischen Gegenstücken überlegen, weil sie die Notwendigkeit von Typumwandlungen eliminieren und Laufzeitfehler reduzieren.

List<string> names = new List<string>();
names.Add("Alice");
names.Add("Bob");

Dictionary<int, string> keyValuePairs = new Dictionary<int, string>();
keyValuePairs.Add(1, "One");
keyValuePairs.Add(2, "Two");

List<string> names = new List<string>();
names.Add("Alice");
names.Add("Bob");

Dictionary<int, string> keyValuePairs = new Dictionary<int, string>();
keyValuePairs.Add(1, "One");
keyValuePairs.Add(2, "Two");

Dim names As New List(Of String)()
names.Add("Alice")
names.Add("Bob")

Dim keyValuePairs As New Dictionary(Of Integer, String)()
keyValuePairs.Add(1, "One")
keyValuePairs.Add(2, "Two")

Dim names As New List(Of String)()
names.Add("Alice")
names.Add("Bob")

Dim keyValuePairs As New Dictionary(Of Integer, String)()
keyValuePairs.Add(1, "One")
keyValuePairs.Add(2, "Two")

Benutzerdefinierte generische Typen erstellen

Neben der Verwendung integrierter generischer Typen können Sie Ihre eigenen erstellen, um Operationen zu kapseln, die für verschiedene Datentypen gemeinsam sind, aber auf typspezifische Weise behandelt werden müssen. Dieser Ansatz ist besonders nützlich für den Bau von Bibliotheken, Frameworks oder Dienstprogrammen, die mit verschiedenen Datentypen verwendet werden sollen.

Beispiel für einen benutzerdefinierten generischen Typ

Betrachten Sie eine generische Result-Klasse, die Operationsergebnisse zusammen mit einem Erfolgsflag und einer optionalen Nachricht kapselt:

public class Result<t>
{
    public bool Success { get; private set; }
    public T Data { get; private set; }
    public string Message { get; private set; }

    public Result(bool success, T data, string message = "")
    {
        Success = success;
        Data = data;
        Message = message;
    }
}

public class Result<t>
{
    public bool Success { get; private set; }
    public T Data { get; private set; }
    public string Message { get; private set; }

    public Result(bool success, T data, string message = "")
    {
        Success = success;
        Data = data;
        Message = message;
    }
}

Public Class Result(Of T)
    Public ReadOnly Property Success As Boolean
    Public ReadOnly Property Data As T
    Public ReadOnly Property Message As String

    Public Sub New(success As Boolean, data As T, Optional message As String = "")
        Me.Success = success
        Me.Data = data
        Me.Message = message
    End Sub
End Class

Public Class Result(Of T)
    Public ReadOnly Property Success As Boolean
    Public ReadOnly Property Data As T
    Public ReadOnly Property Message As String

    Public Sub New(success As Boolean, data As T, Optional message As String = "")
        Me.Success = success
        Me.Data = data
        Me.Message = message
    End Sub
End Class

IronPDF: C# PDF-Bibliothek

IronPDF ist eine umfassende Bibliothek, die für .NET-Entwickler entwickelt wurde, um PDF-Dokumente innerhalb ihrer Anwendungen zu erstellen, zu bearbeiten und zu extrahieren. IronPDF hilft beim Erstellen von PDFs aus HTML, Bearbeiten bestehender PDFs, Umwandeln von PDFs in Bilder und vielem mehr. Obwohl IronPDF selbst nicht auf Generika basiert, kann das Verständnis, wie man mit dieser Bibliothek in einer C#-Umgebung interagiert, die Dokumentenverwaltungsfähigkeiten Ihrer Anwendung erheblich verbessern.

Code-Beispiel: Verwendung des virtuellen Schlüsselworts mit IronPDF

Die Idee hinter der Verwendung von Generika hier ist es, eine wiederverwendbare Methode zu erstellen, die ein PDF aus einem beliebigen HTML-String generieren kann. Diese Methode wird generisch sein, sodass wir verschiedene Arten von Metadaten oder Konfigurationen nach Bedarf angeben können.

Lassen Sie uns zunächst eine einfache generische Klasse definieren, die unsere PDF-Erstellungsoptionen enthält. Zu Demonstrationszwecken wird diese Klasse grundlegend sein, aber Sie können sie mit mehr Eigenschaften erweitern, um Ihre Anforderungen zu erfüllen.

public class PdfOptions<t>
{
    public T Metadata { get; set; }
    public string HtmlContent { get; set; }
}

public class PdfOptions<t>
{
    public T Metadata { get; set; }
    public string HtmlContent { get; set; }
}

Public Class PdfOptions(Of T)
    Public Property Metadata As T
    Public Property HtmlContent As String
End Class

Public Class PdfOptions(Of T)
    Public Property Metadata As T
    Public Property HtmlContent As String
End Class

Nun, lassen Sie uns eine statische Methode erstellen, die ein PDF mit IronPDF generiert, unter Ausnutzung unserer PdfOptions Klasse. Diese Methode wird eine Instanz von PdfOptions als Parameter nehmen und die Verwendung von Generika in Aktion zeigen.

using IronPdf; // Make sure to include the necessary namespace for IronPDF

public static class PdfGenerator
{
    // Generates a PDF from provided HTML content and options
    public static void GeneratePdf<t>(PdfOptions<t> options)
    {
        // Initialize the IronPDF HtmlToPdf renderer
        var renderer = new ChromePdfRenderer();

        // Optional: Apply any renderer options here, for example, setting the paper size
        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;

        // Generate the PDF from HTML content
        var pdfDocument = renderer.RenderHtmlAsPdf(options.HtmlContent);

        // Optional: Here, you can use options.Metadata in some way, depending on your generic type T
        // For simplicity, we're just printing the metadata to console if it's of type string
        if (options.Metadata is string metadataString)
        {
            Console.WriteLine($"Metadata: {metadataString}");
        }

        // Save the PDF to a file
        var fileName = $"GeneratedPdf_{DateTime.Now.Ticks}.pdf";
        pdfDocument.SaveAs(fileName);
        Console.WriteLine($"PDF generated and saved as {fileName}");
    }
}

using IronPdf; // Make sure to include the necessary namespace for IronPDF

public static class PdfGenerator
{
    // Generates a PDF from provided HTML content and options
    public static void GeneratePdf<t>(PdfOptions<t> options)
    {
        // Initialize the IronPDF HtmlToPdf renderer
        var renderer = new ChromePdfRenderer();

        // Optional: Apply any renderer options here, for example, setting the paper size
        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;

        // Generate the PDF from HTML content
        var pdfDocument = renderer.RenderHtmlAsPdf(options.HtmlContent);

        // Optional: Here, you can use options.Metadata in some way, depending on your generic type T
        // For simplicity, we're just printing the metadata to console if it's of type string
        if (options.Metadata is string metadataString)
        {
            Console.WriteLine($"Metadata: {metadataString}");
        }

        // Save the PDF to a file
        var fileName = $"GeneratedPdf_{DateTime.Now.Ticks}.pdf";
        pdfDocument.SaveAs(fileName);
        Console.WriteLine($"PDF generated and saved as {fileName}");
    }
}

Imports IronPdf ' Make sure to include the necessary namespace for IronPDF

Public Module PdfGenerator
    ' Generates a PDF from provided HTML content and options
    Public Sub GeneratePdf(Of T)(options As PdfOptions(Of T))
        ' Initialize the IronPDF HtmlToPdf renderer
        Dim renderer As New ChromePdfRenderer()

        ' Optional: Apply any renderer options here, for example, setting the paper size
        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4

        ' Generate the PDF from HTML content
        Dim pdfDocument = renderer.RenderHtmlAsPdf(options.HtmlContent)

        ' Optional: Here, you can use options.Metadata in some way, depending on your generic type T
        ' For simplicity, we're just printing the metadata to console if it's of type string
        If TypeOf options.Metadata Is String Then
            Dim metadataString As String = CType(options.Metadata, String)
            Console.WriteLine($"Metadata: {metadataString}")
        End If

        ' Save the PDF to a file
        Dim fileName As String = $"GeneratedPdf_{DateTime.Now.Ticks}.pdf"
        pdfDocument.SaveAs(fileName)
        Console.WriteLine($"PDF generated and saved as {fileName}")
    End Sub
End Module

Imports IronPdf ' Make sure to include the necessary namespace for IronPDF

Public Module PdfGenerator
    ' Generates a PDF from provided HTML content and options
    Public Sub GeneratePdf(Of T)(options As PdfOptions(Of T))
        ' Initialize the IronPDF HtmlToPdf renderer
        Dim renderer As New ChromePdfRenderer()

        ' Optional: Apply any renderer options here, for example, setting the paper size
        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4

        ' Generate the PDF from HTML content
        Dim pdfDocument = renderer.RenderHtmlAsPdf(options.HtmlContent)

        ' Optional: Here, you can use options.Metadata in some way, depending on your generic type T
        ' For simplicity, we're just printing the metadata to console if it's of type string
        If TypeOf options.Metadata Is String Then
            Dim metadataString As String = CType(options.Metadata, String)
            Console.WriteLine($"Metadata: {metadataString}")
        End If

        ' Save the PDF to a file
        Dim fileName As String = $"GeneratedPdf_{DateTime.Now.Ticks}.pdf"
        pdfDocument.SaveAs(fileName)
        Console.WriteLine($"PDF generated and saved as {fileName}")
    End Sub
End Module

Schließlich verwenden wir unsere PdfGenerator-Klasse, um ein PDF-Dokument zu erstellen. In diesem Beispiel könnte die Metadata-Eigenschaft eine Zeichenkette enthalten, die einen Titel oder andere relevante Informationen bereitstellt.

class Program
{
    static void Main(string[] args)
    {
        // Set the license key for IronPDF if needed
        License.LicenseKey = "Your-License-Key-Here";

        // Create PDF options with HTML content and metadata
        var options = new PdfOptions<string>
        {
            HtmlContent = "<h1>Hello, World!</h1><p>This is a test PDF document generated from HTML.</p>",
            Metadata = "Test PDF Title"
        };

        // Generate the PDF using the specified options
        PdfGenerator.GeneratePdf(options);
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Set the license key for IronPDF if needed
        License.LicenseKey = "Your-License-Key-Here";

        // Create PDF options with HTML content and metadata
        var options = new PdfOptions<string>
        {
            HtmlContent = "<h1>Hello, World!</h1><p>This is a test PDF document generated from HTML.</p>",
            Metadata = "Test PDF Title"
        };

        // Generate the PDF using the specified options
        PdfGenerator.GeneratePdf(options);
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Set the license key for IronPDF if needed
		License.LicenseKey = "Your-License-Key-Here"

		' Create PDF options with HTML content and metadata
		Dim options = New PdfOptions(Of String) With {
			.HtmlContent = "<h1>Hello, World!</h1><p>This is a test PDF document generated from HTML.</p>",
			.Metadata = "Test PDF Title"
		}

		' Generate the PDF using the specified options
		PdfGenerator.GeneratePdf(options)
	End Sub
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Set the license key for IronPDF if needed
		License.LicenseKey = "Your-License-Key-Here"

		' Create PDF options with HTML content and metadata
		Dim options = New PdfOptions(Of String) With {
			.HtmlContent = "<h1>Hello, World!</h1><p>This is a test PDF document generated from HTML.</p>",
			.Metadata = "Test PDF Title"
		}

		' Generate the PDF using the specified options
		PdfGenerator.GeneratePdf(options)
	End Sub
End Class

Dieses Beispiel veranschaulicht die Grundlagen der Integration von IronPDF mit C#-Generika und bietet eine flexible Möglichkeit zur PDF-Erstellung aus HTML-Inhalten, während anpassbare Metadaten oder Konfigurationen durch die generische PdfOptions-Klasse ermöglicht werden. Sie können dies erweitern, indem Sie ausgefeiltere Optionen und Renderer-Konfigurationen hinzufügen, die für Ihre Anwendung erforderlich sind.

C# Generics (so funktioniert es für Entwickler): Abbildung 1 - Beispielcode-Ausgabe unter Verwendung von Generics zur Erstellung eines PDF-Dokuments aus einem HTML-String mit IronPDF

Abschluss

C#-Generika sind ein leistungsfähiges Werkzeug zur Entwicklung von hochwertigem, wiederverwendbarem und typsicherem Code. Durch das Verstehen und Anwenden generischer Klassen, Methoden, Schnittstellen und Delegaten können Sie Code schreiben, der anpassungsfähiger und leichter zu warten ist. Generika ermöglichen nicht nur die Wiederverwendung von Code über verschiedene Datentypen hinweg, sondern stellen auch die Typüberprüfung zur Kompilierzeit sicher, was Laufzeitfehler reduziert und die Gesamtqualität des Codes verbessert. IronPDF bietet eine kostenlose Testversion seiner PDF-Bibliotheks-Tools an, mit Kosten ab $999.

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 Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.

...