Convert Any Sting To A Specific Format

I am trying to convert a type of string into camel case. Here's the string:

here %it -RAINS

Expected Output:

hereItRains

I tried the following:

public static string ToCamelCase(this string str)
{
    var words = str.Split(new[] { "_", "-", "%" }, StringSplitOptions.RemoveEmptyEntries);

    words = words.Select(word => char.ToUpper(word[0]) + word.Substring(1)).ToArray();
    
	return string.Join(string.Empty, words);
}

Got the output as below:

Here It RAINS

Is there anything that I missed here? Here's the link that I tried so far - CamelCase

You already have many answers here, but I would like to add a new one, which is using raw C# code to process the string, avoid some memory allocation and reduce processing time.

public static string ToCamelCase(this string value)
{
    if (string.IsNullOrWhiteSpace(value))
        return value;

    var upperCase = false;
    var sb = new StringBuilder();

    for (int i = 0; i < value.Length; i++)
    {
        if (char.IsWhiteSpace(value[i]) || char.IsPunctuation(value[i]))
        {
            upperCase = true;
            continue;
        }

        char ch;

        if (upperCase)
        {
            ch = char.ToUpperInvariant(value[i]);
        }
        else
        {
            ch = char.IsLower(value[i]) ? value[i] : char.ToLowerInvariant(value[i]);
        }

        upperCase = false;

        sb.Append(ch);
    }

    return sb.ToString();
}

When we use methods like ToArray, Split, ToLower, Regex, etc, we are creating many objects in memory and this can be avoided with some logic.

Benchmark tests

I suggest using regular expressions in order to match all the words which we should turn into lower case (the very first word) or title case (all the rest words):

using System.Globalization;
using System.Linq;
using System.Text.RegularExpressions;

...

public static string ToCamelCase(string value) {
  if (string.IsNullOrEmpty(value))
    return value;

  return string.Concat(Regex
    .Matches(value, @"\p{L}+")
    .Select(match => match.Value.ToLower(CultureInfo.InvariantCulture))
    .Select((word, index) => index == 0
       ? word
       : CultureInfo.InvariantCulture.TextInfo.ToTitleCase(word)));
}

Fiddle

Remarks:

1. \p{L}+ pattern stands for "one or more Unicode letters".
2. ToTitleCase turns any word into title case except all capital letters words (which are treated as acronyms and not changed), that's why I call ToLower() for any word.

I did the following code for one of my college assignment and it worked perfectly fine. The ToCamelCase function takes an input text, breaks it into words using spaces, underscores, and hyphens as delimiters, and then transforms each word to title case (capitalising the initial letter) except the first. The TextInfo class handles correct case depending on current culture.

class Program
{
    static string ToCamelCase(string input)
    {
        TextInfo textInfo = new CultureInfo("en-US", false).TextInfo;
        string[] words = input.Split(new[] { ' ', '_', '-' }, StringSplitOptions.RemoveEmptyEntries);

        if (words.Length == 0)
            return input;

        string camelCase = words[0].ToLower();
        for (int i = 1; i < words.Length; i++)
        {
            camelCase += textInfo.ToTitleCase(words[i].ToLower());
        }

        return camelCase;
    }

    static void Main(string[] args)
    {
        string input = "convert_this_string_to_camel_case";
        string camelCaseOutput = ToCamelCase(input);

        Console.WriteLine(camelCaseOutput);
    }
}

Edit the ToCamelCase function as follows:

public string ToCamelCase(string str)
{
    var allWords = str.Split(new[] { "_", "-", "%", " " }, StringSplitOptions.RemoveEmptyEntries).ToList();                      
    var words = allWords.Skip(1).Select(word => char.ToUpper(word[0]) + word.Substring(1).ToLower()).ToList();
    words.Insert(0, allWords[0]);
    return string.Join(string.Empty, words);
}

1. add " " to your Split collection.

2. add .ToLower() to word.Substring(1)

3. skip the first word with allWords.Skip(1)

result:

a b c %d ==> aBCD
here %it -RAINS ==> hereItRains