Liste d'impression en C# : Un tutoriel rapide

En C#, l'impression d'une liste est une tâche courante, qui peut être accomplie de différentes manières, offrant ainsi souplesse et personnalisation. Les listes sont des structures de données fondamentales en C#, et la possibilité d'imprimer leur contenu est cruciale pour le débogage, la journalisation ou l'affichage d'informations aux utilisateurs.

Dans cet article, nous allons explorer différentes méthodes pour imprimer une liste en C#.

Les bases de la liste en C# ;

En C#, une list est un tableau dynamique qui peut augmenter ou diminuer en taille. Elle fait partie de l'espace de noms System.Collections.Generic et offre flexibilité et efficacité dans la gestion des collections d'éléments. Le code suivant crée une simple liste de nombres :

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
    }
}

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Impression d'une liste à l'aide d'une boucle

1. Utilisation de la boucle foreach

La méthode traditionnelle et simple pour imprimer les éléments d'une liste consiste à utiliser une boucle foreach. Voici un exemple simple :

using System;
using System.Collections.Generic;
class Program
{
    public static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        Console.WriteLine("Printing list using foreach loop:");
        foreach (var number in numbers)
        {
            Console.WriteLine(number);
        }
    }
}

using System;
using System.Collections.Generic;
class Program
{
    public static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        Console.WriteLine("Printing list using foreach loop:");
        foreach (var number in numbers)
        {
            Console.WriteLine(number);
        }
    }
}

Imports System
Imports System.Collections.Generic
Friend Class Program
	Public Shared Sub Main()
		Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5}
		Console.WriteLine("Printing list using foreach loop:")
		For Each number In numbers
			Console.WriteLine(number)
		Next number
	End Sub
End Class

Cette méthode est concise et lisible, ce qui la rend adaptée à la plupart des scénarios.

2. Utilisation de la boucle for

Si vous avez besoin de plus de contrôle sur l'index ou souhaitez imprimer des éléments de manière conditionnelle, vous pouvez utiliser une boucle for. Voici un exemple de liste de chaînes :

using System;
using System.Collections.Generic;
class Program
{
    public static void Main()
    {
    // create list of strongly typed objects
        List<string> colors = new List<string> { "Red", "Green", "Blue", "Yellow" };
        Console.WriteLine("Printing list using for loop:");
        for (int index = 0; index < colors.Count; index++)
        {
            Console.WriteLine($"Color at index {index}: {colors[index]}");
        }
    }
}

using System;
using System.Collections.Generic;
class Program
{
    public static void Main()
    {
    // create list of strongly typed objects
        List<string> colors = new List<string> { "Red", "Green", "Blue", "Yellow" };
        Console.WriteLine("Printing list using for loop:");
        for (int index = 0; index < colors.Count; index++)
        {
            Console.WriteLine($"Color at index {index}: {colors[index]}");
        }
    }
}

Imports System
Imports System.Collections.Generic
Friend Class Program
	Public Shared Sub Main()
	' create list of strongly typed objects
		Dim colors As New List(Of String) From {"Red", "Green", "Blue", "Yellow"}
		Console.WriteLine("Printing list using for loop:")
		For index As Integer = 0 To colors.Count - 1
			Console.WriteLine($"Color at index {index}: {colors(index)}")
		Next index
	End Sub
End Class

Cette approche est avantageuse lorsque vous avez besoin d'accéder à l'index ou que vous souhaitez appliquer une logique spécifique lors de l'impression.

Impression inversée des éléments de la liste

Imprimer une liste dans l'ordre inverse peut être accompli en utilisant la méthode Reverse. Cette méthode inverse l'ordre des éléments de la liste, ce qui vous permet de les parcourir et de les imprimer.

1. Utilisation de la méthode List.Reverse

Par exemple, vous pouvez imprimer la liste dans l'ordre inverse en utilisant la méthode Reverse puis en imprimant chaque élément.

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
numbers.Reverse();
foreach (var number in numbers)
{
    Console.WriteLine(number);
}

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
numbers.Reverse();
foreach (var number in numbers)
{
    Console.WriteLine(number);
}

Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5}
numbers.Reverse()
For Each number In numbers
	Console.WriteLine(number)
Next number

2. Utilisation de LINQ OrderByDescending

