Numerous operations treat a string as a single object — for example, the Compare() method. Compare(), with the following properties, compares two strings as though they were numbers:

The algorithm works as follows when written in notational C# (that is, C# without all the details, also known as pseudocode):

compare(string s1, string s2)
{
  // Loop through each character of the strings until
  // a character in one string is greater than the
  // corresponding character in the other string.
  foreach character in the shorter string
    if (s1's character > s2's character when treated as a number)
      return 1
    if (s2's character < s1's character)
      return −1
  // Okay, every letter matches, but if the string s1 is longer,
  // then it's greater.
  if s1 has more characters left
    return 1
  // If s2 is longer, it's greater.
  if s2 has more characters left
    return −1
  // If every character matches and the two strings are the same
  // length, then they are "equal."
  return 0
}

Thus, "abcd" is greater than "abbd", and "abcde" is greater than "abcd". More often than not, you don't care whether one string is greater than the other, but only whether the two strings are equal.

The Compare() operation returns 0 when two strings are identical. The following test program uses the equality feature of Compare() to perform a certain operation when the program encounters a particular string or strings.

BuildASentence prompts the user to enter lines of text. Each line is concatenated to the previous line to build a single sentence. This program exits if the user enters the word EXIT, exit, QUIT, or quit:

// BuildASentence -- The following program constructs sentences
//   by concatenating user input until the user enters one of the
//   termination characters. This program shows when you need to look for
//   string equality.
using System;
namespace BuildASentence
{
  public class Program
  {
    public static void Main(string[] args)
    {
      Console.WriteLine("Each line you enter will be "
                      + "added to a sentence until you "
                      + "enter EXIT or QUIT");
      // Ask the user for input; continue concatenating
      // the phrases input until the user enters exit or
      // quit (start with an empty sentence).
      string sentence = "";
      for (; ; )
      {

// Get the next line.
        Console.WriteLine("Enter a string ");
        string line = Console.ReadLine();
        // Exit the loop if line is a terminator.
        string[] terms = { "EXIT", "exit", "QUIT", "quit" };
        // Compare the string entered to each of the
        // legal exit commands.
        bool quitting = false;
        foreach (string term in terms)
        {
          // Break out of the for loop if you have a match.
          if (String.Compare(line, term) == 0)
          {
            quitting = true;
          }
        }
        if (quitting == true)
        {
          break;
        }
        // Otherwise, add it to the sentence.
        sentence = String.Concat(sentence, line);
        // Let the user know how she's doing.
        Console.WriteLine("
you've entered: " + sentence);
      }
      Console.WriteLine("
total sentence:
" + sentence);
      // Wait for user to acknowledge the results.
      Console.WriteLine("Press Enter to terminate...");
      Console.Read();
    }
  }
}

After prompting the user for what the program expects, the program creates an empty initial sentence string called sentence. From there, the program enters an infinite loop.

BuildASentence prompts the user to enter a line of text, which the program reads using the ReadLine() method. Having read the line, the program checks to see whether it is a terminator using the boldfaced lines in the preceding example.

The termination section of the program defines an array of strings called terms and a bool variable quitting, initialized to false. Each member of the terms array is one of the strings you're looking for. Any of these strings causes the program to quit faster than a programmer forced to write COBOL.

The termination section loops through each of the strings in the array of target strings. If Compare() reports a match to any of the terminator phrases, quitting is set to true. If quitting remains false after the termination section and line is not one of the terminator strings, it is concatenated to the end of the sentence using the String.Concat() method. The program outputs the immediate result just so the user can see what's going on.

Here's a sample run of the BuildASentence program:

Each line you enter will be added to a
sentence until you enter EXIT or QUIT
Enter a string
Programming with

You've entered: Programming with
Enter a string
 C# is fun

You've entered: Programming with C# is fun
Enter a string
 (more or less)

You've entered: Programming with C# is fun (more or less)
Enter a string
EXIT

Total sentence:
Programming with C# is fun (more or less)
Press Enter to terminate...

I've flagged my input in bold to make the output easier to read.

The Compare() method used in the previous example considers "EXIT" and "exit" to be different strings. However, the Compare() method has a second version that includes a third argument. This argument indicates whether the comparison should ignore the letter case. A true indicates "ignore."

The following version of the lengthy termination section in the BuildASentence example sets quitting to true whether the string passed is uppercase, lowercase, or a combination of the two:

// Indicate true if passed either exit or quit,
  // irrespective of case.
  if (String.Compare("exit", source, true) == 0) ||
         (String.Compare("quit", source, true) == 0)
  {
    quitting = true;
  }
}

This version is simpler than the previous looping version. This code doesn't need to worry about case, and it can use a single conditional expression because it now has only two options to consider instead of a longer list: any spelling variation of QUIT or EXIT.

I almost hate to bring it up, but you can use the switch command (see Chapter 5 of this minibook) to look for a particular string. Normally, you use the switch command to compare a counting number to some set of possible values; however, switch does work on string objects, as well. This version of the termination section in BuildASentence uses the switch construct:

switch(line)
{
  case "EXIT":
  case "exit":
  case "QUIT":
  case "quit":
    return true;
}
return false;

This approach works because you're comparing only a limited number of strings. The for loop offers a much more flexible approach for searching for string values. Using the case-less Compare() in the previous section gives the program greater flexibility in understanding the user.

Suppose you have a string in lowercase and need to convert it to uppercase. You can use the ToUpper() method:

string lowcase = "armadillo";
string upcase = lowcase.ToUpper();  // ARMADILLO.

Similarly, you can convert uppercase to lowercase with ToLower().

What if you want to convert just the first character in a string to uppercase? The following rather convoluted code will do it (but you can see a better way in the last section of this chapter):

string name = "chuck";
string properName =
   char.ToUpper(name[0]).ToString() + name.Substring(1, name.Length - 1);

The idea in this example is to extract the first char in name (that's name[0]), convert it to a one-character string with ToString(), and then tack on the remainder of name after removing the old lowercase first character with Substring().

You can tell whether a string is uppercased or lowercased by using this scary-looking if statement:

if (string.Compare(line.ToUpper(CultureInfo.InvariantCulture),
                   line, false) == 0) ...  // True if line is all upper.

Here the Compare() method is comparing an uppercase version of line to line itself. There should be no difference if line is already uppercase. You can puzzle over the CultureInfo.InvariantCulture gizmo in Help, 'cause I'm not going to explain it here. For "is it all lowercase," stick a not (!) operator in front of the Compare() call. Alternatively, you can use a loop, as described in the next section.

The simplest thing is finding an individual character with IndexOf():

int indexOfLetterS = favoriteFood.IndexOf('s'),  // 4.

Class String also has other methods for finding things, either individual characters or substrings:

How can you tell if a target string is empty ("") or has the value null? (null means that no value has been assigned yet, not even to the empty string.) Use the IsNullOrEmpty() method, like this:

bool notThere = string.IsNullOrEmpty(favoriteFood);  // False

Notice how you call IsNullOrEmpty(): string.IsNullOrEmpty(s).

You can set a string to the empty string in these two ways:

string name = "";
string name = string.Empty;

First, consider that in some cases, you don't want to mess with any white space on either end of the string. The term white space refers to the characters that don't normally display on the screen, for example, space, newline (or ), and tab ( ). You may sometimes also encounter the carriage return character, .

You can use the Trim() method to trim off the edges of the string, like this:

// Get rid of any extra spaces on either end of the string.
random = random.Trim();

Class String also provides TrimFront() and TrimEnd() methods for getting more specific, and you can pass an array of chars to be included in the trimming along with white space. For example, you might trim a leading currency sign, such as '$'.Cleaning up a string can make it easier to parse. The trim methods return a new string.

A program can read from the keyboard one character at a time, but you have to worry about newlines and so on. An easier approach reads a string and then parses the characters out of the string.

Parsing characters out of a string is another topic I don't like to mention, for fear that programmers will abuse this technique. In some cases, programmers are too quick to jump into the middle of a string and start pulling out what they find there. This is particularly true of C++ programmers because that's the only way they could deal with strings — until the addition of a string class.

The ReadLine() method used for reading from the console returns a string object. A program that expects numeric input must convert this string. C# provides just the conversion tool you need in the Convert class. This class provides a conversion method from string to each built-in variable type. Thus, this code segment reads a number from the keyboard and stores it in an int variable:

string s = Console.ReadLine();  // Keyboard input is string data
int n = Convert.ToInt32(s);     // but you know it's meant to be a number.

The other conversion methods are a bit more obvious: ToDouble(), ToFloat(), and ToBoolean().

When Convert() encounters an unexpected character type, it can generate unexpected results. Thus, you must know for sure what type of data you're processing and ensure that no extraneous characters are present.

Although I haven't fully discussed methods yet (see Book II ), here's one anyway. The following method returns true if the string passed to it consists of only digits. You can call this method prior to converting into a type of integer, assuming that a sequence of nothing but digits is probably a legal number.

Here's the method:

// IsAllDigits -- Return true if all characters
//   in the string are digits.
public static bool IsAllDigits(string raw)
{
  // First get rid of any benign characters at either end;
  // if there's nothing left, you don't have a number.
  string s = raw.Trim();  // Ignore white space on either side.
  if (s.Length == 0) return false;
  // Loop through the string.
  for(int index = 0; index < s.Length; index++)
  {
    // A nondigit indicates that the string probably isn't a number.
    if (Char.IsDigit(s[index]) == false) return false;
  }
  // No nondigits found; it's probably okay.
  return true;
}

The method IsAllDigits() first removes any harmless white space at either end of the string. If nothing is left, the string was blank and could not be an integer. The method then loops through each character in the string. If any of these characters turns out to be a nondigit, the method returns false, indicating that the string is probably not a number. If this method returns true, the probability is high that the string can be converted into an integer successfully.

The following code sample inputs a number from the keyboard and prints it back out to the console. (I omitted the IsAllDigits() method from the listing to save space, but I've boldfaced where this program calls it.)

// IsAllDigits -- Demonstrate the IsAllDigits method.
using System;
namespace IsAllDigits
{
  class Program
  {
    public static void Main(string[] args)
    {
      // Input a string from the keyboard.
      Console.WriteLine("Enter an integer number");
      string s = Console.ReadLine();
      // First check to see if this could be a number.
      if (!IsAllDigits(s)) // Call the special method.
      {
        Console.WriteLine("Hey! That isn't a number");
      }
      else
      {        // Convert the string into an integer.
               int n = Int32.Parse(s);

// Now write out the number times 2.
        Console.WriteLine("2 * " + n + ", = " + (2 * n));
      }
      // Wait for user to acknowledge the results.
      Console.WriteLine("Press Enter to terminate...");
      Console.Read();
    }
    // IsAllDigits here.
  }
}

The program reads a line of input from the console keyboard. If IsAllDigits() returns false, the program alerts the user. If not, the program converts the string into a number using an alternative to Convert.ToInt32(aString) — the Int32.Parse(aString) call. Finally, the program outputs both the number and two times the number (the latter to prove that the program did, in fact, convert the string as advertised).

The output from a sample run of the program appears this way:

Enter an integer number
1A3
Hey! That isn't a number
Press Enter to terminate...

Often, a program receives a series of numbers in a single line from the keyboard. Using the String.Split() method, you can easily break the string into a number of substrings, one for each number, and parse them separately.

The Split() method chops a single string into an array of smaller strings using some delimiter. For example, if you tell Split() to divide a string using a comma (,) as the delimiter, "1,2,3" becomes three strings, "1", "2", and "3". (The delimiter is whichever character you use to split collections.)

The following program uses the Split() method to input a sequence of numbers to be summed. (Again, I've omitted the IsAllDigits() method to save trees.)

// ParseSequenceWithSplit -- Input a series of numbers separated by commas,
//    parse them into integers and output the sum.
namespace ParseSequenceWithSplit
{
  using System;
  class Program
  {
    public static void Main(string[] args)
    {
      // Prompt the user to input a sequence of numbers.
      Console.WriteLine(
           "Input a series of numbers separated by commas:");
      // Read a line of text.
      string input = Console.ReadLine();
      Console.WriteLine();
      // Now convert the line into individual segments
      // based upon either commas or spaces.
      char[] dividers = {',', ' '};
      string[] segments = input.Split(dividers);
      // Convert each segment into a number.
      int sum = 0;
      foreach(string s in segments)
      {
        // Skip any empty segments.
        if (s.Length > 0)
        {
          // Skip strings that aren't numbers.
          if (IsAllDigits(s))
          {
            // Convert the string into a 32-bit int.
            int num = 0;
            if (Int32.TryParse(s, out num))
            {
                       Console.WriteLine("Next number = {0}", num);
                       // Add this number into the sum.
                       sum += num;
            }
            // If parse fails, move on to next number.
          }
        }
      }
      // Output the sum.
      Console.WriteLine("Sum = {0}", sum);
      // Wait for user to acknowledge the results.
      Console.WriteLine("Press Enter to terminate...");
      Console.Read();
    }
    // IsAllDigits here.
  }
}

The ParseSequenceWithSplit program begins by reading a string from the keyboard. The program passes the dividers array of char to the Split() method to indicate that the comma and the space are the characters used to separate individual numbers. Either character will cause a split there.

The program iterates through each of the smaller subarrays created by Split() using the foreach loop control. The program skips any zero-length subarrays. (This would result from two dividers in a row.) The program next uses the IsAllDigits() method to make sure that the string contains a number. (It won't if, for instance, you type ,.3 with an extra nondigit, nonseparator character.) Valid numbers are converted into integers and then added to an accumulator, sum. Invalid numbers are ignored. (I chose not to generate an error message to keep this short.)

Here's the output of a typical run:

Input a series of numbers separated by commas:
1,2, a, 3 4

Next number = 1
Next number = 2
Next number = 3
Next number = 4
Sum = 10
Press Enter to terminate...

The program splits the list, accepting commas, spaces, or both as separators. It successfully skips over the a to generate the result of 10. In a real-world program, however, you probably don't want to skip over incorrect input without comment. You almost always want to draw the user's attention to garbage in the input stream.

Class String also has a Join() method. If you have an array of strings, you can use Join() to concatenate all of the strings. You can even tell it to put a certain character string between each item and the next in the array:

string[] brothers = { "Chuck", "Bob", "Steve", "Mike" };
string theBrothers = string.Join(":", brothers);

The result in theBrothers is "Chuck:Bob:Steve:Mike", with the names separated by colons. You can put any separator string between the names: ", ", " ", " ". The first item is a comma and a space. The second is a tab character. The third is a string of several spaces.

I show earlier how to use Trim() and its more specialized variants, TrimFront() and TrimEnd(). Here, I discuss another common method for formatting output. You can use the Pad methods, which add characters to either end of a string to expand the string to some predetermined length. For example, you may add spaces to the left or right of a string to left- or right-justify it, or you can add "*" characters to the left of a currency number, and so on.

The following small AlignOutput program uses both Trim() and Pad() to trim up and justify a series of names:

// AlignOutput -- Left justify and align a set of strings
//    to improve the appearance of program output.
namespace AlignOutput
{
  using System;
  using System.Collections.Generic;
  class Program
  {
    public static void Main(string[] args)
    {
      List<string> names = new List<string> {"Christa  ",
                                             "  Sarah",
                                             "Jonathan",
                                             "Sam",
                                             " Schmekowitz "};
      // First output the names as they start out.
      Console.WriteLine("The following names are of "
                        + "different lengths");
      foreach(string s in names)
      {
        Console.WriteLine("This is the name '" + s + "' before");
      }
      Console.WriteLine();

      // This time, fix the strings so they are
      // left justified and all the same length.
      // First, copy the source array into an array that you can manipulate.
      List<string> stringsToAlign = new List<string>();
      // At the same time, remove any unnecessary spaces from either end
      // of the names.
      for (int i = 0; i < names.Count; i++)
      {
        string trimmedName = names[i].Trim();
        stringsToAlign.Add(trimmedName);
      }
      // Now find the length of the longest string so that
      // all other strings line up with that string.
      int maxLength = 0;
      foreach (string s in stringsToAlign)
      {

if (s.Length > maxLength)
        {
          maxLength = s.Length;
        }
      }
      // Now justify all the strings to the length of the maximum string.
      for (int i = 0; i < stringsToAlign.Count; i++)
      {
        stringsToAlign[i] = stringsToAlign[i].PadRight(maxLength + 1);
      }
      // Finally output the resulting padded, justified strings.
      Console.WriteLine("The following are the same names "
                      + "normalized to the same length");
      foreach(string s in stringsToAlign)
      {
        Console.WriteLine("This is the name '" + s + "' afterwards");
      }
      // Wait for user to acknowledge.
      Console.WriteLine("
Press Enter to terminate...");
      Console.Read();
    }
  }
}

AlignOutput defines a List<string> of names of uneven alignment and length. (You could just as easily write the program to read these names from the console or from a file.) The Main() method first displays the names as they are. Main() then aligns the names using the Trim() and PadRight() methods before redisplaying the resulting trimmed up strings:

The following names are of different lengths:
This is the name 'Christa  ' before
This is the name '  Sarah' before
This is the name 'Jonathan' before
This is the name 'Sam' before
This is the name ' Schmekowitz ' before

The following are the same names rationalized to the same length:
This is the name 'Christa     ' afterwards
This is the name 'Sarah       ' afterwards
This is the name 'Jonathan    ' afterwards
This is the name 'Sam         ' afterwards
This is the name 'Schmekowitz ' afterwards

The alignment process begins by making a copy of the input names list.

The code first loops through the list, calling Trim() on each element to remove unneeded white space on either end. The method loops again through the list to find the longest member. The code loops one final time, calling PadRight() to expand each string to match the length of the longest member in the list. Note how the padded names form a neat column in the output.

PadRight(10) expands a string to be at least ten characters long. For example, PadRight(10) adds four spaces to the right of a six-character string.

Finally, the code displays the list of trimmed and padded strings for output. Voilà.

You often face the problem of breaking up a string or inserting some substring into the middle of another. Replacing one character with another is most easily handled with the Replace() method, like this:

string s = "Danger NoSmoking";
s = s.Replace(' ', '!')

This example converts the string into "Danger!NoSmoking".

Replacing all appearances of one character (in this case, a space) with another (an exclamation mark) is especially useful when generating comma-separated strings for easier parsing. However, the more common and more difficult case involves breaking a single string into substrings, manipulating them separately, and then recombining them into a single, modified string.

The following RemoveWhiteSpace sample program uses the Replace() method to remove white space (spaces, tabs, and newlines — all instances of a set of special characters) from a string:

// RemoveWhiteSpace -- Remove any of a set of chars from a given string.
//    Use this method to remove whitespace from a sample string.
namespace RemoveWhiteSpace
{
 using System;
  public class Program
  {
    public static void Main(string[] args)
    {
      // Define the white space characters.
      char[] whiteSpace = {' ', '
', '	'};
      // Start with a string embedded with whitespace.
      string s = " this is a
string"; // Contains spaces & newline.
      Console.WriteLine("before:" + s);
      // Output the string with the whitespace missing.
      Console.Write("after:");
      // Start looking for the white space characters.
      for(;;)
      {
        // Find the offset of the character; exit the loop
        // if there are no more.
        int offset = s.IndexOfAny(whiteSpace);
        if (offset == −1)
        {
          break;
        }
        // Break the string into the part prior to the
        // character and the part after the character.
        string before = s.Substring(0, offset);
        string after  = s.Substring(offset + 1);
        // Now put the two substrings back together with the
        // character in the middle missing.
        s = String.Concat(before, after);
        // Loop back up to find next whitespace char in
        // this modified s.
      }

Console.WriteLine(s);
      // Wait for user to acknowledge the results.
      Console.WriteLine("Press Enter to terminate...");
      Console.Read();
    }
  }
}

The key to this program is the boldfaced loop. This loop continually refines a string consisting of the input string, s, removing every one of a set of characters contained in the array whiteSpace.

The loop uses IndexOfAny() to find the first occurrence of any of the chars in the whiteSpace array. It doesn't return until every instance of any of those chars has been removed. The IndexOfAny() method returns the index within the array of the first white space char that it can find. A return value of −1 indicates that no items in the array were found in the string.

The first pass through the loop removes the leading blank on the target string. IndexOfAny() finds the blank at index 0. The first Substring() call returns an empty string, and the second call returns the whole string after the blank. These are then concatenated with Concat(), producing a string with the leading blank squeezed out.

The second pass through the loop finds the space after "this" and squeezes that out the same way, concatenating the strings "this" and "is a string". After this pass, s has become "thisis a string".

The third pass finds the character and squeezes that out. On the fourth pass, IndexOfAny() runs out of white space characters to find and returns −1 (not found). That ends the loop.

The RemoveWhiteSpace program prints out a string containing several forms of white space. The program then strips out white space characters. The output from this program appears as follows:

before: this is a
string
after:thisisastring
Press Enter to terminate...

The RemoveWhiteSpace program demonstrates the use of the Concat() and IndexOf() methods; however, it doesn't use the most efficient approach. As usual, a little examination reveals a more efficient approach using our old friend Split(). You can find the program containing this code — now in another example of a method — on the Web site under RemoveWhiteSpaceWithSplit. The method that does the work is shown here:

// RemoveWhiteSpace -- The RemoveSpecialChars method removes every
//    occurrence of the specified characters from the string.
// Note: The rest of the program is not shown here.
public static string RemoveSpecialChars(string input, char[] targets)
{
  // Split the input string up using the target
  // characters as the delimiters.
  string[] subStrings = input.Split(targets);

  // output will contain the eventual output information.
  string output = "";

  // Loop through the substrings originating from the split.
  foreach(string subString in subStrings)
  {
    output = String.Concat(output, subString);
  }
  return output;
}

This version uses the Split() method to break the input string into a set of substrings, using the characters to be removed as delimiters. The delimiter is not included in the substrings created, which has the effect of removing the character(s). The logic here is much simpler and less error-prone.

The foreach loop in the second half of the program puts the pieces back together again using Concat(). The output from the program is unchanged.

Pulling the code out into a method further simplifies it and makes it clearer.