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

C# Imprimer variable : simplifiez votre code

Curtis Chau
Curtis Chau
Mis à jour:

L'impression de variables en C# est une compétence essentielle pour tout développeur. Que vous déboguiez votre code, que vous affichiez des informations aux utilisateurs ou que vous vérifiiez simplement l'état de votre programme, l'instruction Console.WriteLine est votre outil de référence pour les opérations de flux de sortie standard. La classe Console de l'espace de noms System fournit les méthodes Write et WriteLine pour imprimer des valeurs variables dans la fenêtre de la console.

Dans cet article complet, nous allons explorer divers aspects de l'impression de variables en C#, en couvrant les différents types de données, les options de formatage et les techniques avancées.

L'impression variable de base

Nous pouvons facilement imprimer des valeurs numériques à l'aide de la méthode Console.WriteLine, comme le montre l'exemple de code ci-dessous.

int integerValue = 42; // Declare and initialize an integer variable
Console.WriteLine($"Integer Value: {integerValue}"); // Print the integer value using string interpolation
int integerValue = 42; // Declare and initialize an integer variable
Console.WriteLine($"Integer Value: {integerValue}"); // Print the integer value using string interpolation
Dim integerValue As Integer = 42 ' Declare and initialize an integer variable
Console.WriteLine($"Integer Value: {integerValue}") ' Print the integer value using string interpolation
$vbLabelText   $csharpLabel

Dans cet exemple de base, nous déclarons une variable entière (integerValue) et utilisons l'instruction Console.WriteLine pour imprimer la valeur spécifiée sur la console. Le symbole $ placé avant la chaîne nous permet d'intégrer la variable directement dans la chaîne littérale à l'aide de l'interpolation de chaîne.

Imprimer des variables de chaîne

string greeting = "Hello, C#!"; // Declare and initialize a string variable
Console.WriteLine($"Greeting: {greeting}"); // Print the string value using string interpolation
string greeting = "Hello, C#!"; // Declare and initialize a string variable
Console.WriteLine($"Greeting: {greeting}"); // Print the string value using string interpolation
Dim greeting As String = "Hello, C#!" ' Declare and initialize a string variable
Console.WriteLine($"Greeting: {greeting}") ' Print the string value using string interpolation
$vbLabelText   $csharpLabel

L'impression des variables de type chaîne de caractères suit le même schéma. Nous déclarons une variable de type chaîne (greeting), attribuons une valeur de type chaîne ("Hello, C# !") et utilisons Console.WriteLine pour la sortie. Cette traduction est utile pour l'affichage de messages ou de toute information textuelle.

C# Print Variable (How It Works For Developers) : Figure 1 - Sortie d'une variable de chaîne

Si vous souhaitez imprimer des valeurs variables sur la même ligne, vous pouvez utiliser la méthode Console.Write. La seule différence entre les deux méthodes est que WriteLine laisse un caractère de retour à la ligne à la fin, de sorte que la sortie suivante est imprimée sur la ligne suivante, alors que Write imprime tout sur la même ligne.

Multiples variables sur une seule ligne

int x = 5, y = 10; // Declare and initialize multiple integers
Console.WriteLine($"X: {x}, Y: {y}"); // Print multiple variables using string interpolation
int x = 5, y = 10; // Declare and initialize multiple integers
Console.WriteLine($"X: {x}, Y: {y}"); // Print multiple variables using string interpolation
Dim x As Integer = 5, y As Integer = 10 ' Declare and initialize multiple integers
Console.WriteLine($"X: {x}, Y: {y}") ' Print multiple variables using string interpolation
$vbLabelText   $csharpLabel

Vous pouvez imprimer plusieurs variables sur une seule ligne en les séparant par des virgules dans la chaîne. Cela permet d'afficher ensemble des informations connexes.

C# Print Variable (How It Works For Developers) : Figure 2 - Variables multiples sur une seule ligne

Formatage des variables

double piValue = Math.PI; // Assign the mathematical constant Pi
Console.WriteLine($"Approximate Value of Pi: {piValue:F5}"); // Format to 5 decimal places and print
double piValue = Math.PI; // Assign the mathematical constant Pi
Console.WriteLine($"Approximate Value of Pi: {piValue:F5}"); // Format to 5 decimal places and print
Dim piValue As Double = Math.PI ' Assign the mathematical constant Pi
Console.WriteLine($"Approximate Value of Pi: {piValue:F5}") ' Format to 5 decimal places and print
$vbLabelText   $csharpLabel

Le formatage est crucial, en particulier pour les nombres à virgule flottante. Ici, le spécificateur de format F5 garantit que la valeur de Pi est imprimée avec cinq chiffres après la virgule.

Concaténation des variables

