The first thing to note about strings in .NET is that they are Reference Types. Reference types are live on the managed heap in .NET and so they are managed by the .NET Garbage Collector and unlike Value types they are not automatically destroyed when they are out of scope.

Strings can be easily instantiated using the below syntax:

string s1;

Note that there is no default value for a string, thus you need to assign a value to the string before attempting to access it:

string s1;
Literal1.Text = s1; //Will give run-time error 

string s2 = ""; //This is as close as you can get to assigning nothing to a string;
Literal1.Text = s2;

There are numerous inbuilt methods in the .NET framework for dealing with strings. Namely:

Note that strings are immutable and thus the original string can never be changed. Therefore if you need to alter the string you will need to re-assign it a new string value:

string s1 = "all lower case";
s1.ToUpper() ; //s1 is unchanged
Literal1.Text = s1;  //outputs 'all lower case' since s1 is unchanged

string s2 = "all lower case";
s2 = s2.ToUpper() ; //s2 is now re-assigned the new uppercase string
Literal2.Text = s2; //outputs 'ALL LOWER CASE'

For more on string immutability see Strings are Immutable.

String Concatenation

C# offers a convenient method for concatenating a string using ‘+’ :

string s1 = "Hong ";
string s2 = "Kong";
Literal1.Text = s1 + s2;

Whilst this method is convenient it is not efficient for performing a large number of concatenations (since strings are immutable and are refenece types created on the managed heap each concatenation results in the creation of an extra string which is not automatically destroyed and stays in memory until the Garbage Collector destroys it).

To get around this limitation the .NET Framework provides the StringBuilder class which can efficiently concatenate strings using its Append() method:

 StringBuilder sb = new StringBuilder();
 sb.Append("Hong ");
 sb.Append("Kong");

Literal1.Text = sb.ToString();

This is by way of demonstration since there would not be any memory saving from concatentating two strings (in fact this can consume more memory since the StringBuilder consumes memory). In general concatenating more than four strings is normally when a StringBuilder should be used.

Escape Characters

In common with other C-based languages, C# strings may contain escape characters which qualify how the string should be output.
Escape characters begin with a backslash followed by a specific character.

Below are listed the various escape characters and their output:

\’ Inserts a single quote
\” Inserts a double quote
\\ Inserts a backslash
\a Triggers a system alert
\n Inserts a new line (on Windows systems)
\r Inserts a carriage return
\t Inserts a horizontal tab

Verbatim Strings

To preserve a string exactly as it is exactly as it was added simply add the @ character at the start of the string.

For example:

string outputStr =   "This site is named \'C# Help\'  ";
Response.Write(outputStr);

This outputs

This site is named 'C# Help'

To output the string verbatim add the @ character at the start of the string.

string outputStr =   @"This site is named \'C# Help\'  ";
Response.Write(outputStr);

This outputs

This site is named \'C# Help\'

Note that this will also preserve white space:

string outputStr =   @"This is a                  broken
up
             string";  

This tutorial provides the information you need about:

• Understanding C# Strings
• Working with the Char Type
• Control Characters
• String Assignment
• The String Constructor
• Verbatim Strings
• Using String Methods
• Understanding the StringBuilder Class

Understanding C# Strings

In C#, a text string is stored in a data type named string, which is analias to the System.String type. In other words, when you create astring, you instantiate a System.String object. In addition to itsinstance members, the System.String class has quite a few importantstatic methods. These methods don.t require a string instance to work.It.s important to understand that the string type is immutable. Thismeans that once it has been created, a string cannot be changed. No characters can be added or removed from it, nor can its length be changed. In those situations in which it appears that a string's contents have been changed, what has really happened is that a new string instance has been created.

But wait, you say, my strings change all the time when I do things like:

string str = "I am having a great deal of fun";
str += " on the DonationCoder website… ";
str += " The End";

Well, my friend, what this set of statements actually does is create a new instance of the variable str each time a value is assigned to str. In other words, in this example, an instance of strhas been created and a literal string value assigned to it three times.The statement that the type is immutable means that an instance cannotbe edited but it can be assigned.

Using an instance method without an assignmentis syntactically legal, but it doesn.t do anything (has no effect). Asa demonstration of my claim that an instance cannot be edited, examinethe following code:

using System;

namespace ConsoleApplication1 {
class Program {
static void Main(string[] args) {
string str = "Mouser";
str.Replace("u", "U");
Console.WriteLine(str);
Console.ReadLine();
}
}
}

The above code does not change the contents of the variable str, because an instance cannot be edited. Run the above code in your IDE, and you'll see this result:

However, combining it with an assignment would work:

using System;

namespace ConsoleApplication1 {
class Program {
static void Main(string[] args) {
string str = "Mouser";
str = str.Replace("u", "U");
Console.WriteLine(str);
Console.ReadLine();
}
}
}

The value of the newly assigned strinstance is, of course, MoUser. If you carefully compare the two sourcecode listings above, you'll see that the only difference occurs in thetwo highlighted lines. The second source code listing differs only byprefacing that line of code with str =, which tells the compiler to assign whatever follows the equal sign to the str instance of the String type. You may remember, from a previous tutorial in this series, that a type is defined by a class. There is, indeed, a String class. So, when I write string str = "Bryan";, what I've really done is created an instance of the String class called str, then assigned the text Bryan to it.

Is there any real problem with this use ofassignment in conjunction with strings? Well, no, it.s easy enough touse assignments when you need to change the value of a string variable.But instantiating and destroying strings every time you need to changeor edit one has negative performance consequences. If performance is anissue, you should consider working with instances of theSystem.Text.StringBuilder class, which are mutable (can be changed).The StringBuilder class is discussed later in this tutorial in a littlemore detail.

Once created, a string has a specific length.which, of course, is fixed (since the stringtype is immutable). Unlike in the C language, in which a string issimply an array of characters terminated with a zero byte, a C# stringis not a terminated array of characters. So, how does onedetermine the length of a C# string? As you probably know, you canquery the read-only Length property of the string instance tofind its length. Let's write a short console program demonstrating theuse of this property:

using System;

namespace ConsoleApplication1 {
class Program {
static void Main(string[] args) {
string name = string.Empty;
do {
Console.Write("Please enter a name (enter "quit" to exit program): ");
name = Console.ReadLine();
if (name.Trim().ToLower() != "quit") {
Console.WriteLine(""{0}", is {1} characters in length.n", name, name.Length);
}
} while (name.Trim().ToLower() != "quit");
}
}
}

Now click on this link to see the program in action.

Working with the Char type

Char is a value type that contains a single Unicode character. Whilechars have a numeric value from hexadecimal 0×0000 through 0xFFFF, theyare not directly numerically usable without explicit type casting.

Literal values are assigned to char variablesusing singl
e quotes
. The literal can be a simple, single letter, or anescape sequence (for more on escape sequences, see the next section).Here are two examples:

char chr = 'P'; // contains capital P
char pi = 'u03A0.; // contains capital Pi

The char data type is related to the stringdata type: A string can be constructed from (or converted into) anarray of characters but string and char are two distinct types.

Suppose you have a string defined like this:

string str = "rotfl";

You can retrieve a character of the string using the string.s indexer. For example, the following statement

char chr = str[1];

stores the character .o. in the variable chr. But you cannot set a character in the string with a statement like str[1] = 'a';because the indexer property of the String class is read-only.(Actually, one would expect this in any case, because the stringinstance is immutable.)

If you use the Object Browser to have a look at the String class, you.ll see that its indexer property, declared as this[int], has a get accessor, but no set accessor.

Control Characters

The backslash() is a special control character, also called the escape character.The character after the backslash has a special significance. See thefollowing table for the meaning of each escape sequence:

Character<o:p></o:p>	Meaning<o:p></o:p>
<o:p></o:p>	Null<o:p></o:p>
b<o:p></o:p>	Backspace<o:p></o:p>
t<o:p></o:p>	Tab<o:p></o:p>
r<o:p></o:p>	Carriage return<o:p></o:p>
n<o:p></o:p>	New line<o:p></o:p>
v<o:p></o:p>	Vertical tab<o:p></o:p>
f<o:p></o:p>	Form feed<o:p></o:p>
u, x<o:p></o:p>	A single Unicode character when followed by a four-digit hexadecimal number<o:p></o:p>
"<o:p></o:p>	Double quote<o:p></o:p>
'<o:p></o:p>	Single quote<o:p></o:p>
<o:p></o:p>	Backslash<o:p></o:p>

Here is a very brief program that demonstrates use of the backspace escape character:

using System;

class Program{

static void Main(){

Console.Write("This is line #1bb");
Console.Write("number 2");
Console.ReadLine();

}//end Main

}//end class Program

The program's output looks like this:

As you can see, there are two backspace escape characters at the end of the first Console.Write()parameter. I've highlighted these in the source code listing above.These have the effect of backing the cursor up to just in front of the # symbol. The subsequent Console.Write() invocation then prints "number 2", starting at the position occupied by the # symbol, and thus effectively overwriting #1.

The escape sequences u or x are used(interchangeably) to specify a single Unicode character. For example,x03A9 and u03A9 both mean the Greek letter capital omega. The escapesequences x03A3 and u03A3 will appear as the Greek letter capitalsigma:

using System;

class Program{

static void Main(){

Console.Write("This is Omega: {0}. And this is Sigma: {1} ",
"u03A9", "u03A3");

Console.ReadLine();

}//end Main

}//end class Program

The output from the above program is:

ass="smallblack">

A complete listing of unicode character sets can be found at http://www.unicode.org/charts/.

String Assignment

There are different ways to create strings in C#. You can, forinstance, declare a string variable, without initializing it, such asin this example:

string mystring;

While this is legal, we've also discussed thefact that attempting to use an uninitialized string variable causes acompiler error. For this reason, it's generally a good idea toinitialize a string variable when you declare it:

string mystring = "Hello, world!";

Because a string variable is a reference type, it can be initialized to null:

string mystring = null;

