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

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

Curtis Chau
Curtis Chau
Mis à jour:

Les listes sont des structures de données polyvalentes et dynamiques utilisées pour stocker et manipuler des collections de données en C#. Elles font partie de l'espace de noms System.Collections.Generic, qui fournit une gamme de classes de collection puissantes et sûres, ainsi que des objets fortement typés. Ce didacticiel pour les débutants vous guidera à travers les bases de l'utilisation des listes en C#, notamment comment créer/ajouter des éléments, accéder à des indices ou premières occurrences spécifiés, modifier des éléments spécifiés et supprimer des éléments, ainsi que quelques cas d'utilisation courants.

Créer des listes

Pour commencer à utiliser la classe List, vous devez d'abord inclure l'espace de noms System.Collections.Generic dans votre code :

using System.Collections.Generic;
using System.Collections.Generic;
Imports System.Collections.Generic
$vbLabelText   $csharpLabel

Après avoir ajouté l'espace de noms générique, créez un nouvel objet List en spécifiant le type des données de tous les éléments que vous souhaitez stocker à l'intérieur des crochets angulaires (< >). Voici un exemple de création d'une liste d'entiers :

List<int> numbers = new List<int>();
List<int> numbers = new List<int>();
Dim numbers As New List(Of Integer)()
$vbLabelText   $csharpLabel

Vous pouvez également initialiser une liste avec des valeurs initiales ou la définir par la collection spécifiée comme ceci :

List<string> fruits = new List<string> { "apple", "banana", "cherry" };
List<string> fruits = new List<string> { "apple", "banana", "cherry" };
Dim fruits As New List(Of String) From {"apple", "banana", "cherry"}
$vbLabelText   $csharpLabel

Nous pouvons également spécifier la capacité initiale par défaut de la liste. La capacité initiale spécifiée est la capacité maximale par défaut de la liste.

Méthodes de la liste

Ajouter un nombre d'éléments à une liste

Pour ajouter des éléments à votre liste, utilisez la méthode Add() :

numbers.Add(1);     // Adds first element
numbers.Add(2);
numbers.Add(3);
numbers.Add(1);     // Adds first element
numbers.Add(2);
numbers.Add(3);
numbers.Add(1) ' Adds first element
numbers.Add(2)
numbers.Add(3)
$vbLabelText   $csharpLabel

Vous pouvez également ajouter une série d'éléments à partir d'une collection spécifiée à la liste en utilisant la méthode AddRange :

List<int> moreNumbers = new List<int> { 4, 5, 6 };
numbers.AddRange(moreNumbers);
List<int> moreNumbers = new List<int> { 4, 5, 6 };
numbers.AddRange(moreNumbers);
Dim moreNumbers As New List(Of Integer) From {4, 5, 6}
numbers.AddRange(moreNumbers)
$vbLabelText   $csharpLabel

Accéder aux éléments de la liste

Vous pouvez accéder aux éléments individuels d'une liste à l'aide d'un indice, de la même manière que les tableaux :

string firstFruit = fruits[0];          // "apple"
string secondFruit = fruits[1];         // "banana"
string firstFruit = fruits[0];          // "apple"
string secondFruit = fruits[1];         // "banana"
Dim firstFruit As String = fruits(0) ' "apple"
Dim secondFruit As String = fruits(1) ' "banana"
$vbLabelText   $csharpLabel

Gardez à l'esprit que les listes sont indexées à zéro, donc le premier élément a un indice de 0. L'exemple ci-dessus stockera l'élément dans la chaîne si elle existe.

Modifier les éléments de la liste

Pour modifier un élément dans une liste, attribuez simplement une nouvelle valeur à l'élément à l'indice souhaité, en gardant à l'esprit l'indice basé sur zéro :

fruits[1] = "blueberry";
fruits[1] = "blueberry";
fruits(1) = "blueberry"
$vbLabelText   $csharpLabel

Maintenant, le deuxième élément de la liste de fruits est "bleuet" au lieu de "banane".

Supprimer des éléments d'une liste

Pour supprimer un élément d'une liste, vous pouvez utiliser la méthode Remove, qui supprime la première occurrence d'un élément spécifié :

