How to Use ToString in C# with Example: Formatting Numbers and Dates

In C#, ToString is a method that is used to convert an object into its string representation. This method is inherited from the Object class, which is the base class for all classes in the .NET framework. It is commonly used when there is a need to display the value of an object as a string, whether for logging, debugging, or UI presentation purposes.

The ToString method can be overridden in any derived class to return meaningful information about the object. When overridden, it can be formatted to provide more human-readable information, which is especially helpful when dealing with complex data types. Different types of objects might require different implementations of ToString, such as for data conversion, or for merely extracting a name or identifier from an object.

In the following examples, the usage of ToString in C# will be demonstrated with both built-in and user-defined types. This will illustrate how to implement and call the ToString method to meet various application requirements.

Understanding ToString in C#

In C#, the ToString() method is a fundamental part of the System.Object class from which all other classes inherit. Consequently, every object in C# has access to this method, which converts an instance to its string representation.

Default Implementation

By default, ToString returns the fully qualified name of the object’s type. For example:

object obj = new object();
string defaultString = obj.ToString();
// defaultString will contain "System.Object"

Overriding ToString

Developers frequently override the ToString method to provide a more meaningful string representation for their custom types. When overridden, it can reflect the object’s current state or important information in a string format.

Example of overriding:

public class Person
    public string Name { get; set; }
    public int Age { get; set; }

    public override string ToString()
        return $"Name: {Name}, Age: {Age}";

Formatting Support

Some classes implement ToString with support for formatting. For example, numerical types like int and double can take a format specifier:

int number = 42;
string formatted = number.ToString("X"); // Converts to hexadecimal

Culture-Specific Formatting

ToString can also consider culture-specific formatting, which is crucial for displaying numerical or date and time data according to cultural norms. To specify the culture:

double value = 1634.56;
var culture = new CultureInfo("fr-FR");
string localized = value.ToString("C", culture); // Formats as currency

Using ToString effectively, allows for the conversion of objects to a readable string format, which is valuable for logging, debugging, or displaying information to users.

Basic Syntax of ToString() Method in C#

In C#, the ToString method is fundamental for object-to-string conversions. It serves as a means to produce a string representation of an object. The method is a member of the Object class, from which all other classes in .NET inherit, making it universally available for any object.

The typical usage of ToString() is as follows:

public override string ToString()
    // Code to convert the object to its string representation

When implementing the ToString method in a class, the programmer overrides it to provide meaningful output that represents the current instance of the class. Below is a basic example:

using System;

public class Person
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public override string ToString()
        return $"Name: {FirstName} {LastName}";

class Program
    static void Main(string[] args)
        // Creating an instance of Person
        Person person = new Person
            FirstName = "John",
            LastName = "Doe"

        // Displaying the person's name using the overridden ToString method

In this example, the Person class overrides ToString to return the full name of the person.

Here you can see the output in the screenshot below:

ToString in C#

Default Behavior: If not overridden, ToString will return the fully qualified name of the object’s type.

Parameters and Return Type:

  • Parameters: The ToString method does not take any parameters.
  • Return Type: It returns a string that represents the current object.

Employing the ToString method allows for a flexible and readable representation of objects, which is particularly useful for debugging or displaying information to users.

Using ToString to Format Numbers in C#

When working with C#, ToString can be used to format numbers in a more readable way or to display them according to cultural norms. It provides various options to represent integer, float, and double values as strings.

Formatting Integers

Example: An integer is formatted to a string with thousands separator.

int intValue = 123456789;
string formattedInt = intValue.ToString("N0"); // Output: "123,456,789"
  • The format specifier "N0" indicates a numeric value with no decimal places and includes a thousands separator.

Formatting Floats

Example: A float number is formatted as a currency.

float floatValue = 12345.6789f;
string formattedFloat = floatValue.ToString("C2"); // Output: "$12,345.68"
  • "C2" represents currency with two decimal places.
  • The actual currency symbol depends on the culture settings of the system.

Formatting Doubles

Example: A double precision number is customized for percentage representation.

double doubleValue = 0.1234;
string formattedDouble = doubleValue.ToString("P2"); // Output: "12.34%"
  • "P2" converts the number to a percent format with two decimal places.

Using ToString with Dates in C#

The ToString method in C# allows for precise formatting of date and time values. One can tailor the output string to include just the date, just the time, or both, depending on the requirements of the application.

Formatting Date Only

To represent a date as a string without the time component, one employs a format specifier within the ToString method. The following table outlines common date format specifiers:

Format SpecifierDescriptionExample Output
“d”Short date12/23/2023
“D”Long dateFriday, December 23, 2023
“yyyy-MM-dd”Custom format – ISO 86012023-12-23

The developer may use code like:

DateTime currentDate = DateTime.Now;
string shortDate = currentDate.ToString("d");
string longDate = currentDate.ToString("D");
string isoDate = currentDate.ToString("yyyy-MM-dd");

Formatting Time Only

When only the time part is necessary, similar use of format specifiers applies. Here are examples of time format specifiers:

Format SpecifierDescriptionExample Output
“t”Short time10:30 PM
“T”Long time10:30:22 PM
“HH”24-hour format22:30

For time-only formatting, the code becomes:

DateTime currentTime = DateTime.Now;
string shortTime = currentTime.ToString("t");
string longTime = currentTime.ToString("T");
string twentyFourHourTime = currentTime.ToString("HH:mm");

Formatting Date and Time

Combining date and time in a single string is achieved by concatenating date and time format specifiers. A frequent requirement is to display date and time in various local or standard forms.

Format SpecifierDescriptionExample Output
“g”General date and time, short time12/23/2023 10:30 PM
“G”General date and time, long time12/23/2023 10:30:22 PM
“yyyy-MM-dd HH”Custom format2023-12-23 22:30

In practice, developers may implement this as:

DateTime now = DateTime.Now;
string generalShort = now.ToString("g");
string generalLong = now.ToString("G");
string customDateTime = now.ToString("yyyy-MM-dd HH:mm");

Overriding ToString in Custom Classes in C#

In C#, the ToString method is a powerful way to provide a string representation of an object. Custom classes can override this method to output meaningful information about an instance.

Creating a Custom Class

To illustrate ToString method overriding, one starts by defining a custom class. Here’s a basic example:

public class Book
    public string Title { get; set; }
    public string Author { get; set; }
    public int Year { get; set; }

This Book class has three properties representing the title, author, and publication year of a book.

Overriding ToString Method in C#

To customize the string output for the Book class, one overrides the ToString method. Here’s how it’s done:

public class Book
    public string Title { get; set; }
    public string Author { get; set; }
    public int Year { get; set; }

    public override string ToString()
        return $"Title: {Title}, Author: {Author}, Year: {Year}";

Now, whenever an instance of Book is converted to a string, it will return the formatted string with the title, author, and year instead of the default namespace and class name.

Best Practices using ToString() method

When implementing the ToString() method in C#, developers commonly encounter issues with null references and culture-specific formatting. This section discusses strategies to avoid these pitfalls and apply best practices for consistent results.

Handling Null Values

Objects in C# can be null, leading to a NullReferenceException if methods are called on them without proper checks. When overriding ToString(), always ensure that the object’s state can support generating a meaningful string.


public override string ToString()
    return this.Property != null ? this.Property : "Default Value";

In this example, a ternary operator checks if Property is null before calling its ToString() method. If it is null, a default string is returned instead of throwing an exception.

Using ToString with Cultures

ToString() can behave differently depending on the current culture settings of the system because it formats certain data types like dates and numbers. It is best to specify the IFormatProvider when culture-specific formatting is required.

Best Practice:

  • Use CultureInfo.InvariantCulture when a consistent, culture-independent string representation is needed.


double number = 1634.42;
string result = number.ToString("C", CultureInfo.InvariantCulture);

In this code snippet, the ToString("C", CultureInfo.InvariantCulture) ensures the currency value is formatted in a consistent way irrespective of the user’s system culture.

By adhering to these strategies, developers can avoid common mistakes and ensure their ToString() implementations handle null values and multicultural environments effectively and predictably.

Advanced Formatting Using ToString in C#

The ToString method in C# can be leveraged to format numeric and datetime data with great precision. Custom format strings allow developers to control the output representation with specificity.

Custom Numeric Format

In C#, numeric types can be formatted using custom format specifiers. These specifiers provide control over how numbers display. For example, the format string "000.##" can be used with ToString to ensure a number always displays with three integer digits and up to two decimal digits:

double number = 23.7;
string formattedNumber = number.ToString("000.##");
// Output: "023.7"

Common Numeric Format Specifiers:

  • 0: Placeholder for a mandatory digit, zero if absent.
  • #: Placeholder for an optional digit, nothing if absent.
  • .: Decimal point.
  • ,: Thousand separator.
  • %: Percentage.

Custom Date and Time Format

DateTime instances have their own set of format specifiers that are passed to ToString. They allow developers to dictate how dates and times are formatted. For instance, the custom format string "dd MMM yyyy HH:mm:ss" will display the day, month abbreviation, year, and time:

DateTime now = new DateTime(2023, 12, 23, 14, 30, 00);
string formattedDate = now.ToString("dd MMM yyyy HH:mm:ss");
// Output: "23 Dec 2023 14:30:00"

Common Date and Time Format Specifiers:

  • d: Day of the month.
  • M: Month.
  • y: Year.
  • H: Hour in 24-hour format.
  • m: Minute.
  • s: Second.

By using these format specifiers with ToString, one can generate strings of numeric and datetime values that adhere to a specific desired format.

Performance Considerations

When utilizing the ToString method in C#, one must be cognizant of its impact on performance, particularly in the context of high-frequency calls or processing large datasets. Below are key considerations to be aware of:

  • String Operations Can Be Costly: Frequent calls to ToString can result in significant performance overhead, as string operations are generally more resource-intensive than primitive type manipulations.
  • Memory Allocation: Each invocation of ToString allocates new memory for the resulting string, which could lead to increased garbage collection activity, especially if these strings are short-lived.
  • Culture-Specific Formatting: ToString can perform culture-specific formatting, which may add overhead. For optimal performance, one may specify CultureInfo.InvariantCulture when culture-specific formatting is unnecessary.
  • Prefer StringBuilder for Concatenations: In scenarios involving concatenation of multiple ToString results, StringBuilder should be used instead of conventional concatenation to reduce memory allocations and improve speed.
  • Caching Results: If the same ToString result is used multiple times, consider caching the result to avoid unnecessary repeat calculations.

The following table summarizes the potential impact of these considerations:

ConsiderationPotential Performance Impact
Frequent ToString CallsHigh Overhead
Memory AllocationIncreased Garbage Collection
Culture-Specific FormattingAdditional Overhead
ConcatenationPrefer StringBuilder to Enhance
Repeated CalculationsCaching Mitigates Performance Cost

Developers are advised to profile their applications to identify and address hotspots where ToString usage could be optimized. Instrumentation tools and performance testing can help in these evaluations.


The ToString method in C# is a versatile tool that they may use to convert any object into its string representation. A developer utilizes ToString to format and display data in a user-readable form. This method can be overridden to provide a more meaningful string output specific to the class, improving the clarity of logging, debugging, and user interface elements.

When using ToString:

  • Remember: Every object inherits the ToString method.
  • Best Practice: Override the method for custom types to return informative strings.
  • String Formatting: Use format specifiers for built-in types to customize the output.

Implementing ToString effectively results in:

  • Enhanced code readability.
  • Easier debugging.
  • Clearer data presentations for users.

Examples demonstrate the practical application of ToString in various contexts. A developer should be mindful of:

  • The default implementation for custom objects.
  • Culture-specific formatting which can be handled properly with ToString(IFormatProvider).

I hope you understand how to use the tostring() in C# with these real examples.

You may also like: