Convert String To camelCase from TitleCase C#

Question

I have a string that I converted to a TextInfo.ToTitleCase and removed the underscores and joined the string together. Now I need to change the first and only the first character in the string to lower case and for some reason, I can not figure out how to accomplish it.

class Program
{
    static void Main(string[] args)
    {
        string functionName = "zebulans_nightmare";
        TextInfo txtInfo = new CultureInfo("en-us", false).TextInfo;
        functionName = txtInfo.ToTitleCase(functionName).Replace('_', ' ').Replace(" ", String.Empty);
        Console.Out.WriteLine(functionName);
        Console.ReadLine();
    }
}

Results: ZebulansNightmare

Desired Results: zebulansNightmare

UPDATE:

class Program
{
    static void Main(string[] args)
    {
        string functionName = "zebulans_nightmare";
        TextInfo txtInfo = new CultureInfo("en-us", false).TextInfo;
        functionName = txtInfo.ToTitleCase(functionName).Replace("_", string.Empty).Replace(" ", string.Empty);
        functionName = $"{functionName.First().ToString().ToLowerInvariant()}{functionName.Substring(1)}";
        Console.Out.WriteLine(functionName);
        Console.ReadLine();
    }
}

Produces the desired output.

Answer 1

Note: My answer is outdated, see this answer below which uses System.Text.Json which is available out of the box with dotnet core or via nuget for older dotnet framework applications

Original answer:

You just need to lower the first char in the array. See this answer

Char.ToLowerInvariant(name[0]) + name.Substring(1)

As a side note, seeing as you are removing spaces you can replace the underscore with an empty string.

.Replace("_", string.Empty)

Answer 2

If you're using .NET Core 3 or .NET 5, you can call:

System.Text.Json.JsonNamingPolicy.CamelCase.ConvertName(someString)

Then you'll definitely get the same results as ASP.NET's own JSON serializer.

Answer 3

Implemented Bronumski's answer in an extension method (without replacing underscores).

 public static class StringExtension
 {
     public static string ToCamelCase(this string str)
     {                    
         if(!string.IsNullOrEmpty(str) && str.Length > 1)
         {
             return char.ToLowerInvariant(str[0]) + str.Substring(1);
         }
         return str.ToLowerInvariant();
     }
 }

 //Or

 public static class StringExtension
 {
     public static string ToCamelCase(this string str) =>
         string.IsNullOrEmpty(str) || str.Length < 2
         ? str.ToLowerInvariant()
         : char.ToLowerInvariant(str[0]) + str.Substring(1);
 }

and to use it:

string input = "ZebulansNightmare";
string output = input.ToCamelCase();

Answer 4

Here is my code, in case it is useful to anyone

    // This converts to camel case
    // Location_ID => locationId, and testLEFTSide => testLeftSide

    static string CamelCase(string s)
    {
        var x = s.Replace("_", "");
        if (x.Length == 0) return "null";
        x = Regex.Replace(x, "([A-Z])([A-Z]+)($|[A-Z])",
            m => m.Groups[1].Value + m.Groups[2].Value.ToLower() + m.Groups[3].Value);
        return char.ToLower(x[0]) + x.Substring(1);
    }

If you prefer Pascal-case use:

    static string PascalCase(string s)
    {
        var x = CamelCase(s);
        return char.ToUpper(x[0]) + x.Substring(1);
    }

Answer 5

The following code works with acronyms as well. If it is the first word it converts the acronym to lower case (e.g., VATReturn to vatReturn), and otherwise leaves it as it is (e.g., ExcludedVAT to excludedVAT).

name = Regex.Replace(name, @"([A-Z])([A-Z]+|[a-z0-9_]+)($|[A-Z]\w*)",
            m =>
            {
                return m.Groups[1].Value.ToLower() + m.Groups[2].Value.ToLower() + m.Groups[3].Value;
            });

Answer 6

Example 01

    public static string ToCamelCase(this string text)
    {
        return CultureInfo.CurrentCulture.TextInfo.ToTitleCase(text);
    }

Example 02

public static string ToCamelCase(this string text)
    {
        return string.Join(" ", text
                            .Split()
                            .Select(i => char.ToUpper(i[0]) + i.Substring(1)));
    }

