Null strings and empty strings

An empty string is an instance of a System.String object that contains zero characters. Empty strings are used often in various programming scenarios to represent a blank text field. You can call methods on empty strings because they're valid System.String objects. Empty strings are initialized as follows:

string s = String.Empty;
By contrast, a null string doesn't refer to an instance of a System.String object and any attempt to call a method on a null string causes a NullReferenceException. However, you can use null strings in concatenation and comparison operations with other strings. The following examples illustrate some cases in which a reference to a null string does and doesn't cause an exception to be thrown:
string str = "hello";
string nullStr = null;
string emptyStr = String.Empty;
string tempStr = str + nullStr;
// Output of the following line: hello
Console.WriteLine(tempStr);
bool b = (emptyStr == nullStr);
// Output of the following line: False
Console.WriteLine(b);
// The following line creates a new empty string.
string newStr = emptyStr + nullStr;
// Null strings and empty strings behave differently. The following
// two lines display 0.
Console.WriteLine(emptyStr.Length);
Console.WriteLine(newStr.Length);
// The following line raises a NullReferenceException.
//Console.WriteLine(nullStr.Length);
// The null character can be displayed and counted, like other chars.
string s1 = "\x0" + "abc";
string s2 = "abc" + "\x0";
// Output of the following line: * abc*
Console.WriteLine("*" + s1 + "*");
// Output of the following line: *abc *
Console.WriteLine("*" + s2 + "*");
// Output of the following line: 4
Console.WriteLine(s2.Length);
Using StringBuilder for fast string creation
String operations in .NET are highly optimized and in most cases don't significantly impact performance. However, in some scenarios such as tight loops that are executing many hundreds or thousands of times, string operations can affect performance. The StringBuilder class creates a string buffer that offers better performance if your program performs many string manipulations. The StringBuilder string also enables you to reassign individual characters, something the built-in string data type doesn't support. This code, for example, changes the content of a string without creating a new string:
System.Text.StringBuilder sb = new System.Text.StringBuilder("Rat: the ideal pet");
sb[0] = 'C';
System.Console.WriteLine(sb.ToString());
//Outputs Cat: the ideal pet
In this example, a StringBuilder object is used to create a string from a set of numeric types:
var sb = new StringBuilder();
// Create a string composed of numbers 0 - 9
for (int i = 0; i < 10; i++)
    sb.Append(i.ToString());
Console.WriteLine(sb);  // displays 0123456789
// Copy one character of the string (not possible with a System.String)
sb[0] = sb[9];
Console.WriteLine(sb);  // displays 9123456789
Strings, extension methods and LINQ
Because the String type implements IEnumerable<T>, you can use the extension methods defined in the Enumerable class on strings. To avoid visual clutter, these methods are excluded from IntelliSense for the String type, but they're available nevertheless. You can also use LINQ query expressions on strings. For more information, see LINQ and Strings.
Related articles
How to modify string contents: Illustrates techniques to transform strings and modify the contents of strings.
How to compare strings: Shows how to perform ordinal and culture specific comparisons of strings.
How to concatenate multiple strings: Demonstrates various ways to join multiple strings into one.
How to parse strings using String.Split: Contains code examples that illustrate how to use the String.Split method to parse strings.
How to search strings: Explains how to use search for specific text or patterns in strings.
How to determine whether a string represents a numeric value: Shows how to safely parse a string to see whether it has a valid numeric value.
String interpolation: Describes the string interpolation feature that provides a convenient syntax to format strings.
Basic String Operations: Provides links to articles that use System.String and System.Text.StringBuilder methods to perform basic string operations.
Parsing Strings: Describes how to convert string representations of .NET base types to instances of the corresponding types.
Parsing Date and Time Strings in .NET: Shows how to convert a string such as "01/24/2008" to a System.DateTime object.
Comparing Strings: Includes information about how to compare strings and provides examples in C# and Visual Basic.
Using the StringBuilder Class: Describes how to create and modify dynamic string objects by using the StringBuilder class.
LINQ and Strings: Provides information about how to perform various string operations by using LINQ queries.