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

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

Curtis Chau
Curtis Chau
Mis à jour:

Les listes font partie de l'espace de noms System.Collections.Generic et sont polyvalentes pour gérer des collections de données. Les listes en C# sont dynamiques, ce qui signifie que leur taille peut changer lors de l'exécution. Cette flexibilité est très utile dans de nombreux scénarios d'ingénierie logicielle où le nombre d'éléments n'est pas connu à l'avance. Explorons différentes façons d'initialiser une liste en C#. Nous aborderons les techniques de base, la syntaxe de l'initialiseur d'objets, les initialiseurs de collection, et la bibliothèque IronPDF.

Initialisation de liste de base

Pour initialiser une liste, commencez par créer une instance de la classe List<T>, où T est le type des éléments dans la liste. Le type le plus courant est string, mais vous pouvez utiliser n'importe quel type.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Initialize an empty list
        List<string> fruits = new List<string>();

        // Adding elements to the list
        fruits.Add("Apple");
        fruits.Add("Banana");
        fruits.Add("Cherry");

        // Display the list
        foreach (var fruit in fruits)
        {
            Console.WriteLine(fruit);
        }
    }
}
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Initialize an empty list
        List<string> fruits = new List<string>();

        // Adding elements to the list
        fruits.Add("Apple");
        fruits.Add("Banana");
        fruits.Add("Cherry");

        // Display the list
        foreach (var fruit in fruits)
        {
            Console.WriteLine(fruit);
        }
    }
}
Imports System
Imports System.Collections.Generic

Friend Class Program
	Shared Sub Main()
		' Initialize an empty list
		Dim fruits As New List(Of String)()

		' Adding elements to the list
		fruits.Add("Apple")
		fruits.Add("Banana")
		fruits.Add("Cherry")

		' Display the list
		For Each fruit In fruits
			Console.WriteLine(fruit)
		Next fruit
	End Sub
End Class
$vbLabelText   $csharpLabel

Dans l'exemple ci-dessus, nous avons créé une liste vide et ajouté des éléments en utilisant la méthode Add. La List<string> représente une liste de chaînes de caractères, et nous avons utilisé la méthode Add pour la remplir avec des valeurs.

Utilisation de la syntaxe des initialiseurs de collection

C# offre un moyen plus concis d'initialiser une liste en utilisant la syntaxe des initialiseurs de collection. Cela vous permet de remplir directement la liste lorsqu'elle est créée sans appeler à plusieurs reprises la méthode Add.

public void InitializeList()
{
    List<string> fruits = new List<string> { "Apple", "Banana", "Cherry" };
}
public void InitializeList()
{
    List<string> fruits = new List<string> { "Apple", "Banana", "Cherry" };
}
Public Sub InitializeList()
	Dim fruits As New List(Of String) From {"Apple", "Banana", "Cherry"}
End Sub
$vbLabelText   $csharpLabel

Ce code atteint le même résultat que l'exemple précédent mais de manière plus compacte. Les initialiseurs de collection vous permettent d'initialiser une liste avec des valeurs en une seule instruction, rendant votre code plus lisible.

Initialiseurs d'objets et initialisation de liste

La syntaxe de l'initialiseur d'objets est un autre moyen d'initialiser des listes, principalement lors de l'utilisation d'objets personnalisés. Voici un exemple de fonctionnement des initialiseurs d'objets avec des listes :

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

List<Person> people = new List<Person>
{
    new Person { Name = "John", Age = 30 },
    new Person { Name = "Jane", Age = 25 },
    new Person { Name = "Jack", Age = 35 }
};
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

List<Person> people = new List<Person>
{
    new Person { Name = "John", Age = 30 },
    new Person { Name = "Jane", Age = 25 },
    new Person { Name = "Jack", Age = 35 }
};
Friend Class Person
	Public Property Name() As String
	Public Property Age() As Integer
End Class

Private people As New List(Of Person) From {
	New Person With {
		.Name = "John",
		.Age = 30
	},
	New Person With {
		.Name = "Jane",
		.Age = 25
	},
	New Person With {
		.Name = "Jack",
		.Age = 35
	}
}
$vbLabelText   $csharpLabel