Example 03

    public static string ToCamelCase(this string text)
    {
        char[] a = text.ToLower().ToCharArray();

        for (int i = 0; i < a.Count(); i++)
        {
            a[i] = i == 0 || a[i - 1] == ' ' ? char.ToUpper(a[i]) : a[i];

        }
        return new string(a);
    }

Answer 7

In .Net 6 and above

public static class CamelCaseExtension
{
  public static string ToCamelCase(this string str) => 
     char.ToLowerInvariant(str[0]) + str[1..];
}

Answer 8

Adapted from Leonardo's answer:

static string PascalCase(string str) {
  TextInfo cultInfo = new CultureInfo("en-US", false).TextInfo;
  str = Regex.Replace(str, "([A-Z]+)", " $1");
  str = cultInfo.ToTitleCase(str);
  str = str.Replace(" ", "");
  return str;
}

Converts to PascalCase by first adding a space before any group of capitals, and then converting to title case before removing all the spaces.

Answer 9

If you are Ok with the Newtonsoft.JSON dependency, the following string extension method will help. The advantage of this approach is the serialization will work on par with standard WebAPI model binding serialization with high accuracy.

using System;
using Newtonsoft.Json.Serialization;

    public static class StringExtensions
    {
        private class CamelCasingHelper : CamelCaseNamingStrategy
        {
            private CamelCasingHelper(){}
            private static CamelCasingHelper helper =new CamelCasingHelper();
            public static string ToCamelCase(string stringToBeConverted)
            {
                return helper.ResolvePropertyName(stringToBeConverted);     
            }
            
        }
        public static string ToCamelCase(this string str)
        {
            return CamelCasingHelper.ToCamelCase(str);
        }
    }

Here is the working fiddle https://dotnetfiddle.net/pug8pP

Answer 10

public static string CamelCase(this string str)  
    {  
      TextInfo cultInfo = new CultureInfo("en-US", false).TextInfo;
      str = cultInfo.ToTitleCase(str);
      str = str.Replace(" ", "");
      return str;
    }

This should work using System.Globalization

Answer 11

Here's my code, includes lowering all upper prefixes:

public static class StringExtensions
{
    public static string ToCamelCase(this string str)
    {
        bool hasValue = !string.IsNullOrEmpty(str);

        // doesn't have a value or already a camelCased word
        if (!hasValue || (hasValue && Char.IsLower(str[0])))
        {
            return str;
        }

        string finalStr = "";

        int len = str.Length;
        int idx = 0;

        char nextChar = str[idx];

        while (Char.IsUpper(nextChar))
        {
            finalStr += char.ToLowerInvariant(nextChar);

            if (len - 1 == idx)
            {
                // end of string
                break;
            }

            nextChar = str[++idx];
        }

        // if not end of string 
        if (idx != len - 1)
        {
            finalStr += str.Substring(idx);
        }

        return finalStr;
    }
}

Use it like this:

string camelCasedDob = "DOB".ToCamelCase();

Answer 12

var camelCaseFormatter = new JsonSerializerSettings();
camelCaseFormatter.ContractResolver = new CamelCasePropertyNamesContractResolver();

JsonConvert.SerializeObject(object, camelCaseFormatter));

Answer 13

Strings are immutable, but we can use unsafe code to make it mutable though. The string.Copy insured that the original string stays as is.

In order for these codes to run you have to allow unsafe code in your project.

        public static unsafe string ToCamelCase(this string value)
        {
            if (value == null || value.Length == 0)
            {
                return value;
            }

            string result = string.Copy(value);

            fixed (char* chr = result)
            {
                char valueChar = *chr;
                *chr = char.ToLowerInvariant(valueChar);
            }

            return result;
        }

This version modifies the original string, instead of returning a modified copy. This will be annoying though and totally uncommon. So make sure the XML comments are warning users about that.

        public static unsafe void ToCamelCase(this string value)
        {
            if (value == null || value.Length == 0)
            {
                return value;
            }

            fixed (char* chr = value)
            {
                char valueChar = *chr;
                *chr = char.ToLowerInvariant(valueChar);
            }

            return value;
        }

