Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. Ayuda para .NET
  4. Indexadores en C#
.NET AYUDA

C# Indexadores (Cómo Funciona para Desarrolladores)

Jacob Mellor, Director de Tecnología @ Team Iron
Jacob Mellor
Actualizado:

Un indexador en C# es un tipo especial de propiedad que permite acceder a instancias de una clase o estructura usando 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 estructura, 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
$vbLabelText   $csharpLabel

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 código del 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#. Considera una clase Program que encapsula una matriz 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
$vbLabelText   $csharpLabel

En el código anterior:

  • La clase Program contiene una matriz de cadenas llamada values.
  • El string this[int index] es la declaración del indexador, donde el int index es la propiedad parametrizada del índice 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 puedes crear una instancia de la clase Program y acceder a su matriz values usando el indexador, así:

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

En este código, ves que el indexador proporciona una sintaxis simple para acceder a la matriz values, similar a cómo accederías a elementos en una matriz.

Comprensión de los accesorios get y set

Los accesorios get y set dentro del indexador son como código de bloque que te permite recuperar y asignar datos de manera similar a cómo lo harías con 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
$vbLabelText   $csharpLabel

En este ejemplo:

  • La clase StudentRecords tiene una matriz privada 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 de la matriz.

Puedes 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
$vbLabelText   $csharpLabel

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; }
    }
}
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

En este código:

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

Ahora puedes usar la clase 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
$vbLabelText   $csharpLabel

Uso de IronPDF con C# Indexer

Indexadores de C# (Cómo Funcionan 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
$vbLabelText   $csharpLabel

Indexadores de C# (Cómo Funcionan 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. Puedes tomarte tu tiempo para explorar el software, y una vez que estés satisfecho, hay licencias disponibles a partir de $799.

Preguntas Frecuentes

¿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.

Jacob Mellor, Director de Tecnología @ Team Iron
Jacob Mellor
  Chatea con el equipo de ingeniería ahora
Director de Tecnología

Jacob Mellor es Director de Tecnología en Iron Software y un ingeniero visionario que lidera la tecnología PDF en C#. Como el desarrollador original detrás de la base de código central de Iron Software, ha moldeado la arquitectura de productos de la compañía desde ...

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Comenzar prueba gratuita