从 TitleCase C # 将 String 转换为 camelCase

我将一个字符串转换为 TextInfo.ToTitleCase 并删除下划线并将该字符串连接在一起。现在我需要将字符串中的第一个也是唯一的第一个字符改为小写，由于某种原因，我无法找出如何实现它。先谢谢你的帮助。

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

结果: 西布兰噩梦

预期结果: 泽布兰斯噩梦

更新:

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

产生所需的输出

150006 次浏览
小开
最佳答案

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)
小开

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

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

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

小开

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.

小开

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

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();
小开 
var camelCaseFormatter = new JsonSerializerSettings();
camelCaseFormatter.ContractResolver = new CamelCasePropertyNamesContractResolver();


JsonConvert.SerializeObject(object, camelCaseFormatter));
小开

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.

小开

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

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.

小开 
    /// <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;
}
小开

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.

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

小开

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

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.

小开

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


*/
小开 
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()));
}
}

提交答案