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 pourimprimer une liste en C#.

Les bases de la liste en C# ;

En C#, unlist est un tableau dynamique dont la taille peut augmenter ou diminuer. Il 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 manière traditionnelle et directe d'imprimer les éléments d'une liste est d'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 si vous voulez imprimer des éléments de manière conditionnelle, vous pouvez utiliser une boucle for. Voici un exemple de liste de chaînes de caractères :

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

L'impression d'une liste dans l'ordre inverse peut être réalisée 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 et en imprimant ensuite 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 fonctionOrderByDescending (Ordre décroissant) 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 lelist qui peuvent être utilisées pour l'impression.

Voici quelques méthodes utiles :

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

• ToArray: Le tableau ToArray() copie la liste dans un nouveau tableau 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

LesString.Join fournit un moyen concis de concaténer les éléments d'une liste en une seule chaîne de caractères avec 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 réunis dans une chaîne de caractères séparée par une virgule et un espace, ce qui donne une sortie formatée. 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, dans lesquels vous souhaitez filtrer, transformer ou formater des éléments avant l'impression, la fonction Language-Integrated Query(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. L'élément Where() est appliquée avec une expression lambda, et la méthode ToList()la méthode est utilisée pour reconvertir le résultat en liste.

Objets personnalisés et méthode ToString()

Si vous avez une liste d'objets personnalisés, il est recommandé de surcharger la méthode ToString dans votre classe d'objets 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 ToString() de la classe Person, vous contrôlez la façon 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+, Android API 21+, Android API 21+, Android API 21+, Android API 21+, Android API 21+(v5 "Lollipop")
• Types de projets : Mobile(Xamarin & MAUI & Avalonia), Bureau(WPF & MAUI & Windows Avalonia)console(Application et 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

Installer leIronPrint à l'aide de la console NuGet Package Manager :

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 NuGet browse, recherchez "ironprint", sélectionnez la dernière version du paquetage IronPrint dans les résultats de la recherche, puis cliquez sur le bouton Installer pour l'ajouter à votre projet.

Impression avec IronPrint : Exemples de code

1. Imprimer le document

IronPrint permet l'impression silencieuse des documents à l'aide de la simplemé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 spécifique pour montrer ladialogue `print 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 services d'information et de conseilparamètres `print qui permettent un contrôle granulaire du document imprimé.

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 les méthodes utilisées, veuillez consulter la sectionRéférence API page.

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é. Qu'il s'agisse d'une simple boucle, de String.Join(), LINQ, ou la personnalisation de la fonction ToString() pour les objets personnalisés, la compréhension de 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 référence si vous recherchez la précision, la facilité d'utilisation et la rapidité. Que vous construisiez des applications Web, que vous travailliez avec MAUI, Avalonia ou tout ce qui est lié à .NET, IronPrint vous soutient. Pour de plus amples informations sur IronPrint, veuillez consulter le site suivantpage de documentation .

IronPrint est une bibliothèque payante, mais uneessai gratuit. Télécharger la bibliothèque à partir deici et l'essayer!