Was ist ein Indexer in C#?

Ein Indexer in C# ist eine spezielle Art von Eigenschaft, die es Instanzen einer Klasse oder Struktur ermöglicht, mit dem Array-Zugriffsoperator [] zugegriffen zu werden. Es bietet eine Möglichkeit, Instanzen einer Klasse wie Arrays zu verwenden.

Wie deklariert man einen grundlegenden Indexer in C#?

Ein grundlegender Indexer in C# wird mit dem Schlüsselwort 'this' gefolgt von der Indexer-Deklaration deklariert. Sie müssen die Parameter- und Rückgabetypen angeben. Zum Beispiel: public return_type this[parameter_type index] { get; set; } .

Was ist der Zweck der 'get'- und 'set'-Zugriffsmethoden in einem Indexer?

Die 'get'-Zugriffsmethode in einem Indexer wird verwendet, um Daten an einem angegebenen Index abzurufen, während die 'set'-Zugriffsmethode verwendet wird, um Daten an einem angegebenen Index zuzuweisen. Sie funktionieren ähnlich wie Eigenschaftszugriffsmethoden, werden jedoch für Datensammlungen verwendet.

Können Sie ein Beispiel für einen Indexer in einer C# Klasse geben?

Sicher. Betrachten Sie eine Klasse 'Program' mit einem privaten String-Array. Der Indexer ermöglicht den Zugriff auf dieses Array mit einem ganzzahligen Index. Zum Beispiel: public string this[int index] { get { return values[index]; } set { values[index] = value; } } .

Wie erstellt man einen generischen Indexer in C#?

Ein generischer Indexer in C# kann innerhalb einer generischen Klasse erstellt werden. Zum Beispiel enthält die Klasse GenericClass einen Indexer, der mit jedem Datentyp umgehen kann. Der Indexer wird als public T this[int index] { get; set; } deklariert.

Wie kann man Indexer in C# verwenden, um die PDF-Generierung zu optimieren?

Mit einer Bibliothek wie IronPDF können Sie Indexer verwenden, um HTML-Vorlagen zu verwalten und zuzugreifen, die innerhalb einer Klasse gespeichert sind und dann in PDF-Dokumente umgewandelt werden. Dieser Ansatz vereinfacht das Generieren dynamischer PDFs aus mehreren HTML-Quellen.

Können Sie ein Beispiel für die Nutzung einer PDF-Bibliothek mit einem Indexer geben?

Sicherlich. Sie können eine Klasse erstellen, die HTML-Vorlagen in einem Array hält und einen Indexer verwendet, um auf diese Vorlagen zuzugreifen. Anschließend verwenden Sie eine PDF-Bibliothek, um diese HTML-Strings als PDF-Dokumente zu rendern. Beispielsweise verwendet eine Klasse namens PdfGenerator einen Indexer, um auf HTML zuzugreifen und PDFs zu generieren.

Welche Vorteile bietet die Verwendung von Indexern in C#?

Indexer in C# bieten eine vereinfachte Syntax für den Zugriff auf Elemente in einer Sammlung, wodurch Ihr Code intuitiver und lesbarer wird. Sie ermöglichen es Klassen und Strukturen, sich wie Arrays zu verhalten und ermöglichen eine effiziente Kapselung und den Zugriff auf Daten.

Wie können Indexer helfen, dynamische Datenstrukturen in C# zu erstellen?

Indexer ermöglichen es Entwicklern, dynamische Datenstrukturen zu erstellen, indem sie Sammlungen den Zugriff und die Modifikation mit einer arrays ähnlichen Syntax ermöglichen. Dies kann besonders in Szenarien nützlich sein, in denen Daten flexibel verwaltet werden müssen, z. B. bei der Generierung dynamischer PDF-Inhalte.

How can developers start using IronPDF?

Developers can start with a free trial of IronPDF, offering full access to its features, and later purchase a license if satisfied with the functionality.

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# Indexer (So funktioniert es für Entwickler)

Jacob Mellor

Updated: 19. Juli 2026

