- Introduction
- Creating and Using String Objects
- Formatting Strings
- Accessing Individual String Characters
- Analyzing Character Attributes
- Case-Insensitive String Comparison
- Working with Substrings
- Using Verbatim String Syntax
- Choosing Between Constant and Mutable Strings
- Optimizing StringBuilder Performance
- Understanding Basic Regular Expression Syntax
- Validating User Input with Regular Expressions
- Replacing Substrings Using Regular Expressions
- Building a Regular Expression Library
This chapter is from the book
This chapter is from the book
This chapter is from the book
3.1. Creating and Using String Objects
You want to create and manipulate string data within your application.
Technique
The C# language, knowing the importance of string data, contains a string keyword that simulates the behavior of a value data type. To create a string, declare a variable using the string keyword. You can use the assignment operator to initialize the variable using a static string or with an already initialized string variable.
string string1 = "This is a string"; string string2 = string1;
To gain more control over string initialization, declare a variable using the System.String data type and create a new instance using the new keyword. The System.String class contains several constructors that you can use to initialize the string value. For instance, to create a new string that is a small subset of an existing string, use the overloaded constructor, which takes a character array and two integers denoting the beginning index and the number of characters from that index to copy:
class Class1
{
[STAThread]
static void Main(string[] args)
{
string string1 = "Field1, Field2";
System.String string2 = new System.String( string1.ToCharArray(), 8, 6 );
Console.WriteLine( string2 );
}
}
Finally, if you know a string will be intensively manipulated, use the System.Text. StringBuilder class. Creating a variable of this data type is similar to using the System.String class, and it contains several constructors to initialize the internal string value. The key internal difference between a regular string object and a StringBuilder lies in performance. Whenever a string is manipulated in some manner, a new object has to be created, which subsequently causes the old object to be marked for deletion by the garbage collector. For a string that undergoes several transformations, the performance hit associated with frequent object creation and deletions can be great. The StringBuilder class, on the other hand, maintains an internal buffer, which expands to make room for more string data should the need arise, thereby decreasing frequent object activations.
Comments
There is no recommendation on whether you use the string keyword or the System.String class. The string keyword is simply an alias for this class, so it is all a matter of taste. We prefer using the string keyword, but this preference is purely aesthetic. For this reason, we simply refer to the System.String class as the string class or data type.
The string class contains many methods, both instance and static, for manipulating strings. If you want to compare strings, you can use the Compare method. If you are just testing for equality, then you might want to use the overloaded equality operator (==). However, the Compare method returns an integer instead of Boolean value denoting how the two strings differ. If the return value is 0, then the strings are equal. If the return value is greater than 0, as shown in Listing 3.1, then the first operand is greater alphabetically than the second operand. If the return value is less than 0, the opposite is true. When a string is said to be alphabetically greater or lower than another, each character reading from left to right from both strings is compared using its equivalent ASCII value.
Listing 3.1 Using the Compare Method in the String Class
using System;
namespace _1_UsingStrings
{
class Class1
{
[STAThread]
static void Main(string[] args)
{
string string1 = "";
String string2 = "";
Console.Write( "Enter string 1: " );
string1 = Console.ReadLine();
Console.Write( "Enter string 2: " );
string2 = Console.ReadLine();
// string and String are the same types
Console.WriteLine( "string1 is a {0}\nstring2 is a {1}",
string1.GetType().FullName, string2.GetType().FullName );
CompareStrings( string1, string2 );
}
public static void CompareStrings( string str1, string str2 )
{
int compare = String.Compare( str1, str2 );
if( compare == 0 )
{
Console.WriteLine( "The strings {0} and {1} are the same.\n",
str1, str2 );
}
else if( compare < 0 )
{
Console.WriteLine( "The string {0} is less than {1}",
str1, str2 );
}
else if( compare > 0 )
{
Console.WriteLine( "The string {0} is greater than {1}",
str1, str2 );
}
}
}
}
As mentioned earlier, the string class contains both instance and static methods. Sometimes you have no choice about whether to use an instance or static method. However, a few of the instance methods contain a static version as well. Because calling a static method is a nonvirtual function call, you see performance gains if you use this version. An example where you might see both instance and static versions appears in Listing 3.1. The string comparison uses the static Compare method. You can also do so using the nonstatic CompareTo method using one of the string instances passed in as parameters. In most cases, the performance gain is negligible, but if an application needs to repeatedly call these methods, you might want to consider using the static over the non-static method.
The string class is immutable. Once a string is created, it cannot be manipulated. Methods within the string class that modify the original string instance actually destroy the string and create a new string object rather than manipulate the original string instance. It can be expensive to repeatedly call string methods if new objects are created and destroyed continuously. To solve this, the .NET Framework contains a StringBuilder class contained within the System.Text namespace, which is explained later in this chapter.