Comment puis-je imprimer une liste en C# ?

Vous pouvez utiliser IronPrint pour imprimer une liste en C# en parcourant les éléments de la liste avec une boucle foreach ou for et en passant la sortie formatée à IronPrint pour l'impression.

Quels sont les avantages d'utiliser un tableau dynamique en C# ?

Les tableaux dynamiques, ou listes, en C# offrent de la flexibilité car ils peuvent augmenter ou diminuer en taille. Ils font partie de l'espace de noms System.Collections.Generic , permettant une gestion et une manipulation efficaces des collections.

Comment puis-je inverser une liste en C# pour l'impression ?

Pour imprimer une liste dans l'ordre inverse, vous pouvez utiliser la méthode Reverse ou OrderByDescending de LINQ, puis imprimer la liste inversée avec IronPrint.

Comment puis-je formater une liste en tant que chaîne pour l'impression ?

Vous pouvez utiliser la méthode String.Join pour concaténer les éléments de la liste en une chaîne unique formatée avec un séparateur spécifié. Cette chaîne formatée peut ensuite être imprimée à l'aide d'IronPrint.

Quel est le rôle de la méthode ToString dans l'impression d'objets personnalisés ?

En redéfinissant la méthode ToString , vous pouvez définir comment les instances d'objets personnalisés sont représentées sous forme de chaînes, ce qui améliore la lisibilité lors de l'impression avec IronPrint.

Comment puis-je filtrer et imprimer des éléments spécifiques d'une liste en C# ?

Les méthodes LINQ comme Where peuvent être utilisées pour filtrer et sélectionner des éléments spécifiques d'une liste. Les résultats filtrés peuvent ensuite être imprimés à l'aide d'IronPrint.

Comment installer une bibliothèque d'impression pour .NET ?

Vous pouvez installer IronPrint à l'aide de la console du gestionnaire de packages NuGet avec la commande Install-Package IronPrint ou via le Gestionnaire de Packages NuGet de Visual Studio.

Quelles fonctionnalités IronPrint offre-t-il aux développeurs .NET ?

IronPrint offre une compatibilité multiplateforme, une prise en charge de divers formats de document, une impression silencieuse, des boîtes de dialogue d'impression et des paramètres d'impression personnalisables, ce qui en fait un choix puissant pour les développeurs .NET.

What are some advanced printing features supported by IronPrint?

IronPrint supports cross-platform compatibility, handles various document formats, provides easy installation through NuGet, and offers customized print settings with features like silent printing and displaying print dialogs.

How can you handle index out-of-range scenarios when printing specific list elements?

You should check if the specified index is within the valid range of the list, using conditions to ensure the index is greater than or equal to zero and less than the list count before attempting to print the element.

La bibliothèque d'impression C#

Explore IronPrint Essai gratuit

paramètres d'impression

Voir tous les exemples de code %s

using IronPrint;

// Configure print setting
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 setting
PrintSettings printSettings = new PrintSettings();
printSettings.Dpi = 150;
printSettings.NumberOfCopies = 2;
printSettings.PaperOrientation = PaperOrientation.Portrait;

// Print the document
Printer.Print("newDoc.pdf", printSettings);

PM >Install-Package IronPrint

Install-Package IronPrint

.NET AIDE

C# Imprimer une liste : un tutoriel rapide

Jacob Mellor

Updated: 21 avril 2026

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

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

Principes de base des listes en C#

En C#, un list est un tableau dynamique qui peut croître 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 };
    }
}

Imports System
Imports System.Collections.Generic

Class Program
    Shared Sub Main()
        Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5}
    End Sub
End Class

Imports System
Imports System.Collections.Generic

Class Program
    Shared Sub Main()
        Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5}
    End Sub
End Class

Afficher une liste à l'aide d'une boucle

1. Utilisation de la boucle `foreach`

La manière traditionnelle et simple 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

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 situations.

2. Utilisation de la boucle `for`