Ein Indexer in C# ist ein spezieller Typ von Eigenschaft, der es ermöglicht, auf Instanzen einer Klasse oder Struktur mit dem Array-Zugriffsoperator [] zuzugreifen. Indexer können sehr nützlich sein, um "intelligente Arrays" zu erstellen oder Daten in einer vereinfachten Syntax zu kapseln. Sie bieten eine Möglichkeit, Instanzen einer Klasse so zu verwenden, wie Sie Arrays verwenden würden, wobei Sie auf Daten über einen Index zugreifen können. Dieser Artikel wird untersuchen, wie man C#-Indexer mit praktischen Beispielen deklariert und verwendet. Und wir werden am Ende des Artikels auch die IronPDF-Bibliothek erkunden.

Basische Indexer-Syntax

Ein Indexer ist ein Instanzmitglied, das das Schlüsselwort this in einer Klasse oder Struktur verwendet, gefolgt von der Indexerdeklaration. Sie geben auch die Parametertypen und den Rückgabetyp an. Die allgemeine Syntax für ein Indexer-Instanzmitglied sieht so aus:

public return_type this[parameter_type index]
{
    get
    {
        // Code to return data
    }
    set
    {
        // Code to set data
    }
}

public return_type this[parameter_type index]
{
    get
    {
        // Code to return data
    }
    set
    {
        // Code to set data
    }
}

Default Public Property Item(ByVal index As parameter_type) As return_type
	Get
		' Code to return data
	End Get
	Set(ByVal value As return_type)
		' Code to set data
	End Set
End Property

Default Public Property Item(ByVal index As parameter_type) As return_type
	Get
		' Code to return data
	End Get
	Set(ByVal value As return_type)
		' Code to set data
	End Set
End Property

Hier ist return_type der Werttyp, den der Indexer zurückgeben wird, wie zum Beispiel ein ganzzahliger Wert, und parameter_type ist der Typ des Indexes, oft ein int. Der get-Accessor gibt den Wert am angegebenen Index zurück, und der set-Blockcode-Accessor weist diesem Index einen Wert zu.

Indexer Erklärung und Verwendung

Wir werden eine grundlegende Darstellung der Implementierung eines Indexers in einer C#-Klasse untersuchen. Betrachten Sie eine Klasse Program, die ein Array von Zeichenketten kapselt.

class Program
{
    private string[] values = new string[5]; // Array with 5 elements
    public string this[int index]
    {
        get
        {
            return values[index];
        }
        set
        {
            values[index] = value;
        }
    }
}

class Program
{
    private string[] values = new string[5]; // Array with 5 elements
    public string this[int index]
    {
        get
        {
            return values[index];
        }
        set
        {
            values[index] = value;
        }
    }
}

Friend Class Program
	Private values(4) As String ' Array with 5 elements
	Default Public Property Item(ByVal index As Integer) As String
		Get
			Return values(index)
		End Get
		Set(ByVal value As String)
			values(index) = value
		End Set
	End Property
End Class

Friend Class Program
	Private values(4) As String ' Array with 5 elements
	Default Public Property Item(ByVal index As Integer) As String
		Get
			Return values(index)
		End Get
		Set(ByVal value As String)
			values(index) = value
		End Set
	End Property
End Class

Im obigen Code:

Die Program-Klasse enthält ein Zeichenkettenarray namens values.
Die string this[int index] ist die Indexerdeklaration, wobei die int index die indexparametrisierte Eigenschaft ist, mit der auf Elemente des Arrays zugegriffen wird.
Der get-Accessor gibt den indizierten Wert am angegebenen Index zurück, und der set-Accessor weist diesem Index einen indizierten Wert zu.

Das bedeutet, dass Sie eine Instanz der Program-Klasse erstellen und auf deren values-Array mit dem Indexer zugreifen können, wie folgt:

class Program
{
    static void Main()
    {
        Program program = new Program();
        // Set values using indexer
        program[0] = "First";
        program[1] = "Second";
        // Access values using indexer
        Console.WriteLine(program[0]); // Output: First
        Console.WriteLine(program[1]); // Output: Second
    }
}

class Program
{
    static void Main()
    {
        Program program = new Program();
        // Set values using indexer
        program[0] = "First";
        program[1] = "Second";
        // Access values using indexer
        Console.WriteLine(program[0]); // Output: First
        Console.WriteLine(program[1]); // Output: Second
    }
}