Why use unsafe code though? Short answer... It's super fast.

Answer 14

Here's my code which is pretty simple. My major objective was to ensure that camel-casing was compatible with what ASP.NET serializes objects to, which the above examples don't guarantee.

public static class StringExtensions
{
    public static string ToCamelCase(this string name)
    {
        var sb = new StringBuilder();
        var i = 0;
        // While we encounter upper case characters (except for the last), convert to lowercase.
        while (i < name.Length - 1 && char.IsUpper(name[i + 1]))
        {
            sb.Append(char.ToLowerInvariant(name[i]));
            i++;
        }

        // Copy the rest of the characters as is, except if we're still on the first character - which is always lowercase.
        while (i < name.Length)
        {
            sb.Append(i == 0 ? char.ToLowerInvariant(name[i]) : name[i]);
            i++;
        }

        return sb.ToString();
    }
}

Answer 15

    /// <summary>
    /// Gets the camel case from snake case.
    /// </summary>
    /// <param name="snakeCase">The snake case.</param>
    /// <returns></returns>
    private string GetCamelCaseFromSnakeCase(string snakeCase)
    {
        string camelCase = string.Empty;

        if(!string.IsNullOrEmpty(snakeCase))
        {
            string[] words = snakeCase.Split('_');
            foreach (var word in words)
            {
                camelCase = string.Concat(camelCase, Char.ToUpperInvariant(word[0]) + word.Substring(1));
            }

            // making first character small case
            camelCase = Char.ToLowerInvariant(camelCase[0]) + camelCase.Substring(1);
        }

        return camelCase;
    }

Answer 16

I use This method to convert the string with separated by "_" to Camel Case

public static string ToCamelCase(string? s)
        {
            var nameArr = s?.ToLower().Split("_");
            var str = "";
            foreach (var name in nameArr.Select((value, i) => new { value, i }))
            {
                if(name.i >= 1)
                {
                    str += string.Concat(name.value[0].ToString().ToUpper(), name.value.AsSpan(1));
                }
                else
                {
                    str += name.value ;
                }
            }
            return str;
        }

u can change the separated by "_" with any other you want.

Answer 17

public static class StringExtension
{
    public static string ToCamelCase(this string str)
    {
        return string.Join(" ", str
                     .Split()
                     .Select(i => char.ToUpper(i[0]) + i.Substring(1).ToLower()));
    }
}

Answer 18

I had the same issue with titleCase so I just created one, hope this helps this is an extension method.

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

        var separators = new[] { '_', ' ' };
        var arr = text
            .Split(separators)
            .Where(word => !string.IsNullOrWhiteSpace(word));

        var camelCaseArr = arr
            .Select((word, i) =>
            {
                if (i == 0)
                    return word.ToLower();

                var characterArr = word.ToCharArray()
                    .Select((character, characterIndex) => characterIndex == 0
                        ? character.ToString().ToUpper()
                        : character.ToString().ToLower());

                return string.Join("", characterArr);
            });

        return string.Join("", camelCaseArr);
    }

Answer 19

Simple and easy in build c#

using System;
using System.Globalization;

public class SamplesTextInfo  {

   public static void Main()  {

      // Defines the string with mixed casing.
      string myString = "wAr aNd pEaCe";

      // Creates a TextInfo based on the "en-US" culture.
      TextInfo myTI = new CultureInfo("en-US",false).TextInfo;

      // Changes a string to lowercase.
      Console.WriteLine( "\"{0}\" to lowercase: {1}", myString, myTI.ToLower( myString ) );

      // Changes a string to uppercase.
      Console.WriteLine( "\"{0}\" to uppercase: {1}", myString, myTI.ToUpper( myString ) );

      // Changes a string to titlecase.
      Console.WriteLine( "\"{0}\" to titlecase: {1}", myString, myTI.ToTitleCase( myString ) );
   }
}

/*
This code produces the following output.

"wAr aNd pEaCe" to lowercase: war and peace
"wAr aNd pEaCe" to uppercase: WAR AND PEACE
"wAr aNd pEaCe" to titlecase: War And Peace

*/