Question

When developing in Java a couple of years ago I learned that it is better to append a char if I had a single character instead of a string with one character because the VM would not have to do any lookup on the string value in its internal string pool.

string stringappend = "Hello " + name + "."; 
string charappend = "Hello " + name + '.'; // better?

When I started programming in C# I never thought of the chance that it would be the same with its “VM”. I came across C# String Theory—String intern pool that states that C# also has an internal string pool (I guess it would be weird if it didn’t) so my question is,

are there actually any benefits in appending a char instead of a string when concatenating to a string regarding C# or is it just jibberish?

Edit: Please disregard StringBuilder and string.Format, I am more interested in why I would replace “.” with ‘.’ in code. I am well aware of those classes and functions.

Answer 1

If given a choice, I would pass a string rather than a char when calling System.String.Concat or the (equivalent) + operator.

The only overloads that I see for System.String.Concat all take either strings or objects. Since a char isn’t a string, the object version would be chosen. This would cause the char to be boxed. After Concat verifies that the object reference isn’t null, it would then call object.ToString on the char. It would then generate the dreaded single-character string that was being avoided in the first place, before creating the new concatinated string.

So I don’t see how passing a char is going to gain anything.

Maybe someone wants to look at the Concat operation in Reflector to see if there is special handling for char?

UPDATE

As I thought, this test confirms that char is slightly slower.

using System;
using System.Diagnostics;

namespace ConsoleApplication19
{
    class Program
    {
        static void Main(string[] args)
        {
            TimeSpan throwAwayString = StringTest(100);
            TimeSpan throwAwayChar = CharTest(100);
            TimeSpan realStringTime = StringTest(10000000);
            TimeSpan realCharTime = CharTest(10000000);
            Console.WriteLine("string time: {0}", realStringTime);
            Console.WriteLine("char time: {0}", realCharTime);
            Console.ReadLine();
        }

        private static TimeSpan StringTest(int attemptCount)
        {
            Stopwatch sw = new Stopwatch();
            string concatResult = string.Empty;
            sw.Start();
            for (int counter = 0; counter < attemptCount; counter++)
                concatResult = counter.ToString() + ".";
            sw.Stop();
            return sw.Elapsed;
        }

        private static TimeSpan CharTest(int attemptCount)
        {
            Stopwatch sw = new Stopwatch();
            string concatResult = string.Empty;
            sw.Start();
            for (int counter = 0; counter < attemptCount; counter++)
                concatResult = counter.ToString() + '.';
            sw.Stop();
            return sw.Elapsed;
        }
    }
}

Results:

string time: 00:00:02.1878399
char time: 00:00:02.6671247