Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Indexeurs C#
.NET AIDE

C# Indexers (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Un indexeur en C# est un type spécial de propriété qui permet d'accéder aux instances d'une classe ou d'une structure en utilisant l'opérateur d'accès au tableau []. Les indexeurs peuvent être très utiles pour créer des "tableaux intelligents" ou encapsuler des données dans une syntaxe simplifiée. Ils fournissent un moyen d'utiliser les instances d'une classe tout comme vous utiliseriez des tableaux, où vous pouvez accéder aux données via un indice. Cet article explorera comment déclarer et utiliser les indexeurs C# avec des exemples pratiques. Et nous explorerons également la bibliothèque IronPDF à la fin de l'article.

Syntaxe de base de l'indexeur

Un indexeur est un membre d'instance utilisant le mot-clé this dans une classe ou une structure, suivi de la déclaration de l'indexeur. Vous devez également spécifier les types de paramètres et le type de retour. La syntaxe générale pour un membre d'instance indexeur ressemble à ceci :

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

Ici, return_type est le type de valeur que l'indexeur renverra, comme une valeur entière, et parameter_type est le type de l'indice, souvent un int. L'accesseur get renvoie la valeur à l'indice spécifié, et le code de bloc set assigne une valeur à cet indice.

Déclaration et utilisation de l'indexeur

Nous examinerons une illustration de base de l'implémentation d'un indexeur au sein d'une classe C#. Considérons une classe Program qui encapsule un tableau de chaînes de caractères.

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

Dans le code ci-dessus :

  • La classe Program contient un tableau de chaînes de caractères nommé values.
  • Le string this[int index] est la déclaration de l'indexeur, où le int index est la propriété indexée paramétrée utilisée pour accéder aux éléments du tableau.
  • L'accesseur get renvoie la valeur indexée à l'indice spécifié, et l'accesseur set assigne une valeur indexée à cet indice.

Cela signifie que vous pouvez créer une instance de la classe Program et accéder à son tableau values en utilisant l'indexeur, comme ceci :

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

Dans ce code, vous voyez que l'indexeur fournit une syntaxe simple pour accéder au tableau values, similaire à la façon dont vous accédez aux éléments dans un tableau.

Comprendre les accesseurs get et set

Les accesseurs get et set à l'intérieur de l'indexeur sont comme des bloc de code qui vous permettent de récupérer et d'assigner des données de manière similaire à l'utilisation de propriétés. La principale différence est que les indexeurs utilisent un paramètre d'indice pour travailler avec des collections de données plutôt qu'avec des membres de données individuels.

Le bloc get est responsable du retour des données à l'indice spécifié, tandis que le bloc set assigne des données à l'indice spécifié. Voici un autre exemple pour consolider votre compréhension :

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

Dans cet exemple :

  • La classe StudentRecords a un tableau privé string[] studentNames qui contient les noms des étudiants.
  • L'indexeur vérifie si l'indice est dans les limites du tableau avant de définir ou de récupérer la valeur.
  • Une propriété Length de type int fournit un accès à la longueur du tableau.

Vous pouvez utiliser cette classe dans la méthode Main comme suit :

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

Créer un indexeur générique

Vous pouvez également créer des classes génériques avec des indexeurs, permettant à votre code de gérer plusieurs types de données. Voici un simple exemple de classe générique avec un indexeur générique :

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

Dans ce code :

  • La classe GenericClass définit un indexeur qui peut fonctionner avec n'importe quel type de données.
  • L'indexeur this[int index] vous permet d'accéder aux éléments dans le tableau, quel que soit le type.

Vous pouvez maintenant utiliser GenericClass avec différents types de données dans la méthode Main :

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

Utiliser IronPDF avec l'indexeur C

Indexeurs C# (Comment ça marche pour les développeurs) : Figure 1 - IronPDF

IronPDF est une bibliothèque C# conçue pour générer, éditer et convertir des PDFs dans des applications .NET. Elle simplifie le travail avec les PDFs pour les développeurs afin de créer des PDFs à partir de HTML, manipuler des fichiers PDF et gérer des fonctionnalités avancées telles que la fusion, l'impression et l'ajout de signatures par programmation.