And initializing a string to null is not the same thing as initializing it to an empty string. The above is not equivalent to this:

string mystring = string.Empty;

In the case of the null assignment, no memoryhas been allocated for the string. An attempt to determine the lengthof a null string by using its Length property causes anexception to be thrown. For an example of this, see the followingprogram listing, and then the output it produces. The program willcompile okay, because there is no syntax error. However, attempting toexecute the highlighted line causes a runtime error:

using System;

class Program{

static void Main(){

string mystring = null;
Console.WriteLine("Length of mystring is {0}", mystring.Length);
Console.ReadLine();

}//end Main

}//end class Program

The Length property of an empty string is 0.The preferred way to initialize an empty string is to use the static Empty field of the String class: string str = string.Empty;

However, you will sometimes see it done thusly: string str = "";

The String Constructor

The String class itself has eight constructors. If you look in theObject Browser, you can see that five of these use pointers and are notsafe under the rules of the Common Language Specification (CLS) that.NET languages must follow. We will only discuss the other threeconstructors.

You may recall from a previous tutorial thatwhen a method has more than one form, via differing method signatures,it is said to be overloaded. You also learned in a previoustutorial that a constructor is a special class method that, if present,is invoked whenever a new instance of that class is created. Well, theString class has several overloaded constructors.

The first such overloaded constructor thatwe'll discuss takes two parameters — a character and an integer. Itthen produces a string of that particular character that is xcharacters in length, where x is the value of the integer passed as theconstructor's second argument. This constructor takes the followingform:

String(char, int)

For example, the following lines of code, placed inside the Main method of a Console C# application…

string s = new string('a',5);
Console.WriteLine(s);
Console.ReadLine();

…would produce the following output:

The next overloaded string constructor we'll consider takes the following form:

String(char[])

This constructor takes a character array as aparameter, and converts the character array into a string. For example,the following code…

using System;

class Program{

static void Main(){

char[] mychararray = new char[5]{'B','r','y','a','n'};
string mystring = new string(mychararray);
Console.WriteLine("The 5-element character array has been converted into this string: "{0}".", mystring);
Console.ReadLine();

}//end Main

}//end class Program

…produces this output…

The final overloaded string constructor we'llconsider is simply an extension of the constructor we just examined,and takes this form:

String(char[],int,int)

Like the previous constructor, it converts acharacter array into a string, but it additionally will then derive astring with a particular starting and stopping position within theconverted string. For example, if these lines were put into a consoleprogram…

char[] mychararray = new char[11]{'N','e','w','Y','o','r','k','C','i','t','y'};
string mystring = new string(mychararray,3,6);
Console.WriteLine(mystring);

…the output would be York.

Verbatim Strings

You could use the @symbol to use a keyword as an identifier if you were so inclined. Youcould create variables named, for example, @if, @string, and @true;but, just because one can do something, doesn.t mean it is a good idea.

In the context of strings, the @ symbol isused to create verbatim string literals. The @ symbol tells the stringconstructor to use the string literal that follows it literally even ifit includes escape characters or spans multiple lines.

This comes in handy when working withdirectory paths (without the @, you would have to double eachbackslash). For example, the following two strings are equivalent:

string desktop = "C:Documents and SettingsOwnerDesktop"; //uses eight slashes
stri

ng desktop = @"C:Documents and SettingsOwnerDesktop"; //uses four slashes

You can also use the ampersand symbol to causea single string to span more than one line. For example, consider thefollowing program listing, and the output it produces:

using System;

class Program {

static void Main() {

string str =
@"I'm so happy to be a string
that is split across
a number of different
lines.";

Console.WriteLine(str);
Console.ReadLine();
}
}

In console mode, line breaks are preserved. Ina WinForms application (we'll learn how to code those in latertutorials), you could assign str to a textbox control that hasits multiline property set to true, and all line breaks and whitespacewould be faithfully preserved.

Using String Methods

The Stringclass provides many powerful instance and static methods. These methodsare described in this section. Most of these methods are overloaded, sothere are multiple ways that each can be used. The table belowdescribes many of the instance methods of the String class.

Method<o:p></o:p>	What It Does<o:p></o:p>
Clone<o:p></o:p>	Returns a reference to the instance of the string.<o:p></o:p>
CompareTo<o:p></o:p>	Compares this string with another.<o:p></o:p>
CopyTo<o:p></o:p>	Copies the specified number of characters from the string instance to a char array.<o:p></o:p>
EndsWith<o:p></o:p>	Returns true if the specified string matches the end of the instance string.<o:p></o:p>
Equals<o:p></o:p>	Determines whether the instance string and a specified string have the same value.<o:p></o:p>
GetEnumerator<o:p></o:p>	Method required to support the IEnumerator interface.<o:p></o:p>
IndexOf<o:p></o:p>	Reports the index of the first occurrence of a specified character or string within the instance.<o:p></o:p>
Insert<o:p></o:p>	Returns a new string with the specified string inserted at the specified position in the current string.<o:p></o:p>
LastIndexOf<o:p></o:p>	Reports the index of the last occurrence of a specified character or string within the instance.<o:p></o:p>
PadLeft<o:p></o:p>	Returns a new string with the characters in this instance right-aligned by padding on the left with spaces or a specified character for a specified total length.<o:p></o:p>
PadRight<o:p></o:p>	Returns a new string with the characters in this instance left-aligned by padding on the right with spaces or a specified character for a specified total length.<o:p></o:p>
Remove<o:p></o:p>	Returns a new string that deletes a specified number of characters from the current instance beginning at a specified position.<o:p></o:p>
Replace<o:p></o:p>	Returns a new string that replaces all occurrences of a specified character or string in the current instance, with another character or string.<o:p></o:p>
<st1:city><st1:place>Split</st1:place></st1:city><o:p></o:p>	Identifies the substrings in this instance that are delimited by one or more characters specified in an array, then places the substrings into a string array.<o:p></o:p>
StartsWith<o:p></o:p>	Returns true if the specified string matches the beginning of the instance string.<o:p></o:p>
Substring<o:p></o:p>	Returns a substring from the instance.<o:p></o:p>
ToCharArray<o:p></o:p>	Copies the characters in the instance to a character array.<o:p></o:p>
ToLower<o:p></o:p>	Returns a copy of the instance in lowercase.<o:p></o:p>
ToUpper<o:p></o:p>	Returns a copy of the instance in uppercase.<o:p></o:p>
Trim<o:p></o:p>	Returns a copy of the instance with all occurrences of a set of specified characters from the beginning and end removed.<o:p></o:p>
TrimEnd<o:p></o:p>	Returns a copy of the instance with all occurrences of a set of specified characters at the end removed.<o:p></o:p>
TrimStart<o:p></o:p>	Returns a copy of the instance with all occurrences of a set of specified characters from the beginning removed.<o:p></o:p>

Whereas the above table shows many of the String class instance methods, the following tables shows some of the static methods of the String class.

Method<o:p></o:p>	What It Does<o:p></o:p>
Compare<o:p></o:p>	Compares two string objects.<o:p></o:p>
CompareOrdinal<o:p></o:p>	Compares two string objects without considering the local national language or culture.<o:p></o:p>
Concat<o:p></o:p>	Creates a new string by concatenating one or more strings.<o:p></o:p>
Copy<o:p></o:p>	Creates a new instance of a string by copying an existing instance.<o:p></o:p>
Format<o:p></o:p>	Formats a string using a format specification. See Formatting Overview in online help for more information about format specifications.<o:p></o:p>
Join<o:p></o:p>	Concatenates a specified string between each element in a string to yield a single concatenated string.<o:p></o:p>

Here is a program that demonstrates the use of String.Clone().What this program shows is that cloning a string returns a reference tothat string instance, which can be assigned to another string variable,giving that other string variable a reference to the exact samelocation in memory. In other words, both strings will reference thesame instance, after cloning has occurred.

using System;

class Program {

static void Main() {

bool test = false;

string s1 = "William";
string s2 = "Bryan";
string s3 = "Miller";

Console.WriteLine("s1 = {0}, s2 = {1}, s3 = {2}n", s1, s2, s3);

s2 = (string)s1.Clone(); //now s2 references the same string instance that s1 does
Console.WriteLine("s2 = (string)s1.Clone(); //now s2 references the same string instance that s1 doesn");

test = SameValue(s1, s2);

if (test) {
Console.WriteLine("s2 now holds the same value that s1 holds, i.e., "{0}"n", s1);
}

test = ReferencesSameObject(s1, s2);

if (test) {
Console.WriteLine("s1 and s2 reference the same instance object.n");
}

s2 = s3;

Console.WriteLine("s2 = s3; // now s2 = {0} and s3 = {1}n", s2, s3);

test = SameValue(s2, s3);

if (test) {
Console.WriteLine("s2 and s3 now hold the same valuen");
}

test = ReferencesSameObject(s2, s3);

if (test) {
Console.WriteLine("s2 and s3 now reference the very same instance.");
} else {
Console.WriteLine("s2 and s3 do NOT reference the same instance.");
}

Console.ReadLine();

}//end Main

private static bool SameValue(object o1, object o2){
if (o1.Equals(o2)) {
return true;
} else {
return false;
}
}

private static bool ReferencesSameObject(object o1, object o2) {

/> if (Object.ReferenceEquals(o1, o2)) {
return true;
} else {
return false;
}
}
}

Here is the output the above program produces:

Whereas the Clone() method of the String object returns a reference to the string instance, the static Copy() method creates a new instance of a string by copying an existing instance, as the following program demonstrates:

// Sample for String.Copy()
using System;

class Sample {
public static void Main() {
string str1 = "abc";
string str2 = "xyz";
Console.WriteLine("1) str1 = '{0}'", str1);
Console.WriteLine("2) str2 = '{0}'", str2);
Console.WriteLine("Copy…");
str2 = String.Copy(str1);
Console.WriteLine("3) str1 = '{0}'", str1);
Console.WriteLine("4) str2 = '{0}'", str2);
}
}
/*
This example produces the following results:
1) str1 = 'abc'
2) str2 = 'xyz'
Copy…
3) str1 = 'abc'
4) str2 = 'abc'
*/

Next we have the CompareTo()method. This method returns an integer whose value signals how the twostrings compare. First, I'll show you code that will throw anexception. The comment in the following program listing explains whatthe problem is that leads to an exception being thrown.

using System;

public class Program {
public static void Main() {

MyClass my = new MyClass();

string s = "sometext";

try {
int i = s.CompareTo(my); //comparing string s to class instance my (which doesn't evaluate to a string)
} catch (Exception e) {
Console.WriteLine("Error: {0}", e.ToString());
}

Console.ReadLine();
}
}

public class MyClass { }

Now, unlike the above program, whichdemonstrates the throwing of an exception due to an invalid parameter,let's see a program that demonstrates the other three cases we mightencounter when dealing with the CompareTo() instance method:

If you wish to view the source code that produces the output shown above, click here.

The example program here produces this output:

A fairly straightforward instance method of the String class is the EndsWith() method. It is used to determine if a specified string matches the end of an instance string. Consider this program listing, and the output it creates (shown below):

Now, the above program uses a couple of thingswe have not covered yet in any of our tutorials — the foreach loop,and arrays. For now, don't worry about those. The lines of code thatare important in this example are these lines, which allow the programto determine how many Millers and Pikes are in the names array:

if(name.EndsWith("Miller")){
m++;
}

if(name.EndsWith("Pike")){
p++;
}

The integer variables m and ppermit us to track how many Millers and Pikes we come across as wetraverse the entire string array of names. By incrementing one or theother of these values when we encounter the corresponding surname inour array, we end up, after finishing stepping through each member ofthe array, having an accurate count of the number of incidents of eachsurname.

The next String instance method we'll demonstrate is the String.Equals()method, which simply determines if the instance string and anotherstring have the same value. An example program can be found here.I'll not dwell on this particular method, because its usage is fairlyobvious, and I think the example program succinctly demonstrates this.

Now we come to the String.GetEnumerator()method, which is included in order for programming languages thatsupport the IEnumerator interface to iterate through members of acollection. For example, the Microsoft Visual Basic and C# programminglanguages' foreach statement invokes this method to return a CharEnumeratorobject that can provide read-only access to the characters in a givenstring instance. This is not a method you'll need in your day to dayprogramming tasks.

Moving on, we come to the String.IndexOf()method, which reports the index of the first occurrence of a specifiedcharacter or string within the instance. Remembering that the firstposition in a string is position 0, what value do you think i holds below?

string s = "abcde";
int i = s.IndexOf("b");

If you said "i = 1", you are correct! How about character e? Position 4, right!

It is worth noting that this method can beuseful whenever you want to determine if a string contains a particularcharacter or substring. The integer value returned by this method, ifthe specified character or string is not found, is negative one, i.e., -1. This can come in handy in any number of common programming tasks.

Another very handy instance method of the String object is String.Substring()instance method, which returns a substring (i.e., a string that lieswithin the string) from the instance string, by acting upon two integervalues you pass the method as arguments for its parameters. The formthat this method takes is String.Substring(start, length), where start is the position within the string where the substring starts, and length is the number of characters, beginning with the character found at position start, that the substring holds.

Perhaps an example will help. Let's take the word internet. To extract the string net from it, we'd have something like this:

string s = "internet";
string t = s.Substring(5,3);

The String.Insert()method returns a new string with a specified string of charactersinserted into the instance string at the specified position. Forexample, let's say we have a string holding a first name and a lastname, and we want to insert a nickname, in quotation marks, in betweenthe two:

string s = "Josh Reichler";
Console.WriteLine("Example #1:nn" + s);
Console.WriteLine();
Console.WriteLine("after insertion…n");
string t = "Mouser ";
s = s.Insert(5, t);
Console.WriteLine(s);
Console.WriteLine("nExample #2:n");
s = "abcefg";
Console.WriteLine(s + " //missing letter dn");
Console.WriteLine("after insertion…n");
t = "d";
s = s.Insert(3, t);
Console.WriteLine(s);
Console.ReadLine();

The code shown above will produce this output:

The String.LastIndexOf() method is rather intutive, and a brief example should serve to demonstrate it adequately:

This program will produce the following output:

The String.PadLeft()method returns a new string with the characters in this instanceright-aligned by padding on the left with spaces or a specifiedcharacter for a specified total length. In thisprogram, whose output is shown below, I use this method to align thedecimals in multiple numbers, before adding them together:

I think that by now you should be becomingfamiliar with the concept of a string's Indexer, and the many waysthese string methods take advantage of it to give us usefulfunctionality. PadRight is simply the symmetrical analogue of PadLeft,if you understand EndsWith you can certainly comprehend StartsWith, andwe've been using Trim() frequently in our example programs, so youshould be able to understand TrimEnd and TrimStart with ease.

Let's examine String.Split().This is a very useful method that programmers find applicable to manysituations. As an example, let's take a sentence, and use this methodto split it up into its constituent words. This program will produce the following output:

Whereas the String.Split() method splits a string into an array of strings, based upon a specified character delimiter, the String.Join() static method takes a string array, and joins its members together into one string, using a specified character delimeter. This program demonstrates this in action.

Understanding the StringBuilder class

As I mentioned earlier in this tutorial, instances of the StringBuilderclass.as opposed to the String class.are mutable, or dynamicallychangeable. StringBuilder is located in the System.Text namespace. Itdoes not have nearly as many members as the String class.but it doeshave enough to get most jobs done. If you have a situation in which youneed to perform many string operations.for example, within a largeloop.from a performance viewpoint it probably makes sense to useStringBuilder instances instead of String instances.In many ways the StringBuilder behaves like a String. But forstring-processing intensive applications, StringBuilder is the betterchoice because its mutability means not nearly so many instances needto be created.

Thisprogram shows one example of the StringBuilder class in action. I leaveit to you to explore the StringBuilder further, on your own.

Okay, that's enough teaching for this tutorial. Now let's finish up with a programming exercise:

Programming Assignment:create a C# console application that prompts the user repeatedly for acharacter. The user can enter whole words, but the program will pullthe first character from the entry and will concatenate it onto string mystring.Whenever the user enters the word "quit", the program will stopprompting for characters, and will display the string that has beenconcatenated from the individual characters which the user has entered.

Sample output:

To view my source code for this program, click here.

Programming Assignment:create a C# console application that finds the very first occurence ofa vowel in a word entered by the user. The program should only allowthe user to enter three to fifteen characters when prompted for a word.If the user enters a string outside this range, the program shouldobject testily, remind the user of the appropriate range for wordlength, then again prompt for a word. When the user has entered a wordwhose length falls in the acceptable range, the program should locatethe very first occurrence of a vowel in that word, counting left toright, and should tell the user what position (start counting at zero)the character occupies in the word (The very first letter in a word isin position zero, and is the 1st character. The second letter is inposition one, and is the 2nd character, and so on). Continue to promptthe user for words until the user enters the word "quit", which signalsthe program that the user wishes to exit.

Sample output:

To view my source code for this program, click here.

Well, I hope that you've benefited, at least a little, from this tutorial. As ever, I welcome any feedback you may wish to impart. 

It is not possible to shorten it without loosing some of the uniqueness of the GUID, but we can come a long way if we can accept a 16 character string instead.

We can change the standard GUID string representation:

21726045-e8f7-4b09-abd8-4bcc926e9e28

Into a shorter string:

3c4ebc5f5f2c4edc

The following method creates the shorter string and it is actually very unique. An iteration of 10 million didn.t create a duplicate. It uses the uniqueness of a GUID to create the string.

private string GenerateId()
{
 long i = 1;
 foreach (byte b in Guid.NewGuid().ToByteArray())
 {
  i *= ((int)b + 1);
 }
 return string.Format("{0:x}", i - DateTime.Now.Ticks);
}

If you instead want numbers instead of a string, you can do that to but then you need to go up to 19 characters. The following method converts a GUID to an Int64.

private long GenerateId()
{
 byte[] buffer = Guid.NewGuid().ToByteArray();
 return BitConverter.ToInt64(buffer, 0);
}

The standard GUID is still the best way to ensure the uniqueness even though it isn't 100% unique.

It would be very rare to create an entireapplication without using a single string. Strings help make sense ofthe seemingly random jumble of binary data that applications use toaccomplish a task. They appear in all facets of application developmentfrom the smallest system utility to large enterprise services. Theirvalue is so apparent that more and more connected systems are leaningtoward string data within their communication protocols by utilizingthe Extensible Markup Language (XML) rather than the more cumbersometraditional transmission of large binary data. This book uses stringsextensively to examine the internal contents of variables and theresults of program flow using Framework Class Libraries (FCL) methodssuch as Console.WriteLine and MessageBox.Show.

In this chapter, you will learn how to takeadvantage of the rich support for strings within the .NET Framework andthe C# language. Coverage includes ways to manipulate string contents,programmatically inspect strings and their character attributes, andoptimize performance when working with string objects. Furthermore,this chapter uncovers the power of regular expressions and how theyallow you to effectively parse and manipulate string data. Afterreading this chapter, you will be able to use regular expressions in avariety of different situations where their value is apparent.

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 stringkeyword. You can use the assignment operator to initialize the variableusing 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.Stringclass contains several constructors that you can use to initialize thestring value. For instance, to create a new string that is a smallsubset of an existing string, use the overloaded constructor, whichtakes a character array and two integers denoting the beginning indexand 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.Stringclass, and it contains several constructors to initialize the internalstring value. The key internal difference between a regular stringobject and a StringBuilder lies in performance.Whenever a string is manipulated in some manner, a new object has to becreated, which subsequently causes the old object to be marked fordeletion by the garbage collector. For a string that undergoes severaltransformations, the performance hit associated with frequent objectcreation and deletions can be great. The StringBuilder class,on the other hand, maintains an internal buffer, which expands to makeroom for more string data should the need arise, thereby decreasingfrequent 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 manymethods, both instance and static, for manipulating strings. If youwant 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 Comparemethod returns an integer instead of Boolean value denoting how the twostrings 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, thenthe first operand is greater alphabetically than the second operand. Ifthe return value is less than 0, the opposite is true. When a string issaid to be alphabetically greater or lower than another, each characterreading from left to right from both strings is compared using itsequivalent 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 stringclass contains both instance and static methods. Sometimes you have nochoice about whether to use an instance or static method. However, afew of the instance methods contain a static version as well. Becausecalling a static method is a nonvirtual function call, you seeperformance gains if you use this version. An example where you mightsee both instance and static versions appears in Listing 3.1. Thestring comparison uses the static Compare method. You can also do so using the nonstatic CompareTomethod using one of the string instances passed in as parameters. Inmost cases, the performance gain is negligible, but if an applicationneeds to repeatedly call these methods, you might want to considerusing the static over the non-static method.

The string class is immutable. Once a string is created, it cannot be manipulated. Methods within the stringclass that modify the original string instance actually destroy thestring and create a new string object rather than manipulate theoriginal string instance. It can be exp

ensive t
o 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.

3.2. Formatting Strings

Given one or more objects, you want to create a single formatted string representation.

Technique

You can format strings using numeric and picture formatting within String.Format or within any method that uses string-formatting techniques for parameters such as Console.WriteLine.

Comments

The String class as well as a fewother methods within the .NET Framework allow you to format strings topresent them in a more ordered and readable format. Up to this point inthe book, we used basic formatting when calling the Console.WriteLine method. The first parameter to Console.WriteLineis the format specifier string. This string controls how the remainingparameters to the method should appear when displayed. You useplaceholders within the format string to insert the value of avariable. This placeholder uses the syntax {n} where n is the index in the parameter list following the format specifier. Take the following line of code, for instance:

Console.WriteLine( "x={0}, y={1}, {0}+{1}={2}", x, y, x+y );

This line of code has three parametersfollowing the format specifier string. You use placeholders within theformat specification, and when this method is called, the appropriatesubstitutions are made. Although you can do the same thing using stringconcatenation, the resultant line of code is slightly obfuscated:

string s = "x=" + x + ",y=" + y + ", " + x + "+" + y + "=" + (x+y);
Console.WriteLine( s );

You can further refine the format byapplying format attributes on the placeholders themselves. Theseadditional attributes follow the parameter index value and areseparated from that index with a : character. There are twotypes of special formatting available. The first is numeric formatting,which lets you format a numeric parameter into one of nine differentnumeric formats, as shown in Table 3.1. The format of these specifiers,using the currency format as an example, is Cxx where xx is a number from 1 to 99 specifying the number of digits to display. Listing3.2 shows how to display an array of integers in hexadecimal format,including how to specify the number of digits to display. Notice alsohow you can change the case of the hexadecimal numbers A through F byusing an uppercase or lowercase format specifier.

Table 3.1 Numeric Formatting Specifiers

Listing 3.2 Specifying a Different Numeric Format by Adding Format Specifiers on a Parameter Placeholder

using System;

namespace _2_Formatting
{
class Class1
{
[STAThread]
static void Main(string[] args)
{
double[] numArray = {2, 5, 4.5, 45.43, 200000};

// format in lowercase hex
Console.WriteLine( "\n\nHex (lower)\n———–" );
foreach( double num in numArray )
{
Console.Write( "0x{0:x}\t", (int) num );
}

// format in uppercase hex
Console.WriteLine( "\n\nHex (upper)\n———–" );
foreach( double num in numArray )
{
Console.Write( "0x{0:X}\t", (int) num );
}
}
}
}

Another type of formatting is pictureformatting. Picture formatting allows you to create a custom formatspecifier using various symbols within the format specifier string.Table 3.2 lists the available picture format characters. Listing 3.3also shows how to create a custom format specifier. In that code, thedigits of the input number are extracted and displayed using acombination of digit placeholders and a decimal-point specifier.Furthermore, you can see that you are free to add characters not listedin the table. This freedom allows you to add literal charactersintermixed with the digits.

Table 3.2 Picture Formatting Specifiers

>

Listing 3.3 shows how custom formatting can separate a number by its decimal point. Using a foreach loop,each value is printed using three different formats. The first formatwill output the value's integer portion using the following formatstring:

0:$#,#

Next, the decimal portion is written. Ifthe value does not explicitly define a decimal portion, zeroes arewritten instead. The format string to output the decimal value is

$.#0;

Finally, the entire value is displayed up to two decimal places using the following format string:

{0:$#,#.00}

Listing 3.3 Using Picture Format Specifiers to Create Special Formats

using System;

namespace _2_Formatting
{
class Class1
{
[STAThread]
static void Main(string[] args)
{
double[] numArray = {2, 5, 4.5, 45.43, 200000};

// format as custom
Console.WriteLine( "\n\nCustom\n——" );
foreach( double num in numArray )
{
Console.WriteLine( "{0:$#,# + $.#0;} = {0:$#,#.00}", num );
}
}
}
}

3.3. Accessing Individual String Characters

You want to process individual characters within a string.

Technique

Use the index operator ([]) byspecifying the zero-based index of the character within the string thatyou want to extract. Furthermore, you can also use the foreach enumerator on the string using a char structure as the enumeration data type.

Comments

The string class is really acollection of objects. These objects are individual characters. You canaccess each character using the same methods you would use to access anobject in most other collections (which is covered in the next chapter).

You use an indexer to specify which objectin a collection you want to retrieve. In C#, the first object begins atthe 0 index of the string. The objects are individual characters whosedata type is System.Char, which is aliased with the char keyword. The indexer for the stringclass, however, can only access a character and cannot set the value ofa character at that position. Because a string is immutable, you cannotchange the internal array of characters unless you create and return anew string. If you need the ability to index a string to set individualcharacters, use a StringBuilder object.

Listing 3.4 shows how to access thecharacters in a string. One thing to point out is that because thestring also implements the IEnumerable interface, you can use the foreach control structure to enumerate through the string.

Listing 3.4 Accessing Characters Using Indexers and Enumeration

using System;
using System.Text;

namespace _3_Characters
{
class Class1
{
[STAThread]
static void Main(string[] args)
{
string str = "abcdefghijklmnopqrstuvwxyz";

str = ReverseString( str );
Console.WriteLine( str );

str = ReverseStringEnum( str );
Console.WriteLine( str );
}

static string ReverseString( string strIn )
{
StringBuilder sb = new StringBuilder(strIn.Length);

for( int i = 0; i < strIn.Length; ++i )
{
sb.Append( strIn[(strIn.Length-1)-i] );
}
return sb.ToString();
}

static string ReverseStringEnum( string strIn )
{
StringBuilder sb = new StringBuilder( strIn.Length );
foreach( char ch in strIn )
{
sb.Insert( 0, ch );
}

return sb.ToString();
}
}
}

3.4. Analyzing Character Attributes

You want to evaluate the individual characters in a string to determine a character's attributes.

Technique

The System.Char structure containsseveral static functions that let you test individual characters. Youcan test whether a character is a digit, letter, or punctuation symbolor whether the character is lowercase or uppercase.

Comments

One of the hardest issues to handle whenwriting software is making sure users input valid data. You can usemany different methods, such as restricting input to only digits, butultimately, you always need an underlying validating test of the inputdata.

You can use the System.Char structure to perform a variety of text-validation procedures. Listing 3.5 demonstrates validating user input as well as inspecting the characteristics of a character. It begins by displaying a menu and then waiting for user input using the Console.ReadLine method. Once a user enters a command, you make a check using the method ValidateMainMenuInput. This method checks to make sure the first character in the input string is not a digit or punctuation symbol. If the validation passes, the string is passed to a method that inspects each character in the input string. This method simply enumerates through all the characters in the input string and prints descriptive messages based on the characteristics. Some of the System.Char methods for inspection have been inadvertently left out of Listing 3.5. Table 3.3 shows the remaining methods and their functionality. The results of runnin

g the application in Listing 3.5 appear in Figure 3.1.

Listing 3.5 Using the Static Methods in System.Char to Inspect the Details of a Single Character

using System;

namespace _4_CharAttributes
{
class Class1
{
[STAThread]
static void Main(string[] args)
{
char cmd = 'x';

string input;
do
{
DisplayMainMenu();
input = Console.ReadLine();

if( (input == "" ) ||
ValidateMainMenuInput( Char.ToUpper(input[0]) ) == 0 )
{
Console.WriteLine( "Invalid command!" );
}
else
{
cmd = Char.ToUpper(input[0]);

switch( cmd )
{
case 'Q':
{
break;
}

case 'N':
{
Console.Write( "Enter a phrase to inspect: " );
input = Console.ReadLine();
InspectPhrase( input );
break;
}
}
}
} while ( cmd != 'Q' );
}

private static void InspectPhrase( string input )
{
foreach( char ch in input )
{
Console.Write( ch + " – ");

if( Char.IsDigit(ch) )
Console.Write( "IsDigit " );
if( Char.IsLetter(ch) )
{
Console.Write( "IsLetter " );
Console.Write( "(lowercase={0}, uppercase={1})",
Char.ToLower(ch), Char.ToUpper(ch));
}
if( Char.IsPunctuation(ch) )
Console.Write( "IsPunctuation " );
if( Char.IsWhiteSpace(ch) )
Console.Write( "IsWhitespace" );

Console.Write("\n");

}
}
private static int ValidateMainMenuInput( char input )
{
// a simple check to see if input == 'N' or 'Q' is good enough
// the following is for illustrative purposes
if( Char.IsDigit( input ) == true )
return 0;
else if ( Char.IsPunctuation( input ) )
return 0;
else if( Char.IsSymbol( input ))
return 0;
else if( input != 'N' && input != 'Q' )
return 0;

return (int) input;
}

private static void DisplayMainMenu()
{
Console.WriteLine( "\nPhrase Inspector\n——————-" );
Console.WriteLine( "N)ew Phrase" );
Console.WriteLine( "Q)uit\n" );
Console.Write( ">> " );
}
}
}

Table 3.3 System.Char Inspection Methods

Figure 3.1
Use the static method in the System.Char class to inspect character attributes.

The System.Char structure isdesigned to work with a single Unicode character. Because a Unicodecharacter is 2 bytes, the range of a character is from 0 to 0xFFFF. Forportability reasons in future systems, you can always check the size ofa char by using the MaxValue constant declared in the System.Char structure. One thing to keep in mind when working with characters is to avoid the confusion of mixing chartypes with integer types. Characters have an ordinal value, which is aninteger value used as a lookup into a table of symbols. One example ofa table is the ASCII table, which contains 255 characters and includesthe digits 0 through 9, letters, punctuation symbols, and formattingcharacters. The confusion lies in the fact that the number 6, forinstance, has an ordinal char value of 0×36. Therefore, the line of code meant to initialize a character to the number 6

char ch = (char) 6;

is wrong because the actual character inthis instance is ^F, the ACK control character used in modemhandshaking protocols. Displaying this value in the console would notprovide the 6 that you were looking for. You could have chosen twodifferent methods to initialize the variable. The first way is

char ch = (char) 0×36;

which produces the desired result and prints the number 6 to the console if passed to the Console.Write method. However, unless you have the ASCII table memorized, this procedure can be cumbersome. To initialize a char variable, simply place the value between single quotes:

char ch = '6';

3.5. Case-Insensitive String Comparison

You want to perform case-insensitive string comparison on two strings.

Technique

Use the overloaded Compare method in the System.String class which accepts a Boolean value, ignoreCase, as the last parameter. This parameter specifies whether the comparison should be case insensitive (true) or case sensitive (false). To compare single characters, convert them to uppercase or lowercase, using ToUpper or ToLower, and then perform the comparison.

Comments

Validating user input requires a lot offorethought into the possible values a user can enter. Making sure youcover the range of possible values can be a daunting task, and you

might ultimately run into human-computer interaction issues by severelylimiting what a user can enter. Case-sensitivity issues increase thepossible range of values, leading to greater security with respect tosuch things as passwords, but this security is usually at the expenseof a user's frustration when she forgets whether a character iscapitalized. As with many other programming problems, you must weighthe pros and cons.

To perform a case-insensitive comparison, you can use one of the many overloaded Compare methods within the System.Stringclass. The methods that allow you to ignore case issues use a Booleanvalue as the last parameter in the method. This parameter is named ignoreCase, and when you set it to true, you make a case-insensitive comparison, as demonstrated in Listing 3.6.

Listing 3.6 Performing a Case-Insensitive String Comparison

using System;

namespace _5_CaseComparison
{
class Class1
{
[STAThread]
static void Main(string[] args)
{
string str1 = "This Is A String.";
string str2 = "This is a string.";

Console.WriteLine( "Case sensitive comparison of" +
" str1 and str2 = {0}", String.Compare( str1, str2 ));

Console.WriteLine( "Case insensitive comparison of" +
" str1 and str2 = {0}", String.Compare( str1, str2, true ));
}
}
}

3.6. Working with Substrings

You need to change or extract a specific portion of a string.

Technique

To copy a portion of a string into a new string, use the SubString method within the System.String class. You call this method using the string object instance of the source string:

string source = "ABCD1234WXYZ";
string dest = source.Substring( 4, 4 );
Console.WriteLine( "{0}\n", dest );

To copy a substring into an already existing character array, use the CopyTo method. To assign a character array to an existing string object, create a new instance of the string using the new keyword, passing the character array as a parameter to the string constructor as shown in the following code, whose ouput appears in Figure 3.2:

string source = "ABCD";
char [] dest = { '1', '2', '3', '4', '5', '6', '7', '8' };

Console.Write( "Char array before = " );
Console.WriteLine( dest );

// copy substring into char array
source.CopyTo( 0, dest, 4, source.Length );

Console.Write( "Char array after = " );
Console.WriteLine( dest );

// copy back into source string
source = new String( dest );

Console.WriteLine( "New source = {0}\n", source );

Figure 3.2
Use the CopyTo method to copy a substring into an existing character array.

If you need to remove a substring within a string and replace it with a different substring, use the Replace method. This method accepts two parameters, the substring to replace and the string to replace it with:

string replaceStr = "1234";
string dest = "ABCDEFGHWXYZ";

dest = dest.Replace( "EFGH", replaceStr );

Console.WriteLine( dest );

To extract an array of substrings that are separated from each other by one or more delimiters, use the Split method. This method uses a character array of delimiter characters and returns a string array of each substring within the original string as shown in the following code, whose output appears in Figure 3.3. You can optionally supply an integer specifying the maximum number of substrings to split:

char delim = '\';
string filePath = "C:\Windows\Temp";
string [] directories = null;

directories = filePath.Split( delim );

foreach (string directory in directories)
{
Console.WriteLine("{0}", directory);
}

Figure 3.3
You can use the Split method in the System.String class to place delimited substrings into a string array.

Comments

Parsing strings is not for the faint ofheart. However, the job becomes easier if you have a rich set ofmethods that allow you to perform all types of operations on strings.Substrings are the goal of a majority of these operations, and the string class within the .NET Framework contains many methods that are designed to extract or change just a portion of a string.

The Substring methodextracts a portion of a string and places it into a new string object.You have two options with this method. If you pass a single integer,the Substring method extracts the substring thatstarts at that index and continues until it reaches the end of thestring. One thing to keep in mind is that C# array indices are 0 based.The first character within the string will have an index of 0. Thesecond Substring method accepts an additionalparameter that denotes the ending index. It lets you extract parts of astring in the middle of the string.

You can create a new character array from a string by using the ToCharArray method of the string class. Furthermore, you can extract a substring from the string and place it into a character array by using the CopyTo method. The difference between these two methods is that the character array used with the CopyTo method must be an already instantiated array. Whereas the ToCharArray returns a new character array, the CopyTomethod expects an existing character array as a parameter to themethod. Furthermore, although methods exist to extract character arraysfrom a string, there is no instance method available to assign acharacter array to a string. To do this, you must create a new stringobject using the new keyword, as opposed to creatingthe familiar value-type string, and pass the character array as aparameter to the string constructor.

Using the Replace method isa powerful way to alter the contents of a string. This method allowsyou to search all instances of a specified substring within a stringand replace those with a different substring. Additionally, the lengthof the substring you want to replace does not have to be the samelength of the string you are replacing it with. If you recall thenumber of times you have performed a search and replace in anyapplication, you can see the possible advantages of this method.

One other powerful method is Split.By passing a character array consisting of delimiter characters, youcan split a string into a group of substrings and place them into astrin

g array. By passing an additional integer parameter, you can alsocontrol how many substrings to extract from the source string.Referring to the code example earlier demonstrating the Split method, you can split a string representing a directory path into individual directory names by passing the \character as the delimiter. You are not, however, confined to using asingle delimiter. If you pass a character array consisting of severaldelimiters, the Split method extracts substrings based on any of the delimiters that it encounters.

3.7. Using Verbatim String Syntax

You want to represent a path to a file using a string without using escape characters for path separators.

Technique

When assigning a literal string to a string object, preface the string with the @ symbol. It turns off all escape-character processing so there is no need to escape path separators:

string nonVerbatim = "C:\Windows\Temp";
string verbatim = @"C:\Windows\Temp";

Comments

A compiler error that happens so frequently comes from forgetting to escape path separators. Although a common programming faux pasis to include hard-coded path strings, you can overlook that rule whentesting an application. Visual C# .NET added verbatim string syntax asa feature to alleviate the frustration of having to escape all the pathseparators within a file path string, which can be especiallycumbersome for large paths.

3.8. Choosing Between Constant and Mutable Strings

You want to choose the correct string data type to best fit your current application design.

Technique

If you know a string's value will not change often, use a string object,which is a constant value. If you need a mutable string, one that canchange its value without having to allocate a new object, use a StringBuilder.

Comments

Using a regular string objectis best when you know the string will not change or will only changeslightly. This change includes the whole gamut of string operationsthat change the value of the object itself, such as concatenation,insertion, replacement, or removal of characters. The Common LanguageRuntime (CLR) can use certain properties of strings to optimizeperformance. If the CLR can determine that two string objects are thesame, it can share the memory that these string objects occupy. Thesestrings are then known as interned strings. The CLR contains anintern pool, which is a lookup table of string instances. Strings areautomatically interned if they are assigned to a literal string withincode. However, you can also manually place a string within the internpool by using the Intern method. To test whether a string is interned, use the IsInterned method, as shown in Listing 3.7.

Listing 3.7 Interning a String by Using the Intern Method

using System;

namespace _7_StringBuilder
{
/// <summary>
/// Summary description for Class1.
/// </summary>
class Class1
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main(string[] args)
{
string sLiteral = "Automatically Interned";
string sNotInterned = "Not " + sLiteral;

TestInterned( sLiteral );
TestInterned( sNotInterned );

String.Intern( sNotInterned );
TestInterned( sNotInterned );
}

static void TestInterned( string str )
{
if( String.IsInterned( str ) != null )
{
Console.WriteLine( "The string \"{0}\" is interned.", str );
}
else
{
Console.WriteLine( "The string \"{0}\" is not interned.", str );
}
}
}
}

A StringBuilder behaves similarlyto a regular string object and also contains similar method calls.However, there are no static methods because the StringBuilder class is designed to work on string instances. Method calls on an instance of a StringBuilder object change the internal string of that object, as shown in Listing 3.8. A StringBuildermaintains its mutable appearance by creating a buffer that is largeenough to contain a string value and additional memory should thestring need to grow.

Listing 3.8 Manipulating an Internal String Buffer Instead of Returning New String Objects

using System;
using System.Text;

namespace _7_StringBuilder
{
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();

BuildStrings( string1, string2 );
}

public static void BuildStrings( string str1, string str2 )
{
StringBuilder sb = new StringBuilder( str1 + str2 );
sb.Insert( str1.Length, " is the first string.\n" );
sb.Insert( sb.Length, " is the second string.\n" );

Console.WriteLine( sb );
}
}
}

3.9. Optimizing StringBuilder Performance

Knowing that a StringBuilder object can suffer more of a performance hit than a regular string object, you want to optimize the StringBuilder object to minimize performance issues.

Technique

Use the EnsureCapacity method in the StringBuilder class. Set this integral value to a value that signifies the length of the longest string you may store in this buffer.

Comments

The StringBuilder classcontains methods that allow you to expand the memory of the internalbuffer based on the size of the string you may store. As your stringcontinually grows, the StringBuilder won't have torepeatedly allocate new memory for the internal buffer. In other words,if you attempt to place a larger length string than what the internalbuffer of the StringBuilder class can accept, then the classwill have to allocate additional memory to accept the new data. If youcontinuously add strings that increase in size from the last inputstring, the StringBuilder class will have to allocate a new buffer size, which it does internally by calling the GetStringForStringBuilder method defined in the System.String class. This method ultimately calls the unmanaged method FastAllocateStrin

g. By giving the StringBuilder class a hint using the EnsureCapacity method, you can help alleviate some of this continual memory reallocation, thereby optimizing the StringBuilder performance by reducing the amount of memory allocations needed to store a string value.

3.10. Understanding Basic Regular Expression Syntax

You want to create a regular expression.

Technique

Regular expressions consist of a series ofcharacters and quantifiers on those characters. The charactersthemselves can be literal or can be denoted by using character classes,such as \d, which denotes a digit character class, or \S, which denotes any nonwhitespace character.

Table 3.4 Regular Expression Single Character Classes

Inaddition to the single character classes, you can also specify a rangeor set of characters using ranged and set character classes. Thisability allows you to narrow the search for a specified character bylimiting characters within a specified range or within a defined set.

Table 3.5 Ranged and Set Character Classes

Quantifierswork on character classes to expand the number of characters thecharacter classes should match. You need to specify, for instance, awildcard character on a character class, which means 0 or morecharacters within that class. Additionally, you can also specify a setnumber of matches of a class that should occur by using an integerwithin braces following the character class designation.

Table 3.6 Character Class Quantifiers

Youcan also specify where a certain regular expression should start withina string. Positional assertions allow you to, for instance, match acertain expression as long as it occurs at the beginning or ending of astring. Furthermore, you can create a regular expression that operateson a set of words within a string by using a positional assertion thatcontinues matching on each subsequent word separated by anynonalphanumeric character.

Table 3.7 Positional (Atomic Zero-Width) Assertions

Comments

Regular expressions use a variety ofcharacters both symbolic and literal to designate how a particularstring of text should be parsed. The act of parsing a string is knownas matching, and when applied to a regular expression, the match willbe either true or false. In other words, when you use a regularexpression to match a series of characters, the match will eithersucceed or fail. As you can see, this process has powerfulapplicability in the area of input validation.