Friend Class Program
	Shared Sub Main()
		Dim program As New Program()
		' Set values using indexer
		program(0) = "First"
		program(1) = "Second"
		' Access values using indexer
		Console.WriteLine(program(0)) ' Output: First
		Console.WriteLine(program(1)) ' Output: Second
	End Sub
End Class

Friend Class Program
	Shared Sub Main()
		Dim program As New Program()
		' Set values using indexer
		program(0) = "First"
		program(1) = "Second"
		' Access values using indexer
		Console.WriteLine(program(0)) ' Output: First
		Console.WriteLine(program(1)) ' Output: Second
	End Sub
End Class

In diesem Code sehen Sie, dass der Indexer eine einfache Syntax zum Zugriff auf das values-Array bietet, ähnlich wie Sie auf Elemente in einem Array zugreifen würden.

Verständnis der `get`- und `set`-Accessors

Die get- und set-Accessors im Indexer sind wie Blockcode, der es Ihnen ermöglicht, Daten abzurufen und zuzuweisen, ähnlich wie Sie es mit Eigenschaften tun würden. Der Hauptunterschied besteht darin, dass Indexer einen Indexparameter verwenden, um mit Datenkollektionen statt mit einzelnen Datenmitgliedern zu arbeiten.

Der get-Block ist verantwortlich für das Zurückgeben der Daten am angegebenen Index, während der set-Block Daten dem angegebenen Index zuweist. Hier ist ein weiteres Beispiel, um Ihr Verständnis zu festigen:

class StudentRecords
{
    private string[] studentNames = new string[3];
    public string this[int index]
    {
        get
        {
            if (index >= 0 && index < studentNames.Length)
            {
                return studentNames[index];
            }
            return "Invalid Index";
        }
        set
        {
            if (index >= 0 && index < studentNames.Length)
            {
                studentNames[index] = value;
            }
        }
    }
    public int Length
    {
        get { return studentNames.Length; }
    }
}

class StudentRecords
{
    private string[] studentNames = new string[3];
    public string this[int index]
    {
        get
        {
            if (index >= 0 && index < studentNames.Length)
            {
                return studentNames[index];
            }
            return "Invalid Index";
        }
        set
        {
            if (index >= 0 && index < studentNames.Length)
            {
                studentNames[index] = value;
            }
        }
    }
    public int Length
    {
        get { return studentNames.Length; }
    }
}

Friend Class StudentRecords
	Private studentNames(2) As String
	Default Public Property Item(ByVal index As Integer) As String
		Get
			If index >= 0 AndAlso index < studentNames.Length Then
				Return studentNames(index)
			End If
			Return "Invalid Index"
		End Get
		Set(ByVal value As String)
			If index >= 0 AndAlso index < studentNames.Length Then
				studentNames(index) = value
			End If
		End Set
	End Property
	Public ReadOnly Property Length() As Integer
		Get
			Return studentNames.Length
		End Get
	End Property
End Class

Friend Class StudentRecords
	Private studentNames(2) As String
	Default Public Property Item(ByVal index As Integer) As String
		Get
			If index >= 0 AndAlso index < studentNames.Length Then
				Return studentNames(index)
			End If
			Return "Invalid Index"
		End Get
		Set(ByVal value As String)
			If index >= 0 AndAlso index < studentNames.Length Then
				studentNames(index) = value
			End If
		End Set
	End Property
	Public ReadOnly Property Length() As Integer
		Get
			Return studentNames.Length
		End Get
	End Property
End Class

In diesem Beispiel:

Die StudentRecords-Klasse verfügt über ein privates string[] studentNames-Array, das die Namen der Studierenden hält.
Der Indexer überprüft, ob der Index innerhalb der Grenzen des Arrays liegt, bevor der Wert gesetzt oder abgerufen wird.
Eine Eigenschaft vom Typ int Length bietet Zugriff auf die Länge des Arrays.

Sie können diese Klasse im Main-Methode wie folgt verwenden:

class Program
{
    public static void Main()
    {
        StudentRecords records = new StudentRecords();
        // Set values using indexer
        records[0] = "John";
        records[1] = "Jane";
        records[2] = "Bob";
        // Access values using indexer
        for (int i = 0; i < records.Length; i++)
        {
            Console.WriteLine(records[i]);
        }
    }
}

