.NET-HILFE

C# Indexers (Wie es für Entwickler funktioniert)

Veröffentlicht 23. Oktober 2024

Teilen Sie:

Einindexer in C# ist eine spezielle Art von Eigenschaft, die den Zugriff auf Instanzen einer Klasse oder Struktur über den Array-Zugriffsoperator ermöglicht[]. 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 wie Arrays zu verwenden, bei denen man über einen Index auf Daten zugreifen kann. In diesem Artikel wird anhand von praktischen Beispielen erläutert, wie C#-Indexer deklariert und verwendet werden. Und wir werden auch dieIronPDF-Bibliothek am Ende des Artikels.

Grundlegende Indexer-Syntax

Ein Indexer ist ein Instanzmitglied mit dem Schlüsselwort "this" in einer Klasse oder Struktur, gefolgt von der Indexer-Deklaration. Sie geben auch die Parametertypen und den Rückgabetyp an. Die allgemeine Syntax für ein Indexer-Instanzmitglied sieht wie folgt aus:

public return_type this[parameter_type index]
{
    get
    {
        // code to return data
    }
    set
    {
        // set accessor, code to set data
    }
}

public return_type this[parameter_type index]
{
    get
    {
        // code to return data
    }
    set
    {
        // set accessor, 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)
		' set accessor, code to set data
	End Set
End Property

Hier ist return_type der Wertetyp, den der Indexer zurückgibt, z. B. ein Integer-Wert, und parameter_type ist der Typ des Index, häufig ein int. Der get-Accessor gibt den Wert am angegebenen Index zurück, und der set-Blockcode-Accessor weist diesem Index einen Wert zu.

Erklärung und Verwendung des Indexers

Wir werden eine grundlegende Illustration der Implementierung eines Indexers innerhalb einer C#-Klasse untersuchen. Nehmen wir eine Klasse Program, die ein Array von Strings 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

Im obigen Code:

Die Klasse Program enthält ein String-Array mit dem Namen values.
Die Zeichenfolge this[int-Index] ist die Indexer-Deklaration, wobei der int-Index die parametrisierte Eigenschaft ist, die für den Zugriff auf die 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.
Der Set-Accessor setzt den Wert am angegebenen Index.
Das bedeutet, dass Sie eine Instanz der Klasse Program erstellen und mit dem Indexer auf das Array der Werte zugreifen können, etwa so:

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

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

Verstehen der get- und set-Accessoren

Die Get- und Set-Accessoren innerhalb des Indexers sind wie Blockcode, mit dem Sie Daten ähnlich wie bei Eigenschaften abrufen und zuweisen können. Der Hauptunterschied besteht darin, dass Indexer einen Indexparameter verwenden, um mit Datensammlungen und nicht mit einzelnen Datenelementen zu arbeiten.

Der get-Block ist für die Rückgabe der Daten am angegebenen Index verantwortlich, während der set-Block die 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

In diesem Beispiel:

Die Klasse StudentRecords hat einen privaten String[] studentNames Array, das die Namen der Studenten enthält.
Der Indexer prüft, ob der Index innerhalb der Grenzen des Arrays liegt, bevor er den Wert setzt oder abruft.
Eine Length-Eigenschaft vom Typ int 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

Erstellen eines generischen Indexers

Sie können auch generische Klassen mit Indexern erstellen, so dass Ihr Code mehrere Datentypen verarbeiten kann. 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

In diesem Code:

Die GenericClassKlasse definiert einen Indexer, der mit jedem Datentyp arbeiten kann.
Die "*diese[int-Index]der Indexer "*" ermöglicht den Zugriff auf die Elemente im Array, unabhängig vom Typ.
Sie können nun 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

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 Erzeugung, Bearbeitung und Konvertierung von PDF-Dateien in .NET-Anwendungen entwickelt wurde. Es vereinfacht die Arbeit mit PDFs für Entwickler, umpDFs aus HTML erstellensie können PDF-Dateien bearbeiten und fortgeschrittene Funktionen wie das Zusammenführen, Drucken und Hinzufügen von Signaturen programmatisch handhaben.

Sie können IronPDF in Ihren C#-Programmen einsetzen, die Indexer zur dynamischen Erzeugung und Verwaltung von PDF-Inhalten verwenden. Angenommen, Sie haben eine Klasse, die HTML-Zeichenfolgen enthält, und Sie möchten mithilfe eines Indexers PDFs für jeden HTML-Eintrag erzeugen. Dieser Ansatz rationalisiert die PDF-Erstellung, während Ihr Code übersichtlich 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

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

Schlussfolgerung

C#-Indexer sind eine nützliche Funktion, die Ihnen hilft, Ihre Klassen und Strukturen wie Arrays zu verhalten. Durch die Bereitstellung einer vereinfachten Syntax und eines flexiblen Datenzugriffs können Sie einen intuitiveren und besser lesbaren Code erstellen. Unabhängig davon, ob Sie mit Zeichenketten, Ganzzahlen oder anderen Datentypen arbeiten, geben Ihnen Indexer die Möglichkeit, Ihre Datenstruktur zu kapseln und mit Indizes sauber und effizient darauf zuzugreifen.

IronPDF erleichtert den Einstieg mit einerkostenloser Test die Ihnen Zugang zu allen Funktionen bietet, die Sie zum Erstellen, Bearbeiten und Rendern von PDFs benötigen. Sie können sich Zeit nehmen, um die Software zu erkunden, und sobald Sie zufrieden sind, sind Lizenzen ab $749 erhältlich.

Regan Pun

Software-Ingenieur

LinkedIn

Regan schloss sein Studium an der University of Reading mit einem BA in Elektrotechnik ab. Bevor er zu Iron Software kam, konzentrierte er sich in seinen früheren Jobs auf einzelne Aufgaben. Was ihm bei Iron Software am meisten Spaß macht, ist das Spektrum der Aufgaben, die er übernehmen kann, sei es im Vertrieb, im technischen Support, in der Produktentwicklung oder im Marketing. Es macht ihm Spaß, die Art und Weise zu verstehen, wie Entwickler die Bibliothek von Iron Software nutzen, und dieses Wissen zu nutzen, um die Dokumentation und die Produkte kontinuierlich zu verbessern.

< PREVIOUS
C# New GUID (Wie es für Entwickler funktioniert)

NÄCHSTES >
C# foreach mit Index (Wie es für Entwickler funktioniert)