Dans cet exemple, nous créons une liste d'objets Person en utilisant des initialiseurs d'objets. La classe Person a deux propriétés : Name et Age, qui se voient attribuer des valeurs explicitement lors de la création de la liste.

Créer une liste avec une taille initiale

Bien que les listes soient dynamiques en taille, vous pouvez spécifier une capacité initiale si vous savez approximativement combien d'éléments la liste contiendra. Cela peut améliorer les performances en réduisant le nombre de réallocations de mémoire.

List<string> fruits = new List<string>(10); // Initial size of 10
List<string> fruits = new List<string>(10); // Initial size of 10
Dim fruits As New List(Of String)(10) ' Initial size of 10
$vbLabelText   $csharpLabel

Cela crée une liste vide avec une capacité initiale de 10. Bien qu'elle n'ajoute pas d'éléments, elle alloue suffisamment de mémoire pour contenir jusqu'à 10 éléments sans redimensionner le tableau interne.

Initialiser une liste à partir d'un tableau

Vous pouvez également initialiser une liste à partir d'un tableau existant en utilisant le constructeur de liste qui prend un argument IEnumerable<T>. C'est utile lorsque vous avez un tableau et que vous souhaitez le convertir en liste pour plus de flexibilité.

// New String array of fruit
string[] fruitArray = { "Apple", "Banana", "Cherry" };
List<string> fruits = new List<string>(fruitArray);
// New String array of fruit
string[] fruitArray = { "Apple", "Banana", "Cherry" };
List<string> fruits = new List<string>(fruitArray);
' New String array of fruit
Dim fruitArray() As String = { "Apple", "Banana", "Cherry" }
Dim fruits As New List(Of String)(fruitArray)
$vbLabelText   $csharpLabel

Ici, un nouveau tableau est créé, puis utilisé pour initialiser une liste. Cela convertit le tableau fruitArray en une liste. Tout IEnumerable<T>, y compris les tableaux, peut être passé au constructeur de liste pour l'initialisation.

Utilisation de la méthode AddRange

Si vous avez une collection existante d'éléments, vous pouvez utiliser la méthode AddRange pour ajouter plusieurs éléments à une liste ensemble.

List<string> fruits = new List<string> { "Apple", "Banana" };
string[] moreFruits = { "Cherry", "Date", "Elderberry" };
fruits.AddRange(moreFruits);
List<string> fruits = new List<string> { "Apple", "Banana" };
string[] moreFruits = { "Cherry", "Date", "Elderberry" };
fruits.AddRange(moreFruits);
Dim fruits As New List(Of String) From {"Apple", "Banana"}
Dim moreFruits() As String = { "Cherry", "Date", "Elderberry" }
fruits.AddRange(moreFruits)
$vbLabelText   $csharpLabel

Dans cet exemple, nous commençons avec une liste contenant deux éléments et ajoutons plusieurs nouveaux éléments à partir d'un tableau en utilisant AddRange. Cette méthode peut améliorer les performances en ajoutant des éléments en masse, car elle minimise la nécessité de plusieurs réallocations.

Initialisation d'une liste avec des objets personnalisés

Lors de l'initialisation d'une liste d'objets personnalisés, vous pouvez combiner les initialiseurs d'objets avec les initialiseurs de collection pour créer des structures de données complexes en une seule expression.

List<Person> people = new List<Person>
{
    new Person { Name = "Alice", Age = 28 },
    new Person { Name = "Bob", Age = 32 },
    new Person { Name = "Charlie", Age = 40 }
};
List<Person> people = new List<Person>
{
    new Person { Name = "Alice", Age = 28 },
    new Person { Name = "Bob", Age = 32 },
    new Person { Name = "Charlie", Age = 40 }
};
Dim people As New List(Of Person) From {
	New Person With {
		.Name = "Alice",
		.Age = 28
	},
	New Person With {
		.Name = "Bob",
		.Age = 32
	},
	New Person With {
		.Name = "Charlie",
		.Age = 40
	}
}
$vbLabelText   $csharpLabel

Cette technique permet de créer et d'initialiser une liste d'objets en une seule instruction, rendant le code concis et facile à lire.

Initialisation de liste avec des méthodes d'extension

Vous pouvez également implémenter une méthode d'extension pour initialiser une liste de manière personnalisée. Les méthodes d'extension offrent un mécanisme pour améliorer les types existants avec de nouvelles capacités sans altérer leur structure d'origine.