Vous pouvez également utiliser la méthode OrderByDescending avec une clé pour organiser une collection spécifiée d'éléments de la classe générique LINQ :

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
var reversedNumbers = numbers.OrderByDescending(n => n);
foreach (var number in reversedNumbers)
{
    Console.WriteLine(number);
}

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
var reversedNumbers = numbers.OrderByDescending(n => n);
foreach (var number in reversedNumbers)
{
    Console.WriteLine(number);
}

Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5}
Dim reversedNumbers = numbers.OrderByDescending(Function(n) n)
For Each number In reversedNumbers
	Console.WriteLine(number)
Next number

Comptage du nombre d'éléments et impression

Compter le nombre d'éléments d'une liste est une opération courante. La propriété Count ou la méthode Count peuvent être utilisées à cette fin. Une fois que vous avez le décompte, vous pouvez facilement l'imprimer.

1. Utilisation de la propriété List.Count

List<string> names = new List<string> { "Alice", "Bob", "Charlie" };
int count = names.Count;
Console.WriteLine($"Number of elements: {count}");

List<string> names = new List<string> { "Alice", "Bob", "Charlie" };
int count = names.Count;
Console.WriteLine($"Number of elements: {count}");

Dim names As New List(Of String) From {"Alice", "Bob", "Charlie"}
Dim count As Integer = names.Count
Console.WriteLine($"Number of elements: {count}")

2. Utilisation de la méthode de comptage LINQ

List<string> names = new List<string> { "Alice", "Bob", "Charlie" };
int count = names.Count();
Console.WriteLine($"Number of elements: {count}");

List<string> names = new List<string> { "Alice", "Bob", "Charlie" };
int count = names.Count();
Console.WriteLine($"Number of elements: {count}");

Dim names As New List(Of String) From {"Alice", "Bob", "Charlie"}
Dim count As Integer = names.Count()
Console.WriteLine($"Number of elements: {count}")

Impression des éléments de la liste à l'index spécifié

L'impression d'éléments à un index spécifié implique l'accès à la liste à cet index. Cela vous permet d'accéder à des éléments situés à différents endroits et de vous assurer que vous gérez les scénarios potentiels d'indexation hors de portée :

List<double> prices = new List<double> { 19.99, 29.99, 39.99 };
int indexToPrint = 1;
if (indexToPrint >= 0 && indexToPrint < prices.Count)
{
    Console.WriteLine($"Element at index {indexToPrint}: {prices[indexToPrint]}");
}
else
{
    Console.WriteLine("Index out of range.");
}

List<double> prices = new List<double> { 19.99, 29.99, 39.99 };
int indexToPrint = 1;
if (indexToPrint >= 0 && indexToPrint < prices.Count)
{
    Console.WriteLine($"Element at index {indexToPrint}: {prices[indexToPrint]}");
}
else
{
    Console.WriteLine("Index out of range.");
}

Dim prices As New List(Of Double) From {19.99, 29.99, 39.99}
Dim indexToPrint As Integer = 1
If indexToPrint >= 0 AndAlso indexToPrint < prices.Count Then
	Console.WriteLine($"Element at index {indexToPrint}: {prices(indexToPrint)}")
Else
	Console.WriteLine("Index out of range.")
End If

Ces exemples fournissent une base pour l'impression d'éléments de liste dans divers scénarios. Il existe d'autres méthodes utiles que la classe list propose et qui peuvent être utilisées dans l'impression.

Voici quelques méthodes utiles :

• Remove : La méthode Remove() supprime la première occurrence dans une liste C#
• RemoveAll : La méthode RemoveAll() est utilisée pour supprimer des éléments basés sur le prédicat spécifié.
• RemoveRange : La méthode RemoveRange() supprime une plage d'éléments en fonction des paramètres d'index et de nombre spécifiés.
• Ajouter : La méthode Add() ne peut ajouter qu'un seul élément à la fin de la liste.
• AddRange : La méthode AddRange() peut être utilisée pour ajouter des éléments de la collection spécifiée à la fin.
• Clear : La méthode Clear() supprime tous les éléments de la liste.
• Insert: La méthode Insert() insère un élément dans la liste à l'index spécifié.
• ForEach : La méthode ForEach() est utilisée pour effectuer une action spécifique sur chaque élément, par exemple, imprimer efficacement chaque valeur de la liste.

• ToArray : La méthode ToArray() copie la liste dans un nouveau tableau de type var.

  Vous pouvez désormais choisir l'approche qui répond le mieux à vos besoins et qui améliore la lisibilité et l'efficacité de votre code C#.

