C# iList (Cómo funciona para desarrolladores)

Introducción a la ILista

IList forma parte del espacio de nombres Collections de .NET Framework. Es una interfaz de colección no genérica que proporciona el modelo para una colección de objetos a los que se puede acceder individualmente por su índice. A diferencia de las matrices, IList permite un número dinámico de elementos de valor de objeto, lo que significa que puede añadir o eliminar elementos de la colección según sea necesario. Sirve de interfaz de base para todas las listas no genéricas de .NET Framework y ofrece una forma de gestionar una colección de objetos más flexible que las matrices. Conoceremos la interfaz IList y Biblioteca IronPDF en este tutorial.

Comprender la interfaz `IList

La declaración public interface IList es una parte fundamental de la creación de colecciones personalizadas en C# que se adhieren al contrato IList especificado por el espacio de nombres Collections de .NET Framework. IList incluye propiedades y métodos que permiten acceder a los elementos de la colección, contarlos y modificar la colección añadiendo, insertando o eliminando elementos. Estas son algunas de las propiedades y métodos clave definidos en la interfaz IList:

• Propiedades como IsFixedSize y IsReadOnly informan de si la colección es de tamaño fijo o de sólo lectura, respectivamente.
• Métodos como Add, void Insert, Remove, y RemoveAt se utilizan para modificar elementos dentro de la colección. Puede añadir, insertar y eliminar elementos.
• El método IndexOf sirve para localizar elementos, y la propiedad `Item (o indexador en C#) permite obtener y fijar elementos en función de su índice.

Uso práctico de la interfaz pública IList.

Para mostrar cómo funciona IList, vamos a crear un ejemplo sencillo. Este ejemplo de versión genérica demostrará cómo declarar una IList, añadirle elementos e iterar sobre su contenido.

Crear y modificar una ILista

En primer lugar, vamos a ver cómo declarar una IList y añadir elementos a la misma:

using System;
using System.Collections;
class Program
{
    void Main(string[] args)
    {
        // Creating an IList instance
        IList myIList = new ArrayList();
        // Adding elements to the IList
        myIList.Add("Hello");
        myIList.Add(10);
        myIList.Add(new object());
        // Displaying the number of values in the IList interface using count property
        Console.WriteLine($"Number of elements: {myIList.Count}");
        // Access Elements
        foreach (var element in myIList)
        {
            Console.WriteLine(element);
        }
    }
}

using System;
using System.Collections;
class Program
{
    void Main(string[] args)
    {
        // Creating an IList instance
        IList myIList = new ArrayList();
        // Adding elements to the IList
        myIList.Add("Hello");
        myIList.Add(10);
        myIList.Add(new object());
        // Displaying the number of values in the IList interface using count property
        Console.WriteLine($"Number of elements: {myIList.Count}");
        // Access Elements
        foreach (var element in myIList)
        {
            Console.WriteLine(element);
        }
    }
}

Imports System
Imports System.Collections
Friend Class Program
	Private Sub Main(ByVal args() As String)
		' Creating an IList instance
		Dim myIList As IList = New ArrayList()
		' Adding elements to the IList
		myIList.Add("Hello")
		myIList.Add(10)
		myIList.Add(New Object())
		' Displaying the number of values in the IList interface using count property
		Console.WriteLine($"Number of elements: {myIList.Count}")
		' Access Elements
		For Each element In myIList
			Console.WriteLine(element)
		Next element
	End Sub
End Class

En el ejemplo anterior, hemos creado una instancia de IList utilizando ArrayList, una clase que implementa IList. Hemos añadido una mezcla de diferentes tipos de objetos para demostrar que una IList puede contener cualquier objeto. Por último, hemos iterado sobre la colección, imprimiendo cada elemento.

Acceso y modificación basados en índices

Acceder y modificar elementos por su índice es una característica clave de IList. El siguiente ejemplo de IList muestra cómo hacerlo:

// Accessing an element by index
object value = myIList[1];
Console.WriteLine($"Element at index 1: {value}");
// Modifying an element by index
myIList[1] = 20;
Console.WriteLine($"Modified element at index 1: {myIList[1]}");

// Accessing an element by index
object value = myIList[1];
Console.WriteLine($"Element at index 1: {value}");
// Modifying an element by index
myIList[1] = 20;
Console.WriteLine($"Modified element at index 1: {myIList[1]}");

' Accessing an element by index
Dim value As Object = myIList(1)
Console.WriteLine($"Element at index 1: {value}")
' Modifying an element by index
myIList(1) = 20
Console.WriteLine($"Modified element at index 1: {myIList(1)}")

Implementación de IList personalizadas

A veces, puede que necesites una colección a medida que herede de IList. Esto permite un mayor control sobre cómo se almacenan, acceden y modifican los elementos. A continuación se muestra un ejemplo de una colección personalizada sencilla que implementa IList:

public class CustomCollection : IList
{
    private ArrayList _innerList = new ArrayList();
    public object this[int index] { get => _innerList[index]; set => _innerList[index] = value; }
    public bool IsFixedSize => _innerList.IsFixedSize;
    public bool IsReadOnly => _innerList.IsReadOnly;
    public int Count => _innerList.Count;
    public bool IsSynchronized => _innerList.IsSynchronized;
    public object SyncRoot => _innerList.SyncRoot;
// int add
    public int Add(object value)
    {
        return _innerList.Add(value);
    }
    public void Clear()
    {
        _innerList.Clear();
    }
    public bool Contains(object value)
    {
        return _innerList.Contains(value);
    }
    public int IndexOf(object value)
    {
        return _innerList.IndexOf(value);
    }
    public void Insert(int index, object value)
    {
        _innerList.Insert(index, value);
    }
    public void Remove(object value)
    {
        _innerList.Remove(value);
    }
    public void RemoveAt(int index)
    {
        _innerList.RemoveAt(index);
    }
    public void CopyTo(Array array, int index)
    {
        _innerList.CopyTo(array, index);
    }
    public IEnumerator GetEnumerator()
    {
        return _innerList.GetEnumerator();
    }
}

public class CustomCollection : IList
{
    private ArrayList _innerList = new ArrayList();
    public object this[int index] { get => _innerList[index]; set => _innerList[index] = value; }
    public bool IsFixedSize => _innerList.IsFixedSize;
    public bool IsReadOnly => _innerList.IsReadOnly;
    public int Count => _innerList.Count;
    public bool IsSynchronized => _innerList.IsSynchronized;
    public object SyncRoot => _innerList.SyncRoot;
// int add
    public int Add(object value)
    {
        return _innerList.Add(value);
    }
    public void Clear()
    {
        _innerList.Clear();
    }
    public bool Contains(object value)
    {
        return _innerList.Contains(value);
    }
    public int IndexOf(object value)
    {
        return _innerList.IndexOf(value);
    }
    public void Insert(int index, object value)
    {
        _innerList.Insert(index, value);
    }
    public void Remove(object value)
    {
        _innerList.Remove(value);
    }
    public void RemoveAt(int index)
    {
        _innerList.RemoveAt(index);
    }
    public void CopyTo(Array array, int index)
    {
        _innerList.CopyTo(array, index);
    }
    public IEnumerator GetEnumerator()
    {
        return _innerList.GetEnumerator();
    }
}

Public Class CustomCollection
	Implements IList

	Private _innerList As New ArrayList()
	Default Public Property Item(ByVal index As Integer) As Object Implements IList.Item
		Get
			Return _innerList(index)
		End Get
		Set(ByVal value As Object)
			_innerList(index) = value
		End Set
	End Property
	Public ReadOnly Property IsFixedSize() As Boolean Implements IList.IsFixedSize
		Get
			Return _innerList.IsFixedSize
		End Get
	End Property
	Public ReadOnly Property IsReadOnly() As Boolean Implements IList.IsReadOnly
		Get
			Return _innerList.IsReadOnly
		End Get
	End Property
	Public ReadOnly Property Count() As Integer Implements System.Collections.ICollection.Count
		Get
			Return _innerList.Count
		End Get
	End Property
	Public ReadOnly Property IsSynchronized() As Boolean Implements System.Collections.ICollection.IsSynchronized
		Get
			Return _innerList.IsSynchronized
		End Get
	End Property
	Public ReadOnly Property SyncRoot() As Object Implements System.Collections.ICollection.SyncRoot
		Get
			Return _innerList.SyncRoot
		End Get
	End Property
' int add
	Public Function Add(ByVal value As Object) As Integer Implements IList.Add
		Return _innerList.Add(value)
	End Function
	Public Sub Clear() Implements IList.Clear
		_innerList.Clear()
	End Sub
	Public Function Contains(ByVal value As Object) As Boolean Implements IList.Contains
		Return _innerList.Contains(value)
	End Function
	Public Function IndexOf(ByVal value As Object) As Integer Implements IList.IndexOf
		Return _innerList.IndexOf(value)
	End Function
	Public Sub Insert(ByVal index As Integer, ByVal value As Object) Implements IList.Insert
		_innerList.Insert(index, value)
	End Sub
	Public Sub Remove(ByVal value As Object) Implements IList.Remove
		_innerList.Remove(value)
	End Sub
	Public Sub RemoveAt(ByVal index As Integer) Implements IList.RemoveAt
		_innerList.RemoveAt(index)
	End Sub
	Public Sub CopyTo(ByVal array As Array, ByVal index As Integer) Implements System.Collections.ICollection.CopyTo
		_innerList.CopyTo(array, index)
	End Sub
	Public Function GetEnumerator() As IEnumerator Implements System.Collections.IEnumerable.GetEnumerator
		Return _innerList.GetEnumerator()
	End Function
End Class

Esta clase CustomCollection encapsula una ArrayList, una clase que a su vez implementa IList. Nuestra CustomCollection reenvía las llamadas a la ArrayList subyacente, permitiendo que se comporte como cualquier otra colección que implemente IList. Este ejemplo demuestra la creación de una colección a la que se puede acceder por índice, modificada (elementos añadidos, insertados o eliminados)y se itera sobre ella, como cualquier colección .NET integrada que implemente IList.

Operaciones avanzadas con `IList

Además de las operaciones básicas de adición, eliminación y acceso, IList permite manipulaciones y consultas más complejas. Por ejemplo, comprobar si la colección contiene un objeto específico o encontrar el índice de un objeto dentro de la colección son operaciones que pueden ser esenciales para ciertas aplicaciones:

// Check if the IList contains a specific object
bool contains = myIList.Contains(10); // Assuming 10 was added previously
Console.WriteLine($"Contains 10: {contains}");
// Find the index of a specific object
int index = myIList.IndexOf(10);
Console.WriteLine($"Index of 10: {index}");

// Check if the IList contains a specific object
bool contains = myIList.Contains(10); // Assuming 10 was added previously
Console.WriteLine($"Contains 10: {contains}");
// Find the index of a specific object
int index = myIList.IndexOf(10);
Console.WriteLine($"Index of 10: {index}");

' Check if the IList contains a specific object
Dim contains As Boolean = myIList.Contains(10) ' Assuming 10 was added previously
Console.WriteLine($"Contains 10: {contains}")
' Find the index of a specific object
Dim index As Integer = myIList.IndexOf(10)
Console.WriteLine($"Index of 10: {index}")

Estas operaciones pueden ser especialmente útiles cuando se trata de colecciones de objetos en las que es necesario determinar la presencia o posición de elementos específicos sin iterar sobre toda la colección.

IronPDF: C# Biblioteca PDF

IronPDF es una biblioteca PDF para desarrolladores .NET que permite crear y manipular documentos PDF directamente dentro de aplicaciones .NET. Permite convertir HTML a PDFimágenes y páginas web a PDF. Los desarrolladores pueden añadir fácilmente funcionalidades PDF a sus aplicaciones con esta biblioteca. IronPDF también incluye funciones para editar, combinar y dividir archivos PDF, que proporcionan un control exhaustivo sobre la manipulación de PDF.

Ejemplo de código

A continuación se muestra un ejemplo sencillo que demuestra la generación de un documento PDF simple a partir de una lista de cadenas utilizando IronPDF y la interfaz IList:

using IronPdf;
using System.Collections.Generic;
public class PDFGenerator
{
    public static void GeneratePDFFromList(IList<string> dataList)
    {
        // Initialize the HtmlToPdf renderer
        var renderer = new ChromePdfRenderer();
        // Start building HTML content from the dataList
        var htmlContent = "<h1>My Data List</h1><ul>";
        foreach (var item in dataList)
        {
            htmlContent += $"<li>{item}</li>";
        }
        htmlContent += "</ul>";
        // Convert HTML string to PDF
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        // Save the PDF to a file
        pdfDocument.SaveAs("DataList.pdf");
    }
}
// Example usage
class Program
{
    static void Main(string[] args)
    {
        License.LicenseKey = "License-Key";
        IList<string> myDataList = new List<string> { "Apple", "Banana", "Cherry" };
        PDFGenerator.GeneratePDFFromList(myDataList);
    }
}

using IronPdf;
using System.Collections.Generic;
public class PDFGenerator
{
    public static void GeneratePDFFromList(IList<string> dataList)
    {
        // Initialize the HtmlToPdf renderer
        var renderer = new ChromePdfRenderer();
        // Start building HTML content from the dataList
        var htmlContent = "<h1>My Data List</h1><ul>";
        foreach (var item in dataList)
        {
            htmlContent += $"<li>{item}</li>";
        }
        htmlContent += "</ul>";
        // Convert HTML string to PDF
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        // Save the PDF to a file
        pdfDocument.SaveAs("DataList.pdf");
    }
}
// Example usage
class Program
{
    static void Main(string[] args)
    {
        License.LicenseKey = "License-Key";
        IList<string> myDataList = new List<string> { "Apple", "Banana", "Cherry" };
        PDFGenerator.GeneratePDFFromList(myDataList);
    }
}

Imports IronPdf
Imports System.Collections.Generic
Public Class PDFGenerator
	Public Shared Sub GeneratePDFFromList(ByVal dataList As IList(Of String))
		' Initialize the HtmlToPdf renderer
		Dim renderer = New ChromePdfRenderer()
		' Start building HTML content from the dataList
		Dim htmlContent = "<h1>My Data List</h1><ul>"
		For Each item In dataList
			htmlContent &= $"<li>{item}</li>"
		Next item
		htmlContent &= "</ul>"
		' Convert HTML string to PDF
		Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
		' Save the PDF to a file
		pdfDocument.SaveAs("DataList.pdf")
	End Sub
End Class
' Example usage
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		Dim myDataList As IList(Of String) = New List(Of String) From {"Apple", "Banana", "Cherry"}
		PDFGenerator.GeneratePDFFromList(myDataList)
	End Sub
End Class

En este ejemplo, una IList<string> se utiliza para almacenar una colección de nombres de frutas. El método GeneratePDFFromList itera sobre esta lista, construyendo una cadena HTML que incluye cada elemento en una lista desordenada. El renderizador ChromePdfRenderer de IronPDF convierte este contenido HTML en un documento PDF, que posteriormente se guarda en un archivo.

Conclusión

Esta guía para principiantes pretende cubrir los fundamentos y usos prácticos de IList en C#. Con ejemplos que van desde el uso sencillo hasta la implementación personalizada, está claro que IList es una potente herramienta del kit de herramientas del desarrollador de C#. Tanto si manipula colecciones de datos como si construye sus propios tipos de colecciones, IList le ofrece la funcionalidad y flexibilidad necesarias para un desarrollo de software eficaz. IronPDF ofrece un prueba gratuita para los usuarios interesados, con licencias disponibles a partir de $749.