Certain characters have special meaning in strings. For example, strings are always enclosed in double quotation marks, and if you want to use the actual double-quote character in the string, you need to tell the C# compiler by "escaping" the character's special meaning. For instance, say you need to represent the following in a string:

"I don't necessarily agree with everything I say." Marshall McLuhan

Because the sentence contains the double-quote characters, simply using a pair of double-quotes to contain it will cause an error:

//---error---
string quotation;
quotation = ""I don't necessarily agree with everything I say." Marshall McLuhan";

To represent the double-quote character in a string, you use the backslash () character to turn off its special meanings, like this:

string quotation =
   ""I don't necessarily agree with everything I say." Marshall McLuhan";
Console.WriteLine(quotation);

The output is shown in Figure 8-1.

Figure 8.1. Figure 8-1

A backslash, then, is another special character. To represent the C:Windows path, for example, you need to turn off the special meaning of by using another , like this:

string path = "C:\Windows";

What if you really need two backslash characters in your string, as in the following?

"\servernamepath"

In that case, you use the backslash character twice, once for each of the backslash characters you want to turn off, like this:

string UNC = "\\servername\path";

In addition to using the character to turn off the special meaning of characters like the double-quote (") and backslash (), there are other escape characters that you can use in strings.

One common escape character is the . Here's an example:

string lines = "Line 1
Line 2
Line 3
Line 4
Line 5";
            Console.WriteLine (lines);

The escape character creates a newline, as Figure 8-2 shows.

Figure 8.2. Figure 8-2

You can also use to insert tabs into your string, as the following example shows (see also Figure 8-3):

string columns1 = "Column 1	Column 2	Column 3	Column 4";
            string columns2 = "1	5	25	125";
            Console.WriteLine(columns1);
            Console.WriteLine(columns2);

Figure 8.3. Figure 8-3

Besides the and escape characters, C# also supports the escape character. is the carriage return character. Consider the following example:

string str1 = "       One";
            string str2 = "Two";
            Console.Write(str1);
            Console.Write(str2);

The output is shown in Figure 8-4.

Figure 8.4. Figure 8-4

However, if you prefix a escape character to the beginning of str2, the effect will be different:

string str1 = "       One";
            string str2 = "
Two";
            Console.Write(str1);
            Console.Write(str2);

The output is shown in Figure 8-5.

Figure 8.5. Figure 8-5

The escape character simply brings the cursor to the beginning of the line, and hence in the above statements the word "Two" is printed at the beginning of the line. The escape character is often used together with to form a new line (see Figure 8-6):

string str1 = "Line 1

";
            string str2 = "Line 2

";
            Console.Write(str1);
            Console.Write(str2);

Figure 8.6. Figure 8-6

The following table summarizes the different escape sequences you have seen in this section:

In C#, strings can also be @-quoted. Earlier, you saw that to include special characters (such as double-quote, backslash, and so on) in a string you need to use the backslash character to turn off its special meaning:

string path="C:\Windows";

You can actually use the @ character, and prefix the string with it, like this:

string path=@"C:Windows";

Using the @ character makes your string easier to read. Basically, the compiler treats strings that are prefixed with the @ character verbatim — that is, it just accepts all the characters in the string (inside the quotes). To better appreciate this, consider the following example where a string containing an XML snippet is split across multiple lines (with each line ending with a carriage return):

string XML = @"
                 <Books>
                    <title>C# 3.0 Programmers' Reference</title>
                 </Book>";
            Console.WriteLine(XML);

Figure 8-7 shows the output. The WriteLine() method prints out the line verbatim.

Figure 8.7. Figure 8-7

To illustrate the use of the @ character on a double-quoted string, the following:

string quotation =
    ""I don't necessarily agree with everything I say." Marshall McLuhan";
Console.WriteLine(quotation);

can be rewritten as:

string quotation =
    @"""I don't necessarily agree with everything I say."" Marshall McLuhan";
Console.WriteLine(quotation);

string symbol = "u00A3";
     Console.WriteLine(symbol);

Often, once your values are stored in string variables, you need to perform a wide variety of operations on them, such as comparing the values of two strings, inserting and deleting strings from an existing string, concatenating multiple strings, and so on. The String class in the .NET Framework provides a host of methods for manipulating strings, some of the important ones of which are explained in the following sections.

string str1 = "This is a string";
            string str2 = "This is a ";
            str2 += "string";
            string str3 = str2;

Console.WriteLine(str1 == str2); //--True---
            Console.WriteLine(str1 == str3); //--True---
            Console.WriteLine(str2 != str3); //---False---

Console.WriteLine((object)str1 == (object)str2); //--False---
            Console.WriteLine((object)str2 == (object)str3); //--True---

string str3 = str2;
            Console.WriteLine((object)str2 == (object)str3); //--True---

            str2 = "This string has changed";
            Console.WriteLine((object)str2 == (object)str3); //--False---

Console.WriteLine(str1 == str2); //--True---
            Console.WriteLine(str1.Equals(str2)); //--True---
            Console.WriteLine(string.Equals(str1,str2)); //--True---

string str1 = "Microsoft";
     string str2 = "microsoft";

Console.WriteLine(string.Compare(str1, str2));       // 1;str1 is greater than str2
Console.WriteLine(string.Compare(str2, str1));       // −1;str2 is less than str1
Console.WriteLine(string.Compare(str1, str2, true)); // 0;str1 equals str2

Console.WriteLine(str1.CompareTo(str2)); // 1; str1 is greater than str2
     Console.WriteLine(str2.CompareTo(str1)); // −1; str2 is less than str1

string str1 = "Hello ";
            string str2 = "world!";
            string str3 = str1 + str2;
            Console.WriteLine(str3); //---Hello world!---

string Name = "Wei-Meng Lee";
            int age = 18;
            string str1 = string.Format("My name is {0} and I am {1} years old",
                          Name, age);

            //---str1 is now "My name is Wei-Meng Lee and I am 18 years old"---
            Console.WriteLine(str1);

string str1 = string.Concat("My name is ", Name, " and I am ", age ,
                                         " years old");
            //---str1 is now "My name is Wei-Meng Lee and I am 18 years old"---
            Console.WriteLine(str1);

str1 = str1.Insert(10, "modified ");

string[] pts = { "1,2", "3,4", "5,6" };
            string str1 = string.Join("|", pts);
            Console.WriteLine(str1); //---1,2|3,4|5,6---

string str1 = "This is a string";
            str1 = str1.Insert(10, "modified ");
            Console.WriteLine(str1); //---This is a modified string---

string str1 = "This is a string";
            char[] ch = { '*', '*', '*', '*', '*', '*','*', '*' };
            str1.CopyTo(0, ch, 2, 4);
            Console.WriteLine(ch); //---**This**---

string str1 = "This is a string";
            string str2;

            str2 = str1.PadLeft(20, '*'),
            Console.WriteLine(str2); //---"****This is a string"---

            str2 = str1.PadRight(20, '*'),
            Console.WriteLine(str2); //---"This is a string****"---

string str1 = "   Computer   ";
            string str2;
            Console.WriteLine(str1); //---"   Computer   "---
            str2 = str1.Trim();
            Console.WriteLine(str2); //---"Computer"---

            str2 = str1.TrimStart();
            Console.WriteLine(str2); //---"Computer   "---

            str2 = str1.TrimEnd();
            Console.WriteLine(str2); //---"   Computer"---

string str1 = "1,2|3,4|5,6|7,8|9,10";

string[] strArray = str1.Split('|'),

foreach (string s in strArray)
                Console.WriteLine(s);

1,2
3,4
5,6
7,8
9,10

string str1 = "1,2|3,4|5,6|7,8|9,10";
            string[] strArray = str1.Split('|'),

            foreach (string s in strArray)
            {
               string[] xy= s.Split(','),
               Point p = new Point(Convert.ToInt16(xy[0]), Convert.ToInt16(xy[1]));
               Console.WriteLine(p.ToString());
            }

{X=1,Y=2}
{X=3,Y=4}
{X=5,Y=6}
{X=7,Y=8}
{X=9,Y=10}

string str1 = "This is a long long long string...";
            Console.WriteLine(str1.IndexOf("long"));     //---10---
            Console.WriteLine(str1.LastIndexOf("long")); //---20---

int position = −1;
            string str1 = "This is a long long long string...";
            do
            {
                position = str1.IndexOf("long", ++position);
                if (position > 0)
                    Console.WriteLine(position);
            } while (position > 0);

10
15
20

char[] anyof = "abcde".ToCharArray();
            Console.WriteLine(str1.IndexOfAny(anyof)); //---8---

string str1 = "This is a long string...";
            string str2;
            Console.WriteLine(str1.Substring(10)); //---long string...---
            Console.WriteLine(str1.Substring(10, 4)); //---long---

Console.WriteLine(str1.StartsWith("This")); //---True---
            Console.WriteLine(str1.EndsWith("...")); //---True---

str2 = str1.Remove(10);
            Console.WriteLine(str2); //---"This is a"---

str2 = str1.Remove(10,5);  //---remove 5 characters from index 10---
            Console.WriteLine(str2); //---"This is a string..."---

str2 = str1.Replace("long", "short");
            Console.WriteLine(str2); //---"This is a short string..."---

str2 = str1.Replace("long ", string.Empty);
            Console.WriteLine(str2); //---"This is a string..."---

string str1 = "This is a string";
            string str2;

            str2 = str1.ToUpper();
            Console.WriteLine(str2); //---"THIS IS A STRING"---

            str2 = str1.ToLower();
            Console.WriteLine(str2); //---"this is a string"---

You've seen the use of the Console.WriteLine() method to print the output to the console. For example, the following statement prints the value of num1 to the console:

int num1 = 5;
            Console.WriteLine(num1); //---5---

You can also print the values of multiple variables like this:

int num1 = 5;
            int num2 = 12345;
            Console.WriteLine(num1 + " and " + num2); //---5 and 12345---

If you have too many variables to print (say more than five), though, the code can get messy very quickly. A better way would be to use a format specifier, like this:

Console.WriteLine("{0} and {1}", num1, num2); //---5 and 12345---

A format specifier ({0}, {1}, and so forth) automatically converts all data types to string. Format specifiers are labeled sequentially ({0}, {1}, {2}, and so on). Each format specifier is then replaced with the value of the variable to be printed. The compiler looks at the number in the format specifier, takes the argument with the same index in the argument list, and makes the substitution. In the preceding example, num1 and num2 are the arguments for the format specifiers.

What happens if you want to print out the value of a number enclosed with the {} characters? For example, say that you want to print the string {5} when the value of num1 is 5. You can do something like this:

num1 = 5;
            Console.WriteLine("{{{0}}}", num1); //---{5}---

Why are there two additional sets of {} characters for the format specifier? Well, if you only have one additional set of {} characters, the compiler interprets this to mean that you want to print the string literal {0}, as the following shows:

num1 = 5;
            Console.WriteLine("{{0}}", num1); //---{0}---

The two additional sets of {} characters indicate to the compiler that you want to specify a format specifier and at the same time surround the value with a pair of {} characters.

And as demonstrated earlier, the String class contains the Format() static method, which enables you to create a new string (as well as perform formatting on string data). The preceding statement could be rewritten using the following statements:

string formattedString = string.Format("{{{0}}}", num1);
            Console.WriteLine(formattedString); //---{5}---

To format numbers, you can use the format specifiers as shown here:

num1=5;
            Console.WriteLine("{0:N}", num1);      //---5.00---

            Console.WriteLine("{0:00000}", num1);  //---00005---
            //---OR---
            Console.WriteLine("{0:d5}", num1);     //---00005---

            Console.WriteLine("{0:d4}", num1);     //---0005---

            Console.WriteLine("{0,5:G}", num1);    //---    5 (4 spaces on left)---

You can also print out specific strings based on the value of a number. Consider the following example:

num1 = 0;
            Console.WriteLine("{0:yes;;no}", num1); //---no---
            num1 = 1;
            Console.WriteLine("{0:yes;;no}", num1); //---yes---
            num1 = 5;
            Console.WriteLine("{0:yes;;no}", num1); //---yes---

In this case, the format specifier contains two strings: yes and no. If the value of the variable (num) is nonzero, the first string will be returned (yes). If the value is 0, then it returns the second string (no). Here is another example:

num1 = 0;
            Console.WriteLine("{0:OK;;Cancel}", num1); //---Cancel---
            num1 = 1;
            Console.WriteLine("{0:OK;;Cancel}", num1); //---OK---
            num1 = 5;
            Console.WriteLine("{0:OK;;Cancel}", num1); //---OK---

For decimal number formatting, use the following format specifiers:

double val1 = 3.5;
            Console.WriteLine("{0:##.00}", val1);   //---3.50---
            Console.WriteLine("{0:##.000}", val1);  //---3.500---
            Console.WriteLine("{0:0##.000}", val1); //---003.500---

There are times when numbers are represented in strings. For example, the value 9876 may be represented in a string with a comma denoting the thousandth position. In this case, you cannot simply use the Parse() method from the int class, like this:

string str2 = "9,876";
            int num3 = int.Parse(str2); //---error---

To correctly parse the string, use the following statement:

int num3 = int.Parse(
                str2,
                System.Globalization.NumberStyles.AllowThousands);
            Console.WriteLine(num3);  //---9876---

Here is another example:

string str3 = "1,239,876";
            num3 = int.Parse(
                str3,
                System.Globalization.NumberStyles.AllowThousands);
            Console.WriteLine(num3);  //---1239876---

What about the reverse — formatting a number with the comma separator? Here is the solution:

num3 = 9876;
            Console.WriteLine("{0:#,0}", num3); //---9,876---

            num3 = 1239876;
            Console.WriteLine("{0:#,0}", num3); //---1,239,876---

Last, to format a special number (such as a phone number), use the following format specifier:

long phoneNumber = 1234567890;
          Console.WriteLine("{0:###-###-####}", phoneNumber); //---123-456-7890---

Earlier in this chapter you saw how to easily concatenate two strings by using the + operator. That's fine if you are concatenating a small number of strings, but it is not recommended for large numbers of strings. The reason is that String objects in .NET are immutable, which means that once a string variable is initialized, its value cannot be changed. When you concatenate another string to an existing one, you actually discard its old value and create a new string object containing the result of the concatenation. When you repeat this process several times, you incur a performance penalty as new temporary objects are created and old objects discarded.

Consider the following example, where you concatenate all the numbers from 0 to 9999:

int counter = 9999;
            string s = string.Empty;
            for (int i = 0; i <= counter; i++) {
                s += i.ToString();
            }
            Console.WriteLine(s);

At first glance, the code looks innocent enough. But let's use the Stopwatch object to time the operation. Modify the code as shown here:

int counter = 9999;
            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            sw.Start();

            string s = string.Empty;
            for (int i = 0; i <= counter; i++) {
                s += i.ToString();
            }

            sw.Stop();
            Console.WriteLine("Took {0} ms", sw.ElapsedMilliseconds);
            Console.WriteLine(s);

On average, it took about 374 ms on my computer to run this operation. Let's now use the StringBuilder class in .NET to perform the string concatenation, using its Append() method:

System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            sw.Start();

            StringBuilder sb = new StringBuilder();
            for (int i = 0; i <= 9999; i++) {
                sb.Append (i.ToString());
            }

            sw.Stop();

            Console.WriteLine("Took {0} ms", sw.ElapsedMilliseconds);
            Console.WriteLine(sb.ToString());

On average, it took about 6 ms on my computer to perform this operation. As you can deduce, the improvement is drastic — 98% ((374—6)/374). If you increase the value of the loop variant (counter), you will find that the improvement is even more dramatic.

The StringBuilder class represents a mutable string of characters. Its behavior is like the String object except that its value can be modified once it has been created.

The StringBuilder class contains some other important methods, which are described in the following table.

To use the RegEx class, first you need to import the System.Text.RegularExpressions namespace:

using System.Text.RegularExpressions;

The following statements shows how you can create an instance of the RegEx class, specify the pattern to search for, and match it against a string:

string s = "This is a string";
            Regex r = new Regex("string");
            if (r.IsMatch(s))
            {
                Console.WriteLine("Matches.");
            }

In this example, the Regex class takes in a string constructor, which is the pattern you are searching for. In this case, you are searching for the word "string" and it is matched against the s string variable. The IsMatch() method returns True if there is a match (that is, the string s contains the word "string").

To find the exact position of the text "string" in the variable, you can use the Match() method of the RegEx class. It returns a Match object that you can use to get the position of the text that matches the search pattern using the Index property:

string s = "This is a string";
            Regex r = new Regex("string");
            if (r.IsMatch(s))
            {
                Console.WriteLine("Matches.");
            }

            Match m = r.Match(s);
            if (m.Success)
            {
                Console.WriteLine("Match found at " + m.Index);
                //---Match found at 10---
            }

What if you have multiple matches in a string? In this case, you can use the Matches() method of the RegEx class. This method returns a MatchCollection object, and you can iteratively loop through it to obtain the index positions of each individual match:

string s = "This is a string and a long string indeed";
            Regex r = new Regex("string");

            MatchCollection mc = r.Matches(s);
            foreach (Match m1 in mc)
            {
                Console.WriteLine("Match found at " + m1.Index);
                //---Match found at 10---
                //---Match found at 28---
            }

You can specify more complex searches using regular expressions operators. For example, to know if a string contains either the word "Mr" or "Mrs", you can use the operator |, like this:

string gender = "Mr Wei-Meng Lee";
            Regex r = new Regex("Mr|Mrs");
            if (r.IsMatch(gender))
            {
                Console.WriteLine("Matches.");
            }

The following table describes regular expression operators commonly used in search patterns.

Another common search pattern is verifying a string containing a date. For example, if a string contains a date in the format "yyyy/mm/dd", you would specify the search pattern as follows: "(19|20)dd[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])". This pattern will match dates ranging from 1900-01-01 to 2099-12-31.

string date = "2007/03/10";
            Regex r = new Regex(@"(19|20)dd[- /.](0[1-9]|1[012])[- /.]
(0[1-9]|[12][0-9]|3[01])");
            if (r.IsMatch(date))
            {
                Console.WriteLine("Matches.");
            }

You can use the following date separators with the pattern specified above:

string date = "2007/03/10";
string date = "2007-03-10";
string date = "2007 03 10";
string date = "2007.03.10";

Some commonly used search patterns are described in the following table.

To verify that an email address is correctly formatted, you can use the following statements with the specified regular expression:

string email = "[email protected]";
            Regex r = new Regex(@"^[w-.]+@([w-]+.)+[w-]{2,4}$");
            if (r.IsMatch(email))
                Console.WriteLine("Email address is correct.");
            else
                Console.WriteLine("Email address is incorrect.");