Skip to footer content
.NET HELP

How to Use C# Print Line Effectively

Printing lines in C# is a fundamental aspect of console applications, and it involves displaying text or specified values on the console screen. Whether you're working with the standard output stream or formatting strings, understanding how to print lines efficiently is crucial in C# Console Applications.

In this article, we'll explore various methods and techniques related to printing lines in C#.

Print Line Basics

In C#, printing a line often involves using the Console.WriteLine method. Let's start by looking at a simple example:

using System;

class Program 
{
    public static void Main() 
    {
        Console.WriteLine("Hello, C# Print Line!");
    }
}
using System;

class Program 
{
    public static void Main() 
    {
        Console.WriteLine("Hello, C# Print Line!");
    }
}
Imports System

Friend Class Program
	Public Shared Sub Main()
		Console.WriteLine("Hello, C# Print Line!")
	End Sub
End Class
$vbLabelText   $csharpLabel

In the above code, the Console.WriteLine statement outputs the specified string value ("Hello, C# Print Line!") followed by a new line. This is achieved by the WriteLine method, which appends a line terminator to the end of the output.

Line Terminators

A line terminator is a special character or sequence that indicates the end of a line. The two most common line terminators are the carriage return ('\r') and line feed ('\n'). In C#, the Console.WriteLine method takes care of using the appropriate current line terminator based on the operating system.

public static void Main() 
{
    Console.WriteLine("This is on the first line.");
    Console.WriteLine("This is on the second line.");
}
public static void Main() 
{
    Console.WriteLine("This is on the first line.");
    Console.WriteLine("This is on the second line.");
}
Public Shared Sub Main()
	Console.WriteLine("This is on the first line.")
	Console.WriteLine("This is on the second line.")
End Sub
$vbLabelText   $csharpLabel

In the example above, after the program execution, each Console.WriteLine produces a new line in the C# console window, resulting in the two specified lines.

C# Print Line (How It Works For Developers): Figure 1 - Console output from the previous code

Specifying Line Terminators

If you need to control the line terminator explicitly, you can use the Console.Write method and add the desired line terminator manually:

public static void Main() 
{
    Console.Write("This is on the first line.");
    Console.Write('\r'); // Carriage return
    Console.Write("This is on the same line but very far left position.");
}
public static void Main() 
{
    Console.Write("This is on the first line.");
    Console.Write('\r'); // Carriage return
    Console.Write("This is on the same line but very far left position.");
}
Imports Microsoft.VisualBasic

Public Shared Sub Main()
	Console.Write("This is on the first line.")
	Console.Write(ControlChars.Cr) ' Carriage return
	Console.Write("This is on the same line but very far left position.")
End Sub
$vbLabelText   $csharpLabel

In this example, the carriage return ('\r') is used to position the cursor at the beginning of the line, resulting in the second part of the text appearing at the far-left position, i.e., overwriting the previous output.

C# Print Line (How It Works For Developers): Figure 2 - Console output showcasing \r

Printing Multiple Lines

To print multiple lines without repeating the Console.WriteLine statement, you can use a variable-length parameter list:

public static void Main() 
{
    PrintLines("Line 1", "Line 2", "Line 3");
}

static void PrintLines(params string[] lines) 
{
    foreach (var line in lines) 
    {
        Console.WriteLine(line);
    }
}
public static void Main() 
{
    PrintLines("Line 1", "Line 2", "Line 3");
}

static void PrintLines(params string[] lines) 
{
    foreach (var line in lines) 
    {
        Console.WriteLine(line);
    }
}
Public Shared Sub Main()
	PrintLines("Line 1", "Line 2", "Line 3")
End Sub

Shared Sub PrintLines(ParamArray ByVal lines() As String)
	For Each line In lines
		Console.WriteLine(line)
	Next line
End Sub
$vbLabelText   $csharpLabel

The PrintLines method we have created takes a specified array of string parameters, allowing you to pass any number of new lines to print a specified string value:

C# Print Line (How It Works For Developers): Figure 3 - Console output from using the PrintLines method

Formatting Output

Formatting output is crucial, especially when dealing with different data types. The Console.WriteLine method provides several overloads that accept a specified object and format information:

public static void Main() 
{
    int answer = 42;
    string name = "John Doe";
    Console.WriteLine("The answer is {0}.", answer);
    Console.WriteLine("Hello, {0}!", name);
}
public static void Main() 
{
    int answer = 42;
    string name = "John Doe";
    Console.WriteLine("The answer is {0}.", answer);
    Console.WriteLine("Hello, {0}!", name);
}
Public Shared Sub Main()
	Dim answer As Integer = 42
	Dim name As String = "John Doe"
	Console.WriteLine("The answer is {0}.", answer)
	Console.WriteLine("Hello, {0}!", name)
End Sub
$vbLabelText   $csharpLabel

In this example, {0} is a placeholder for the specified objects (in this case, answer and name), allowing you to include variable data in the output and print the specified format information.

C# Print Line (How It Works For Developers): Figure 4 - Console output showing formatting

Line Breaks and Unicode Characters

For special line breaks or Unicode characters, you can use escape sequences. You can also print any ASCII literal or valid HTML code using Console.WriteLine. For example, to include a one-line break in the same string:

public static void Main() 
{
    Console.WriteLine("This is line 1.\nThis is line 2.");
    Console.WriteLine("Line 1\u000Aline 2");
}
public static void Main() 
{
    Console.WriteLine("This is line 1.\nThis is line 2.");
    Console.WriteLine("Line 1\u000Aline 2");
}
Imports Microsoft.VisualBasic

Public Shared Sub Main()
	Console.WriteLine("This is line 1." & vbLf & "This is line 2.")
	Console.WriteLine("Line 1" & vbLf & "line 2")
End Sub
$vbLabelText   $csharpLabel

Here, \n and \u000A, the specified Unicode character, both represent a line feed character, causing the text to move to the next line in each case.

C# Print Line (How It Works For Developers): Figure 5 - Console output showing line-breaking characters

Random Boolean Values

The below code uses string interpolation in the Console.WriteLine method. String interpolation is a feature introduced in C# 6.0 that simplifies the process of embedding expressions or variables within string literals and displaying the specified boolean value on the Console application properly.

using System;

class Program
{
    static void Main()
    {
        Random rnd = new Random();
        for (int i = 1; i <= 5; i++)
        { 
            bool isTrue = rnd.Next(0, 2) == 1;
            Console.WriteLine($"True or False: {isTrue}");
        }
    }
}
using System;

class Program
{
    static void Main()
    {
        Random rnd = new Random();
        for (int i = 1; i <= 5; i++)
        { 
            bool isTrue = rnd.Next(0, 2) == 1;
            Console.WriteLine($"True or False: {isTrue}");
        }
    }
}
Imports System

Friend Class Program
	Shared Sub Main()
		Dim rnd As New Random()
		For i As Integer = 1 To 5
			Dim isTrue As Boolean = rnd.Next(0, 2) = 1
			Console.WriteLine($"True or False: {isTrue}")
		Next i
	End Sub
End Class
$vbLabelText   $csharpLabel

The specified data returned from the expression is printed on the console application as shown below:

C# Print Line (How It Works For Developers): Figure 6 - Console output showing boolean values using string interpolation

Printing Different Numeric Formats

Printing various numeric formats is a common requirement in programming, especially when dealing with double-precision floating-point and single-precision floating-point numbers. Again, the Console.WriteLine statements can be utilized to print them with precision and ease.

Double Precision Floating-Point

double doubleValue = 0.123456789;
Console.WriteLine($"Double Precision: {doubleValue:F7}");
double doubleValue = 0.123456789;
Console.WriteLine($"Double Precision: {doubleValue:F7}");
Dim doubleValue As Double = 0.123456789
Console.WriteLine($"Double Precision: {doubleValue:F7}")
$vbLabelText   $csharpLabel

In this example, F7 specifies that the double value should be formatted with 7 digits after the decimal point. You can adjust the number after 'F' to control the precision.

Existing String

string existingString = "Hello, C#!";
Console.WriteLine($"Existing String: {existingString}");
string existingString = "Hello, C#!";
Console.WriteLine($"Existing String: {existingString}");
Dim existingString As String = "Hello, C#!"
Console.WriteLine($"Existing String: {existingString}")
$vbLabelText   $csharpLabel

Printing an existing string is straightforward. Simply use Console.WriteLine and include the string you want to display.

Single Precision Floating-Point

float singleValue = 0.123456789f;
Console.WriteLine($"Single Precision: {singleValue:F7}");
float singleValue = 0.123456789f;
Console.WriteLine($"Single Precision: {singleValue:F7}");
Dim singleValue As Single = 0.123456789F
Console.WriteLine($"Single Precision: {singleValue:F7}")
$vbLabelText   $csharpLabel

Similar to double precision, the F7 format specifier is used here for single-precision floating-point. You can adjust the number after 'F' based on your precision requirements.

Unlocking Powerful Printing Capabilities with IronPrint in C#

Printing documents is a fundamental aspect of many applications, and when it comes to harnessing the full potential of printing in C#, IronPrint stands out as a versatile and feature-rich library.

Introduction to IronPrint

IronPrint, developed by Iron Software, is an advanced print library designed for the .NET ecosystem, including C#. Whether you are working on a desktop, mobile, or web application, IronPrint seamlessly integrates with your C# projects, providing a comprehensive set of tools for handling diverse printing needs.

C# Print Line (How It Works For Developers): Figure 7 - IronPrint webpage

Key Features of IronPrint

1. Cross-Platform Compatibility:

IronPrint supports various operating systems, including Windows, macOS, Android, and iOS. This cross-platform compatibility ensures that your printing solutions can reach users across different environments.

2. .NET Version Support:

Compatible with .NET Framework 4.6.2 and above, .NET Core 3.1+, and the latest .NET versions, IronPrint covers a wide range of .NET environments.

3. Project Type Support:

IronPrint caters to different project types, including Mobile (Xamarin & MAUI), Desktop (WPF & MAUI), and Console (App & Library). This flexibility makes it suitable for a variety of application architectures.

4. Easy Installation:

Getting started with IronPrint is a breeze. You can quickly install the library by using the NuGet Package Manager Console and executing the Install-Package IronPrint command.

Basic Usage of IronPrint

Here's a simple example demonstrating how easy it is to use IronPrint in a C# console application to print documents:

using IronPrint;

class Program
{
    static void Main()
    {
        Console.WriteLine("Printing Started...");
        // Silent printing of a document
        Printer.Print("document.pdf");
        // Or display a print dialog
        Printer.ShowPrintDialog("document.pdf");
        Console.WriteLine("Printing Completed...");
    }
}
using IronPrint;

class Program
{
    static void Main()
    {
        Console.WriteLine("Printing Started...");
        // Silent printing of a document
        Printer.Print("document.pdf");
        // Or display a print dialog
        Printer.ShowPrintDialog("document.pdf");
        Console.WriteLine("Printing Completed...");
    }
}
Imports IronPrint

Friend Class Program
	Shared Sub Main()
		Console.WriteLine("Printing Started...")
		' Silent printing of a document
		Printer.Print("document.pdf")
		' Or display a print dialog
		Printer.ShowPrintDialog("document.pdf")
		Console.WriteLine("Printing Completed...")
	End Sub
End Class
$vbLabelText   $csharpLabel

The output here shows the printing of a document using the Print and ShowPrintDialog method. If the physical printer is not installed then the default printer is used for printing.

C# Print Line (How It Works For Developers): Figure 8 - Printing started popup and save print output popup

Advanced Printing Capabilities

IronPrint goes beyond basic printing tasks and offers advanced features such as:

  • Silent Printing: Print documents without showing a dialog using Printer.PrintAsync.
  • Custom Print Settings: Fine-tune printing parameters with the PrintSettings class.
  • Async Printing: Execute printing operations asynchronously to prevent blocking the main thread.
  • Select Printer: The GetPrinterNames method allows you to choose from the available printers giving more granular control over the printing process.

Platform-Specific Adjustments

IronPrint allows you to tailor your printing solutions for different platforms. For example, when working with .NET Core projects targeting specific platforms like Windows, Android, iOS, or macOS, you can adjust the TargetFrameworks property in your project file accordingly.

To get more detailed information on IronPrint, please visit this documentation and API reference pages.

Conclusion

Printing lines in C# is a foundational skill for console application development. Whether you're displaying text, formatting output, or controlling line terminators, understanding the various techniques available will enhance your ability to create effective and readable console programs. Explore the diverse methods provided by the Console class, experiment with formatting options, and leverage the flexibility of C# to produce clear and well-structured console output in your applications.

IronPrint emerges as a powerful ally for C# developers seeking robust and flexible printing capabilities. With its cross-platform support, compatibility with various .NET versions, and advanced printing features, IronPrint simplifies the implementation of printing solutions in diverse C# applications. Whether you're developing for desktop, mobile, or web, IronPrint provides the tools you need to bring your printing requirements to life in the world of C# development.

IronPrint offers a free trial for commercial use. Download the library from here and give it a try.

Frequently Asked Questions

What is the primary method for printing lines in C#?

The primary method for printing lines in C# is the Console.WriteLine method, which outputs a specified string value followed by a new line.

How can I control line terminators in C#?

You can control line terminators in C# by using the Console.Write method and manually adding the desired line terminators, such as carriage return ('\r') or line feed ('\n').

How do I print multiple lines using a single method in C#?

You can print multiple lines using a single method by creating a method like PrintLines that accepts a variable-length parameter list and iterates over each line to print using Console.WriteLine.

What are the key features of a versatile print library for C#?

A versatile print library for C# should support cross-platform compatibility, various .NET versions, and different project types. Key features may include silent printing, custom print settings, async printing, and the ability to select printers, as seen with IronPrint.

How can I format output in C#?

In C#, the Console.WriteLine method supports formatting output by using placeholders like {0} for variables or expressions, allowing for formatted and dynamic content display.

Can I use Unicode characters and special line breaks in C#?

Yes, you can use escape sequences for special line breaks, such as '\n', and Unicode characters like '\u000A' to include them in your console output.

How do I print numeric values with specific precision in C#?

You can print numeric values with specific precision using format specifiers in Console.WriteLine, such as 'F7' for floating-point numbers to specify the number of digits after the decimal point.

What are some advanced features of a robust print library for C#?

A robust print library for C# offers advanced features like silent printing, custom print settings, async printing, and the ability to select a printer using methods like Printer.PrintAsync and GetPrinterNames, which are provided by IronPrint.

How can I install a comprehensive print library in my C# project?

You can install a comprehensive print library like IronPrint in your C# project using the NuGet Package Manager Console by executing the Install-Package IronPrint command.

Is there a free trial available for a versatile print library?

Yes, there is a free trial available for commercial use of IronPrint, which can be downloaded from the Iron Software website.

Chaknith Bin
Software Engineer
Chaknith works on IronXL and IronBarcode. He has deep expertise in C# and .NET, helping improve the software and support customers. His insights from user interactions contribute to better products, documentation, and overall experience.
Talk to an Expert Five Star Trust Score Rating

Ready to Get Started?

Nuget Passed