Icône de message
Passer au contenu du pied de page
  1. IronPrint
  2. Blog IronPrint
  3. .NET Aide
  4. csharp-print-list
.NET AIDE

C# Imprimer une liste : un tutoriel rapide

Jacob Mellor, Directeur technique @ Team Iron
Jacob Mellor
Mis à jour:

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 tableau dynamique (list) peut voir sa taille 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 };
    }
}
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
$vbLabelText   $csharpLabel

Afficher une liste à l'aide d'une boucle

1. Utilisation de la boucle foreach

La méthode traditionnelle et simple pour afficher les éléments d'une liste consiste à utiliser une boucle. 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
$vbLabelText   $csharpLabel

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'index ou si vous souhaitez afficher des éléments de manière conditionnelle, vous pouvez utiliser une boucle. 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
$vbLabelText   $csharpLabel

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

L'impression d'une liste en 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 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
$vbLabelText   $csharpLabel

2. Utilisation de LINQ OrderByDescending

Vous pouvez également utiliser la méthode OrderByDescending avec une clé pour organiser une collection spécifique d'éléments de la classe générique de 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
$vbLabelText   $csharpLabel

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 à cette fin. 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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

Ces exemples constituent une base pour l'impression des éléments de liste dans divers scénarios. Il existe d'autres méthodes utiles offertes par la classe list 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 en fonction du 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.
  • 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'index 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 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
$vbLabelText   $csharpLabel

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

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
$vbLabelText   $csharpLabel

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# Afficher une liste (Fonctionnement 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'objet 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
$vbLabelText   $csharpLabel

En remplaçant la méthode ToString() dans 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 une fois imprimée.

C# Afficher une liste (Fonctionnement 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 (Fonctionnement pour les développeurs) : Figure 3 - IronPrint for .NET: La bibliothèque d'impression C#

Fonctionnalités clés

Voici quelques fonctionnalités clés importantes qui distinguent IronPrint 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 :

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 la recherche, puis cliquez sur le bouton Installer pour l'ajouter à votre projet.

Impression avec IronPrint : exemples de code

1. Imprimer le document

IronPrint propose 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
$vbLabelText   $csharpLabel

2. Imprimer avec boîte de dialogue

Il fournit également une méthode dédiée pour afficher la boîte de 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
$vbLabelText   $csharpLabel

3. Personnaliser les paramètres d'impression

IronPrint propose divers paramètres print qui permettent un contrôle précis de 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
$vbLabelText   $csharpLabel

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 ce soit en utilisant une simple boucle, String.Join(), LINQ ou en personnalisant la méthode ToString() pour des 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 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 !

Questions Fréquemment Posées

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.

Jacob Mellor, Directeur technique @ Team Iron
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, ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi