Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe & Anleitungen
  4. C# Indexierer
.NET HILFE

C# Indexer (So funktioniert es für Entwickler)

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

Ein Indexer in C# ist eine spezielle Art von Eigenschaft, die es ermöglicht, Instanzen einer Klasse oder Struktur mit dem Array-Zugriffsoperator [] zu verwenden. 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 this-Schlüsselwort in einer Klasse oder Struktur verwendet, gefolgt von der Indexer-Deklaration. 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
$vbLabelText   $csharpLabel

Hier ist return_type der Werttyp, den der Indexer zurückgeben wird, wie zum Beispiel ein Ganzzahlwert, und parameter_type ist der Typ des Indexes, oft ein int. Der get-Accessor gibt den Wert an dem angegebenen Index zurück, und der set-Block-Code-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 Zeichenfolgen 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
$vbLabelText   $csharpLabel

Im obigen Code:

  • Die Klasse Program enthält ein Zeichenfolgen-Array namens values.
  • Die Deklaration string this[int index] ist der Indexer, bei dem der int index die indizierte Eigenschaft ist, die zum Zugreifen auf Elemente des Arrays verwendet 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, Sie können eine Instanz der Klasse Program erstellen und auf deren values-Array mit dem Indexer zugreifen, 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
$vbLabelText   $csharpLabel

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

Verständnis der get und set Accessors

Die get- und set-Accessoren im Indexer sind wie Block-Code, der es Ihnen ermöglicht, Daten ähnlich abzurufen und zuzuweisen, 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 dafür verantwortlich, die Daten am angegebenen Index zurückzugeben, während der set-Block Daten am 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
$vbLabelText   $csharpLabel

In diesem Beispiel:

  • Die Klasse StudentRecords hat ein privates string[] studentNames-Array, das die Namen der Schüler enthält.
  • Der Indexer überprüft, ob der Index innerhalb der Grenzen des Arrays liegt, bevor der Wert gesetzt oder abgerufen wird.
  • Eine int-Typ Length-Eigenschaft ermöglicht den Zugriff auf die Länge des Arrays.

Sie können diese Klasse in der 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
$vbLabelText   $csharpLabel

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; }
    }
}
Friend Class GenericClass(Of T)
	Private elements(4) As T
	Default Public Property Item(ByVal index As Integer) As T
		Get
			Return elements(index)
		End Get
		Set(ByVal 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
$vbLabelText   $csharpLabel

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 jetzt die GenericClass mit verschiedenen 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
$vbLabelText   $csharpLabel

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

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 lassen, die Software zu erkunden, und sobald Sie zufrieden sind, sind Lizenzen ab $799 verfügbar.

Häufig gestellte Fragen

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 array-ä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.

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