Introduction:

When working with string manipulation, one common task is to convert a string into camel case format. Camel case is a naming convention where words are concatenated without spaces but with the first letter of each word capitalized except for the first word. For example, "the quick brown fox" would become "theQuickBrownFox" in the camel case. In this blog, we will explore several ways to convert strings to camel case in C#.

Method 1: String.Split() and ToTitleCase()

One way to convert a string to camel case is to use the String.Split() method to split the original string into an array of words, then use the TextInfo.ToTitleCase() method to capitalize the first letter of each word. Finally, we concatenate the words together without any spaces.

Here's an example program that implements this method:

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        string input = "the quick brown fox";
        TextInfo textInfo = new CultureInfo("en-US", false).TextInfo;
        string[] words = input.Split(' ');
        string camelCase = "";
        foreach (string word in words)
        {
            camelCase += textInfo.ToTitleCase(word);
        }
        camelCase = char.ToLowerInvariant(camelCase[0]) + camelCase.Substring(1);
        Console.WriteLine(camelCase);
    }
}

Output:

theQuickBrownFox

In this example, we first define a string variable called input that contains the original string we want to convert to camel case. We then create a TextInfo object to provide culture-specific formatting information, such as capitalization rules. We use the Split() method to split the input string into an array of words, using the space character as the separator.

Next, we create an empty string variable called camelCase that we will use to build the final camel case string. We then loop through each word in the words array, using the ToTitleCase() method to capitalize the first letter of each word. Finally, we concatenate the capitalized words together and store the result in the camelCase variable.

The last step is to lowercase the first letter of the camelCase string to comply with camel case naming conventions. We use the ToLowerInvariant() method to lowercase the first letter and then concatenate the rest of the camelCase string using the Substring() method.

Method 2: Regex and Lambda Expressions

Another way to convert a string to a camel case is to use regular expressions and lambda expressions. In this method, we use a regular expression to split the original string into an array of words, then use a lambda expression to capitalize the first letter of each word. Finally, we concatenate the words together without any spaces.

Here's an example program that implements this method:

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string input = "the quick brown fox";
        Regex regex = new Regex(@"\s+");
        string camelCase = regex.Replace(input, " ").Split(' ')
            .Select(word => char.ToUpperInvariant(word[0]) + word.Substring(1))
            .Aggregate("", (current, next) => current + next);
        camelCase = char.ToLowerInvariant(camelCase[0]) + camelCase.Substring(1);
        Console.WriteLine(camelCase);
    }
}

Output:

theQuickBrownFox

In this example, we first define a string variable called input that contains the original string we want to convert to camel case. We then create a regular expression object that matches one or more whitespace characters. We use the Replace() method to replace any matches of the regular expression with a single space character. We then use the Split() method to split the input string into an array of words, using the space character as the separator.

Next, we use the Select() method with a lambda expression to capitalize the first letter of each word. The char.ToUpperInvariant() method is used to capitalize the first letter, and the Substring() method is used to concatenate the rest of the word. The result is an array of capitalized words.

Finally, we use the Aggregate() method to concatenate the capitalized words together and store the result in the camelCase variable. The first argument of the Aggregate() method is an empty string, which is the initial value of the accumulator. The second argument is a lambda expression that specifies how to concatenate the current and next values of the accumulator.

The last step is to lowercase the first letter of the camelCase string to comply with camel case naming conventions. We use the ToLowerInvariant() method to lowercase the first letter and then concatenate the rest of the camelCase string using the Substring() method.

Method 3: StringBuilder and Char.IsWhiteSpace()

A third way to convert a string to camel case is to use the StringBuilder class and the Char.IsWhiteSpace() method. In this method, we use a StringBuilder object to build the final camel case string, and the Char.IsWhiteSpace() method to determine when to capitalize the next letter.

Here's an example program that implements this method:

using System;
using System.Text;

class Program
{
    static void Main()
    {
        string input = "the quick brown fox";
        StringBuilder sb = new StringBuilder(input.Length);
        bool capitalize = true;
        foreach (char c in input)
        {
            if (Char.IsWhiteSpace(c))
            {
                capitalize = true;
            }
            else if (capitalize)
            {
                sb.Append(Char.ToUpperInvariant(c));
                capitalize = false;
            }
            else
            {
                sb.Append(Char.ToLowerInvariant(c));
            }
        }
        string camelCase = sb.ToString();
        Console.WriteLine(camelCase);
    }
}

Output:

theQuickBrownFox

In this example, we first define a string variable called input that contains the original string we want to convert to camel case. We then create a StringBuilder object with an initial capacity equal to the length of the input string.

Next, we define a Boolean variable called capitalize and set it to true. This variable keeps track of whether the next letter should be capitalized or not. We then loop through each character in the input string, using the Char.IsWhiteSpace() method to determine when to capitalize the next letter.

If the current character is a whitespace character, we set the capitalize variable to true. Otherwise, if capitalize is true, we use the Append() method of the StringBuilder object to append the capitalized letter to the final camel case string, and set capitalize to false. Otherwise, we append the lowercase letter to the final camel case string.

Finally, we use the ToString() method of the StringBuilder object to convert the final camel case string to a regular string, and store the result in the camelCase variable. We then output the camelCase variable to the console.

Conclusion:

In this blog, we explored three ways to convert strings to camel case in C#. The first method used the String.Split() method and the ToTitleCase() method. The second method used regular expressions and lambda expressions. The third method used the StringBuilder class and the Char.IsWhiteSpace() method.