Méthode String.Join

La méthode String.Join offre une façon concise d'assembler les éléments d'une liste en une seule chaîne en utilisant un séparateur spécifié. Cela peut être utile pour créer une représentation sous forme de chaîne formatée de la liste.

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
string result = string.Join(", ", numbers);
Console.WriteLine(result);

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
string result = string.Join(", ", numbers);
Console.WriteLine(result);

Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5}
Dim result As String = String.Join(", ", numbers)
Console.WriteLine(result)

Ici, les éléments de la liste numbers sont joints pour former une chaîne de caractères séparée par une virgule et un espace, ce qui donne un résultat formaté. La méthode de tri peut également être utilisée avant d'imprimer les éléments de la liste.

Utilisation de LINQ pour des scénarios avancés

Pour des scénarios plus complexes, où vous souhaitez filtrer, transformer ou formater des éléments avant l'impression, la requête intégrée au langage (LINQ) peut être bénéfique.

using System.Linq;
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
List<int> evenNumbers = numbers.Where(n => n % 2 == 0).ToList();
Console.WriteLine("Even numbers: " + string.Join(", ", evenNumbers));

using System.Linq;
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
List<int> evenNumbers = numbers.Where(n => n % 2 == 0).ToList();
Console.WriteLine("Even numbers: " + string.Join(", ", evenNumbers));

Imports System.Linq
Private numbers As New List(Of Integer) From {1, 2, 3, 4, 5}
Private evenNumbers As List(Of Integer) = numbers.Where(Function(n) n Mod 2 = 0).ToList()
Console.WriteLine("Even numbers: " & String.Join(", ", evenNumbers))

Dans cet exemple, LINQ est utilisé pour filtrer les nombres pairs de la liste originale. La méthode Where() est appliquée avec une expression lambda, et la méthode ToList() est utilisée pour convertir le résultat en une liste.

Objets personnalisés et méthode ToString()

Si vous avez une liste d'objets personnalisés, il est recommandé de substituer la méthode ToString dans votre classe d'objet pour une représentation significative. L'exemple suivant montre comment procéder :

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public override string ToString()
    {
        return $"{Name}, {Age} years old";
    }
}
class Program
{
    public static void Main()
    {
    List<Person> people = new List<Person>
    {
        new Person { Name = "Alice", Age = 30 },
        new Person { Name = "Bob", Age = 25 }
    };
    foreach (Person person in people)
    {
        Console.WriteLine(person);
    }
    }
}

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public override string ToString()
    {
        return $"{Name}, {Age} years old";
    }
}
class Program
{
    public static void Main()
    {
    List<Person> people = new List<Person>
    {
        new Person { Name = "Alice", Age = 30 },
        new Person { Name = "Bob", Age = 25 }
    };
    foreach (Person person in people)
    {
        Console.WriteLine(person);
    }
    }
}

Friend Class Person
	Public Property Name() As String
	Public Property Age() As Integer
	Public Overrides Function ToString() As String
		Return $"{Name}, {Age} years old"
	End Function
End Class
Friend Class Program
	Public Shared Sub Main()
	Dim people As New List(Of Person) From {
		New Person With {
			.Name = "Alice",
			.Age = 30
		},
		New Person With {
			.Name = "Bob",
			.Age = 25
		}
	}
	For Each person As Person In people
		Console.WriteLine(person)
	Next person
	End Sub
End Class

En surchargeant la méthode ToString() dans la classe Person, vous contrôlez la manière dont les instances de la classe sont représentées sous forme de chaînes de caractères. Cela améliore la lisibilité de votre liste lorsqu'elle est imprimée.

Présentation d'IronPrint - C&num ; Bibliothèque d'impression

IronPrint se distingue comme une bibliothèque d'impression puissante et déployable, privilégiant la précision, la facilité d'utilisation et la rapidité. Sa prise en charge multiplateforme et sa compatibilité avec divers formats de documents en font un outil précieux pour les développeurs .NET à la recherche de solutions d'impression efficaces dans leurs applications.

Caractéristiques principales

Voici quelques caractéristiques clés importantes qui permettent à IronPrint de se démarquer pour l'impression de documents physiques dans les applications C# :

1. Compatibilité multiplateforme

