Pruebe en producción sin marcas de agua.
Funciona donde lo necesite.
Obtén 30 días de producto totalmente funcional.
Ténlo en funcionamiento en minutos.
Acceso completo a nuestro equipo de asistencia técnica durante la prueba del producto
IList
IList
es parte del espacio de nombres Collections del .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 los arrays, IList
permite un número dinámico de elementos de valor de objeto, lo que significa que puedes agregar 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. Aprenderemos sobre la interfaz IList
y la IronPDF C# PDF Library en este tutorial.
IList
La declaración public interface IList
es una parte fundamental para crear colecciones personalizadas en C# que se adhieren al contrato IList
especificado por el espacio de nombres de Colecciones del .NET Framework. IList
incluye propiedades y métodos que permiten acceder a los elementos en la colección, contarlos y modificar la colección añadiendo, insertando o eliminando elementos. A continuación, se presentan algunas de las propiedades y métodos clave definidos en la interfaz IList
:
IsFixedSize
e IsReadOnly
informan si la colección es de tamaño fijo o de solo lectura, respectivamente.Add
, void Insert
, Remove
y RemoveAt
se utilizan para modificar elementos dentro de la colección. Se pueden añadir, insertar y eliminar elementos.IndexOf
es para localizar elementos, y la propiedad Item
(o indexador en C#) permite obtener y establecer elementos basados en su índice.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
, agregar elementos a ella e iterar sobre su contenido.
IList
Primero, veamos cómo declarar un IList
y agregar elementos a él:
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 un IList
puede contener cualquier objeto. Por último, hemos iterado sobre la colección, imprimiendo cada elemento.
Acceder y modificar elementos por su índice es una característica clave de IList
. El siguiente ejemplo de IList
muestra cómo puede 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)}")
IList
personalizadaA veces, es posible que necesites una colección personalizada 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 simple 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 un ArrayList
, una clase que implementa IList
por sí misma. Nuestra CustomCollection
reenvía llamadas a la subyacente ArrayList
, permitiéndole comportarse como cualquier otra colección que implemente IList
. Este ejemplo demuestra la creación de una colección que puede ser accedida por índice, modificada (elementos añadidos, insertados o eliminados) y recorrida, al igual que cualquier colección incorporada de .NET que implemente IList
.
IList
Más allá de las operaciones básicas de agregar, quitar y acceder, 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 es una biblioteca PDF para desarrolladores .NET que permite crear y manipular documentos PDF directamente dentro de aplicaciones .NET. Admite la conversión de HTML a documentos 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.
IronPDF se destaca en la conversión de HTML a PDF, asegurando una preservación precisa de los diseños y estilos originales. Es perfecto para crear PDFs a partir de contenido basado en la web, como informes, facturas y documentación. Con soporte para archivos HTML, URLs y cadenas de HTML en bruto, IronPDF produce fácilmente documentos PDF de alta calidad.
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
// 1. Convert HTML String to PDF
var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
// 2. Convert HTML File to PDF
var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
// 3. Convert URL to PDF
var url = "http://ironpdf.com"; // Specify the URL
var pdfFromUrl = renderer.RenderUrlAsPdf(url);
pdfFromUrl.SaveAs("URLToPDF.pdf");
}
}
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
// 1. Convert HTML String to PDF
var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
// 2. Convert HTML File to PDF
var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
// 3. Convert URL to PDF
var url = "http://ironpdf.com"; // Specify the URL
var pdfFromUrl = renderer.RenderUrlAsPdf(url);
pdfFromUrl.SaveAs("URLToPDF.pdf");
}
}
Imports IronPdf
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim renderer = New ChromePdfRenderer()
' 1. Convert HTML String to PDF
Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")
' 2. Convert HTML File to PDF
Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")
' 3. Convert URL to PDF
Dim url = "http://ironpdf.com" ' Specify the URL
Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
pdfFromUrl.SaveAs("URLToPDF.pdf")
End Sub
End Class
A continuación, se muestra un ejemplo sencillo que demuestra cómo generar 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, se utiliza un IList<string>
para almacenar una colección de nombres de frutas. El método GeneratePDFFromList
luego itera sobre esta lista, construyendo una cadena HTML que incluye cada elemento en una lista desordenada. ChromePdfRenderer
de IronPDF convierte este contenido HTML en un documento PDF, que posteriormente se guarda en un archivo.
Esta guía para principiantes está destinada a cubrir los conceptos básicos y los usos prácticos de IList
en C#. Con ejemplos que van desde un uso simple hasta una implementación personalizada, está claro que IList
es una herramienta poderosa en el kit de herramientas del desarrollador de C#. Ya sea que esté manipulando colecciones de datos o construyendo sus tipos de colecciones, IList
ofrece la funcionalidad y flexibilidad necesarias para un desarrollo de software efectivo. IronPDF ofrece una prueba gratuita de su biblioteca PDF para usuarios interesados, con licencias disponibles a partir de $749.