AYUDA .NET

C# iList (Cómo funciona para desarrolladores)

Actualizado 6 de junio, 2024
Compartir:

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)
    {
        //  Creación de una instancia IList
        IList myIList = new ArrayList();
        //  Añadir elementos a la IList
        myIList.Add("Hello");
        myIList.Add(10);
        myIList.Add(new object());
        //  Visualización del número de valores en la interfaz IList mediante la propiedad count
        Console.WriteLine($"Number of elements: {myIList.Count}");
        //  Elementos de acceso
        foreach (var element in myIList)
        {
            Console.WriteLine(element);
        }
    }
}
using System;
using System.Collections;
class Program
{
    void Main(string[] args)
    {
        //  Creación de una instancia IList
        IList myIList = new ArrayList();
        //  Añadir elementos a la IList
        myIList.Add("Hello");
        myIList.Add(10);
        myIList.Add(new object());
        //  Visualización del número de valores en la interfaz IList mediante la propiedad count
        Console.WriteLine($"Number of elements: {myIList.Count}");
        //  Elementos de acceso
        foreach (var element in myIList)
        {
            Console.WriteLine(element);
        }
    }
}
Imports System
Imports System.Collections
Friend Class Program
	Private Sub Main(ByVal args() As String)
		'  Creación de una instancia IList
		Dim myIList As IList = New ArrayList()
		'  Añadir elementos a la IList
		myIList.Add("Hello")
		myIList.Add(10)
		myIList.Add(New Object())
		'  Visualización del número de valores en la interfaz IList mediante la propiedad count
		Console.WriteLine($"Number of elements: {myIList.Count}")
		'  Elementos de acceso
		For Each element In myIList
			Console.WriteLine(element)
		Next element
	End Sub
End Class
VB   C#

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:

//  Acceso a un elemento por índice
object value = myIList[1];
Console.WriteLine($"Element at index 1: {value}");
//  Modificar un elemento por índice
myIList[1] = 20;
Console.WriteLine($"Modified element at index 1: {myIList[1]}");
//  Acceso a un elemento por índice
object value = myIList[1];
Console.WriteLine($"Element at index 1: {value}");
//  Modificar un elemento por índice
myIList[1] = 20;
Console.WriteLine($"Modified element at index 1: {myIList[1]}");
'  Acceso a un elemento por índice
Dim value As Object = myIList(1)
Console.WriteLine($"Element at index 1: {value}")
'  Modificar un elemento por índice
myIList(1) = 20
Console.WriteLine($"Modified element at index 1: {myIList(1)}")
VB   C#

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 añadir
    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 añadir
    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 añadir
	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
VB   C#

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:

//  Comprueba si la IList contiene un objeto específico
bool contains = myIList.Contains(10); //  Suponiendo que se haya añadido 10 anteriormente
Console.WriteLine($"Contains 10: {contains}");
//  Encontrar el índice de un objeto específico
int index = myIList.IndexOf(10);
Console.WriteLine($"Index of 10: {index}");
//  Comprueba si la IList contiene un objeto específico
bool contains = myIList.Contains(10); //  Suponiendo que se haya añadido 10 anteriormente
Console.WriteLine($"Contains 10: {contains}");
//  Encontrar el índice de un objeto específico
int index = myIList.IndexOf(10);
Console.WriteLine($"Index of 10: {index}");
'  Comprueba si la IList contiene un objeto específico
Dim contains As Boolean = myIList.Contains(10) '  Suponiendo que se haya añadido 10 anteriormente
Console.WriteLine($"Contains 10: {contains}")
'  Encontrar el índice de un objeto específico
Dim index As Integer = myIList.IndexOf(10)
Console.WriteLine($"Index of 10: {index}")
VB   C#

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

C# iList (Cómo funciona para desarrolladores): Figura 1 - IronPDF

IronPDF es una biblioteca PDF para desarrolladores .NET que permite crear y manipular documentos PDF directamente dentro de aplicaciones .NET. Permite convertir HTML a PDF imá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)
    {
        //  Inicializar el renderizador HtmlToPdf
        var renderer = new ChromePdfRenderer();
        //  Empezar a crear contenido HTML a partir de dataList
        var htmlContent = "<h1>My Data List</h1><ul>";
        foreach (var item in dataList)
        {
            htmlContent += $"<li>{item}</li>";
        }
        htmlContent += "</ul>";
        //  Convertir cadena HTML a PDF
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        //  Guardar el PDF en un archivo
        pdfDocument.SaveAs("DataList.pdf");
    }
}
//  Ejemplo de uso
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)
    {
        //  Inicializar el renderizador HtmlToPdf
        var renderer = new ChromePdfRenderer();
        //  Empezar a crear contenido HTML a partir de dataList
        var htmlContent = "<h1>My Data List</h1><ul>";
        foreach (var item in dataList)
        {
            htmlContent += $"<li>{item}</li>";
        }
        htmlContent += "</ul>";
        //  Convertir cadena HTML a PDF
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        //  Guardar el PDF en un archivo
        pdfDocument.SaveAs("DataList.pdf");
    }
}
//  Ejemplo de uso
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))
		'  Inicializar el renderizador HtmlToPdf
		Dim renderer = New ChromePdfRenderer()
		'  Empezar a crear contenido HTML a partir de dataList
		Dim htmlContent = "<h1>My Data List</h1><ul>"
		For Each item In dataList
			htmlContent &= $"<li>{item}</li>"
		Next item
		htmlContent &= "</ul>"
		'  Convertir cadena HTML a PDF
		Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
		'  Guardar el PDF en un archivo
		pdfDocument.SaveAs("DataList.pdf")
	End Sub
End Class
'  Ejemplo de uso
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
VB   C#

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.

C# iList (Cómo funciona para desarrolladores): Figura 2 - Salida PDF

Conclusión

C# iList (Cómo funciona para desarrolladores): Figura 3 - Licencias

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.

< ANTERIOR
C# Linked List (Cómo funciona para desarrolladores)
SIGUIENTE >
Polly Retry (Cómo funciona para los desarrolladores)

¿Listo para empezar? Versión: 2024.7 recién publicada

Descarga gratuita de NuGet Descargas totales: 9,848,088 Ver licencias >
123