fruits.Remove("apple");
fruits.Remove("apple");
fruits.Remove("apple")
$vbLabelText   $csharpLabel

Alternativement, vous pouvez utiliser la méthode RemoveAt pour supprimer un élément à l'indice spécifié :

fruits.RemoveAt(0);
fruits.RemoveAt(0);
fruits.RemoveAt(0)
$vbLabelText   $csharpLabel

Pour supprimer tous les éléments d'une liste, utilisez la méthode Clear :

fruits.Clear();
fruits.Clear();
fruits.Clear()
$vbLabelText   $csharpLabel

Trouver des éléments dans une liste

Vous pouvez utiliser la méthode Contains() pour vérifier si une liste contient un élément spécifique :

bool containsApple = fruits.Contains("apple");  // true
bool containsApple = fruits.Contains("apple");  // true
Dim containsApple As Boolean = fruits.Contains("apple") ' true
$vbLabelText   $csharpLabel

Pour trouver l'indice de la première occurrence d'un élément, utilisez la méthode IndexOf :

int appleIndex = fruits.IndexOf("apple");  // 0
int appleIndex = fruits.IndexOf("apple");  // 0
Dim appleIndex As Integer = fruits.IndexOf("apple") ' 0
$vbLabelText   $csharpLabel

Si l'élément n'est pas trouvé, IndexOf renvoie -1.

Parcourir une liste

Pour itérer à travers les éléments d'une liste, vous pouvez utiliser une boucle foreach :

foreach (string fruit in fruits)
{
    Console.WriteLine(fruit);
}
foreach (string fruit in fruits)
{
    Console.WriteLine(fruit);
}
For Each fruit As String In fruits
	Console.WriteLine(fruit)
Next fruit
$vbLabelText   $csharpLabel

Alternativement, vous pouvez utiliser une boucle for avec la propriété Count, qui renvoie le nombre d'éléments dans la liste :

for (int i = 0; i < fruits.Count; i++)
{
    Console.WriteLine(fruits[i]);
}
for (int i = 0; i < fruits.Count; i++)
{
    Console.WriteLine(fruits[i]);
}
For i As Integer = 0 To fruits.Count - 1
	Console.WriteLine(fruits(i))
Next i
$vbLabelText   $csharpLabel

Trier une liste

Pour trier une liste par ordre croissant, utilisez la méthode Sort :

List<int> unsortedNumbers = new List<int> { 5, 2, 8, 1, 4 };
unsortedNumbers.Sort();

// Now, unsortedNumbers is { 1, 2, 4, 5, 8 }
List<int> unsortedNumbers = new List<int> { 5, 2, 8, 1, 4 };
unsortedNumbers.Sort();

// Now, unsortedNumbers is { 1, 2, 4, 5, 8 }
Dim unsortedNumbers As New List(Of Integer) From {5, 2, 8, 1, 4}
unsortedNumbers.Sort()

' Now, unsortedNumbers is { 1, 2, 4, 5, 8 }
$vbLabelText   $csharpLabel

Pour trier une liste par ordre décroissant, vous pouvez utiliser la méthode Sort avec une comparaison personnalisée :

unsortedNumbers.Sort((a, b) => b.CompareTo(a));

// Now, unsortedNumbers is { 8, 5, 4, 2, 1 }
unsortedNumbers.Sort((a, b) => b.CompareTo(a));

// Now, unsortedNumbers is { 8, 5, 4, 2, 1 }
unsortedNumbers.Sort(Function(a, b) b.CompareTo(a))

' Now, unsortedNumbers is { 8, 5, 4, 2, 1 }
$vbLabelText   $csharpLabel

Pour un tri plus complexe, vous pouvez implémenter une classe IComparer personnalisée ou utiliser LINQ (Language Integrated Query). L'algorithme de recherche binaire fonctionne sur des listes triées.

Utiliser LINQ avec des listes

LINQ vous permet d'effectuer des requêtes et des transformations puissantes sur des collections, y compris les listes. Pour utiliser LINQ, vous devez d'abord inclure l'espace de noms System.Linq dans votre code :

using System.Linq;
using System.Linq;
Imports System.Linq
$vbLabelText   $csharpLabel

Voici quelques exemples de requêtes LINQ sur une liste :

Filtrer une liste

List<int> evenNumbers = numbers.Where(x => x % 2 == 0).ToList();
List<int> evenNumbers = numbers.Where(x => x % 2 == 0).ToList();
Dim evenNumbers As List(Of Integer) = numbers.Where(Function(x) x Mod 2 = 0).ToList()
$vbLabelText   $csharpLabel

Mapper (transformer) les éléments d'une liste

List<string> fruitNamesUpperCase = fruits.Select(x => x.ToUpper()).ToList();
List<string> fruitNamesUpperCase = fruits.Select(x => x.ToUpper()).ToList();
Dim fruitNamesUpperCase As List(Of String) = fruits.Select(Function(x) x.ToUpper()).ToList()
$vbLabelText   $csharpLabel

Trouver les valeurs minimales et maximales d'une liste

int minValue = numbers.Min();
int maxValue = numbers.Max();
int minValue = numbers.Min();
int maxValue = numbers.Max();
Dim minValue As Integer = numbers.Min()
Dim maxValue As Integer = numbers.Max()
$vbLabelText   $csharpLabel

Convertir une liste en tableau

Pour convertir une liste en tableau, vous pouvez utiliser la méthode ToArray :

int[] numbersArray = numbers.ToArray();
int[] numbersArray = numbers.ToArray();
Dim numbersArray() As Integer = numbers.ToArray()
$vbLabelText   $csharpLabel

Exporter les données de la liste vers un PDF en utilisant IronPDF

Dans cette section, nous allons démontrer comment exporter les données d'une liste dans un fichier PDF en utilisant la bibliothèque IronPDF. Cela peut être utile lorsque vous souhaitez générer un rapport ou une version imprimable de vos données.

Tout d'abord, téléchargez et installez le package NuGet IronPDF dans votre projet :

Install-Package IronPdf

Ensuite, incluez l'espace de noms IronPdf dans votre code :

using IronPdf;
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

Maintenant, créons une fonction simple qui convertit une List de chaînes en un tableau HTML, puis l'exporte vers un fichier PDF :

using System.Collections.Generic;
using System.Text;
using IronPdf;

void ExportListToPdf(List<string> data, string pdfFilePath)
{
    // Create an HTML table from the list data
    StringBuilder htmlBuilder = new StringBuilder();
    htmlBuilder.Append("<table><tr><th>Item</th></tr>");

    foreach (string item in data)
    {
        htmlBuilder.Append($"<tr><td>{item}</td></tr>");
    }

    htmlBuilder.Append("</table>");

    // Convert the HTML table to a PDF using IronPDF
    var renderer = new ChromePdfRenderer();
    PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlBuilder.ToString());

    // Save the PDF to the specified file path
    pdf.SaveAs(pdfFilePath);
}
using System.Collections.Generic;
using System.Text;
using IronPdf;

void ExportListToPdf(List<string> data, string pdfFilePath)
{
    // Create an HTML table from the list data
    StringBuilder htmlBuilder = new StringBuilder();
    htmlBuilder.Append("<table><tr><th>Item</th></tr>");

    foreach (string item in data)
    {
        htmlBuilder.Append($"<tr><td>{item}</td></tr>");
    }

    htmlBuilder.Append("</table>");

    // Convert the HTML table to a PDF using IronPDF
    var renderer = new ChromePdfRenderer();
    PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlBuilder.ToString());

    // Save the PDF to the specified file path
    pdf.SaveAs(pdfFilePath);
}
Imports System.Collections.Generic
Imports System.Text
Imports IronPdf

Private Sub ExportListToPdf(ByVal data As List(Of String), ByVal pdfFilePath As String)
	' Create an HTML table from the list data
	Dim htmlBuilder As New StringBuilder()
	htmlBuilder.Append("<table><tr><th>Item</th></tr>")

	For Each item As String In data
		htmlBuilder.Append($"<tr><td>{item}</td></tr>")
	Next item

	htmlBuilder.Append("</table>")

	' Convert the HTML table to a PDF using IronPDF
	Dim renderer = New ChromePdfRenderer()
	Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlBuilder.ToString())

	' Save the PDF to the specified file path
	pdf.SaveAs(pdfFilePath)
