¿Qué es un indizador en C#?

Un indizador en C# es un tipo especial de propiedad que permite acceder a instancias de una clase o estructura usando el operador de acceso de array [] . Proporciona una forma de usar instancias de una clase como si fueran arrays.

¿Cómo se declara un indizador básico en C#?

Un indizador básico en C# se declara usando la palabra clave 'this' seguida de la declaración del indizador. Debes especificar los tipos de parámetros y el tipo de retorno. Por ejemplo: public return_type this[parameter_type index] { get; set; } .

¿Cuál es el propósito de los accesores 'get' y 'set' en un indizador?

El accesor 'get' en un indizador se utiliza para recuperar datos en un índice específico, mientras que el accesor 'set' se usa para asignar datos a un índice específico. Funcionan de manera similar a los accesores de propiedades, pero se usan para colecciones de datos.

¿Puedes proporcionar un ejemplo de un indizador en una clase de C#?

Claro. Considera una clase 'Program' con un array privado de strings. El indizador permite el acceso a este array usando un índice entero. Por ejemplo: public string this[int index] { get { return values[index]; } set { values[index] = value; } } .

¿Cómo se crea un indizador genérico en C#?

Un indizador genérico en C# se puede crear dentro de una clase genérica. Por ejemplo, la clase GenericClass incluye un indizador que puede manejar cualquier tipo de dato. El indizador se declara como public T this[int index] { get; set; } .

¿Cómo puedes usar indizadores en C# para agilizar la generación de PDFs?

Usando una biblioteca como IronPDF, puedes emplear indizadores para gestionar y acceder a plantillas HTML almacenadas dentro de una clase, que luego se convierten en documentos PDF. Este enfoque simplifica el proceso de generar PDFs dinámicos desde múltiples fuentes HTML.

¿Puedes dar un ejemplo de uso de una biblioteca PDF con un indizador?

Por supuesto. Puedes crear una clase que sostenga plantillas HTML en un array y usar un indizador para acceder a estas plantillas. Luego, utilizar una biblioteca PDF para renderizar estos strings HTML como documentos PDF. Por ejemplo, una clase llamada PdfGenerator usa un indizador para acceder al HTML y generar PDFs.

¿Cuáles son las ventajas de usar indizadores en C#?

Los indizadores en C# proporcionan una sintaxis simplificada para acceder a elementos en una colección, haciendo que tu código sea más intuitivo y legible. Permiten que las clases y estructuras se comporten como arrays, permitiendo una encapsulación y acceso eficiente a los datos.

¿Cómo pueden los indizadores ayudar en la creación de estructuras de datos dinámicas en C#?

Los indizadores permiten a los desarrolladores crear estructuras de datos dinámicas al permitir que las colecciones se accedan y modifiquen usando una sintaxis similar a un array. Esto puede ser particularmente útil en escenarios donde se necesita gestionar datos de forma flexible, como en la generación de contenido PDF dinámico.

La Biblioteca PDF de C#

Explore IronPDF Prueba gratis

HTML a PDF

Online Demo Ver Todos los Ejemplos 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

ACTUALIZACIONES PARA DESARROLLADORES

C# Indexadores (Cómo Funciona para Desarrolladores)

Jacob Mellor

Updated: 19 de julio de 2026

Un indexador en C# es un tipo especial de propiedad que permite que las instancias de una clase o struct sean accedidas utilizando el operador de acceso de matriz []. Los indexadores pueden ser muy útiles para crear "matrices inteligentes" o encapsular datos en una sintaxis simplificada. Proporcionan una manera de usar instancias de una clase igual que usarías matrices, donde puedes acceder a los datos a través de un índice. Este artículo explorará cómo declarar y usar indexadores de C# con ejemplos prácticos. Y también exploraremos la biblioteca IronPDF al final del artículo.

Sintaxis básica del indexador

Un indexador es un miembro de instancia que utiliza la palabra clave this en una clase o struct, seguido de la declaración del indexador. También especificas los tipos de parámetros y el tipo de retorno. La sintaxis general para un miembro de instancia del indexador se ve así:

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

Aquí, return_type es el tipo de valor que el indexador devolverá, como un valor entero, y parameter_type es el tipo del índice, a menudo un int. El accesor get devuelve el valor en el índice especificado, y el accessor de código de bloque set asigna un valor a ese índice.