Vous pouvez tirer parti d'IronPDF dans vos programmes C# qui utilisent des indexeurs pour générer et gérer dynamiquement le contenu des PDFs. Par exemple, supposons que vous ayez une classe qui contient des chaînes HTML, et que vous souhaitiez générer des PDFs pour chaque entrée HTML en utilisant un indexeur. Cette approche rationalise la génération de PDFs tout en gardant votre code organisé et intuitif.

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

Indexeurs C# (Comment ça marche pour les développeurs) : Figure 2 - Sortie de la console

Conclusion

Les indexeurs C# sont une fonctionnalité utile qui vous aide à faire en sorte que vos classes et structures se comportent comme des tableaux. En fournissant une syntaxe simplifiée et un accès flexible aux données, vous pouvez créer un code plus intuitif et lisible. Que vous travailliez avec des chaînes de caractères, des entiers ou tout autre type de données, les indexeurs vous donnent la possibilité d'encapsuler votre structure de données et d'y accéder en utilisant des indices de manière propre et efficace.

IronPDF facilite vos débuts avec un essai gratuit qui vous donne accès à toutes les fonctionnalités dont vous avez besoin pour créer, manipuler et restituer des PDFs. Vous pouvez prendre votre temps pour explorer le logiciel, et une fois satisfait, des licences sont disponibles à partir de $799.

Questions Fréquemment Posées

Qu'est-ce qu'un indexeur en C#?

Un indexeur en C# est un type spécial de propriété qui permet d'accéder aux instances d'une classe ou d'une structure en utilisant l'opérateur d'accès au tableau []. Il offre un moyen d'utiliser les instances d'une classe comme des tableaux.

Comment déclarez-vous un indexeur de base en C#?

Un indexeur de base en C# est déclaré en utilisant le mot-clé 'this' suivi de la déclaration de l'indexeur. Vous devez spécifier les types de paramètres et le type de retour. Par exemple : public return_type this[parameter_type index] { get; set; }.

Quel est le but des accesseurs 'get' et 'set' dans un indexeur?

L'accesseur 'get' dans un indexeur est utilisé pour récupérer des données à un index spécifié, tandis que l'accesseur 'set' est utilisé pour assigner des données à un index spécifié. Ils fonctionnent de manière similaire aux accesseurs de propriétés mais sont utilisés pour des collections de données.

Pouvez-vous fournir un exemple d'indexeur dans une classe C#?

Bien sûr. Considérez une classe 'Program' avec un tableau de chaînes privé. L'indexeur permet l'accès à ce tableau à l'aide d'un index entier. Par exemple : public string this[int index] { get { return values[index]; } set { values[index] = value; } }.

Comment créez-vous un indexeur générique en C#?

Un indexeur générique en C# peut être créé au sein d'une classe générique. Par exemple, la classe GenericClass inclut un indexeur pouvant gérer tout type de données. L'indexeur est déclaré comme public T this[int index] { get; set; }.

Comment pouvez-vous utiliser les indexeurs en C# pour rationaliser la génération de PDF?

En utilisant une bibliothèque comme IronPDF, vous pouvez utiliser des indexeurs pour gérer et accéder à des modèles HTML stockés dans une classe, qui sont ensuite convertis en documents PDF. Cette approche simplifie le processus de génération de PDF dynamiques à partir de multiples sources HTML.

Pouvez-vous donner un exemple d'utilisation d'une bibliothèque PDF avec un indexeur?

Certainement. Vous pouvez créer une classe qui contient des modèles HTML dans un tableau et utiliser un indexeur pour accéder à ces modèles. Ensuite, utilisez une bibliothèque PDF pour rendre ces chaînes HTML en tant que documents PDF. Par exemple, une classe appelée PdfGenerator utilise un indexeur pour accéder au HTML et générer des PDF.

Quels sont les avantages de l'utilisation des indexeurs en C#?

Les indexeurs en C# offrent une syntaxe simplifiée pour accéder aux éléments dans une collection, rendant votre code plus intuitif et lisible. Ils permettent aux classes et structures de se comporter comme des tableaux, permettant une encapsulation et un accès aux données efficace.

Comment les indexeurs peuvent-ils aider à créer des structures de données dynamiques en C#?

Les indexeurs permettent aux développeurs de créer des structures de données dynamiques en rendant les collections accessibles et modifiables à l'aide d'une syntaxe semblable à celle des tableaux. Cela peut être particulièrement utile dans des scénarios où les données doivent être gérées de manière flexible, comme dans la génération de contenu PDF dynamique.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit