Which Methods Were Tested?

• The concatenation operator. In C#, it is the + operator. In VB.NET, it is the & operator.
• The String.Concat() method.
• The System.Text.StringBuilder class.
• The String.Format() method.

How Were They Tested?

A console application was prepared to test operation scenarios. The scenarios were timed using the System.Diagnostics.Stopwatch class. The full Visual Studio solution can be found in my CodePlex project.

What Were the Results?

Scenario 1: Loop Concatenation

The Loop Concatenation scenario was built to test string concatenation within a loop. This data set had the most straight-forward results. The StringBuilder class gives the best performance when using concatenation in this scenaraio.

Loop Concatenation Results (in milliseconds)

Code sample using StringBuilder in this scenario:

var builder = new StringBuilder();

for (int i = 0; i < this.iterations; i++)
{
    builder.Append("x");
}

var testString = builder.ToString();

Scenario 2: Full Name Concatenation

The Full Name Concatenation scenario was built to test simple string concatenation in which few concatenations occur. It concatenates first name, a space, and last name. This is commonly used to build display names for a UI. These results point to the String.Concat method as the most efficient way to concatenate small numbers of strings.

Full Name Concatenation Results (in ticks)

Code sample using String.Concat in this scenario:

string first = "John";
string last = "Deaux";
string fullName = string.Concat(first, " ", last);

Scenario 3: Long Text Concatenation

The Long Text Concatenation scenario was built to test long concatenations in which many concatenations occur. It simulates building the body of an email message. These results also point to the String.Concat method as the most efficient. Comparing the prior scenario with this scenario you can begin to see pattern. As you add concatenations, the efficiency of String.Format and StringBuilder (when out of a looping scenario) declines.

Long Text Concatenation Results (in ticks)

Code sample using String.Concat in this scenario:

string newLine = System.Environment.NewLine;
string name = "John Deaux";
string email = "john.deaux@123.me";
string subject = "The Subject of the Message";
string product = "ABC";
string feature = "XYZ";
string body = "The comment(s) made about product/feature.";

string[] values = new[]
    {
        "Name: ", name, newLine,
        "Email: ", email, newLine,
        "Subject: ", subject, newLine,
        "Product: ", product, newLine,
        "Feature: ", feature, newLine,
        "Message: ", newLine, body
    };

var emailBody = string.Concat(values);

Scenario 4: Date Concatenation

The Date Concatenation scenario was built to test the formatting of dates. It formats a date into the sortable format of 2011-12-31T15:30:15. Of the people I’ve talked to about this little experiment, this one has surprised the most. Why? Because it is highly touted by articles, books, and even Microsoft as the way to format data and it’s extremely inefficient. The String.Format method is slower and less efficient than every other method tested including the StringBuilder operator for formatting DateTime objects as strings.

Date Concatentation Results (in ticks)

Code sample using String.Concat in this scenario:

DateTime date = DateTime.Now;

var values = new[]
    {
        date.Year.ToString("0000"),
        "-",
        date.Month.ToString("00"),
        "-",
        date.Day.ToString("00"),
        "T",
        date.Hour.ToString("00"),
        ":",
        date.Minute.ToString("00"),
        ":",
        date.Second.ToString("00")
    };

var sortable = string.Concat(values);

Yes, you did read that correctly. The above code is a lot faster and more efficient than:

var sortable = string.Format("{0:u}", DateTime.Now);
// or
var sortable = string.Format("{0:yyyy-MM-ddTHH:mm:ss}", DateTime.Now);

Ragnarok Dark as I’ve chosen to call it can be found here: http://studiostyl.es/schemes/ragnarok-dark-grey-customized

And remember to rate it if you like it!

Now a bonus for those of you that use ReSharper. The following line pasted into the bottom of the items section in the XML downloaded from the site before you import will make those To Do Comments and Not Implemented Exceptions stand out.

<Item Name="ReSharper Todo Item" Foreground="0x0000FFFF" Background="0x02000000" BoldFont="Yes"/>

Free SQL Server, SharePoint and .NET training!  Chance to win great prizes!  What more could an IT Professional ask for?  If this sounds good to you, then don’t miss your opportunity to attend SQL Saturday #150 and TECH Day, the largest FREE training event in Louisiana dedicated exclusively to SQL Server, .NET, Development, SharePoint and Business Intelligence.   This is a COMMUNITY driven event!

For more information visit the official website at: http://sqlsaturday.com/150/eventhome.aspx

I have also changed the location of the CSS sheet. The is no longer a zip file available for download. You can now view the CSS sheet directly in the source view of my CodePlex project: Jeremy Knight CodePlex Project.

Again, my thanks go out to the following:

• Eric Meyer for his reset style sheet.
• Jess Planck for his table styles.
• Particletree for their article Rediscovering the Button Element

What is System.String?

In the .NET framework, the string type is a reference type. It is not a value type as is often the belief. It is an object that consists of a collection of System.Char values in sequential order. Characters within the string can be referenced as follows:

string foo = "bar";
char r = foo[2];

Immutable

The string type is also immutable. You cannot change the contents of a string without reflection or unsafe code. The methods, operators, etc. that appear to modify a string actually return a new string with the modified contents. The Replace function of the string object is a great example of this. You cannot simply call the Replace method. You have to return the results of the method to a string variable.

string foo = "abc";
foo = foo.Replace("abc", "xyz");

Concatenation and the Compiler

The compiler does some interesting things when working with strings. For example, when concatenating with variables in a single statement:

string foobar = foo + " " + bar;

// compiler sees the above as:
string foobar = string.Concat(foo, " ", bar);

When you use constants such as literals and const string members, the compiler knows that all the parts are constant and it does all the concatenation at compile time, storing the full string in the compiled code.

string foobar = "foo" + " " + "bar";

// compiler sees the above as:
string foobar = "foo bar";

const string foo = "foo";
string foobar = foo + " " + "bar";

// compiler sees the above as:
string foobar = "foo bar";

String.Empty versus “”

And finally, there is a difference between string.Empty and “”. When you use “”, .NET creates an object but when you use string.Empty it does not. The difference may be small, but its a difference that can make a performance impact.

string foo = ""; // creates an object
string bar = string.Empty; // doesn't create an object

The examples below show how the null coalescing operator achieves the same result as traditional conditional statements but with less lines of code. Both sets of examples use property getter methods with assumed fields.

Reference Examples with Conditional Statements

public MyObject MyObjectProperty
{
    get
    {
        if (this.myObject == null)
        {
            return new MyObject();
        }

        return this.myObject;
    }
}

Reference Examples with Null Coalescing Operator

public MyObject MyObjectProperty
{
    get
    {
        return this.myObject ?? new MyObject();
    }
}

Nullable<T> Example with Conditional Statements

public int Number
{
    get
    {
        if (this.nullableNumber.HasValue)
        {
            return this.nullableNumber.Value;
        }

        return 0;
    }
}

Nullable<T> Example with Null Coalescing Operator

public int Number
{
    get { return this.nullableNumber ?? 0; }
}

The main argument against the ?? operator is that developers don’t understand it so it makes the code less readable and maintainable. This is a poor argument in my opinion. As developers, we should never stop trying to improve both ourselves and our teams. This is something that can be taught over lunch one day.

More reading: ?? Operator (C# Reference) – MSDN

That’s where the default style sheet comes in. A default style sheet is zeroes out the styles of a browser but then defines default styles for common HTML elements. There are a few default style sheets out there but I’ve always found they didn’t default enough elements. The following link will take you to a zip file download containing my version of a default style sheet.

Default CSS v1.0

My thanks go out to the following:

• Eric Meyer for his reset style sheet.
• Jess Planck for his table styles.
• Particletree for their article Rediscovering the Button Element

The first is entitled How It Works and states:

Picasa Web provides 1 GB for photos and videos. Files under certain sizes don’t count towards this limit.

The second is entitled Free Storage Limits and it states the following:

If you’ve signed up for Google+

Free storage limits

Photos up to 2048 x 2048 pixels and videos up to 15 minutes won’t count towards your free storage.

Automatic resizing

All photos uploaded in Google+ will be automatically resized to 2048 pixels (on their longest edge) and won’t count towards your free storage quota.

All photos uploaded to Picasa Web Albums over the free size limit will count towards your 1 GB of free storage. When you reach your storage limit, any new photos you upload to Picasa Web larger than the free size limit will be automatically resized to 2048 pixels (on their longest edge).

If you haven’t signed up for Google+

Free storage limits

Photos up to 800 x 800 pixels and videos up to 15 minutes won’t count towards your free storage.

Automatic resizing

All photos uploaded over the free size limit will count towards your 1 GB of free storage. When you reach your storage limit, any new photos you upload to Picasa Web larger than the free size limit will be automatically resized to 800 pixels (on their longest edge).

That’s right you read that right. If you’re a Google+ member, you get over double the resolution free.

That means that target=”_blank” is 100% valid in HTML5!

private static void Main(string[] args)
{
    int count;
    byte[] byteArray;
    char[] charArray;
    UnicodeEncoding uniEncoding = new UnicodeEncoding();

    // Create the data to write to the stream.
    byte[] firstString = uniEncoding.GetBytes("Invalid file path characters are: ");
    byte[] secondString = uniEncoding.GetBytes(Path.GetInvalidPathChars());

    using(MemoryStream memStream = new MemoryStream(100))
    {
        // Write the first string to the stream.
        memStream.Write(firstString, 0 , firstString.Length);

        // Write the second string to the stream, byte by byte.
        count = 0;
        while(count < secondString.Length)
        {
            memStream.WriteByte(secondString[count++]);
        }

        // Write the stream properties to the console.
        Console.WriteLine(
            "Capacity = {0}, Length = {1}, Position = {2}\n",
            memStream.Capacity.ToString(),
            memStream.Length.ToString(),
            memStream.Position.ToString());

        // Set the position to the beginning of the stream.
        memStream.Seek(0, SeekOrigin.Begin);

        // Read the first 20 bytes from the stream.
        byteArray = new byte[memStream.Length];
        count = memStream.Read(byteArray, 0, 20);

        // Read the remaining bytes, byte by byte.
        while(count < memStream.Length)
        {
            byteArray[count++] = Convert.ToByte(memStream.ReadByte());
        }

        // Decode the byte array into a char array
        // and write it to the console.
        charArray = new char[uniEncoding.GetCharCount(byteArray, 0, count)];
        uniEncoding.GetDecoder().GetChars(byteArray, 0, count, charArray, 0);
        Console.WriteLine(charArray);
    }
}

private static void Main(string[] args)
{
    using (var memoryStream = new MemoryStream(100))
    using (var streamWriter = new StreamWriter(memoryStream))
    using (var streamReader = new StreamReader(memoryStream))
    {
        var invalidPath = new string(Path.GetInvalidPathChars());
        streamWriter.WriteLine("Invalid file path characters are:");
        streamWriter.WriteLine(invalidPath);

        streamWriter.Flush();
        memoryStream.Position = 0;

        var stringToOutput = streamReader.ReadToEnd();
        Console.WriteLine(stringToOutput);
    }
}