public static class ListExtensions
{
    public static List<T> InitializeWith<T>(this List<T> list, params T[] elements)
    {
        list.AddRange(elements);
        return list;
    }
}

// Usage
List<string> fruits = new List<string>().InitializeWith("Apple", "Banana", "Cherry");
public static class ListExtensions
{
    public static List<T> InitializeWith<T>(this List<T> list, params T[] elements)
    {
        list.AddRange(elements);
        return list;
    }
}

// Usage
List<string> fruits = new List<string>().InitializeWith("Apple", "Banana", "Cherry");
Public Module ListExtensions
	<System.Runtime.CompilerServices.Extension> _
	Public Function InitializeWith(Of T)(ByVal list As List(Of T), ParamArray ByVal elements() As T) As List(Of T)
		list.AddRange(elements)
		Return list
	End Function
End Module

' Usage
Private fruits As List(Of String) = (New List(Of String)()).InitializeWith("Apple", "Banana", "Cherry")
$vbLabelText   $csharpLabel

Ici, nous définissons une méthode d'extension, InitializeWith, qui ajoute des éléments à la liste et renvoie la liste elle-même. Cela vous permet de chaîner l'initialisation et la population de la liste.

IronPDF : Bibliothèque PDF C

C# Initialize List (How It Works For Developers) : Figure 1 - IronPDF : The C# PDF Library

If you have a list, like a list of fruits, you can quickly turn it into an HTML table and render it as a PDF using IronPDF, all in just a few lines of code. Le processus est simple : initialisez votre liste, convertissez-la en HTML et laissez IronPDF générer le PDF. Voici un exemple :

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

class Program
{
    static void Main()
    {
        // Initialize a list of strings representing data
        List<string> fruits = new List<string> { "Apple", "Banana", "Cherry" };

        // Convert the list to an HTML table
        StringBuilder htmlContent = new StringBuilder();
        htmlContent.Append("<table border='1'><tr><th>Fruit Name</th></tr>");
        foreach (var fruit in fruits)
        {
            htmlContent.Append($"<tr><td>{fruit}</td></tr>");
        }
        htmlContent.Append("</table>");

        // Render the HTML to PDF using IronPDF
        var Renderer = new ChromePdfRenderer();
        var PDF = Renderer.RenderHtmlAsPdf(htmlContent.ToString());

        // Save the PDF to a file
        PDF.SaveAs("FruitsList.pdf");
        Console.WriteLine("PDF generated successfully.");
    }
}
using IronPdf;
using System;
using System.Collections.Generic;
using System.Text;

class Program
{
    static void Main()
    {
        // Initialize a list of strings representing data
        List<string> fruits = new List<string> { "Apple", "Banana", "Cherry" };

        // Convert the list to an HTML table
        StringBuilder htmlContent = new StringBuilder();
        htmlContent.Append("<table border='1'><tr><th>Fruit Name</th></tr>");
        foreach (var fruit in fruits)
        {
            htmlContent.Append($"<tr><td>{fruit}</td></tr>");
        }
        htmlContent.Append("</table>");

        // Render the HTML to PDF using IronPDF
        var Renderer = new ChromePdfRenderer();
        var PDF = Renderer.RenderHtmlAsPdf(htmlContent.ToString());

        // Save the PDF to a file
        PDF.SaveAs("FruitsList.pdf");
        Console.WriteLine("PDF generated successfully.");
    }
}
Imports IronPdf
Imports System
Imports System.Collections.Generic
Imports System.Text

Friend Class Program
	Shared Sub Main()
		' Initialize a list of strings representing data
		Dim fruits As New List(Of String) From {"Apple", "Banana", "Cherry"}

		' Convert the list to an HTML table
		Dim htmlContent As New StringBuilder()
		htmlContent.Append("<table border='1'><tr><th>Fruit Name</th></tr>")
		For Each fruit In fruits
			htmlContent.Append($"<tr><td>{fruit}</td></tr>")
		Next fruit
		htmlContent.Append("</table>")

		' Render the HTML to PDF using IronPDF
		Dim Renderer = New ChromePdfRenderer()
		Dim PDF = Renderer.RenderHtmlAsPdf(htmlContent.ToString())

		' Save the PDF to a file
		PDF.SaveAs("FruitsList.pdf")
		Console.WriteLine("PDF generated successfully.")
	End Sub
