Liste d'initialisation C# (Comment ça marche pour les développeurs)

Les listes font partie de laSystem.Collections.Generic la traduction doit rester professionnelle et préserver l'exactitude technique tout en expliquant les caractéristiques et les avantages de ces outils de développement. Les listes en C# sont dynamiques, ce qui signifie que leur taille peut changer au moment de l'exécution. Cette flexibilité est très utile dans de nombreux scénarios de génie logiciel où le nombre d'éléments n'est pas connu à l'avance. Plongeons dans les différentes façons d'initialiser une liste en C#. Nous couvrirons les techniques de base, la syntaxe des initialisateurs d'objets, les initialisateurs de collections et le système de gestion de l'informationBibliothèque IronPDF.

Initialisation de la liste de base

Pour initialiser une liste, commencez par créer une instance de la classe Listclasse, où T est le type d'éléments de la liste. Le type le plus courant est la chaîne de caractères, 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

Dans l'exemple ci-dessus, nous avons créé une liste vide et ajouté des éléments à l'aide de la méthode Add. La listereprésente une liste de chaînes de caractères, et nous avons utilisé la méthode Add pour la remplir de valeurs.

Utilisation de la syntaxe de l'initialisateur de collection

C# offre un moyen plus concis d'initialiser une liste en utilisant la syntaxe de l'initialisateur de collection. Cela vous permet de remplir la liste directement lorsqu'elle est créée, sans avoir à 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

Ce code permet d'obtenir le même résultat que l'exemple précédent, mais sous une forme plus compacte. Les initialisateurs de collection vous permettent d'initialiser une liste avec des valeurs en une seule instruction, ce qui rend votre code plus lisible.

Initialisateurs d'objets et initialisation de listes

La syntaxe de l'initialisateur d'objets est une autre façon d'initialiser les listes, principalement lorsque l'on travaille avec des objets personnalisés. Voici un exemple de la façon dont les initialisateurs d'objets fonctionnent avec les 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
	}
}

Dans cet exemple, nous créons une liste d'objets Person à l'aide d'initialisateurs d'objets. La classe Personne possède deux propriétés : Nom et Âge, auxquelles des valeurs sont explicitement attribuées lors de la création de la liste.

Création d'une liste avec une taille initiale

Bien que la taille des listes soit dynamique, 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

Cette opération crée une liste vide d'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 à l'aide du constructeur de liste qui prend un IEnumerableargument. Ceci est utile lorsque vous avez un tableau et que vous voulez 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)

Ici, un nouveau tableau est créé, puis utilisé pour initialiser une liste. Cela convertit le tableau fruitArray en une liste. Tout IEnumerableles listes, y compris les tableaux, peuvent être transmises au constructeur de liste pour l'initialisation.

Utilisation de la méthode AddRange

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

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)

Dans cet exemple, nous partons d'une liste contenant deux éléments et nous ajoutons plusieurs nouveaux éléments à partir d'un tableau à l'aide de AddRange. Cette méthode peut améliorer les performances en ajoutant des éléments un par un, car elle minimise le besoin de réallocations multiples.

Initialisation d'une liste avec des objets personnalisés

Lors de l'initialisation d'une liste d'objets personnalisés, vous pouvez combiner des initialisateurs d'objets avec des initialisateurs de collections 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
	}
}

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

Initialisation de liste avec des méthodes d'extension

Vous pouvez également mettre en œuvre une méthode d'extension pour initialiser une liste d'une manière personnalisée. Les méthodes d'extension fournissent un mécanisme permettant d'améliorer les types existants en les dotant de nouvelles capacités sans modifier 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")

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

IronPDF : C&num ; Bibliothèque PDF

Si vous avez une liste, comme une liste de fruits, vous pouvez rapidement la transformer en une liste de fruits Tableau HTML et rendu au format PDFen utilisantIronPDFle tout en quelques lignes de code. Le processus est simple : initialisez votre liste, convertissez-la en HTML et laissez IronPDF générer le PDF. En 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

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

L'initialisation des listes en C# est un concept fondamental que tout ingénieur logiciel doit maîtriser. Que vous travailliez avec de simples listes de chaînes ou des listes complexes d'objets, C# propose plusieurs méthodes pour initialiser et remplir des listes de manière efficace. De l'initialisation de base aux initialisateurs d'objets et de collections, ces techniques vous aident à écrire un code propre, concis et facile à maintenir.

IronPDF offre un service deessai gratuit la traduction doit rester professionnelle, en préservant l'exactitude technique tout en expliquant les caractéristiques et les avantages de ces outils de développement. Si vous êtes convaincu que la traduction répond à vos besoins, des licences sont disponibles à partir de 749 $.