class Program
{
    public static void Main()
    {
        StudentRecords records = new StudentRecords();
        // Set values using indexer
        records[0] = "John";
        records[1] = "Jane";
        records[2] = "Bob";
        // Access values using indexer
        for (int i = 0; i < records.Length; i++)
        {
            Console.WriteLine(records[i]);
        }
    }
}

Friend Class Program
	Public Shared Sub Main()
		Dim records As New StudentRecords()
		' Set values using indexer
		records(0) = "John"
		records(1) = "Jane"
		records(2) = "Bob"
		' Access values using indexer
		For i As Integer = 0 To records.Length - 1
			Console.WriteLine(records(i))
		Next i
	End Sub
End Class

Friend Class Program
	Public Shared Sub Main()
		Dim records As New StudentRecords()
		' Set values using indexer
		records(0) = "John"
		records(1) = "Jane"
		records(2) = "Bob"
		' Access values using indexer
		For i As Integer = 0 To records.Length - 1
			Console.WriteLine(records(i))
		Next i
	End Sub
End Class

Erstellung eines generischen Indexers

Sie können auch generische Klassen mit Indexern erstellen, die es Ihrem Code ermöglichen, mehrere Datentypen zu verarbeiten. Hier ist ein einfaches Beispiel für eine generische Klasse mit einem generischen Indexer:

class GenericClass<t>
{
    private T[] elements = new T[5];
    public T this[int index]
    {
        get
        {
            return elements[index];
        }
        set
        {
            elements[index] = value;
        }
    }
    public int Length
    {
        get { return elements.Length; }
    }
}

class GenericClass<t>
{
    private T[] elements = new T[5];
    public T this[int index]
    {
        get
        {
            return elements[index];
        }
        set
        {
            elements[index] = value;
        }
    }
    public int Length
    {
        get { return elements.Length; }
    }
}

Option Strict On
Option Infer On

Public Class GenericClass(Of T)
    Private elements As T() = New T(4) {}

    Default Public Property Item(index As Integer) As T
        Get
            Return elements(index)
        End Get
        Set(value As T)
            elements(index) = value
        End Set
    End Property

    Public ReadOnly Property Length As Integer
        Get
            Return elements.Length
        End Get
    End Property
End Class

Option Strict On
Option Infer On

Public Class GenericClass(Of T)
    Private elements As T() = New T(4) {}

    Default Public Property Item(index As Integer) As T
        Get
            Return elements(index)
        End Get
        Set(value As T)
            elements(index) = value
        End Set
    End Property

    Public ReadOnly Property Length As Integer
        Get
            Return elements.Length
        End Get
    End Property
End Class

In diesem Code:

Die Klasse GenericClass definiert einen Indexer, der mit jedem Datentyp funktionieren kann.
Der this[int index]-Indexer ermöglicht Ihnen den Zugriff auf die Elemente im Array, unabhängig vom Typ.

Sie können nun den GenericClass mit unterschiedlichen Datentypen in der Main-Methode verwenden:

class Program
{
    public static void Main()
    {
        GenericClass<int> intArray = new GenericClass<int>();
        intArray[0] = 10;
        intArray[1] = 20;

        GenericClass<string> stringArray = new GenericClass<string>();
        stringArray[0] = "Hello";
        stringArray[1] = "World";

        // Output the integer array values
        for (int i = 0; i < intArray.Length; i++)
        {
            Console.WriteLine(intArray[i]);
        }

        // Output the string array values
        for (int i = 0; i < stringArray.Length; i++)
        {
            Console.WriteLine(stringArray[i]);
        }
    }
}

class Program
{
    public static void Main()
    {
        GenericClass<int> intArray = new GenericClass<int>();
        intArray[0] = 10;
        intArray[1] = 20;

        GenericClass<string> stringArray = new GenericClass<string>();
        stringArray[0] = "Hello";
        stringArray[1] = "World";

        // Output the integer array values
        for (int i = 0; i < intArray.Length; i++)
        {
            Console.WriteLine(intArray[i]);
        }

        // Output the string array values
        for (int i = 0; i < stringArray.Length; i++)
        {
            Console.WriteLine(stringArray[i]);
        }
    }
}