You build regular expressions using aseries of character classes and quantifiers on those character classesas well as a few miscellaneous regular-expression constructs. You usecharacter classes to match a single character based either on what typeof character it is, such as a digit or letter, or whether it belongswithin a specified range or set of characters (as shown in Table 3.4).Using this information, you can create a series of character classes tomatch a certain string of text. For instance, if you want to specify
aphone number using character classes, you can use the following regularexpression:

\(\d\d\d\)\s\d\d\d-\d\d\d\d

This expression begins by first escapingthe left parenthesis. You must escape it because parentheses are usedfor grouping expressions. Next you can see three digits representing aphone number's area code followed by the closing parenthesis. You use a\s to denote a whitespace character. The remainder of the regular expression contains the remaining digits of the phone number.

In addition to the single characterclasses, you can also use ranged and set character classes. They giveyou fine-grain control on exactly the type of characters the regularexpression should match. For instance, if you want to match anycharacter as long as it is a vowel, use the following expression:

[aeiou]

This line means that a character shouldmatch one of the literal characters within that set of characters. Aneven more specialized form of single character classes are Unicodecharacter categories. Unicode categories are similar to some of thecharacter-attribute inspection methods shown earlier in this chapter.For instance, you can use Unicode categories to match on uppercase orlowercase characters. Other categories include punctuation characters,currency symbols, and math symbols, to name a few. You can easily findthe full list of Unicode categories in MSDN under the topic "UnicodeCategories Enumeration."

You can optimize the phone-number expression, although it's completely valid, by using quantifiers.Quantifiers specify additional information about the character,character class, or expression to which it applies. Some quantifiersinclude wildcards such as *, which means 0 or more occurrences, and ?,which means only 0 or 1 occurrences of a pattern. You can also usebraces containing an integer to specify how many characters within agiven character class to match. Using this quantifier in thephone-number expression, you can specify that the phone number shouldcontain three digits for the area code followed by three digits andfour digits separated by a dash:

\(\d{3}\)\s\d{3}-\d{4}

Because the regular expression itself isn'tthat complicated, you can still see that using quantifiers can simplifyregular-expression creation. In addition to character classes andquantifiers, you can also use positional information within a regularexpression. For instance, you can specify that given an input string,the regular expression should operate at the beginning of the string.You express it using the ^ character. Likewise, you can also denote the end of a string using the $symbol. Take note that this doesn't mean start at the end of the stringand attempt to make a match because that obviously seemscounterintuitive; no characters exist at the end of the string. Rather,by placing the $ character following the rest of the regularexpression, it means to match the string with the regular expression aslong as the match occurs at the end of the string. For instance, if youwant to match a sentence in which a phone number is the last portion ofthe sentence, you could use the following:

\(\d{3}\)\s\d{3}-\d{4}$
My phone number is (555) 555-5555 = Match
(555) 555-5555 is my phone number = Not a match

3.11. Validating User Input with Regular Expressions

You want to ensure valid user input by using regular expressions to test for validity.

Technique

Create a RegEx object, which exists within the System.Text.RegularExpressions namespace, passing the regular expression in as a parameter to the constructor. Next, call the member method Match using the string you want to validate as a parameter to the method. The method returns a Match object regardless of the outcome. To test whether a match is made, evaluate the Boolean Success property on that Match objectas demonstrated in Listing 3.9. It should also be noted that in manycases, the forward slash (\) character is used when working withregular expressions. To avoid compilation errors from inadvertentlyspecifying an invalid control character, use the @ symbol to turn off escape processing.

Listing 3.9 Validating User Input of a Phone Number Using a Regular Expression

using System;
using System.Text.RegularExpressions;

namespace _11_RegularExpressions
{
class Class1
{
[STAThread]
static void Main(string[] args)
{
Regex phoneExp = new Regex( @"^\(\d{3}\)\s\d{3}-\d{4}$" );
string input;

Console.Write( "Enter a phone number: " );
input = Console.ReadLine();

while( phoneExp.Match( input ).Success == false )
{
Console.WriteLine( "Invalid input. Try again." );
Console.Write( "Enter a phone number: " );
input = Console.ReadLine();
}

Console.WriteLine( "Validated!" );
}
}
}

Comments

Earlier in this chapter I mentioned that you could perform data validation using the static methods within the System.Char class.You can inspect each character within the input string to ensure itmatches exactly what you are looking for. However, this method of inputvalidation can be extremely cumbersome if you have different inputtypes to validate because it requires custom code for each validation.In other words, using the methods in the System.Char class is not recommended for anything but the simplest of data-validation procedures.

Regular expressions, on the other hand,allow you to perform the most advanced input validation possible, allwithin a single expression. You are in effect passing the parsing ofthe input string to the regular-expression engine and offloading allthe work that you would normally do.

In Listing 3.9, you can see how you createand use a regular expression to test the validity of a phone numberentered by a user. The regular expression is similar to the previousexpressions used earlier for phone numbers except for the addition ofpositional markers. The regular expression is valid if a user enters aphone number and nothing else. A match is successful when the Success property within the Match object, which is returned from the Regex.Match method, is true.The only caveat to using regular expressions for input validation isthat even though you know the validation failed, you are unable toquery the Regex or Match class to see what part of the string failed.

3.12. Replacing Substrings Using Regular Expressions

You want to replace all substrings thatmatch a regular expression with a different substring that also usesregular-expression syntax.

Technique

Create a Regex object, passing the regular expression used to match characters in the input string to the Regex constructor. Next,

call the Regex method Replace, passing the input string to process and the string to replace each match within the input string. You can also use the static Replace method, passing the regular expression as the first parameter to the method as shown in the last line of Listing 3.10.

Listing 3.10 Using Regular Expressions to Replace Numbers in a Credit Card with xs

using System;
using System.Text.RegularExpressions;

namespace _12_RegExpReplace
{
class Class1
{
[STAThread]
static void Main(string[] args)
{
Regex cardExp = new Regex( @"(\d{4})-(\d{4})-(\d{4})-(\d{4})" );
string safeOutputExp = "$1-xxxx-xxxx-$4";
string cardNum;

Console.Write( "Please enter your credit card number: " );
cardNum = Console.ReadLine();

while( cardExp.Match( cardNum ).Success == false )
{
Console.WriteLine( "Invalid card number. Try again." );
Console.Write( "Please enter your credit card number: " );

cardNum = Console.ReadLine();
}

Console.WriteLine( "Secure Output Result = {0}",
cardExp.Replace( cardNum, safeOutputExp ));
}
}
}

Comments

Although input validation is an extremelyuseful feature of regular expressions, they also work well as textparsers. The previous recipe used regular expressions to verify that aparticular string matched a regular expression exactly. However, youcan also use regular expressions to match substrings within a stringand return each of those substrings as a group. Furthermore, you canuse a separate regular expression that acts on the result of theregular-expression evaluation to replace substrings within the originalinput string.

Listing 3.10 creates a regular expressionthat matches the format for a credit card. In that regular expression,you can see that it will match on four different groups of four digitsapiece separated by a dash. However, you might also notice that eachone of these groups is surrounded with parentheses. In an earlierrecipe, I mentioned that to use a literal parenthesis, you must escapeit using a backslash because of the conflict with regular-expressiongrouping symbols. In this case, you want to use the grouping feature ofregular expressions. When you place a portion of a regular expressionwithin parentheses, you are creating a numbered group. Groups arenumbered starting with 1 and are incremented for each subsequent group.In this case, there are four numbered groups. These groups are used bythe replacement string, which is contained in the string safeOutputExp. To reference a numbered group, use the $symbol followed by the number of the group to reference. This sequencerepresents all characters within the input string that match the groupexpression within the regular expression. Therefore, in the replacementstring, you can see that it prints the characters within the firstgroup, replaces the characters in the second and third groups with xs,and finally prints the characters in the fourth group.

One thing to note is that you can use the RegEx class to view the groups themselves. If you change the regular expression to "\d{4}", you can then use the Matches method to enumerate all the groups using the foreach keyword,as shown in Listing 3.11. In the listing, the program first checks tomake sure at least four matches were made. This number corresponds tofour groups of four digits. Next, it uses a foreach enumeration on each Match object that is returned from the Matches method. If the match is in the second or third group, the values are replaced with xs; otherwise, the Match object's value, the characters within that group, are concatenated to the result string.

Listing 3.11 Enumerating Through the Match Collection to Perform Special Operations on Each Match in a Regular Expression

static void TestManualGrouping()
{
Regex cardExp = new Regex( @"\d{4}" );
string cardNum;
string safeOutputExp = "";

Console.Write( "Please enter your credit card number: " );
cardNum = Console.ReadLine();

if( cardExp.Matches( cardNum ).Count < 4 )
{
Console.WriteLine( "Invalid card number" );
return;
}

foreach( Match field in cardExp.Matches( cardNum ))
{
if( field.Success == false )
{
Console.WriteLine( "Invalid card number" );
return;
}

if( field.Index == 5 || field.Index == 10 )
{
safeOutputExp += "-xxxx-";
}
else
{
safeOutputExp += field.Value;
}
}

Console.WriteLine( "Secure Output Result = {0}", safeOutputExp );
}

3.13. Building a Regular Expression Library

You want to create a library of regular expressions that you can reuse in other projects.

Technique

Use the CompileToAssembly static method within the Regex class to compile a regular expression into an assembly. This method uses an array of RegexCompilationInfo objects that contain any number of regular expressions you want to add to the assembly.

The RegexCompilationInfo classcontains a constructor with five fields that you must fill out. Theparameters denote the string for the regular expression; any optionsfor the regular expression, which appear in the RegexOptionsenumerated type; a name for the class that is created to hold theregular expression; a corresponding namespace; and a Boolean valuespecifying whether the created class should have a public accessmodifier.

After creating the RegexCompilationInfo object, create an AssemblyName object, making sure to reference the System.Reflection namespace, and set the Name property to a name you want the resultant assembly filename to be. Because the CompileToAssembly creates a DLL, exclude the DLL extension on the assembly name. Finally, place all the RegexCompilationInfo objects within an array, as shown in Listing 3.12, and call the CompileToAssembly method. Listing 3.12 demonstrates how to create a RegexCompilationInfo object and how to use that object to compile a regular expression into an assembly using the CompileToAssembly method.

Listing 3.12 Using the CompileToAssembly Regex Method to Save Regular Expressions in a New Assembly for Later Reuse

using System;
using System.Text.RegularExpressions;
using System.Reflection;

namespace _12_RegExpReplace
{
class Class1
{
[STAThread]
static void Main(string[] args)
{
CompileRegex(@"(\d{4})-(\d{4})-(\d{4})-(\d{4})", @"regexlib" );
}

static void CompileRegex( string exp, string assemblyName )
{
RegexCompilationInfo compInfo =
new RegexCompilationInfo( exp, 0, "CreditCardExp", "", true );
AssemblyName assembly = new AssemblyName();
ass

embly.Name = assemblyName;

RegexCompilationInfo[] rciArray = { compInfo };

Regex.CompileToAssembly( rciArray, assembly );
}
}
}

Comments

If you use regular expressions regularly,then you might find it advantageous to create a reusable library of theexpressions you tend to use the most. The Regex class contains a method named CompileToAssembly that allows you to compile several regular expressions into an assembly that you can then reference within other projects.

Internally, you will find a class for eachregular expression you added, all contained within its correspondingnamespace, as specified in the RegexCompilationInfo object when you created it. Furthermore, each of these classes inherits from the Regex class so all the Regex methodsare available for you to use. As you can see, creating a library ofcommonly used regular expressions allows you to reuse and share theseexpressions in a multitude of different projects. A change in a regularexpression simply involves changing one assembly instead of eachproject that hard-coded the regular expression.

© Copyright Pearson Education. All rights reserved.

The main purpose of this article is to exploresome common and uncommon issues regarding DotNet and C#. Among suchcommon things my first article is on string data type which isreference type but some developers don?t understand it?s behavior whencompare with others reference type.

Problem

Changing the value of an alias reflect the change in the actual class object and vice versa.

Explanation

Reference Type

Let assume that we have a class called MyType.There is another class called AppType. MyType has a property calledName. AppType is simply used to run the application by providing Mainmethod.

Here, is the code

//Program#1

using System;
using System.Console;
class MyType
{
private string name;
private string Name
{ set
{
name=value;
}
get
{
return name;
}
}
}

class AppType
{
public static void Main()
{
MyType obj1,obj2;
Console.WriteLine("*****Learning reference philosophy*****");
obj2=new MyType();
obj2.Name="Sadiq";
obj1=obj2;
Console.WriteLine("values of obj1={0} and obj2={1}",obj1.Name,obj2.Name);
obj1.Name="Ahmed";
Console.WriteLine("values of obj1={0} and obj2={1}",obj1.Name,obj2.Name);
}
}

when you compile the code, you?ll get the following output

*****Learning reference philosophy*****

values of obj1=Sadiq and obj2=Sadiq

values of obj1=Ahmed and obj2=Ahmed

It means that object obj1 is nothing exceptthe alias of obj2.In other words, both obj1 and obj2 are pointing tothe same memory.

Value Type

Let assume that we have a structure calledMyType. There is another structure called AppType. MyType has aproperty called Name. AppType is simply used to run the application byproviding Main method.

Here, is the code

//Program#2
using System;
using System.Console;
class MyType
{
private string name;
private string Name
{ set
{
name=value;
}
get
{
return name;
}
}
}

class AppType
{
public static void Main()
{
MyType obj1,obj2;
Console.WriteLine("*****Learning reference philosophy*****");
obj2=new MyType();
obj2.Name="Sadiq";
obj1=obj2;
Console.WriteLine("values of obj1={0} and obj2={1}",obj1.Name,obj2.Name);
obj1.Name="Ahmed";
Console.WriteLine("values of obj1={0} and obj2={1}",obj1.Name,obj2.Name);
}
}

when you compile the code, you?ll get the following output

*****Learning reference philosophy*****

values of obj1=Sadiq and obj2=Sadiq

values of obj1=Ahmed and obj2=Sadiq

It means that object obj1 and obj2 both aredifferent .In other words, both obj1 and obj2 are distinct and pointingto the different memory.

Reference or Value type

Now, consider String type instead of user defined data type. The above code will become,

//Program#3
class AppType
{
public static void Main()
{
String obj1,obj2;
Console.WriteLine("*****Learning reference philosophy*****");
//No need of it
//obj2=new MyType();
obj2="Sadiq";
obj1=obj2;
Console. WriteLine("values of obj1={0} and obj2={1}",obj1,obj2);
obj1="Ahmed";
Console.WriteLine("values of obj1={0} and obj2={1}",obj1,obj2);
}
}

when you compile the code, you?ll get the following output

*****Learning reference philosophy*****

values of obj1=Sadiq and obj2=Sadiq

values of obj1=Ahmed and obj2=Sadiq

It means that object obj1 is not an alias of obj2.In other words, both obj1 and obj2 are pointing to the different memory.

Strange!

Now, we all know that String type objectdynamically grow. It implies that it must allocate its memory on theHeap. Since, reference type allocates the memory on Heap, therefore, itshould be reference type.

If it is reference type than why it behaves as value type.

Reason

The fact lies in these following two lines,
string obj1;

obj1 = ?value forces to allocate a memory?;

The first line is nothing except thedeclaration of an object while second line actually creates the object.It means that you can conceptually relate second line to

obj=new string();.

Summary

Therefore, whenever the value of a string object initialized or assigned it creates an object in memory.

Now, we It means that object obj1 is not analias of obj2.In other words, both obj1 and obj2 are pointing to thedifferent memory.

In this article U will show you couple of tricks that will make the transitition to C# from C/C++ easier.

Let's start with a simple C++ code to reverse a string:

int Reverse(char* str)
{

if (NULL==str)return -1; //no string
int l=strlen(str)-1; //get the string length
if (1==l)return 1;

for(int x=0;x < l;x++,l–)
{
str[x]^=str[l]; //triple XOR Trick
str[l]^=str[x]; //for not using a temp
str[x]^=str[l];
}

return 0;

}

That is easy right? We want to accomplish the same without any recursion needed.

Here is how it is done using recursion in c#:

public static string Reverse(string str)
{
/*termination condition*/
if(1==str.Length)
{
return str;
}
else
{
return Reverse( str.Substring(1) ) + str.Substring(0,1);
}
}

While the C# recursion version looks smart andeasy enough, it's hard for some of us to keep track of what is going oninside, and you know what .. it might just look a lot smarter to usethe old pointer-like string manipulations.

This C# version of the same reverse functionuses the string.Substring method for getting a char[] array of thestring representation, after playing with the char array (we couldsearch it, cut/inside, and normally everything we did in C++ chararrays) we will convert it to a C# string back to the user:

private string Rev(string str)
{
char[] c = str.ToCharArray (); /*convert to chararray*/
int l = str.Length -1;

if (1==l)return str; //no need to reverse.

for (int j=0;j < l;j++,l–)
{
c[j]^=c[l]; /*triple xor will */
c[l]^=c[j]; /*replace c[j] with c[i]*/
c[j]^=c[l]; /*without a temp var*/
}

string s=new string(c); /*convert back to string*/
return s;
}

You can see here, that after converting thestring to a char array, basically we are doing much of the C++ codingstyles we used to. We are promised by .NET that the string x that isprovided will not be NULL, and so we are guaranteed to not fall forthat here.

Let's have one more.

There is an old interview question in C++ thatgoes like: "implement the atoi STL function (the function that gets achar* that represent (or not) a number and returns an integer".

In C++ the code might look like:

int atoi(char* str)
{
int sign=1;
int x=0; //counter
if (NULL==str)return 0; //might confuse

if ('-'==str[0]){sign=-1; x=1;}

int TheNumber=0;
int tmp;

int l=strlen(str)-1;

for(;x <= l;x++)
{
if ((str[x]>='0')&&(str[x]<='9'))
{
tmp=(str[x]-'0');//0 is the 0 index
TheNumber=TheNumber*10+tmp; //to enlarge the number by *10 every time
}
}

TheNumber*=sign;

return TheNumber;
}

In this example, the string "12mn4" willproduce 124 as a result, meaning – coming across a non-number char willnot break the loop.

To look really bad, the same code could be writen in C# like this:

public static int atoi(string str)
{
return int.Parse(str);
}

To look smarter in a C# interview, you might wanna consider writing it like so:

public static int atoi(string str)
{
int sign=1;
int TheNumber=0;
int tmp=0;
int x=0;
int l=(str.Length)-1;
char[] c=str.ToCharArray();

if ('-'==c[0]){sign=-1; x=1;}

for(;x < l;x++)
{
if ((c[x]>='0')&&(c[x]<='9'))
{
tmp=(c[x]-'0');//0 is the 0 index
TheNumber=TheNumber*10+tmp; //to enlarge the number by *10 every time
}
}

return TheNumber*sign;

}

Pretty much the same ha?

Conclusion:
If you like C++ and find the string jargon annoying while moving to C#, use ToCharArray.

How to build XML string with only changed rows/columns edit on user form?

Formerly I've been working on three-tier applications on J2EE platform. All aplication logic was written in EJB and all the data was send as XML string from PowerBuilder clients. I was thinking how to implement such kind of solution in .NET through ADO.NET. The most simple way is to send data as DataSet object which also includes XMLrepresetation of containing data objects (datatables, datacolumns, etc.). But sending the whole dataset has too much overhead. We only want to send changed/modified data to middle-tier .NET component. How to do this in aefficient manner?

The basic idea is to send only changed rows/columns of DataTable object. The method below takes two parameters:- DataTable table: only changed rows from input form/datagrid
- string keyColName: name of key column of table

We use three different statuses for row tag:
- "INSERT": new added row
- "UPDATE": updated row
- "DELETE": deleted row

/// <summary>
/// Returns XML string of changed DataTable rows
/// </summary>
public string GetXML(DataTable table, string keyColName) {
DataView ldvOriginal = new DataView(table);
DataView ldvChanged = new DataView(table);
DataView ldvAdded = new DataView(table);
DataView ldvDeleted = new DataView(table);
ldvOriginal.RowStateFilter = DataViewRowState.ModifiedOriginal;
ldvChanged.RowStateFilter = DataViewRowState.ModifiedCurrent;
ldvAdded.RowStateFilter = DataViewRowState.Added;
ldvDeleted.RowStateFilter = DataViewRowState.Deleted;

string lsXml = "<?xml version=\"1.0\"?>\n";
string lsStatusInsert = "<row status=\"INSERT\">\n";
string lsStatusUpdate = "<row status=\"UPDATE\">\n";
string lsStatusDelete = "<row status=\"DELETE\">\n";
int noAdded = ldvAdded.Count;
int noChanged = ldvChanged.Count;
int noDeleted = ldvDeleted.Count;

try {
// added rows
lsXml += "<" + table.TableName + ">\n";
for (int i=0; i < noAdded; i++) {
lsXml += lsStatusInsert;
foreach (DataColumn dc in ldvAdded.Table.Columns) {
if (ldvAdded[i][dc.ColumnName].ToString().Length > 0)
lsXml += "<" + dc.ColumnName + ">" +
ldvAdded[i][dc.ColumnName] +
"<" + dc.ColumnName + ">\n";
} // foreach column
lsXml += "</row>\n";
} // for
// modified rows
for (int i=0; i < noChanged; i++) {
lsXml += lsStatusUpdate;
foreach (DataColumn dc in ldvChanged.Table.Columns) {
if (keyColName.Equals(dc.ColumnName))
lsXml += "<" + dc.ColumnName + ">" +
ldvChanged[i][dc.ColumnName] +
"<" + dc.ColumnName + ">\n";
else
if (!ldvOriginal[i][dc.ColumnName].ToString().Equals(ldvChanged[i][dc.ColumnName].ToString()))
lsXml += "<" + dc.ColumnName + ">" +
ldvChanged[i][dc.ColumnName] +
"<" + dc.ColumnName + ">\n";
} // foreach column
lsXml += "</row>\n";
} // for
// deleted rows
for (int i=0; i < noDeleted; i++) {
lsXml += lsStatusDelete;
lsXml += "<" + keyColName + ">" + ldvDeleted[i][keyColName] + "<" + keyColName + ">\n";
lsXml += "</row>\n";
} // for
lsXml += "<" + table.TableName + ">\n";

} catch (Exception ex) {
throw ex;
}
return lsXml;
}

…

Example:

DataTable dt = new DataTable("DemoTable");
// we fill this table through DataAdapter Fill() method
// and we edit data in user control such as DataGrid, form,..
..

if (dt.GetChanges()!=null) {
string xml = this.GetXML(dt.GetChanges(), "customer_id");
// pass xml to middle-tier..

}

Method returns XML string which can be passed to middle tier. Here we parse it and do all necessary bussiness logic due to row status. We do not need XSD because we can get metadata in the middle tier component directly from database table.

preamble

this simple function converts a string to a byte[] that is in compliant with the visual c++ 6.0 BSTR/WCHAR.

why might you want to use it?

well for a start, for data compatability with those all programs you laboured over.

Another reason I use it is for eventlogging.

The EventLog class has an overloaded member function (WriteEntry) that allows you to end a byte array as the data for an event:public void WriteEntry(string message, EventLogEntryType type, int eventID, short category, byte[] rawData);

The value you pass as rawData appears in the Data pane when you view the Event\;s properties in the system\;s Event Viewer, thus:

figure 1 the data pane in the event properties

As you can see, the data pane provide an invaluable way of providing extra debugging information.

function declaration

protected internal void StringToByteArray(string theString, ref byte[] data, int offset) 
{
    int realI = 0;
    for(int i = 0; i < theString.Length; ++i)
    {
        realI = (i*2) + offset;
        data[realI] = (byte)(theString[i] & 0xFF);
        data[realI + 1] = (byte)((theString[i] & 0xFF00) >> 16);
    }
}

notes

the first thing to note is that no error checking occurs and that it\;s therefore very probable that exceptions will be thrown if the byte[] isn\;t big enough.

the offset parameter allows you to specify an offset, in bytes, from the start of the data array, to start copying into. It is important to realise that this is in bytes, as each element of a string is two bytes long.

example

string firstName = "Bill";
string surname = "Gates";

//for compatability with vc++6, remember to pad each string with two zero bytes at the end.
//also, as we\;re putting a space in the middle of the string, we need to add an extra two bytes.
byte[] bData = new byte[(firstName.Length + surname.Length) * 2 + 4] ;

StringToByteArray(firstName + " ", ref bData, 0); //copies firstName into the bData array

StringToByteArray(surname, ref bData,  (firstName.Length * 2) + 2);
//remember, each element in a string is two bytes long, and the space we added abve will count as an extra 2 bytes.

The "toupper" and "tolower" methods, in thefollowing class, are both similar except for the one line conversion ofthe 'int' type data member ucode, which represents the ASCII value ofthe character read from the string or keyboard, to lowercase oruppercase. After determining the length of the string passed to it,both the methods scan each character in the string into a 'char' typedata member and then convert the character to the opposite case afterevaluating the case in an if…else block. Quite simple ! And thissimplicity is because of the indexer of the class provided by C#, whichallows for each character in the string to be scanned as if from anarray of strings ! Both methods return objects and receive objectshence are defined of type object.

The following is the class which converts characters in a string into uppercase or lowercase

using system;

class convertstr
{
private string s1; // The string type data member which is used to return the
// converted string
private int ucode; // The int type data member which is used to
public string toupper(string s2) // The toupper method returning a string object
{
public int strlen=s2.Length; // Determines the string length for the 'for' loop
for (int i=0;i < strlen;i++) // Reads each character in string via the indexer
{
char ch=s2[i];
if (ch > ='a' && ch < ='z') // Determines if the character is an alphabet and in {
// lower case
ucode=(int)ch;
ucode=ucode-32;
s1[i]=(char)ucode;
}
else // else retains the same case into the string object of {
// the class
s1[i]=ch;
}
}
return s1; // Method returns converted string
}
public string tolower(string s4) // The tolower method returning a string object
{
public int strlen=s4.Length;
for (int i=0;i < strlen;i++) // Reads each character in string via the indexer
{
char ch=s4[i];
if (ch > ='A' && ch < ='Z') // Determines if the character is an alphabet and in
{ // upper case
ucode=(int)ch;
ucode=ucode+32;
s1[i]=(char)ucode;
}
else // else retains the same case into the string object of
{ // the class
s1[i]=ch;
}
return s1; // Method returns converted string
}
}

This program explores the 'String' class, with this you will be able to create the string using the constructors and explore all the methods in this class.

Download stringclass.cs