• prise en charge des versions .NET : .NET 8, 7, 6, 5 et Core 3.1+
• Systèmes d'exploitation : Windows (7+, Server 2016+), macOS (10+), iOS (11+), Android API 21+ (v5 "Lollipop")
• Types de projets : Mobile (Xamarin & MAUI & Avalonia), Bureau (WPF & MAUI & Windows Avalonia), Console (Application & Bibliothèque)

2. Formats pris en charge

• Traitement de divers formats de documents, notamment PDF, PNG, HTML, TIFF, GIF, JPEG, IMAGE, BITMAP.
• Personnaliser les paramètres d'impression en fonction des exigences du document.

3. Installation facile

Installez la bibliothèque IronPrint en utilisant la console du gestionnaire de packages NuGet :

Install-Package IronPrint

Install-Package IronPrint

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPrint

Vous pouvez également l'installer dans votre projet à l'aide de Visual Studio. Cliquez avec le bouton droit de la souris sur le projet dans l'explorateur de solutions et cliquez sur Gérer NuGet Package Manager for Solutions. Dans l'onglet Parcourir de NuGet, recherchez "ironprint", sélectionnez la dernière version du package IronPrint dans les résultats de recherche, puis cliquez sur le bouton Installer pour l'ajouter à votre projet.

Impression avec IronPrint : Exemples de code

1. Imprimer le document

IronPrint offre une impression silencieuse des documents en utilisant la simple méthode Print. Si l'imprimante physique n'est pas disponible, l'impression se fait à l'aide de l'imprimante par défaut spécifiée par le système d'exploitation.

using IronPrint;
// Print the document
Printer.Print("newDoc.pdf");

using IronPrint;
// Print the document
Printer.Print("newDoc.pdf");

Imports IronPrint
' Print the document
Printer.Print("newDoc.pdf")

2. Imprimer avec le dialogue

Il fournit également une méthode dédiée pour afficher la boîte de dialogue d'impression pour un meilleur contrôle lors de l'impression. La méthode ShowPrintDialogAsync peut également être utilisée pour imprimer de manière asynchrone.

using IronPrint;
// Show print dialog
Printer.ShowPrintDialog("newDoc.pdf");

using IronPrint;
// Show print dialog
Printer.ShowPrintDialog("newDoc.pdf");

Imports IronPrint
' Show print dialog
Printer.ShowPrintDialog("newDoc.pdf")

3. Personnaliser les paramètres d'impression

IronPrint fournit divers print settings qui permettent un contrôle granulaire du document à imprimer.

using IronPrint;
// Configure print settings
PrintSettings printSettings = new PrintSettings();
printSettings.Dpi = 150;
printSettings.NumberOfCopies = 2;
printSettings.PaperOrientation = PaperOrientation.Portrait;
// Print the document
Printer.Print("newDoc.pdf", printSettings);

using IronPrint;
// Configure print settings
PrintSettings printSettings = new PrintSettings();
printSettings.Dpi = 150;
printSettings.NumberOfCopies = 2;
printSettings.PaperOrientation = PaperOrientation.Portrait;
// Print the document
Printer.Print("newDoc.pdf", printSettings);

Imports IronPrint
' Configure print settings
Private printSettings As New PrintSettings()
printSettings.Dpi = 150
printSettings.NumberOfCopies = 2
printSettings.PaperOrientation = PaperOrientation.Portrait
' Print the document
Printer.Print("newDoc.pdf", printSettings)

Pour mieux comprendre les classes et méthodes utilisées, veuillez visiter la page Référence API.

Conclusion

L'impression d'une liste en C# implique de choisir la bonne méthode en fonction de la complexité des données et du résultat souhaité. Que ce soit en utilisant une boucle simple, String.Join(), LINQ, ou en personnalisant la méthode ToString() pour des objets personnalisés, comprendre ces approches vous permet d'afficher efficacement le contenu des listes dans vos applications C#. Expérimentez ces techniques et choisissez celle qui correspond le mieux à votre cas d'utilisation spécifique.

IronPrint est votre bibliothèque d'impression de choix si vous recherchez précision, facilité d'utilisation et rapidité. Que vous construisiez des applications Web, que vous travailliez avec MAUI, Avalonia ou tout ce qui est lié à .NET, IronPrint vous soutient. Pour plus d'informations détaillées sur IronPrint, veuillez visiter cette page de documentation.

IronPrint est une bibliothèque payante, mais un essai gratuit. Téléchargez la bibliothèque depuis ici et essayez-la !