Si vous avez besoin de plus de contrôle sur l'indice ou souhaitez imprimer des éléments sous certaines conditions, 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

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.

Afficher les éléments de la liste à l'envers

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 ensuite de les parcourir et de les afficher.

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.

using System;
using System.Collections.Generic;
class Program
{
    public static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        numbers.Reverse();
        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 };
        numbers.Reverse();
        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}
		numbers.Reverse()
		For Each number In numbers
			Console.WriteLine(number)
		Next number
	End Sub
End Class

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}
		numbers.Reverse()
		For Each number In numbers
			Console.WriteLine(number)
		Next number
	End Sub
End Class

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 :

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    public static void Main()
    {
        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);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    public static void Main()
    {
        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);
        }
    }
}

Imports System
Imports System.Collections.Generic
Imports System.Linq

Friend Class Program
	Public Shared Sub Main()
		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
	End Sub
End Class

Imports System
Imports System.Collections.Generic
Imports System.Linq

Friend Class Program
	Public Shared Sub Main()
		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
	End Sub
End Class

Comptage et impression du nombre d'éléments

Compter le nombre d'éléments dans une liste est une opération courante. La propriété Count peut être utilisée à cet effet. Une fois le décompte effectué, vous pouvez facilement l'imprimer.

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

using System;
using System.Collections.Generic;

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

using System;
using System.Collections.Generic;

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

Imports System
Imports System.Collections.Generic

Friend Class Program
	Public Shared Sub Main()
		Dim names As New List(Of String) From {"Alice", "Bob", "Charlie"}
		Dim count As Integer = names.Count
		Console.WriteLine($"Number of elements: {count}")
	End Sub
End Class

Imports System
Imports System.Collections.Generic

Friend Class Program
	Public Shared Sub Main()
		Dim names As New List(Of String) From {"Alice", "Bob", "Charlie"}
		Dim count As Integer = names.Count
		Console.WriteLine($"Number of elements: {count}")
	End Sub
End Class

2. Utilisation de la méthode Count de LINQ

Si LINQ est préféré, il peut également être utilisé pour le comptage :

using System;
using System.Collections.Generic;
using System.Linq;

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

using System;
using System.Collections.Generic;
using System.Linq;

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

Imports System
Imports System.Collections.Generic
Imports System.Linq

Friend Class Program
	Public Shared Sub Main()
		Dim names As New List(Of String) From {"Alice", "Bob", "Charlie"}
		Dim count As Integer = names.Count()
		Console.WriteLine($"Number of elements: {count}")
	End Sub
End Class

Imports System
Imports System.Collections.Generic
Imports System.Linq

Friend Class Program
	Public Shared Sub Main()
		Dim names As New List(Of String) From {"Alice", "Bob", "Charlie"}
		Dim count As Integer = names.Count()
		Console.WriteLine($"Number of elements: {count}")
	End Sub
End Class

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

L'affichage des éléments à un index spécifié implique l'accès à la liste à cet index. Cela vous permet d'accéder aux éléments situés à différents emplacements et vous assure de gérer les éventuels scénarios d'index hors limites :

using System;
using System.Collections.Generic;

class Program
{
    public static void Main()
    {
        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.");
        }
    }
}

using System;
using System.Collections.Generic;

class Program
{
    public static void Main()
    {
        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.");
        }
    }
}

Imports System
Imports System.Collections.Generic

Friend Class Program
	Public Shared Sub Main()
		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
	End Sub
End Class

Imports System
Imports System.Collections.Generic

Friend Class Program
	Public Shared Sub Main()
		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
	End Sub
End Class

Ces exemples constituent une base pour l'impression des é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 pour l'impression.

Voici quelques méthodes utiles :

Remove: La méthode Remove() supprime la première occurrence dans la 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 basée sur les paramètres d'index et de nombre spécifiés.
Add: La méthode Add() ne peut ajouter qu'un seul élément à la fin de la liste.
AddRange: La méthode AddRange() peut 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'indice spécifié.
ForEach: La méthode ForEach() est utilisée pour effectuer des actions spécifiques sur chaque élément, par exemple, pour imprimer efficacement chaque valeur de la liste.
ToArray: La méthode ToArray() copie la liste dans un nouveau tableau.

