CODEWITHSUNDEEP
c#
Patrick
Patrick

Reputation: 17973

Is there any penalty between appending string vs char in C#

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.

Upvotes: 23

Views: 4656

Answers (8)

Stephen C
Stephen C

Reputation: 719576

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.

Appending a char to a String is likely to be slightly faster than appending a 1 character String because:

  • the append(char) operation doesn't have to load the string length,
  • it doesn't have to load the reference to the string characters array,
  • it doesn't have to load and add the string's start offset,
  • it doesn't have to do a bounds check on the array index, and
  • it doesn't have to increment and test a loop variable.

Take a look at the Java source code for String and related classes. You might be surprised what goes on under the hood.

The intern pool has nothing to do with it. The interning of string literals happens just once during class loading. Interning of non-literal strings occurs only if the application explicitly calls String.intern().

Upvotes: 12

Jeffrey L Whitledge
Jeffrey L Whitledge

Reputation: 59543

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

Upvotes: 16

CraigTP
CraigTP

Reputation: 44939

All string concatenation in .NET (with the standard operators i.e. +) requires the runtime to reserve enough memory for a complete new string to hold the results of the concatenation. This is due to the string type being immutable.

If you are performing string concatenation many times over (i.e. within a loop etc.) you will suffer performance issues (and eventually memory issues if the string is sufficiently large) as the .NET runtime needs to continually allocate and deallocate memory space to hold each new string.

It's probably for this reason that you're thinking (correctly) that excessive string concatenation can be problematic. It has very little (if anything) to do with concatenating a char rather than a string type.

The alternative to this is to use the StringBuilder class within the System.Text namespace. This class represents a mutable string-like object that can be used to concatenate strings without much of the resulting performance issues. This is because the StringBuilder class will reserve a specific amount of memory for a string, and will allow concatenations to be appended to the end of the reserved memory amount without requiring a complete new copy of the entire string.

EDIT:

With regard to the specifics of string lookups versus char lookups, I whipped up this little test:

class Program
{
    static void Main(string[] args)
    {
        string stringtotal = "";
        string chartotal = "";
        Stopwatch stringconcat = new Stopwatch();
        Stopwatch charconcat = new Stopwatch();
        stringconcat.Start();
        for (int i = 0; i < 100000; i++)
        {
            stringtotal += ".";
        }
        stringconcat.Stop();
        charconcat.Start();
        for (int i = 0; i < 100000; i++)
        {
            chartotal += '.';
        }
        charconcat.Stop();
        Console.WriteLine("String: " + stringconcat.Elapsed.ToString());
        Console.WriteLine("Char  : " + charconcat.Elapsed.ToString());
        Console.ReadLine();
    }
}

It merely times (using the high-performance StopWatch class) how long it takes to concatenate 100000 dots/periods (.) of type string vs. 100000 dots/periods of type char. I ran this test a few times over to prevent the results being skewed from one specific run, however, each time the results were similar to as follows:

String: 00:00:06.4606331
Char  : 00:00:06.4528073

Therefore, in the context of multiple concatenations, I'd say that there's very little difference (in all likelihood, no difference when taking standard test run tolerances into account) between the two!

Upvotes: 3

Jay
Jay

Reputation: 27502

I can't speak to C#, but in Java, the main advantage is not the compile-time gain but the run-time gain.

Yes, if you use a String, than at compile time Java will have to look the String up in its internal pool and possibly create a new String object. But this just happens once, at compile-time, when you create the .class files. The user will never see this.

What the user will see is that at run-time, if you give a character the program just has to retrieve the character. Done. If you give a String, it must first retrieve the String object handle. Then it must set up a loop to go through all the characters, retrieve the one character, observe that there are no more characters, and stop. I haven't looked at the generated byte-code but it's clearly seveal times as much work.

Upvotes: 0

atamanroman
atamanroman

Reputation: 11818

This may be interesting: http://www.codeproject.com/KB/cs/StringBuilder_vs_String.aspx

Stringbuilder are not necessarily faster than Strings, it, as said before, depends. It depends on machine configuration, available memory vs processor power, framework version and machine config. Your profiler is your best buddy in this case :)

Back 2 Topic: You should just TRY which is faster. Do that concatenation a bazillion times and let your profiler watch. You will see possible differences.

Upvotes: 4

theburningmonk
theburningmonk

Reputation: 16071

I agree with what everyone is saying about using StringBuilder if you are doing lots of string concatenation because String is an immutable type, but don't forget there's an overhead with creating the StringBuilder class too so you'll have to make a choice when to use which.

In one of Bill Wagner's Effect C# books (or might be in all 3 of them..), he touched on this too. Broadly speaking, if all you need is to add a few string fragments together, string.Format is better but if you need to build up a large string value in a potentially large loop, use the StringBuilder.

Upvotes: 2

Wallace Breza
Wallace Breza

Reputation: 4948

Since strings are immutable types both would require creating a new instance of a string before the value is returned back to you.

I would consider string.Concat(...) for a small number of concatenations or use the StringBuilder class for many string concatenations.

Upvotes: 0

Goran Obradovic
Goran Obradovic

Reputation: 9051

Every time when you concatenate strings using + operator, runtime creates a new string, and for avoiding that, recommended practice is usage of StringBuilder class, which has Append method. You can also use AppendLine and AppendFormat. If you do not want to use StringBuilder, then you can use string.Format:

string str = string.Format("Hello {0}.", name);

Upvotes: 0

Related Questions