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.

Unspent

You should just post your own answer instead of putting a solution in the question, its a little more confusing this way. – Backfire

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)

Bengurion

Thanks just what I needed. – Unspent

Good call. Made the adjustments and updated the question. – Unspent

That doesn't work with acronyms in the beginning (e.g., VATReturnAmount). See my answer. – Paratrooper

Agreed with @Mojtaba. DON'T use this if you want to have compatibility with camelCase JSON serialization in ASP.NET. Acronyms at the beginning won't come out the same. – Gold

In .NET Core C#9 you can make it even more concise: return char.ToLowerInvariant(s[0]) + s[1..]; – Separatrix

With time, this answer should get more and more downvoted, and the other answer (System.Text.Json.JSonNamingPolicy.CamelCase) should be more and more upvoted. – Society

@Society - Actually my answer should be removed but you cannot delete the accepted answer. There needs to be a way to flag something as obsolete or link it to a specific framework. In the meantime I will update my answer to point people below. – Bengurion

DBs like Oracle yields the column names in UPPERCASE by default. When we use the JsonNamingPolicy, it converts them all to lower case. Thats not the solution for camelCasing. Either we have to follow this answer or the one below for cases like mine. – Coccid

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.

Degeneracy

this did not work for me, it converted everything to lower case in my situation – Pearl

Just to note, this does not remove spaces so you need to do JsonNamingPolicy.CamelCase.ConvertName(str).Replace(" ", string.Empty) – Burlington

@Pearl if the input string (which you didn't provide) was all capital letters then the output string is expected to be all small letters because that's how the standard camel case handles acronyms – Society

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();

Loquat

The only issue I see is if the string is just a "A". It should return "a", right? – Sight

Does not handle the sneaky way camel case handles acronyms. I'd suggest using the native function provided by C#. – Society

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);
    }

Invincible

Finally an example that converts MYCase to myCase, instead of mYCase. Thanks! – Unbearable

@MusterStation But why? Shouldn't you just have "MyCase" in the first place? If "Y" is uppercase, then it's probably another word, right? – Digress

@Digress maybe. in "MYCase" perhaps M is a word, Y is a word, and Case is a word. However, it is more likely that "MY" is a two letter acronym. For example "innerHTML" is two words, not five. – Invincible

This converts to PascalCase not camelCase – Gold

@CraigShearer yes.... the last line can be ToLower if you want camelCase. – Invincible

Why is your function called CamelCase while it actually converts to PascalCase? :) – Jahnke

@JoepBeusenberg ok i fixed it – Invincible

To fix the "InnerHTMLExample" change the regex to "(^[A-Z])([A-Z]+)($|[A-Z])" – Bouton

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;
            });

Paratrooper

Thank you, this is much better. It matches the behaviour of MVC when you return Json(new { CAPSItem = ... } whereas the accepted answer will create a mismatch – Threecornered

A problem with acronyms arises if you must convert from camelCase back to PascalCase. For example, I don't see how to convert vatReturn back to VATReturn. Better to use VatReturn as your pascal naming convention, then you can stick to just modifying the first letter. – Churchwell

@Churchwell although your point is valid in its context, the question is about converting to camelCase; that means using VatReturn instead of vatReturn for acronyms is not an answer for this question. – Paratrooper

Extending this one a bit. The above RegEx fails to match e.g. ABC123 (output is abC123). Capturing numbers in the last group using ([A-Z])([A-Z]+|[a-z0-9_]+)($|[A-Z0-9]\w*) will correctly output abc123 (while still working with ABCFoo et al). – Carlita

This would be my second go-to answer after the native .Net method. any method that does not handle acronyms cannot be marked as the right answer. – Society

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);
    }

Elberfeld

Welcome to StackOverflow! Although this might answer the question, consider adding text to why this is a suitable answer and links to support your answer! – Alesiaalessandra

Given that no other answer has an essay supporting the answer and only one has a link I think this a bit harsh, or very "StackOverflow-ish". The first answer Kenny gave was a good anser imo (although I agree there is a typo in te to text). – Ruff

That was harsh? – Horsemanship

@Horsemanship No, it wasn't. He could have said "please" though. BTW, the code style looks ugly (probably not just to me), hard to read. – Digress

Most of all it doesn't even answer the question. It converts to TitleCase, which was not the question asked. – Jahnke

TitleCase (sans spaces) is also PascalCase which IS CamelCase (upper) This is the problem with using the term "camel case" in general as there is a common assumption camelCase must start with lowercase, but that is not the case :). CamelCase can start with uppercase, PascalCase must start with uppercase. It is best to state camelCase or camel case (lower) in a technical design document to avoid confusion. ASSumptions are bad, mkay. – Thremmatology

Answer 7

In .Net 6 and above

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

Mercantilism

Does not handle camel case acronyms. Cannot be considered correct. – Society

What is a camel case acronym? – Mercantilism

By "camel case acronym" I meant "the way camel case handles any kind of acronyms". Check the norm (or other answers) to see how camel case handles a sequence of capital letters. – Society

Answer 8

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

Autoerotic

Consider editing your answer to include the "using" statements at the top. – Society

Added using statements – Autoerotic

Answer 9

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.

Cablegram

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

Scrubland

This is good, but unfortunately it will convert PascalCase into Pascalcase. – Cablegram

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();

Zebec

Sorry but this is not a good code at all... Concatenating strings create new strings... In this case you are creating as many strings as your original string in str. If you have a long string, the GC will hate you. – Funerary

Wanted to upvote because it DOES handle camel case acronyms, but ended up downvoting because this answer is way too resource-consuming. – Society

Answer 12

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

JsonConvert.SerializeObject(object, camelCaseFormatter));

Bravado

While this might answer the question, it would be much more helpful if you explain your code a bit. – Blackfoot

this is quite strange forward answer. you just create JsonSerilizerSetting by setting its contractresovler option to Camelcase. So, the object, is anything you want to serilize, together wtih the setting. you can customize any setting you wish to – Bravado

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.

Funerary

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();
    }
}

Gold

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;
    }

Norinenorita

Please, add some description or comments for help them. – Rinee

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.

Enrol

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()));
    }
}

Darkness

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);
    }

Daukas

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

*/

Regional