Vous pouvez désormais choisir l'approche qui correspond 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 fournit un moyen concis de concaténer les éléments d'une liste en une seule chaîne avec un séparateur spécifié. Cela peut s'avérer utile pour créer une représentation sous forme de chaîne de caractères formatée de la liste.

using System;
using System.Collections.Generic;

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

using System;
using System.Collections.Generic;

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

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}
		Dim result As String = String.Join(", ", numbers)
		Console.WriteLine(result)
	End Sub
End Class

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}
		Dim result As String = String.Join(", ", numbers)
		Console.WriteLine(result)
	End Sub
End Class

Ici, les éléments de la liste numbers sont joints en une chaîne 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 l'impression des é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 les éléments avant de les imprimer, la requête intégrée au langage (LINQ) peut être bénéfique.

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    public static void Main()
    {
        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;
using System.Collections.Generic;
using System.Linq;

class Program
{
    public static void Main()
    {
        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
Imports System.Collections.Generic
Imports System.Linq

Friend Class Program
	Public Shared Sub Main()
		Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5}
		Dim evenNumbers As List(Of Integer) = numbers.Where(Function(n) n Mod 2 = 0).ToList()
		Console.WriteLine("Even numbers: " & String.Join(", ", evenNumbers))
	End Sub
End Class

Imports System
Imports System.Collections.Generic
Imports System.Linq

Friend Class Program
	Public Shared Sub Main()
		Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5}
		Dim evenNumbers As List(Of Integer) = numbers.Where(Function(n) n Mod 2 = 0).ToList()
		Console.WriteLine("Even numbers: " & String.Join(", ", evenNumbers))
	End Sub
End Class

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

C# Imprimer une liste (comment cela fonctionne pour les développeurs) : Figure 1 - Sortie console : nombres pairs : 2, 4

Objets personnalisés et méthode ToString()

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

using System;
using System.Collections.Generic;

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);
        }
    }
}

using System;
using System.Collections.Generic;

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);
        }
    }
}

Imports System
Imports System.Collections.Generic

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

Imports System
Imports System.Collections.Generic

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 remplaçant la méthode ToString() dans la classe Person, vous contrôlez comment les instances de la classe sont représentées sous forme de chaînes. Cela améliore la lisibilité de votre liste une fois imprimée.

C# Imprimer une liste (comment cela fonctionne pour les développeurs) : Figure 2 - Sortie console

Présentation d'IronPrint - Bibliothèque d'impression C#

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 compatibilité multiplateforme et avec différents formats de documents en fait un outil précieux pour les développeurs .NET à la recherche de solutions d'impression efficaces pour leurs applications.

C# Imprimer une liste (comment cela fonctionne pour les développeurs) : Figure 3 - IronPrint for .NET : la bibliothèque d'impression C#

Fonctionnalités clés

Voici quelques fonctions clés importantes qui font qu'IronPrint se distingue pour l'impression de documents physiques dans les applications C# :

1. Compatibilité multiplateforme

Compatibilité avec les 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 et Avalonia), Bureau (WPF, MAUI et Windows Avalonia), Console (Application et Bibliothèque)

2. Formats pris en charge

Gérer différents formats de documents, notamment PDF, PNG, HTML, TIFF, GIF, JPEG, IMAGE et BITMAP.
Personnalisez les paramètres d'impression en fonction des exigences du document.

3. Installation facile

Installez la bibliothèque IronPrint à l'aide de la console du gestionnaire de packages NuGet :

PM > Install-Package IronPrint

Install-Package IronPrint

Vous pouvez également l'installer dans votre projet à l'aide de Visual Studio. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le projet, puis cliquez sur Gérer le Gestionnaire de packages NuGet pour les solutions. Dans l'onglet de navigation 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 méthode simple Print. Si aucune imprimante physique n'est disponible, l'impression se fera à l'aide de l'imprimante par défaut spécifiée par le système d'exploitation.