End Class
$vbLabelText   $csharpLabel

C# Initialize List (How It Works For Developers) : Figure 2 - Exemple de sortie

Ce code initialise une liste, crée un tableau HTML à partir de celle-ci et utilise IronPDF pour créer un fichier PDF. C'est un moyen simple et direct de générer des PDF à partir de vos collections de données.

Conclusion

C# Initialize List (How It Works For Developers) : Figure 3 - IronPDF licensing page

L'initialisation de liste en C# est un concept fondamental que tout ingénieur logiciel devrait maîtriser. Que vous travailliez avec de simples listes de chaînes ou des listes complexes d'objets, C# offre plusieurs méthodes pour initialiser et remplir efficacement les listes. De l'initialisation de base aux initialiseurs d'objet et de collection, ces techniques vous aident à écrire un code clair, concis et maintenable.

IronPDF offre un essai gratuit qui vous permet d'essayer le produit sans faire d'investissement initial. Lorsque vous êtes convaincu qu'il répond à vos besoins, les licences sont disponibles à partir de $799.

Questions Fréquemment Posées

Quelles sont les méthodes de base pour initialiser une liste en C# ?

En C#, vous pouvez initialiser une liste en créant une instance de la classe List<T>, où T est le type des éléments. Par exemple, List<string> fruits = new List<string>(); est une façon basique d'initialiser une liste.

Comment la syntaxe d'initialisation de collection peut-elle améliorer l'initialisation d'une liste en C# ?

La syntaxe d'initialisation de collection vous permet de remplir une liste directement lors de sa création, rendant le code plus concis. Par exemple : List<string> fruits = new List<string> { 'Pomme', 'Banane', 'Cerise' };.

Quel est le but de la syntaxe d'initialisation d'objets lors de l'initialisation des listes ?

La syntaxe d'initialisation d'objets est bénéfique pour initialiser des listes avec des objets personnalisés, permettant de définir les valeurs des propriétés lors de la création de la liste. Par exemple : new Person { Name = 'John', Age = 30 }; dans une liste.

Pouvez-vous définir une capacité initiale pour une liste et pourquoi est-ce utile ?

Oui, définir une capacité initiale pour une liste peut améliorer les performances en réduisant le besoin de réallocations de mémoire à mesure que la liste grandit. Exemple : List<string> fruits = new List<string>(10);.

Comment une liste peut-elle être initialisée à partir d'un tableau existant en C# ?

Vous pouvez initialiser une liste à partir d'un tableau en utilisant le constructeur de liste qui accepte un IEnumerable<T>. Exemple : List<string> fruits = new List<string>(fruitArray);.

Quel rôle joue la méthode AddRange dans l'initialisation des listes ?

La méthode AddRange ajoute plusieurs éléments d'une collection à une liste en une seule fois, optimisant les performances en minimisant les réallocations. Exemple : fruits.AddRange(moreFruits);.

Comment des objets personnalisés peuvent-ils être initialisés dans une liste à l'aide d'initialiseurs ?

Les objets personnalisés peuvent être initialisés dans une liste en utilisant une combinaison d'initialiseurs d'objets et de collections, permettant une expression unique pour la création de la liste. Exemple : new List<Person> { new Person { Name = 'Alice', Age = 28 } };.

Que sont les méthodes d'extension et comment se rapportent-elles à l'initialisation des listes ?

Les méthodes d'extension permettent d'ajouter de nouvelles fonctionnalités à des types existants. Par exemple, une méthode d'extension comme InitializeWith peut être écrite pour simplifier l'initialisation et la population des listes.

Comment les listes peuvent-elles être converties en PDFs en C# ?

En utilisant IronPDF, vous pouvez convertir une liste en un tableau HTML et le rendre sous forme de PDF, simplifiant ainsi le processus de génération de PDFs à partir de collections de données en C#.

Existe-t-il un essai gratuit pour générer des PDFs à partir de collections de données ?

Oui, IronPDF propose un essai gratuit, permettant aux utilisateurs de tester ses capacités de génération de PDFs à partir de collections de données sans achat initial.

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