IListIList fait partie du namespace Collections du .NET Framework. Il s'agit d'une interface de collection non générique qui fournit le modèle pour une collection d'objets pouvant être accédés individuellement par leur index. Contrairement aux tableaux, IList permet un nombre dynamique d'éléments de valeur d'objet, ce qui signifie que vous pouvez ajouter ou supprimer des éléments de la collection selon vos besoins. Il sert d'interface de base pour toutes les listes non génériques du .NET Framework, offrant un moyen de gérer une collection d'objets de manière plus flexible que les tableaux. Nous allons apprendre l'interface IList et la bibliothèque IronPDF C# PDF dans ce tutoriel.
IListLa déclaration public interface IList est une partie fondamentale de la création de collections personnalisées en C# qui adhèrent au contrat IList spécifié par le namespace Collections du .NET Framework. IList comprend des propriétés et méthodes qui permettent d'accéder aux éléments de la collection, de les compter et de modifier la collection en ajoutant, insérant ou en supprimant des éléments. Voici quelques-unes des propriétés et méthodes clés définies dans l'interface IList :
IsFixedSize et IsReadOnly indiquent si la collection est de taille fixe ou en lecture seule, respectivement.Add, Insert, Remove et RemoveAt sont utilisées pour modifier les éléments au sein de la collection. Vous pouvez ajouter, insérer et supprimer des éléments.IndexOf sert à localiser des éléments, et la propriété Item (ou indexeur en C#) permet d'obtenir et de définir des éléments en fonction de leur index.IListPour montrer comment fonctionne IList, créons un exemple simple. Cet exemple démontrera comment déclarer un IList, y ajouter des éléments, et itérer sur son contenu.
IListTout d'abord, voyons comment déclarer un IList et y ajouter des éléments :
using System;
using System.Collections;
class Program
{
static 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 using the Count property
Console.WriteLine($"Number of elements: {myIList.Count}");
// Accessing elements using a loop
foreach (var element in myIList)
{
Console.WriteLine(element);
}
}
}Imports System
Imports System.Collections
Friend Class Program
Shared 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 using the Count property
Console.WriteLine($"Number of elements: {myIList.Count}")
' Accessing elements using a loop
For Each element In myIList
Console.WriteLine(element)
Next element
End Sub
End ClassDans l'exemple ci-dessus, nous avons créé une instance IList en utilisant ArrayList, une classe qui implémente IList. Nous avons ajouté un mélange de différents types d'objets pour démontrer qu'un IList peut contenir n'importe quel objet. Enfin, nous avons parcouru la collection, affichant chaque élément.
Accéder et modifier des éléments par leur index est une fonctionnalité clé de IList. L'exemple suivant montre comment vous pouvez le faire:
using System;
using System.Collections;
class Program
{
static void Main(string[] args)
{
IList myIList = new ArrayList { "Hello", 10, new object() };
// 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]}");
}
}Imports System
Imports System.Collections
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim myIList As IList = New ArrayList From { "Hello", 10, New Object() }
' 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)}")
End Sub
End ClassIList PersonnaliséParfois, vous pourriez avoir besoin d'une collection sur mesure qui hérite de IList. Cela permet un meilleur contrôle sur la façon dont les éléments sont stockés, accédés et modifiés. Voici un exemple d'une collection personnalisée simple implémentant IList :
using System;
using System.Collections;
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;
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();
}
}Imports System
Imports System.Collections
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
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 ClassCette classe CustomCollection encapsule un ArrayList, une classe qui elle-même implémente IList. Notre CustomCollection redirige les appels vers le ArrayList sous-jacent, lui permettant de se comporter comme toute autre collection qui implémente IList. Cet exemple montre comment créer une collection qui peut être accessible par index, modifiée (éléments ajoutés, insérés ou supprimés), et itérée, tout comme toute collection intégrée .NET qui implémente IList.
IListAu-delà des opérations de base d'ajout, suppression, et accès, IList permet des manipulations et requêtes plus complexes. Par exemple, vérifier si la collection contient un objet spécifique ou trouver l'index d'un objet au sein de la collection sont des opérations qui peuvent être essentielles pour certaines applications:
using System;
using System.Collections;
class Program
{
static void Main(string[] args)
{
IList myIList = new ArrayList { "Hello", 10, new object() };
// 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}");
}
}Imports System
Imports System.Collections
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim myIList As IList = New ArrayList From { "Hello", 10, New Object() }
' 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}")
End Sub
End ClassCes opérations peuvent être particulièrement utiles lorsqu'il s'agit de collections d'objets où vous devez déterminer la présence ou la position d'éléments spécifiques sans parcourir toute la collection.
IronPDF est une bibliothèque PDF pour les développeurs .NET qui permet la création et la manipulation de documents PDF directement dans les applications .NET. Il prend en charge la conversion de HTML en documents PDF, images et pages web en PDF. Les développeurs peuvent facilement ajouter des fonctionnalités PDF à leurs applications avec cette bibliothèque. IronPDF inclut également des fonctionnalités pour l'édition, le fusionnement et la division des fichiers PDF, offrant un contrôle total sur la manipulation des PDF.
IronPDF excelle dans la conversion HTML en PDF, garantissant une préservation précise des mises en page et styles originaux. Il est parfait pour créer des PDF à partir de contenus basés sur le Web tels que des rapports, des factures et de la documentation. Avec le support des fichiers HTML, des URLs et des chaînes HTML brutes, IronPDF produit facilement des documents PDF de haute qualité.
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 ClassVoici un exemple simple qui démontre la génération d'un document PDF à partir d'une liste de chaînes en utilisant IronPDF et l'interface 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);
}
}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 ClassDans cet exemple, un IList<string> est utilisé pour stocker une collection de noms de fruits. La méthode GeneratePDFFromList itère ensuite sur cette liste, construisant une chaîne HTML qui inclut chaque élément dans une liste non ordonnée. Le ChromePdfRenderer de IronPDF convertit ce contenu HTML en document PDF, qui est ensuite enregistré dans un fichier.
Ce guide convivial pour les débutants visait à couvrir les bases et utilisations pratiques de IList en C#. Avec des exemples allant de l'utilisation simple à l'implémentation personnalisée, il est clair que IList est un outil puissant dans la boîte à outils du développeur C#. Que vous modifiiez des collections de données ou construisiez vos types de collection, IList offre la fonctionnalité et la flexibilité nécessaires pour un développement logiciel efficace. IronPDF propose une version d'essai gratuite de sa bibliothèque PDF pour les utilisateurs intéressés, avec des licences disponibles à partir de $999.
Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
