Demystifying C# Programming's ToString Method

Introduction

The ToString method of the .NET framework object has a good set of useful features.

For. e.g. the ToString method is very useful as a formatting tool. This method and its overloads offer a ton of formatting functionalities, which makes other formatting practices redundant. This is possible through the string parameters that it accepts that tells the object how to format itself.

You can do simple stuff like padding to a string. Look below for a sample. The syntax shows that it takes a formatting expression in its overload.

  Syntax: myObject.ToString("{0}", " formatting expression"})
  
  string meF = String.Format("-{0,8}-", "me");
  string meB = String.Format("-{0,-8}-", "me");

The first one produces "- me-" and the second line produces "-me -"

The ToString implementations on an object can produce interesting and helpful results. One such object is the Querystring collection. If you have used the ToString implementation on the QueryString object, you would be amazed by the readable output that it presents.

For example, consider a page with three querystring objects ID, FirstName and Lastname. If you would use the Request.QueryString.ToString() on this page, the output would be similar to below:

  id=1&firstname=joe&lastname=kittle

It is well formatted and can be parsed easily. The well-formatted string is because of the ToString implementation of the underlying HttpValueCollection class.

We can also do formatting stuff like currency, decimals on numbers, etc. Refer to the references at the end of this article for some examples on these.

The QueryString's ToString implementation leads us to another important aspect: its importance in giving us quick info during debugging.

Debugging is almost a part of our life now. And Microsoft Visual Studio has improved a lot on its every version. The hover inspection and the dialogs that appear instantaneously are so helpful. The ToString method also plays an important role during debugging. You would have already noticed that when you are working with complex objects, these windows only display the qualified type name of the object. This is because the default ToString method is invoked by the dialogs, which results in the fully qualified type of the object.

Nevertheless, you can override the default ToString implementations to provide a meaningful display of the object in the quick watch and other debugger windows.

For. example, refer to the following class which has three properties.

   public class MyClass
       {
           /// <summary>
           /// Gets or sets the name.
           /// </summary>
           /// <value>The name.</value>
           private string Name { get; set; }
    
           /// <summary>
           /// Gets or sets the title.
           /// </summary>
           /// <value>The title.</value>
           private string Title { get; set; }
    
           /// <summary>
           /// Gets or sets the age.
           /// </summary>
           /// <value>The age.</value>
           private double Age { get; set; }
    
           /// <summary>
           /// Initializes a new instance of the <see cref="MyClass"/> class.
           /// </summary>
           public MyClass()
           { }
    
           /// <summary>
           /// Initializes a new instance of the <see cref="MyClass"/> class.
           /// </summary>
           /// <param name="name">The name.</param>
           /// <param name="title">The title.</param>
           /// <param name="age">The age.</param>
           public MyClass(string name, string title, double age)
           {
               Name  = name;
               Title = title; 
               Age   = age;
           }
 

When an instance of this class is seen in the debugger windows, the below screen appears. Only the qualified type name appears.

 an instance of this class
Figure 1

Now, Let us override the ToString method to return the Name and the Age properties.

    	/// <summary>
           /// Returns a <see cref="System.String"/> that represents this instance.
           /// </summary>
           /// <returns>
           /// A <see cref="System.String"/> that represents this instance.
           /// </returns>
           public override string ToString()
           {
               return string.Format("Name = {0}, Age = {1}", Name, Age);
           }
 

And, if you see the instance of MyClass in the debugger windows, the formatted string appears.

the instance of MyClass in the debugger windows
Figure 2

Now, you know that when you are working with complex objects, the ToString overriding can be very useful and can save heaps of time.

The ToString method internally invokes the culture info to get the current culture and then uses the corresponding IFormatProvider to derive the culture-sensitive human readable string. The ToString overload takes a NumberFormatInfo instance, which can be provide a faster result.

The following excerpt is from http://dotnetperls.com/tostring.

excerpt
Figure 4

And remember, the ToString method can also cause your code to slowdown and prove inefficient. One such example worthy to be noted is from the same website as above: http://dotnetperls.com/string-for-loop

  using System;
  
  class Program
  {
      static void Main()
      {
          string input = "Dot Net Perls website";
          //
          // Check each character in the string using for-loop.
          //
          int spaces1 = 0;
          for (int i = 0; i < input.Length; i++)
          {
              if (input[i] == ' ')
              {
                  spaces1++;
              }
          }
  
          //
          // BAD: Check each character in the string with ToString calls.
          //
          int spaces2 = 0;
          for (int i = 0; i < input.Length; i++)
          {
              if (input[i].ToString() == " ") // NO
              {
                  spaces2++;
              }
          }
          //
          // Write results.
          //
          Console.WriteLine(spaces1);
          Console.WriteLine(spaces2);
      }
  }

And this excerpt from the same webpage explains why.

"Accessing characters with the string indexer. The first loop in the program text uses a three-part for-loop statement with an if-statement in the loop body. If the character is a space, the value stored in the spaces1 variable is incremented. In this way, the for-loop iterates over all characters in the string and counts the total number of spaces. No allocations on the managed heap occur and this is a well-performing loop over the string.

Converting each character to a new string. The second loop in the program text also uses a for-loop statement to iterate over the characters in the string. However, after accessing the character value, it calls the ToString method. This requires an allocation of a new string on the managed heap, because strings are reference types. Then, the op_Equality method is invoked on the two string instances in the loop body. This loop is much slower because it must allocate the strings and then use string comparisons. It has no advantages in this context."

Hope this article was informative. Thanks for reading.

Related Articles



About the Author

Srinath M S

I would love to leave a footprint in this flat world

Comments

  • There are no comments yet. Be the first to comment!

Leave a Comment
  • Your email address will not be published. All fields are required.

Top White Papers and Webcasts

  • On-demand Event Event Date: December 18, 2014 The Internet of Things (IoT) incorporates physical devices into business processes using predictive analytics. While it relies heavily on existing Internet technologies, it differs by including physical devices, specialized protocols, physical analytics, and a unique partner network. To capture the real business value of IoT, the industry must move beyond customized projects to general patterns and platforms. Check out this webcast and join industry experts as …

  • Today's agile organizations pose operations teams with a tremendous challenge: to deploy new releases to production immediately after development and testing is completed. To ensure that applications are deployed successfully, an automatic and transparent process is required. We refer to this process as Zero Touch Deployment™. This white paper reviews two approaches to Zero Touch Deployment--a script-based solution and a release automation platform. The article discusses how each can solve the key …

Most Popular Programming Stories

More for Developers

RSS Feeds