Declaración y uso del indexador

Examinaremos una ilustración básica de cómo implementar un indexador dentro de una clase de C#. Considere una clase Program que encapsula un array de cadenas.

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

En el código anterior:

La clase Program contiene un array de cadenas llamado values.
El string this[int index] es la declaración del indexador, donde el int index es la propiedad indexada parametrizada utilizada para acceder a los elementos del array.
El accesor get devuelve el valor indexado en el índice especificado, y el accesor set asigna un valor indexado a ese índice.

Esto significa que puede crear una instancia de la clase Program y acceder a su array values usando el indexador, de esta manera:

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

En este código, observa que el indexador proporciona una sintaxis simple para acceder al array values, similar a cómo accedería a los elementos en un array.

Comprendiendo los Accesores `get` y `set`

Los accesores get y set dentro del indexador son como un código de bloque que le permite recuperar y asignar datos de manera similar a como lo haría con las propiedades. La principal diferencia es que los indexadores utilizan un parámetro de índice para trabajar con colecciones de datos en lugar de miembros de datos individuales.

El bloque get es responsable de devolver los datos en el índice especificado, mientras que el bloque set asigna datos al índice especificado. Aquí hay otro ejemplo para solidificar tu comprensión:

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

En este ejemplo:

La clase StudentRecords tiene un array privado string[] studentNames que contiene los nombres de los estudiantes.
El indexador verifica si el índice está dentro de los límites de la matriz antes de establecer o recuperar el valor.
Una propiedad de tipo int Length proporciona acceso a la longitud del array.

Puede usar esta clase en el método Main de la siguiente manera:

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

Creación de un indexador genérico

También puedes crear clases genéricas con indexadores, permitiendo que tu código maneje múltiples tipos de datos. Aquí hay un ejemplo simple de una clase genérica con un 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

En este código:

La clase GenericClass define un indexador que puede trabajar con cualquier tipo de datos.
El indexador this[int index] le permite acceder a los elementos en el array, independientemente del tipo.

Ahora puede usar el GenericClass con diferentes tipos de datos en el 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 con el Indexador C#

Indexadores en C# (Cómo Funciona Para Desarrolladores): Figura 1 - IronPDF

IronPDF es una biblioteca de C# diseñada para generar, editar y convertir PDFs en aplicaciones .NET. Simplifica el trabajo con PDFs para los desarrolladores para crear PDFs desde HTML, manipular archivos PDF y manejar funcionalidades avanzadas como combinar, imprimir y agregar firmas programáticamente.

Puedes aprovechar IronPDF dentro de tus programas de C# que utilizan indexadores para generar y gestionar contenido PDF dinámicamente. Por ejemplo, supongamos que tienes una clase que contiene cadenas HTML, y quieres generar PDFs para cada entrada HTML usando un indexador. Este enfoque simplifica la generación de PDFs mientras mantiene tu 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 en C# (Cómo Funciona Para Desarrolladores): Figura 2 - Salida de Consola

Conclusión

Los indexadores de C# son una característica útil que te ayuda a que tus clases y estructuras se comporten como matrices. Al proporcionar una sintaxis simplificada y acceso flexible a los datos, puedes crear un código más intuitivo y legible. Ya sea que estés trabajando con cadenas, enteros o cualquier otro tipo de datos, los indexadores te dan la capacidad de encapsular tu estructura de datos y acceder a ella usando índices de manera clara y eficiente.

IronPDF hace que sea fácil comenzar con una prueba gratuita que te da acceso a todas las funciones que necesitas para crear, manipular y renderizar PDFs. Puede tomarse su tiempo explorando el software, y una vez que esté satisfecho, las licencias están disponibles a partir de $999.

Jacob Mellor

Chatea con el equipo de ingeniería ahora

Director de Tecnología

Jacob Mellor es Director de Tecnología de Iron Software y un ingeniero visionario pionero en la tecnología C# PDF. Como desarrollador original de la base de código principal de Iron Software, ha dado forma a la arquitectura de productos de la empresa desde su creación, transformándola, junto con el director ejecutivo Cameron Rimington, en una empresa de más de 50 personas que presta servicios a la NASA, Tesla y organismos gubernamentales de todo el mundo.

...