int apples = 3, oranges = 5; // Declare and initialize integer variables for fruit counts
Console.WriteLine("Total Fruits: " + (apples + oranges)); // Calculate the total and print using concatenation
int apples = 3, oranges = 5; // Declare and initialize integer variables for fruit counts
Console.WriteLine("Total Fruits: " + (apples + oranges)); // Calculate the total and print using concatenation
Dim apples As Integer = 3, oranges As Integer = 5 ' Declare and initialize integer variables for fruit counts
Console.WriteLine("Total Fruits: " & (apples + oranges)) ' Calculate the total and print using concatenation
$vbLabelText   $csharpLabel

La concaténation de chaînes peut être utilisée pour des résultats plus complexes. Ici, le nombre total de fruits est calculé et imprimé sur une seule ligne.

Imprimer les types de variables

bool isTrue = true; // Declare and initialize a boolean variable
Console.WriteLine($"Is True? {isTrue}, Variable Type: {isTrue.GetType()}"); // Print the value and type of the variable
bool isTrue = true; // Declare and initialize a boolean variable
Console.WriteLine($"Is True? {isTrue}, Variable Type: {isTrue.GetType()}"); // Print the value and type of the variable
Dim isTrue As Boolean = True ' Declare and initialize a boolean variable
Console.WriteLine($"Is True? {isTrue}, Variable Type: {isTrue.GetType()}") ' Print the value and type of the variable
$vbLabelText   $csharpLabel

Il est parfois utile d'afficher non seulement la valeur par défaut de la variable, mais aussi son type. La méthode GetType() permet d'atteindre cet objectif.

Techniques avancées pour l'impression de variables

Utilisation de String.Format

int width = 10, height = 5; // Declare dimensions
string formattedOutput = String.Format("Dimensions: {0} x {1}", width, height); // Format the string
Console.WriteLine(formattedOutput); // Print formatted output
int width = 10, height = 5; // Declare dimensions
string formattedOutput = String.Format("Dimensions: {0} x {1}", width, height); // Format the string
Console.WriteLine(formattedOutput); // Print formatted output
Dim width As Integer = 10, height As Integer = 5 ' Declare dimensions
Dim formattedOutput As String = String.Format("Dimensions: {0} x {1}", width, height) ' Format the string
Console.WriteLine(formattedOutput) ' Print formatted output
$vbLabelText   $csharpLabel

La méthode String.Format offre un autre moyen de formater les chaînes et d'imprimer les variables, ce qui permet de mieux contrôler la structure de sortie.

Chaîne littérale verbatim

string filePath = @"C:\MyDocuments\file.txt"; // Use verbatim to handle file paths
Console.WriteLine($"File Path: {filePath}"); // Print the file path
string filePath = @"C:\MyDocuments\file.txt"; // Use verbatim to handle file paths
Console.WriteLine($"File Path: {filePath}"); // Print the file path
Dim filePath As String = "C:\MyDocuments\file.txt" ' Use verbatim to handle file paths
Console.WriteLine($"File Path: {filePath}") ' Print the file path
$vbLabelText   $csharpLabel

Pour les chemins d'accès ou les chaînes contenant des caractères d'échappement, des chaînes littérales (préfixées par @) peuvent être utilisées pour simplifier le code. Ici, le formatage des chaînes de caractères permet d'imprimer facilement le chemin d'accès au fichier.

Console Output Control

Redirection de la sortie de la console

L'exemple de code suivant vous aide à écrire la sortie de la fenêtre de la console dans un fichier :

using System;
using System.IO;

class Program
{
    public static void Main(string[] args)
    {
        string outputPath = "output.txt"; // Specify the output file path
        using (StreamWriter sw = new StreamWriter(outputPath))
        {
            Console.SetOut(sw); // Redirect console output to a file
            Console.WriteLine("This will be written to the file."); // This output goes to the file
        }
    }
}
using System;
using System.IO;

class Program
{
    public static void Main(string[] args)
    {
        string outputPath = "output.txt"; // Specify the output file path
        using (StreamWriter sw = new StreamWriter(outputPath))
        {
            Console.SetOut(sw); // Redirect console output to a file
            Console.WriteLine("This will be written to the file."); // This output goes to the file
        }
    }
}
Imports System
Imports System.IO

Friend Class Program
	Public Shared Sub Main(ByVal args() As String)
		Dim outputPath As String = "output.txt" ' Specify the output file path
		Using sw As New StreamWriter(outputPath)
			Console.SetOut(sw) ' Redirect console output to a file
			Console.WriteLine("This will be written to the file.") ' This output goes to the file
		End Using
	End Sub
End Class
$vbLabelText   $csharpLabel

La redirection de la sortie de la console vers un fichier vous permet de capturer et d'enregistrer la sortie à des fins d'analyse ou de journalisation.

Couleurs de la console

Console.ForegroundColor = ConsoleColor.Red; // Set text color to red
Console.WriteLine("This text will be displayed in red."); // Print in specified color
Console.ResetColor(); // Reset color to default
Console.ForegroundColor = ConsoleColor.Red; // Set text color to red
Console.WriteLine("This text will be displayed in red."); // Print in specified color
Console.ResetColor(); // Reset color to default
Console.ForegroundColor = ConsoleColor.Red ' Set text color to red
Console.WriteLine("This text will be displayed in red.") ' Print in specified color
Console.ResetColor() ' Reset color to default
$vbLabelText   $csharpLabel

La modification de la couleur du texte de la console permet d'accentuer visuellement certains résultats, ce qui facilite la distinction entre les différents types d'informations.

IronPrint : Donner aux développeurs .NET des capacités d'impression avancées

IronPrint est une puissante bibliothèque d'impression développée par Iron Software. IronPrint est une bibliothèque d'impression complète conçue pour s'intégrer de manière transparente aux applications .NET. IronPrint se présente comme une bibliothèque d'impression fiable et riche en fonctionnalités pour les développeurs .NET. Sa compatibilité multiplateforme, sa prise en charge de divers formats de documents et ses paramètres personnalisables en font un outil précieux pour gérer diverses tâches d'impression. Que vous développiez pour des applications de bureau, mobiles ou web, IronPrint offre une solution polyvalente pour répondre à vos besoins d'impression dans le paysage en constante évolution du développement .NET.

Variable d'impression C# (Comment ça marche pour les développeurs) : Figure 3 - IronPrint

Il offre une gamme de fonctionnalités qui permettent aux développeurs de répondre à diverses exigences en matière d'impression, de l'impression de documents de base aux paramètres personnalisables et à la compatibilité multiplateforme.

Caractéristiques principales

  1. Support de format: IronPrint prend en charge une variété de formats de documents, notamment PDF, PNG, HTML, TIFF, GIF, JPEG et BITMAP. Cette polyvalence permet aux développeurs de travailler avec différents types de contenus à imprimer.
  2. Paramètres personnalisables: Les développeurs ont la possibilité de personnaliser les paramètres d'impression en fonction des exigences de leur application. La traduction doit rester professionnelle et préserver l'exactitude technique tout en expliquant les caractéristiques et les avantages de ces outils de développement, notamment les options permettant de définir le nombre de points par pouce (DPI), de spécifier l'orientation du papier (portrait ou paysage) et de contrôler le nombre de copies.
  3. Dialogue d'impression : IronPrint facilite une expérience utilisateur transparente en permettant aux développeurs d'afficher un dialogue d'impression avant d'imprimer. Cela peut être utile dans des scénarios où les utilisateurs doivent interagir avec le processus d'impression et sélectionner des options spécifiques.

Compatibilité et installation

IronPrint se targue d'une compatibilité étendue entre les différentes versions de .NET, ce qui le rend accessible à un large éventail de développeurs. Elle prend en charge .NET 8, 7, 6, 5 et .NET Core 3.1+, ainsi que .NET Framework (4.6.2+). La bibliothèque s'adresse à différents types de projets, y compris les applications mobiles (Xamarin, MAUI), de bureau (WPF, MAUI, Windows Avalonia) et de console.

Installation

Pour commencer à utiliser IronPrint, les développeurs peuvent rapidement installer la bibliothèque à l'aide du gestionnaire de paquets NuGet.

Install-Package IronPrint

Il est également possible de télécharger le package directement sur le site officiel NuGet d'IronPrint ou en utilisant le gestionnaire de packages NuGet pour les solutions.

Application de la clé de licence

Avant d'utiliser les fonctionnalités d'IronPrint, les développeurs doivent appliquer une licence ou une clé d'essai valide. Il s'agit d'attribuer la clé de licence à la propriété LicenseKey de la classe License. L'extrait de code suivant illustre cette étape :

using IronPrint; 

// Apply license key
License.LicenseKey = "IRONPRINT.MYLICENSE.KEY.1EF01";
using IronPrint; 

// Apply license key
License.LicenseKey = "IRONPRINT.MYLICENSE.KEY.1EF01";
Imports IronPrint

' Apply license key
License.LicenseKey = "IRONPRINT.MYLICENSE.KEY.1EF01"
$vbLabelText   $csharpLabel

Exemples de code

Document imprimé

Pour imprimer un document à l'aide d'IronPrint, les développeurs peuvent simplement transmettre le chemin d'accès au fichier à la méthode Print :

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

Imprimer avec le dialogue