Friend Class Program
	Public Shared Sub Main()
		Dim intArray As New GenericClass(Of Integer)()
		intArray(0) = 10
		intArray(1) = 20

		Dim stringArray As New GenericClass(Of String)()
		stringArray(0) = "Hello"
		stringArray(1) = "World"

		' Output the integer array values
		For i As Integer = 0 To intArray.Length - 1
			Console.WriteLine(intArray(i))
		Next i

		' Output the string array values
		For i As Integer = 0 To stringArray.Length - 1
			Console.WriteLine(stringArray(i))
		Next i
	End Sub
End Class

Friend Class Program
	Public Shared Sub Main()
		Dim intArray As New GenericClass(Of Integer)()
		intArray(0) = 10
		intArray(1) = 20

		Dim stringArray As New GenericClass(Of String)()
		stringArray(0) = "Hello"
		stringArray(1) = "World"

		' Output the integer array values
		For i As Integer = 0 To intArray.Length - 1
			Console.WriteLine(intArray(i))
		Next i

		' Output the string array values
		For i As Integer = 0 To stringArray.Length - 1
			Console.WriteLine(stringArray(i))
		Next i
	End Sub
End Class

Verwendung von IronPDF mit C# Indexer

C# Indexer (Wie es für Entwickler funktioniert): Abbildung 1 - IronPDF

IronPDF ist eine C#-Bibliothek, die für die Erstellung, Bearbeitung und Konvertierung von PDFs in .NET-Anwendungen entwickelt wurde. Sie vereinfacht die Arbeit mit PDFs für Entwickler, um PDFs aus HTML zu erstellen, PDF-Dateien zu manipulieren und fortschrittliche Funktionalitäten wie das Zusammenführen, Drucken und Hinzufügen von Signaturen programmgesteuert zu bearbeiten.

Sie können IronPDF in Ihren C#-Programmen verwenden, die Indexer nutzen, um PDF-Inhalte dynamisch zu erstellen und zu verwalten. Stellen Sie sich zum Beispiel vor, Sie haben eine Klasse, die HTML-Zeichenfolgen speichert, und Sie möchten mit einem Indexer für jeden HTML-Eintrag PDFs generieren. Dieser Ansatz vereinfacht die PDF-Erstellung, während Ihr Code organisiert und intuitiv bleibt.

using IronPdf;
using System;

class PdfGenerator
{
    private string[] htmlTemplates = new string[3];
    public string this[int index]
    {
        get { return htmlTemplates[index]; }
        set { htmlTemplates[index] = value; }
    }

    public void GeneratePdf(int index, string outputPath)
    {
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(this[index]); // Access HTML string using indexer
        pdfDocument.SaveAs(outputPath);
    }
}

class Program
{
    public static void Main()
    {
        PdfGenerator pdfGen = new PdfGenerator();
        // Populate HTML templates
        pdfGen[0] = "<h1>First Document</h1><p>This is the first PDF.</p>";
        pdfGen[1] = "<h1>Second Document</h1><p>This is the second PDF.</p>";
        pdfGen[2] = "<h1>Third Document</h1><p>This is the third PDF.</p>";

        // Generate PDFs using the indexer
        pdfGen.GeneratePdf(0, "first.pdf");
        pdfGen.GeneratePdf(1, "second.pdf");
        pdfGen.GeneratePdf(2, "third.pdf");

        Console.WriteLine("PDFs generated successfully.");
    }
}

using IronPdf;
using System;

class PdfGenerator
{
    private string[] htmlTemplates = new string[3];
    public string this[int index]
    {
        get { return htmlTemplates[index]; }
        set { htmlTemplates[index] = value; }
    }

    public void GeneratePdf(int index, string outputPath)
    {
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(this[index]); // Access HTML string using indexer
        pdfDocument.SaveAs(outputPath);
    }
}

class Program
{
    public static void Main()
    {
        PdfGenerator pdfGen = new PdfGenerator();
        // Populate HTML templates
        pdfGen[0] = "<h1>First Document</h1><p>This is the first PDF.</p>";
        pdfGen[1] = "<h1>Second Document</h1><p>This is the second PDF.</p>";
        pdfGen[2] = "<h1>Third Document</h1><p>This is the third PDF.</p>";

        // Generate PDFs using the indexer
        pdfGen.GeneratePdf(0, "first.pdf");
        pdfGen.GeneratePdf(1, "second.pdf");
        pdfGen.GeneratePdf(2, "third.pdf");

        Console.WriteLine("PDFs generated successfully.");
    }
}

Imports IronPdf
Imports System

Friend Class PdfGenerator
	Private htmlTemplates(2) As String
	Default Public Property Item(ByVal index As Integer) As String
		Get
			Return htmlTemplates(index)
		End Get
		Set(ByVal value As String)
			htmlTemplates(index) = value
		End Set
	End Property

	Public Sub GeneratePdf(ByVal index As Integer, ByVal outputPath As String)
		Dim renderer = New ChromePdfRenderer()
		Dim pdfDocument = renderer.RenderHtmlAsPdf(Me(index)) ' Access HTML string using indexer
		pdfDocument.SaveAs(outputPath)
	End Sub
End Class

Friend Class Program
	Public Shared Sub Main()
		Dim pdfGen As New PdfGenerator()
		' Populate HTML templates
		pdfGen(0) = "<h1>First Document</h1><p>This is the first PDF.</p>"
		pdfGen(1) = "<h1>Second Document</h1><p>This is the second PDF.</p>"
		pdfGen(2) = "<h1>Third Document</h1><p>This is the third PDF.</p>"

		' Generate PDFs using the indexer
		pdfGen.GeneratePdf(0, "first.pdf")
		pdfGen.GeneratePdf(1, "second.pdf")
		pdfGen.GeneratePdf(2, "third.pdf")

		Console.WriteLine("PDFs generated successfully.")
	End Sub
End Class

Imports IronPdf
Imports System

Friend Class PdfGenerator
	Private htmlTemplates(2) As String
	Default Public Property Item(ByVal index As Integer) As String
		Get
			Return htmlTemplates(index)
		End Get
		Set(ByVal value As String)
			htmlTemplates(index) = value
		End Set
	End Property

	Public Sub GeneratePdf(ByVal index As Integer, ByVal outputPath As String)
		Dim renderer = New ChromePdfRenderer()
		Dim pdfDocument = renderer.RenderHtmlAsPdf(Me(index)) ' Access HTML string using indexer
		pdfDocument.SaveAs(outputPath)
	End Sub
End Class

Friend Class Program
	Public Shared Sub Main()
		Dim pdfGen As New PdfGenerator()
		' Populate HTML templates
		pdfGen(0) = "<h1>First Document</h1><p>This is the first PDF.</p>"
		pdfGen(1) = "<h1>Second Document</h1><p>This is the second PDF.</p>"
		pdfGen(2) = "<h1>Third Document</h1><p>This is the third PDF.</p>"

		' Generate PDFs using the indexer
		pdfGen.GeneratePdf(0, "first.pdf")
		pdfGen.GeneratePdf(1, "second.pdf")
		pdfGen.GeneratePdf(2, "third.pdf")

		Console.WriteLine("PDFs generated successfully.")
	End Sub
End Class

C# Indexer (Wie es für Entwickler funktioniert): Abbildung 2 - Konsolenausgabe

Abschluss

C#-Indexer sind ein nützliches Feature, das Ihnen hilft, Ihre Klassen und Strukturen wie Arrays verhalten zu lassen. Durch die Bereitstellung einer vereinfachten Syntax und flexiblen Datenzugriff können Sie intuitiveren und lesbareren Code erstellen. Egal, ob Sie mit Zeichenfolgen, Ganzzahlen oder einem anderen Datentyp arbeiten, Indexer geben Ihnen die Möglichkeit, Ihre Datenstruktur zu kapseln und sie sauber und effizient über Indizes zuzugreifen.

IronPDF macht es einfach, mit einer kostenlosen Testversion zu beginnen, die Ihnen Zugriff auf alle Funktionen gibt, die Sie zum Erstellen, Bearbeiten und Rendern von PDFs benötigen. Sie können sich Zeit nehmen, die Software zu erkunden, und sobald Sie zufrieden sind, sind Lizenzen ab $999 erhältlich.

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.

...