O que é um indexador em C#?

Um indexador em C# é um tipo especial de propriedade que permite acessar instâncias de uma classe ou struct usando o operador de acesso a arrays [] . Ele fornece uma maneira de usar instâncias de uma classe da mesma forma que arrays.

Como declarar um indexador básico em C#?

Um indexador básico em C# é declarado usando a palavra-chave 'this' seguida pela declaração do indexador. Você deve especificar os tipos de parâmetro e o tipo de retorno. Por exemplo: public return_type this[parameter_type index] { get; set; } .

Qual é a finalidade dos acessadores 'get' e 'set' em um indexador?

O acessador 'get' em um indexador é usado para recuperar dados em um índice específico, enquanto o acessador 'set' é usado para atribuir dados a um índice específico. Eles funcionam de forma semelhante aos acessadores de propriedade, mas são usados para coleções de dados.

Você pode fornecer um exemplo de um indexador em uma classe C#?

Claro. Considere uma classe 'Program' com um array de strings privado. O indexador permite o acesso a este array usando um índice inteiro. Por exemplo: public string this[int index] { get { return values[index]; } set { values[index] = value; } } .

Como criar um indexador genérico em C#?

Um indexador genérico em C# pode ser criado dentro de uma classe genérica. Por exemplo, a classe GenericClass inclui um indexador que pode manipular qualquer tipo de dado. O indexador é declarado como public T this[int index] { get; set; } .

Como usar indexadores em C# para agilizar a geração de PDFs?

Utilizando uma biblioteca como o IronPDF, você pode empregar indexadores para gerenciar e acessar modelos HTML armazenados em uma classe, que são então convertidos em documentos PDF. Essa abordagem simplifica o processo de geração de PDFs dinâmicos a partir de múltiplas fontes HTML.

Você pode dar um exemplo de como usar uma biblioteca PDF com um indexador?

Certamente. Você pode criar uma classe que armazene modelos HTML em um array e usar um indexador para acessar esses modelos. Em seguida, use uma biblioteca PDF para renderizar essas strings HTML como documentos PDF. Por exemplo, uma classe chamada PdfGenerator usa um indexador para acessar o HTML e gerar PDFs.

Quais são as vantagens de usar indexadores em C#?

Os indexadores em C# fornecem uma sintaxe simplificada para acessar elementos em uma coleção, tornando seu código mais intuitivo e legível. Eles permitem que classes e structs se comportem como arrays, possibilitando o encapsulamento e o acesso eficientes aos dados.

Como os indexadores podem ajudar na criação de estruturas de dados dinâmicas em C#?

Os indexadores permitem que os desenvolvedores criem estruturas de dados dinâmicas, possibilitando o acesso e a modificação de coleções usando uma sintaxe semelhante à de arrays. Isso pode ser particularmente útil em cenários onde os dados precisam ser gerenciados de forma flexível, como na geração dinâmica de conteúdo em PDFs.

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.

A biblioteca C# PDF

Explore IronPDF Comece seu teste gratuito

HTML para PDF

Online Demo Veja todos os exemplos de código %s

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

ATUALIZAÇÕES DO DESENVOLVEDOR

Indexadores em C# (Como funcionam para desenvolvedores)

Curtis Chau

Updated: 19 de julho de 2026

Um indexador em C# é um tipo especial de propriedade que permite que instâncias de uma classe ou estrutura sejam acessadas usando o operador de acesso a array []. Os indexadores podem ser muito úteis na criação de "matrizes inteligentes" ou no encapsulamento de dados em uma sintaxe simplificada. Elas fornecem uma maneira de usar instâncias de uma classe da mesma forma que você usaria arrays, onde você pode acessar os dados por meio de um índice. Este artigo explorará como declarar e usar indexadores em C# com exemplos práticos. E também exploraremos a biblioteca IronPDF no final do artigo.

Sintaxe básica do indexador

Um indexador é um membro de instância usando a palavra-chave this em uma classe ou estrutura, seguido pela declaração do indexador. Você também especifica os tipos de parâmetros e o tipo de retorno. A sintaxe geral para um membro de instância de indexador é a seguinte:

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

Aqui, return_type é o tipo de valor que o indexador retornará, como um valor inteiro, e parameter_type é o tipo do índice, frequentemente um int. O acessor get retorna o valor no índice especificado, e o acessor de bloco de código set atribui um valor a esse índice.

Declaração e uso do indexador

Vamos examinar uma ilustração básica de como implementar um indexador dentro de uma classe C#. Considere uma classe Program que encapsula um array de strings.

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

No código acima:

A classe Program contém um array de strings chamado values.
O string this[int index] é a declaração do indexador, onde o int index é a propriedade parametrizada pelo índice usada para acessar elementos do array.
O acessor get retorna o valor indexado no índice especificado, e o acessor set atribui um valor indexado a esse índice.

Isso significa que você pode criar uma instância da classe Program e acessar seu array values usando o indexador, assim:

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

Neste código, você vê que o indexador fornece uma sintaxe simples para acessar o array values, semelhante a como você acessaria elementos em um array.

Compreendendo os Acessores `get` e `set`

Os acessores get e set dentro do indexador são como blocos de código que permitem que você recupere e atribua dados de maneira semelhante a como faria com propriedades. A principal diferença é que os indexadores usam um parâmetro de índice para trabalhar com coleções de dados em vez de membros de dados individuais.

O bloco get é responsável por retornar os dados no índice especificado, enquanto o bloco set atribui dados ao índice especificado. Aqui está outro exemplo para consolidar seu entendimento:

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

Neste exemplo:

A classe StudentRecords tem um vetor string[] studentNames privado que contém os nomes dos alunos.
O indexador verifica se o índice está dentro dos limites da matriz antes de definir ou recuperar o valor.
Uma propriedade de tipo int Length fornece acesso ao comprimento do array.

Você pode usar esta classe no método Main da seguinte maneira:

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

Criando um Indexador Genérico

Você também pode criar classes genéricas com indexadores, permitindo que seu código manipule vários tipos de dados. Aqui está um exemplo simples de uma classe genérica com um indexador genérico:

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

Neste código:

A classe GenericClass define um indexador que pode trabalhar com qualquer tipo de dado.
O indexador this[int index] permite que você acesse os elementos no array, independentemente do tipo.

Agora você pode usar o GenericClass com diferentes tipos de dados no método 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

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

Usando IronPDF com o Indexador C#

Indexadores C# (Como Funciona para Desenvolvedores): Figura 1 - IronPDF

IronPDF é uma biblioteca C# projetada para gerar, editar e converter PDFs em aplicações .NET . Simplifica o trabalho com PDFs para desenvolvedores, permitindo criar PDFs a partir de HTML , manipular arquivos PDF e lidar com funcionalidades avançadas, como mesclagem, impressão e adição de assinaturas, de forma programática.

Você pode aproveitar o IronPDF em seus programas C# que utilizam indexadores para gerar e gerenciar conteúdo PDF dinamicamente. Por exemplo, suponha que você tenha uma classe que armazena strings HTML e queira gerar PDFs para cada entrada HTML usando um indexador. Essa abordagem simplifica a geração de PDFs, mantendo seu código organizado e intuitivo.

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

Indexadores C# (Como Funciona para Desenvolvedores): Figura 2 - Saída do Console

Conclusão

Os indexadores em C# são um recurso útil que ajuda a fazer com que suas classes e structs se comportem como arrays. Ao fornecer uma sintaxe simplificada e acesso flexível aos dados, você pode criar um código mais intuitivo e legível. Quer você esteja trabalhando com strings, números inteiros ou qualquer outro tipo de dado, os indexadores permitem encapsular sua estrutura de dados e acessá-la de forma limpa e eficiente usando índices.

O IronPDF facilita o início com um período de teste gratuito que lhe dá acesso a todos os recursos necessários para criar, manipular e renderizar PDFs. Você pode levar o tempo que precisar explorando o software, e uma vez que estiver satisfeito, as licenças estão disponíveis a partir de $999.

Curtis Chau

Converse agora mesmo com a equipe de engenharia.

Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.

...