Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. C# IList
.NET AIDE

C# iList (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Introduction au IList

IList fait partie de l'espace de noms 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 retirer des éléments de la collection au besoin. 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 PDF IronPDF en C# dans ce tutoriel.

Comprendre l'interface IList

La 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 l'espace de noms Collections du .NET Framework. IList inclut des propriétés et des 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 supprimant des éléments. Voici quelques-unes des principales propriétés et méthodes définies dans l'interface IList:

  • Les propriétés comme IsFixedSize et IsReadOnly informent si la collection a une taille fixe ou est en lecture seule, respectivement.
  • Des méthodes telles que Add, Insert, Remove et RemoveAt sont utilisées pour modifier les éléments de la collection. Vous pouvez ajouter, insérer et supprimer des éléments.
  • La méthode 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.

Utilisation pratique de l'interface IList

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

Créer et modifier un IList

Tout 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);
        }
    }
}
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 Class
$vbLabelText   $csharpLabel

Dans l'exemple ci-dessus, nous avons créé une instance IList à l'aide de ArrayList, une classe qui implémente IList. Nous avons ajouté un mélange de différents types d'objets pour montrer qu'un IList peut contenir n'importe quel objet. Enfin, nous avons parcouru la collection, affichant chaque élément.

Accès et modification basés sur l'index

L'accès et la modification 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]}");
    }
}
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 Class
$vbLabelText   $csharpLabel

Mise en œuvre d'un IList 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 simple collection personnalisée 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();
    }
}
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 Class
$vbLabelText   $csharpLabel

Cette classe CustomCollection encapsule un ArrayList, une classe qui elle-même implémente IList. Notre CustomCollection transfère les appels au ArrayList sous-jacent, lui permettant de se comporter comme n'importe quelle autre collection implémentant IList. Cet exemple illustre la création d'une collection pouvant être accédée par index, modifiée (éléments ajoutés, insérés ou supprimés) et parcourue comme n'importe quelle collection .NET intégrée implémentant IList.

Opérations avancées avec IList

Au-delà des opérations d'ajout, de suppression et d'accès de base, 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}");
    }
}
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 Class
$vbLabelText   $csharpLabel

Ces 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 : Bibliothèque PDF C

C# iList (How It Works For Developers): Figure 1 - IronPDF

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");
    }
}
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
$vbLabelText   $csharpLabel

Exemple de code

Voici un exemple simple qui démontre la génération d'un document PDF simple à partir d'une liste de chaînes avec 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);
    }
}
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
$vbLabelText   $csharpLabel

Dans cet exemple, un IList<string> est utilisé pour stocker une collection de noms de fruits. La méthode GeneratePDFFromList parcourt ensuite cette liste, construisant une chaîne HTML qui inclut chaque élément dans une liste non ordonnée. Le ChromePdfRenderer d'IronPDF convertit ce contenu HTML en un document PDF, qui est ensuite enregistré dans un fichier.

C# iList (How It Works For Developers): Figure 2 - PDF Output

Conclusion

C# iList (How It Works For Developers): Figure 3 - Licensing

Ce guide pour débutants visait à couvrir les bases et les utilisations pratiques de IList en C#. Avec des exemples allant de l'utilisation simple à la mise en œuvre personnalisée, il est clair que IList est un outil puissant dans la boîte à outils du développeur C#. Que vous manipuliez 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 offre un essai gratuit de sa bibliothèque PDF pour les utilisateurs intéressés, avec des licences disponibles à partir de $799.

Questions Fréquemment Posées

Qu'est-ce que l'interface IList en C# ?

L'interface `IList` fait partie de l'espace de noms Collections du .NET Framework, utilisée pour créer des collections dynamiques accessibles par index. Elle fournit des méthodes pour ajouter, insérer, supprimer et accéder à des éléments, offrant plus de flexibilité que les tableaux statiques.

Comment pouvez-vous convertir HTML en PDF en C# ?

Vous pouvez convertir du HTML en PDF en C# en utilisant la méthode `RenderHtmlAsPdf` de IronPDF. Cela vous permet de transformer des chaînes HTML, des fichiers ou des URL en documents PDF de haute qualité.

Quelles sont les méthodes clés de l'interface IList ?

Les méthodes clés de l'interface `IList` incluent `Add`, `Insert`, `Remove`, `RemoveAt` et `IndexOf`. Ces méthodes sont essentielles pour gérer et modifier dynamiquement les éléments dans la collection.

Comment pouvez-vous créer un IList personnalisé en C# ?

Pour créer un `IList` personnalisé en C#, vous pouvez implémenter l'interface `IList` dans une classe, en surclassant les méthodes et propriétés nécessaires telles que `Add`, `Remove` et `IndexOf`, pour personnaliser la gestion des éléments dans la collection.

Comment IronPDF crée-t-il des PDF à partir de HTML ?

IronPDF utilise la classe `ChromePdfRenderer` pour convertir le contenu HTML en PDFs. Il prend en charge la conversion à partir de chaînes HTML, fichiers ou URL, assurant une création précise de PDFs à partir de contenu web.

Pouvez-vous générer un PDF à partir d'un IList de données ?

Oui, vous pouvez générer un PDF à partir d'un IList en parcourant la liste pour construire une chaîne HTML, puis utiliser le `ChromePdfRenderer` de IronPDF pour convertir le HTML en un document PDF, qui peut être sauvegardé avec la méthode `SaveAs`.

Quelles opérations avancées l'IList prend-elle en charge ?

Les opérations avancées dans `IList` incluent la vérification si la collection contient un objet spécifique en utilisant `Contains` et la recherche de l'index d'un objet avec `IndexOf`. Ces fonctions aident à gérer efficacement les collections sans avoir besoin de chercher manuellement parmi les éléments.

Comment résoudre les problèmes de génération de PDF en C# ?

Si vous rencontrez des problèmes avec la génération de PDF en C#, assurez-vous que votre contenu HTML est correctement formaté et que vous utilisez la dernière version de IronPDF. Vérifiez toute exception levée lors du processus de conversion pour plus d'informations.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit