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

Introduction à la IListe

IList fait partie de l'espace de noms Collections du Framework .NET. Il s'agit d'une interface de collection non générique qui fournit le modèle d'une collection d'objets auxquels on peut accéder 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 en fonction de vos besoins. Elle sert d'interface de base pour toutes les listes non génériques dans le Framework .NET, offrant un moyen de gérer une collection d'objets d'une manière plus souple que les tableaux. Nous apprendrons à connaître l'interface IList et l'interfaceIronPDF C# PDF Library (Bibliothèque PDF C#) dans ce tutoriel.

Comprendre l'interface `IList

La déclaration public interface IList est un élément fondamental 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 Framework .NET. IList comprend 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 telles que IsFixedSize et IsReadOnly indiquent si la collection est de taille fixe ou en lecture seule, respectivement.
• Les méthodes telles que Add, void 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 permet de localiser les éléments et la propriété Item permet de localiser les éléments(ou indexeur en C#) permet d'obtenir et de définir des éléments en fonction de leur index.

Utilisation pratique de l'interface publique IList (en anglais)

Pour montrer comment fonctionne IList, créons un exemple simple. Cet exemple de version générique montre comment déclarer une IList, y ajouter des éléments et itérer sur son contenu.

Création et modification d'une IListe

Tout d'abord, voyons comment déclarer une IList et y ajouter des éléments :

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

Dans l'exemple ci-dessus, nous avons créé une instance de 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'une IList peut contenir n'importe quel objet. Enfin, nous avons itéré sur la collection, en imprimant chaque élément.

Accès et modification sur la base d'un index

L'accès et la modification des éléments par leur index est une caractéristique essentielle de IList. L'exemple suivant de IList montre comment vous pouvez le faire :

// 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)}")

Implémentation d'une IList personnalisée

Parfois, vous pouvez avoir besoin d'une collection personnalisée qui hérite de IList. Cela permet de mieux contrôler la manière dont les éléments sont stockés, accessibles et modifiés. Voici un exemple de collection personnalisée simple mettant en œuvre 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

Cette classe CustomCollection encapsule une ArrayList, une classe qui implémente elle-même IList. Notre CustomCollection transmet les appels à la ArrayList sous-jacente, ce qui lui permet de se comporter comme n'importe quelle autre collection qui implémente IList. Cet exemple illustre la création d'une collection à laquelle il est possible d'accéder par l'index, la modification, etc(les éléments ajoutés, insérés ou supprimés)et itérée, tout comme n'importe quelle collection .NET intégrée qui implémente IList.

Opérations avancées avec IList

Au-delà des opérations de base d'ajout, de suppression et d'accès, IList permet des manipulations et des requêtes plus complexes. Par exemple, vérifier si la collection contient un objet spécifique ou trouver l'index d'un objet dans la collection sont des opérations qui peuvent être essentielles pour certaines applications :

// 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}")

Ces opérations peuvent être particulièrement utiles lorsqu'il s'agit de collections d'objets et qu'il faut déterminer la présence ou la position d'éléments spécifiques sans avoir à itérer sur l'ensemble de la collection.

IronPDF : Bibliothèque PDF C

IronPDF for .NET 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 permet de convertirHTML vers documents PDFla traduction d'images et de pages web au format PDF. Les développeurs peuvent facilement ajouter des fonctionnalités PDF à leurs applications grâce à cette bibliothèque. IronPDF comprend également des fonctions d'édition, de fusion et de division de fichiers PDF, qui permettent un contrôle complet de la manipulation des PDF.

Exemple de code

Voici un exemple simple qui montre comment générer un document PDF simple à partir d'une liste de chaînes de caractères 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);
    }
}

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

Dans cet exemple, une 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. IronPDF's ChromePdfRenderer convertit ce contenu HTML en un document PDF, qui est ensuite sauvegardé dans un fichier.

Conclusion

Ce guide destiné aux débutants a pour but de 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 que vous construisiez vos types de collections, IList offre les fonctionnalités et la flexibilité nécessaires à un développement logiciel efficace. IronPDF offre un service deessai gratuit de sa bibliothèque PDF pour les utilisateurs intéressés, avec des licences disponibles à partir de $749.