AIDE .NET

Indexeurs C# (Comment ça marche pour les développeurs)

Jordi Bardia

octobre 23, 2024

Unindexeur en C# est un type spécial de propriété qui permet d'accéder aux instances d'une classe ou d'une structure à l'aide de l'opérateur d'accès aux tableaux[]. Les indexeurs peuvent être très utiles pour créer des "tableaux intelligents" ou encapsuler des données dans une syntaxe simplifiée. Ils permettent d'utiliser les instances d'une classe comme on utilise des tableaux, où l'on peut accéder aux données par le biais d'un index. Cet article explorera la manière de déclarer et d'utiliser les indexeurs C# à l'aide d'exemples pratiques. Nous explorerons également lesBibliothè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 d'un membre d'instance d'indexeur ressemble à ceci :

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

Ici, return_type est le type de valeur que l'indexeur retournera, par exemple une valeur entière, et parameter_type est le type de l'index, souvent un int. L'accesseur get renvoie la valeur à l'index spécifié, et l'accesseur set block code attribue une valeur à cet index.

Déclaration et utilisation de l'indexeur

Nous examinerons une illustration de base de la mise en œuvre 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

Dans le code ci-dessus :

La classe Program contient un tableau de chaînes nommé values.
La chaîne de caractères suivante[int index] est la déclaration de l'indexeur, où int index est la propriété paramétrée index utilisée pour accéder aux éléments du tableau.
L'accesseur get renvoie la valeur indexée à l'index spécifié, et l'accesseur set affecte une valeur indexée à cet index.
L'accesseur set définit la valeur à l'index donné.
Cela signifie que vous pouvez créer une instance de la classe Program et accéder à son tableau de valeurs à l'aide de 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

Dans ce code, vous voyez que l'indexeur fournit une syntaxe simple pour accéder au tableau des valeurs, de la même manière que vous accédez aux éléments d'un tableau.

Comprendre les accesseurs get et set

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

Le bloc get est chargé de renvoyer les données à l'index spécifié, tandis que le bloc set affecte les données à l'index spécifié. Voici un autre exemple pour vous aider à mieux comprendre :

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

Dans cet exemple :

La classe StudentRecords possède une chaîne privée[] tableau studentNames qui contient les noms des étudiants.
L'indexeur vérifie si l'index se trouve dans les limites du tableau avant de définir ou de récupérer la valeur.
Une propriété Length de type int permet d'accéder à 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

Création d'un indexeur générique

Vous pouvez également créer des classes génériques avec des indexeurs, ce qui permet à votre code de gérer plusieurs types de données. Voici un exemple simple 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

Dans ce code :

La *Classe génériquela classe * définit un indexeur qui peut fonctionner avec n'importe quel type de données.
La rubrique "*cette[int index]l'indexeur "*" vous permet d'accéder aux éléments du tableau, quel que soit leur type.
Vous pouvez maintenant utiliser la classe générique 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

Utilisation d'IronPDF avec C&num ; Indexer

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 PDF dans des applications .NET. Elle simplifie le travail des développeurs avec les PDF pourcréer des PDF à partir de HTMLces outils permettent de créer des fichiers PDF, de les manipuler et de gérer des fonctionnalités avancées telles que la fusion, l'impression et l'ajout de signatures de manière programmatique.

Vous pouvez tirer parti d'IronPDF au sein de vos programmes C# qui utilisent des indexeurs pour générer et gérer dynamiquement du contenu PDF. Par exemple, supposons que vous ayez une classe qui contient des chaînes HTML et que vous souhaitiez générer des PDF pour chaque entrée HTML à l'aide d'un indexeur. Cette approche permet de rationaliser la génération de PDF tout en conservant un 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

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 vos 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 plus lisible. Que vous travailliez avec des chaînes de caractères, des entiers ou tout autre type de données, les indexeurs vous permettent d'encapsuler votre structure de données et d'y accéder à l'aide d'index de manière propre et efficace.

IronPDF facilite la mise en place d'uneessai gratuit ce logiciel vous donne accès à toutes les fonctionnalités dont vous avez besoin pour créer, manipuler et restituer des PDF. Vous pouvez prendre votre temps pour explorer le logiciel, et une fois satisfait, des licences sont disponibles à partir de $749.

Jordi Bardia

Discutez avec l'équipe d'ingénierie maintenant

Ingénieur logiciel

Jordi maîtrise parfaitement Python, C# et C++. Lorsqu'il ne met pas à profit ses compétences chez Iron Software, il se consacre à la programmation de jeux. Partageant des responsabilités en matière de tests de produits, de développement de produits et de recherche, Jordi apporte une valeur ajoutée considérable à l'amélioration continue des produits. Cette expérience variée le stimule et l'engage, et il dit que c'est l'un des aspects qu'il préfère dans son travail chez Iron Software. Jordi a grandi à Miami, en Floride, et a étudié l'informatique et les statistiques à l'université de Floride.

< PRÉCÉDENT
C# New GUID (How It Works For Developers) (Nouveau GUID en C# (Comment cela fonctionne pour les développeurs))

SUIVANT >
C# foreach avec index (Comment ça marche pour les développeurs)