using IronPrint;

class Program
{
    static void Main()
    {
        // Print the document
        Printer.Print("newDoc.pdf");
    }
}

using IronPrint;

class Program
{
    static void Main()
    {
        // Print the document
        Printer.Print("newDoc.pdf");
    }
}

Imports IronPrint

Friend Class Program
	Shared Sub Main()
		' Print the document
		Printer.Print("newDoc.pdf")
	End Sub
End Class

Imports IronPrint

Friend Class Program
	Shared Sub Main()
		' Print the document
		Printer.Print("newDoc.pdf")
	End Sub
End Class

2. Imprimer avec boîte de dialogue

Il offre également une méthode dédiée pour afficher le dialogue 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;

class Program
{
    static void Main()
    {
        // Show print dialog
        Printer.ShowPrintDialog("newDoc.pdf");
    }
}

using IronPrint;

class Program
{
    static void Main()
    {
        // Show print dialog
        Printer.ShowPrintDialog("newDoc.pdf");
    }
}

Imports IronPrint

Friend Class Program
	Shared Sub Main()
		' Show print dialog
		Printer.ShowPrintDialog("newDoc.pdf")
	End Sub
End Class

Imports IronPrint

Friend Class Program
	Shared Sub Main()
		' Show print dialog
		Printer.ShowPrintDialog("newDoc.pdf")
	End Sub
End Class

3. Personnaliser les paramètres d'impression

IronPrint fournit divers paramètres print qui permettent un contrôle granulaire sur l'impression du document.

using IronPrint;

class Program
{
    static void Main()
    {
        // Configure print settings
        PrintSettings printSettings = new PrintSettings()
        {
            Dpi = 150,
            NumberOfCopies = 2,
            PaperOrientation = PaperOrientation.Portrait
        };
        // Print the document
        Printer.Print("newDoc.pdf", printSettings);
    }
}

using IronPrint;

class Program
{
    static void Main()
    {
        // Configure print settings
        PrintSettings printSettings = new PrintSettings()
        {
            Dpi = 150,
            NumberOfCopies = 2,
            PaperOrientation = PaperOrientation.Portrait
        };
        // Print the document
        Printer.Print("newDoc.pdf", printSettings);
    }
}

Imports IronPrint

Friend Class Program
	Shared Sub Main()
		' Configure print settings
		Dim printSettings As New PrintSettings() With {
			.Dpi = 150,
			.NumberOfCopies = 2,
			.PaperOrientation = PaperOrientation.Portrait
		}
		' Print the document
		Printer.Print("newDoc.pdf", printSettings)
	End Sub
End Class

Imports IronPrint

Friend Class Program
	Shared Sub Main()
		' Configure print settings
		Dim printSettings As New PrintSettings() With {
			.Dpi = 150,
			.NumberOfCopies = 2,
			.PaperOrientation = PaperOrientation.Portrait
		}
		' Print the document
		Printer.Print("newDoc.pdf", printSettings)
	End Sub
End Class

Pour mieux comprendre les classes et les méthodes utilisées, veuillez consulter la page de référence de l'API .

Conclusion

L'affichage d'une liste en C# implique de choisir la méthode appropriée en fonction de la complexité des données et du résultat souhaité. Que vous utilisiez une boucle simple, String.Join(), LINQ, ou que vous personnalisiez 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 convient le mieux à votre cas d'utilisation spécifique.

IronPrint est la bibliothèque d'impression idéale si vous recherchez précision, facilité d'utilisation et rapidité. Que vous développiez des applications Web, travailliez avec MAUI, Avalonia ou tout autre projet lié à .NET, IronPrint est là pour vous. Pour plus d'informations sur IronPrint, veuillez consulter cette page de documentation .

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

Jacob Mellor

Discutez maintenant avec l'équipe d'ingénierie

Directeur technique

Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.

...