Pour les scénarios où un dialogue d'impression est souhaitable, la méthode ShowPrintDialog peut être utilisée :

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

Personnaliser les paramètres d'impression

Pour configurer les paramètres d'impression de manière programmatique, les développeurs peuvent instancier la classe PrintSettings :

using IronPrint;

// Configure print settings
PrintSettings printSettings = new PrintSettings();
printSettings.Dpi = 150;
printSettings.NumberOfCopies = 2;
printSettings.PaperOrientation = PaperOrientation.Portrait;

// Print the document with custom settings
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 with custom settings
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 with custom settings
Printer.Print("newDoc.pdf", printSettings)
$vbLabelText   $csharpLabel

Pour plus d'exemples de codage, veuillez consulter cette page exemple de code.

Conclusion

L'impression de variables en C# est une compétence fondamentale que tout développeur devrait maîtriser. L'instruction Console.WriteLine, associée à diverses techniques de formatage telles que la concaténation de chaînes, les littéraux de chaînes et l'interpolation de chaînes, constitue un moyen souple et efficace de produire des valeurs variables. À mesure que vous explorerez des scénarios plus complexes, tels que le travail avec différents types de données et des options de formatage avancées, vous améliorerez votre capacité à communiquer efficacement des informations au sein de vos programmes C#.

IronPrint est une bibliothèque payante, mais les développeurs peuvent explorer ses fonctionnalités à l'aide de licences d'essai gratuites. For more information, developers can visit the official documentation and API Reference page. Téléchargez la bibliothèque à partir de ici et essayez-la.

Questions Fréquemment Posées

Comment puis-je imprimer des variables en C# ?

En C#, imprimer des variables peut être facilement réalisé en utilisant la méthode Console.WriteLine du namespace System. Cette méthode vous permet de sortir les valeurs des variables sur la console. Par exemple : Console.WriteLine($"Variable: {yourVariable}");

Quelles sont les différences entre Console.Write et Console.WriteLine en C# ?

La méthode Console.Write écrit la sortie sur la console sans ajouter de caractère de nouvelle ligne à la fin, tandis que Console.WriteLine ajoute un caractère de nouvelle ligne, garantissant que les sorties suivantes apparaissent sur une nouvelle ligne.

Comment puis-je formater des nombres lors de l'impression en C# ?

Vous pouvez formater des nombres en C# en utilisant des spécificateurs de format avec l'interpolation de chaîne. Par exemple, pour imprimer un double avec deux décimales, utilisez : Console.WriteLine($"{yourDouble:F2}");

Comment puis-je concaténer des chaînes et des variables en C# ?

En C#, les chaînes et les variables peuvent être concaténées en utilisant l'opérateur + ou l'interpolation de chaîne avec le symbole $. Par exemple : Console.WriteLine("Total: " + totalCount); ou Console.WriteLine($"Total: {totalCount}");

Qu'est-ce qu'un littéral de chaîne verbatim en C# ?

Un littéral de chaîne verbatim en C# est précédé d'un symbole @ et est utilisé pour gérer des chaînes avec des caractères d'échappement, comme les chemins de fichier. Il vous permet d'écrire une chaîne telle quelle sans devoir échapper les antislashs.

Comment puis-je imprimer le type de données d'une variable en C# ?

Pour imprimer le type de données d'une variable en C#, utilisez la méthode GetType(). Par exemple : Console.WriteLine($"Type de Variable: {yourVariable.GetType()}");

Est-il possible de rediriger la sortie de la console vers un fichier en C# ?

Oui, en utilisant la classe StreamWriter, vous pouvez rediriger la sortie de la console vers un fichier. Pour cela, configurez Console.SetOut(sw), où sw est une instance de StreamWriter.

Quelles options d'impression avancées sont disponibles pour les développeurs .NET ?

Les options d'impression avancées pour les développeurs .NET incluent l'utilisation d'IronPrint, une bibliothèque qui prend en charge divers formats de documents et des paramètres d'impression personnalisables. Elle permet la compatibilité multiplateforme et une gestion efficace des tâches d'impression dans les applications.

Comment gérer les caractères d'échappement dans les littéraux de chaîne C# ?

Les caractères d'échappement dans les littéraux de chaîne C# peuvent être gérés en utilisant des antislashs pour des séquences d'échappement spécifiques ou en employant des littéraux de chaînes verbatims avec le préfixe @ pour prendre la chaîne telle quelle.

Quels outils sont disponibles pour personnaliser la sortie de la console en C# ?

Pour personnaliser la sortie de la console, vous pouvez changer les couleurs du texte en utilisant les propriétés Console.ForegroundColor et Console.BackgroundColor pour améliorer la présentation visuelle de vos données.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit