Home > ASP.NET Articles

Improving .NET performance using the StringBuilder Class

Improving the performance of applications can be a complex and time consuming operation. Thankfully, there are a few development techniques that are relatively straightforward to implement and can result in significant application performance benefits.

One weakness of Visual Basic derived languages such as Visual Basic 6.0 and the VBScript scripting language commonly used to write ASP scripts is that string concatenation is very inefficient.  This inefficiency can be magnified exponentially if concatenation is performed during a looping operation, such as joining together records from an ADO RecordSet.  The inefficiency exists because every time a concatenation is performed a new string object must be created in the memory.  The inefficiencies of string concatenation also affect the .NET Framework.

Fortunately, Microsoft has included the solution to the string concatenation problem within the Framework itself.  This solution is in the form of the StringBuilder class, which may be found in the System.Text namespace.

If you are experiencing performance problems with code that performs a lot of string concatenation, then this optimization technique is well worth considering.  Note that a similar technique can also be used with ASP/VBScript and Visual Basic 6.0.  You can either write your own string builder class or use a search engine to find a prewritten algorithm.  This article describes how to implement an equivalent to the StringBuilder class in both VBScript and Visual Basic 6.0.

Using the StringBuilder class

The StringBuilder class is a member of the System.Text namespace and can be instantiated using the following code.

Code Listing 1

Dim NewStringBuilder As New System.Text.StringBuilder

Once an instance of the class has been instantiated, text may be added to the class by using the Append method, as shown below.

Code Listing 2

NewStringBuilder.Append("Hello")

Subsequent text may be concatenated to the text already contained in the class by making further uses of the Append method.

Code Listing 3

NewStringBuilder.Append("World")

Finally, once all of the concatenations have been performed, the entire text may be accessed using the ToString() method of the class.

Code Listing 4

NewStringBuilder.ToString()

Note that the StringBuilder class contains a number of other methods and properties that are beyond the scope of this article.

A demonstration of string concatenation performance

The VB.NET sample code below can be used to demonstrate the relative performance of string concatenation using either the traditional method or by making use of the StringBuilder class.  The code is currently configured to perform 50,000 iterations of each concatenation technique.

Code Listing 5

Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
  Dim OldMethodStart As New TimeSpan
  Dim OldMethodEnd As New TimeSpan
  Dim OldString As String = ""
  Dim NewMethodStart As New TimeSpan
  Dim NewMethodEnd As New TimeSpan
  Dim NewString As String = ""
  Dim NewStringBuilder As New System.Text.StringBuilder

  'Old method of appending strings
  OldMethodStart = DateTime.Now.TimeOfDay
  Dim i As Integer = 0
  For i = 1 To 50000
    OldString = OldString & "Number " & i.ToString()
  Next

  OldMethodEnd = DateTime.Now.TimeOfDay

  Response.Write("Old method took ")
  Response.Write((OldMethodEnd.TotalMilliseconds -
  OldMethodStart.TotalMilliseconds).ToString("N2"))
  Response.Write(" milliseconds.")

  'New method of appending strings
  NewMethodStart = DateTime.Now.TimeOfDay
  Dim j As Integer = 0
  For j = 1 To 50000
    NewStringBuilder.Append("Number " & j.ToString())
  Next

  NewMethodEnd = DateTime.Now.TimeOfDay

  Response.Write("new method took ")
  Response.Write((NewMethodEnd.TotalMilliseconds -
  NewMethodStart.TotalMilliseconds).ToString("N2"))
  Response.Write(" milliseconds.")
End Sub

As an example, this code was run three times using 10,000, 25,000 and 50,000 iterations.  With 10,000 iterations, the traditional string concatenation method took an average of 4831.5 milliseconds.  By contrast, the string append method took 10.4 milliseconds.  The difference is exponentially greater the more the iterations are performed.  With 25,000 iterations, the traditional string concatenation method took an average of 29,239.2 milliseconds and the string append method took only 20.8 milliseconds.  At 50,000 iterations, the traditional method took an average of 116,899.4 milliseconds and the string append method took 41.7 milliseconds.

Summary

It is easy to see from these examples that replacing your string concatenation routines with the StringBuilder class may drastically improve your application's performance.

Useful Development Tools

ASP Documentation Tool™

Automatically creates developer documentation for ASP 2.0 and 3.0 web applications written in VBScript and JScript. Documentation for Microsoft Access, SQL Server 7/2000 databases and Visual Basic 6.0 components associated with the web application can also be incorporated into the reports. Documentation is created in HTML, HTML Help and plain text formats.

View Sample Output (HTML Help format).     View Sample Output (HTML Format).     Download Trial Version (5.2Mb ZIP file).

.NET Documentation Tool

Automatically creates technical documentation for .NET Framework Windows and ASP.NET applications written in C# or VB.NET and SQL Server 7/2000/2005 or Microsoft Access databases associated with the application. Documentation is created in HTML, HTML Help and plain text formats.

View Sample Output (HTML Help format).     View Sample Output (HTML Format).     Download Trial Version (5Mb ZIP file).

SQL Documentation Tool

The SQL Documentation Tool creates technical documentation for Microsoft SQL Server 7.0 and 2000 databases. Technical documentation is created in HTML and HTML Help formats. The HTML Help format documentation is fully searchable and cross referenced. The SQL Documentation Tool documents SQL Server Tables, Views, Stored Procedures, Triggers and Table Relationships.

View Sample Output (HTML Help format).     View Sample Output (HTML Format).     Download Trial Version (10.3Mb ZIP file).

VB Documentation Tool

The VB Documentation Tool creates technical documentation for Microsoft Visual Basic 6.0 projects. Technical documentation is created in HTML and HTML Help formats. The HTML Help format documentation is fully searchable and cross referenced.

View Sample Output (HTML Help format).     View Sample Output (HTML Format).     Download Trial Version (1Mb ZIP file).

Indexing Service Companion

The Indexing Service Companion is a Windows application that extends the functionality of the Microsoft Windows Indexing Service so that it is able to index content from remote websites and also from ODBC databases. As such it can be used as a low cost alternative to Sharepoint Portal Search Services.

Try Sample Search Facility.     Download Trial Version (1.7Mb ZIP file).

The Website Utility

The Website Utility examines websites for errors and areas that need to be optimised for search engines by using a built in web crawling engine. Errors checked for include broken or moved hyperlinks, missing page titles and missing meta tags. It also generates HTML for use in creating website site maps (table of contents pages - like this one), and is able to create both client-side JavaScript Search Engines and server-side ASP Search Engines for a website.

View Sample Output (HTML Format).     Download Trial Version (3Mb ZIP file).

PHP Documentation Tool™

Automatically creates developer documentation for PHP web applications. Documentation is created in HTML, HTML Help and plain text formats.

View Sample Output (HTML Help format).     View Sample Output (HTML Format).     Download Trial Version (1.0Mb ZIP file).