End Sub
$vbLabelText   $csharpLabel

Pour utiliser cette fonction, appelez-la simplement avec votre liste et le chemin de fichier PDF souhaité :

List<string> fruits = new List<string> { "apple", "banana", "cherry" };
ExportListToPdf(fruits, "Fruits.pdf");
List<string> fruits = new List<string> { "apple", "banana", "cherry" };
ExportListToPdf(fruits, "Fruits.pdf");
Dim fruits As New List(Of String) From {"apple", "banana", "cherry"}
ExportListToPdf(fruits, "Fruits.pdf")
$vbLabelText   $csharpLabel

Cela générera un fichier PDF nommé "Fruits.pdf" contenant un tableau avec la liste des fruits en convertissant HTML en PDF avec IronPDF. Vous pouvez modifier la fonction ExportListToPdf pour répondre à vos besoins, comme ajouter un style personnalisé au tableau HTML ou du contenu supplémentaire au PDF.

Liste C# (Comment cela fonctionne pour les développeurs) Figure 1 - HTML en PDF

Conclusion

Dans ce didacticiel pour débutants, nous avons couvert les bases de l'utilisation des listes en C# et nous avons démontré comment intégrer IronPDF pour exporter les données de la liste dans un fichier PDF. En incorporant IronPDF dans vos projets, vous pouvez facilement générer des rapports, des factures ou d'autres documents imprimables à partir de vos projets C#.

IronPDF propose un essai gratuit, vous permettant de tester ses capacités avant de vous engager dans un achat.

Questions Fréquemment Posées

Comment puis-je créer une liste en C#?

Pour créer une liste en C#, vous devez inclure l'espace de noms System.Collections.Generic. Vous pouvez ensuite déclarer une liste en spécifiant le type de données entre des crochets. Par exemple : List numbers = new List();

Quelles méthodes sont utilisées pour ajouter des éléments à une liste C#?

Les éléments peuvent être ajoutés à une liste C# en utilisant la méthode Add() pour les éléments individuels et AddRange() pour ajouter une collection d'éléments.

Comment puis-je exporter une liste C# dans un fichier PDF?

Pour exporter une liste C# dans un fichier PDF, vous pouvez utiliser la bibliothèque IronPDF. Convertissez vos données de liste en format de tableau HTML, puis affichez-les sous forme de PDF à l'aide d'IronPDF.

Quelle est la meilleure façon de trier une liste C#?

Vous pouvez trier une liste C# dans l'ordre croissant en utilisant la méthode Sort(). Pour trier dans l'ordre décroissant, vous pouvez utiliser Sort() avec un délégué de comparaison personnalisé.

Comment accédez-vous aux éléments d'une liste C#?

Les éléments d'une liste C# peuvent être accessibles en utilisant leur index, de la même manière que pour les tableaux. Les listes sont indexées à partir de zéro, vous pouvez donc utiliser la position d'un élément dans la liste pour le récupérer.

Quelles options sont disponibles pour supprimer des éléments d'une liste C#?

Vous pouvez supprimer des éléments d'une liste C# en utilisant la méthode Remove() pour des éléments spécifiques, RemoveAt() pour un index spécifique, ou Clear() pour supprimer tous les éléments.

Comment LINQ peut-il être utilisé avec les listes C#?

LINQ peut être utilisé avec les listes C# pour effectuer des requêtes et transformations puissantes, telles que le filtrage, le mapping, et la recherche efficace des valeurs minimales ou maximales.

Comment puis-je convertir une liste en tableau en C#?

Vous pouvez convertir une liste C# en tableau en utilisant la méthode ToArray(), qui crée un nouveau tableau contenant les éléments de la liste.

Quelles sont les utilisations courantes des listes C#?

Les listes C# sont couramment utilisées pour gérer des collections de données dynamiques, exécuter des requêtes complexes avec LINQ, et générer des rapports ou des documents à l'aide de bibliothèques comme IronPDF.

Comment parcourez-vous les éléments dans une liste C#?

Vous pouvez parcourir les éléments d'une liste C# en utilisant des boucles foreach pour une itération simple ou des boucles for lorsque vous avez besoin de l'index.

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