我有DetailsView TextBox
我希望输入数据
示例：
"red" --> "Red"
"red house" --> " Red house"
如何实现最大化性能？
注意：
根据答案和答案下的评论，许多人认为这是在询问如何在字符串中大写所有单词。例如。 => Red House 不是，但如果这是您寻求的内容，请查找使用TextInfo的{{1}}方法的答案之一。 （注意：对于实际提出的问题，这些答案不正确。）
有关警告，请参阅TextInfo.ToTitleCase doc（不接触所有大写单词 - 它们被视为首字母缩略词;可以在“不应该”降低的单词中间小写字母，例如“麦当劳”=＆gt;“麦当劳”;不保证能够处理所有特定文化的细微差别资本化规则。）
注意：
关于第一个字母后面的字母是否应强制到小写，问题是含糊不清。接受的答案假设只应更改第一个字母。如果要强制除第一个之外的字符串中的所有字母为小写，请查找包含ToTitleCase和不包含ToTitleCase 的答案。
答案 0 :(得分：477)
编辑：更新为更新的语法（以及更正确的答案），也作为扩展方法。
public static class StringExtensions
{
public static string FirstCharToUpper(this string input)
{
switch (input)
{
case null: throw new ArgumentNullException(nameof(input));
case "": throw new ArgumentException($"{nameof(input)} cannot be empty", nameof(input));
default: return input.First().ToString().ToUpper() + input.Substring(1);
}
}
}
OLD ANSWERS
public static string FirstCharToUpper(string input)
{
if (String.IsNullOrEmpty(input))
throw new ArgumentException("ARGH!");
return input.First().ToString().ToUpper() + String.Join("", input.Skip(1));
}
修改： 这个版本更短。要获得更快的解决方案，请查看Equiso's answer
public static string FirstCharToUpper(string input)
{
if (String.IsNullOrEmpty(input))
throw new ArgumentException("ARGH!");
return input.First().ToString().ToUpper() + input.Substring(1);
}
编辑2 ：
可能最快的解决方案是Darren's（甚至还有一个基准）虽然我会更改它的string.IsNullOrEmpty(s)验证以抛出异常，因为原始要求期望第一个字母存在，因此它可以是大写的。请注意，此代码适用于通用字符串，而不适用于Textbox。
答案 1 :(得分：287)
public string FirstLetterToUpper(string str)
{
if (str == null)
return null;
if (str.Length > 1)
return char.ToUpper(str[0]) + str.Substring(1);
return str.ToUpper();
}
旧答案： 这使得每个第一个字母大写
public string ToTitleCase(string str)
{
return CultureInfo.CurrentCulture.TextInfo.ToTitleCase(str.ToLower());
}
答案 2 :(得分：129)
正确的方法是使用文化：
Globalization.CultureInfo.CurrentCulture.TextInfo.ToTitleCase(word.ToLower())
注意：这会将字符串中的每个单词大写，例如“红房子” - ＆gt; “红房子”。该解决方案还将在单词内进行小写大小写，例如“老麦当劳” - ＆gt; “老麦克唐纳”。
答案 3 :(得分：52)
我从http://www.dotnetperls.com/uppercase-first-letter采用最快的方法并转换为扩展方法：
/// <summary>
/// Returns the input string with the first character converted to uppercase, or mutates any nulls passed into string.Empty
/// </summary>
public static string FirstLetterToUpperCaseOrConvertNullToEmptyString(this string s)
{
if (string.IsNullOrEmpty(s))
return string.Empty;
char[] a = s.ToCharArray();
a[0] = char.ToUpper(a[0]);
return new string(a);
}
注意：使用ToCharArray的原因比替代char.ToUpper(s[0]) + s.Substring(1)快，是只分配了一个字符串，而Substring方法为子字符串分配字符串，然后是第二个字符串用于组成最终结果的字符串。
编辑：以下是此方法的结果，并结合CarlosMuñoz accepted answer的初始测试：
/// <summary>
/// Returns the input string with the first character converted to uppercase
/// </summary>
public static string FirstLetterToUpperCase(this string s)
{
if (string.IsNullOrEmpty(s))
throw new ArgumentException("There is no first letter");
char[] a = s.ToCharArray();
a[0] = char.ToUpper(a[0]);
return new string(a);
}
答案 4 :(得分：41)
您可以使用“ToTitleCase方法”
string s = new CultureInfo("en-US").TextInfo.ToTitleCase("red house");
//result : Red House
这种扩展方法解决了每个标题问题。
易于使用
string str = "red house";
str.ToTitleCase();
//result : Red house
string str = "red house";
str.ToTitleCase(TitleCase.All);
//result : Red House
扩展方法
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;
namespace Test
{
public static class StringHelper
{
private static CultureInfo ci = new CultureInfo("en-US");
//Convert all first latter
public static string ToTitleCase(this string str)
{
str = str.ToLower();
var strArray = str.Split(' ');
if (strArray.Length > 1)
{
strArray[0] = ci.TextInfo.ToTitleCase(strArray[0]);
return string.Join(" ", strArray);
}
return ci.TextInfo.ToTitleCase(str);
}
public static string ToTitleCase(this string str, TitleCase tcase)
{
str = str.ToLower();
switch (tcase)
{
case TitleCase.First:
var strArray = str.Split(' ');
if (strArray.Length > 1)
{
strArray[0] = ci.TextInfo.ToTitleCase(strArray[0]);
return string.Join(" ", strArray);
}
break;
case TitleCase.All:
return ci.TextInfo.ToTitleCase(str);
default:
break;
}
return ci.TextInfo.ToTitleCase(str);
}
}
public enum TitleCase
{
First,
All
}
}
答案 5 :(得分：31)
对于第一个字母，错误检查：
public string CapitalizeFirstLetter(string s)
{
if (String.IsNullOrEmpty(s))
return s;
if (s.Length == 1)
return s.ToUpper();
return s.Remove(1).ToUpper() + s.Substring(1);
}
这就像一个方便的扩展
public static string CapitalizeFirstLetter(this string s)
{
if (String.IsNullOrEmpty(s)) return s;
if (s.Length == 1) return s.ToUpper();
return s.Remove(1).ToUpper() + s.Substring(1);
}
答案 6 :(得分：10)
public static string ToInvarianTitleCase(this string self)
{
if (string.IsNullOrWhiteSpace(self))
{
return self;
}
return CultureInfo.InvariantCulture.TextInfo.ToTitleCase(self);
}
答案 7 :(得分：6)
如果性能/内存使用是个问题，那么这个只会创建一（1）个StringBuilder和一（1）个与原始字符串大小相同的新String。
public static string ToUpperFirst(this string str) {
if( !string.IsNullOrEmpty( str ) ) {
StringBuilder sb = new StringBuilder(str);
sb[0] = char.ToUpper(sb[0]);
return sb.ToString();
} else return str;
}
答案 8 :(得分：6)
因为这个问题是关于最大化性能，所以我采用了Darren版本来使用Span，这样可以减少垃圾并提高速度约10％。
/// <summary>
/// Returns the input string with the first character converted to uppercase
/// </summary>
public static string ToUpperFirst(this string s)
{
if (string.IsNullOrEmpty(s))
throw new ArgumentException("There is no first letter");
Span<char> a = stackalloc char[s.Length];
s.AsSpan(1).CopyTo(a.Slice(1));
a[0] = char.ToUpper(s[0]);
return new string(a);
}
| Method | Data | Mean | Error | StdDev |
|-------- |---------- |----------:|----------:|----------:|
| Carlos | red | 107.29 ns | 2.2401 ns | 3.9234 ns |
| Darren | red | 30.93 ns | 0.9228 ns | 0.8632 ns |
| Marcell | red | 26.99 ns | 0.3902 ns | 0.3459 ns |
| Carlos | red house | 106.78 ns | 1.9713 ns | 1.8439 ns |
| Darren | red house | 32.49 ns | 0.4253 ns | 0.3978 ns |
| Marcell | red house | 27.37 ns | 0.3888 ns | 0.3637 ns |
using System;
using System.Linq;
using BenchmarkDotNet.Attributes;
namespace CorePerformanceTest
{
public class StringUpperTest
{
[Params("red", "red house")]
public string Data;
[Benchmark]
public string Carlos() => Data.Carlos();
[Benchmark]
public string Darren() => Data.Darren();
[Benchmark]
public string Marcell() => Data.Marcell();
}
internal static class StringExtensions
{
public static string Carlos(this string input) =>
input switch
{
null => throw new ArgumentNullException(nameof(input)),
"" => throw new ArgumentException($"{nameof(input)} cannot be empty", nameof(input)),
_ => input.First().ToString().ToUpper() + input.Substring(1)
};
public static string Darren(this string s)
{
if (string.IsNullOrEmpty(s))
throw new ArgumentException("There is no first letter");
char[] a = s.ToCharArray();
a[0] = char.ToUpper(a[0]);
return new string(a);
}
public static string Marcell(this string s)
{
if (string.IsNullOrEmpty(s))
throw new ArgumentException("There is no first letter");
Span<char> a = stackalloc char[s.Length];
s.AsSpan(1).CopyTo(a.Slice(1));
a[0] = char.ToUpper(s[0]);
return new string(a);
}
}
}
编辑： 有一个typeo，而不是s [0]，而是a [0]-这导致分配的Span a杯形相同，空值。
答案 9 :(得分：4)
试试这个：
static public string UpperCaseFirstCharacter(this string text) {
return Regex.Replace(text, "^[a-z]", m => m.Value.ToUpper());
}
答案 10 :(得分：3)
最快的方法。
private string Capitalize(string s){
if (string.IsNullOrEmpty(s))
{
return string.Empty;
}
char[] a = s.ToCharArray();
a[0] = char.ToUpper(a[0]);
return new string(a);
}
测试显示下一个结果（带有10000000个符号作为输入的字符串）： Test results
答案 11 :(得分：3)
如果您只关心第一个字母大写，并且字符串的其余部分无关紧要，您可以选择第一个字符，将其设置为大写，并将其与字符串的其余部分连接，而不使用原始的第一个字符。< / p>
String word ="red house";
word = word[0].ToString().ToUpper() + word.Substring(1, word.length -1);
//result: word = "Red house"
我们需要转换第一个字符ToString（），因为我们将它作为Char数组读取，而Char类型没有ToUpper（）方法。
答案 12 :(得分：3)
我在http://www.dotnetperls.com/uppercase-first-letter发现了一些内容：
static string UppercaseFirst(string s)
{
// Check for empty string.
if (string.IsNullOrEmpty(s))
{
return string.Empty;
}
// Return char and concat substring.
return char.ToUpper(s[0]) + s.Substring(1);
}
也许这有帮助!!
答案 13 :(得分：3)
因为我也碰巧正在研究这个问题，并且正在寻找任何想法，这就是我所遇到的解决方案。它使用LINQ，并且能够大写字符串的第一个字母，即使第一个字母不是字母。这是我最终制作的扩展方法。
public static string CaptalizeFirstLetter(this string data)
{
var chars = data.ToCharArray();
// Find the Index of the first letter
var charac = data.First(char.IsLetter);
var i = data.IndexOf(charac);
// capitalize that letter
chars[i] = char.ToUpper(chars[i]);
return new string(chars);
}
我确信有一种方法可以优化或清理它。
答案 14 :(得分：3)
这是一种将其作为扩展方法的方法：
static public string UpperCaseFirstCharacter(this string text)
{
if (!string.IsNullOrEmpty(text))
{
return string.Format(
"{0}{1}",
text.Substring(0, 1).ToUpper(),
text.Substring(1));
}
return text;
}
然后可以像：
一样调用//yields "This is Brian's test.":
"this is Brian's test.".UpperCaseFirstCharacter();
这里有一些单元测试：
[Test]
public void UpperCaseFirstCharacter_ZeroLength_ReturnsOriginal()
{
string orig = "";
string result = orig.UpperCaseFirstCharacter();
Assert.AreEqual(orig, result);
}
[Test]
public void UpperCaseFirstCharacter_SingleCharacter_ReturnsCapital()
{
string orig = "c";
string result = orig.UpperCaseFirstCharacter();
Assert.AreEqual("C", result);
}
[Test]
public void UpperCaseFirstCharacter_StandardInput_CapitalizeOnlyFirstLetter()
{
string orig = "this is Brian's test.";
string result = orig.UpperCaseFirstCharacter();
Assert.AreEqual("This is Brian's test.", result);
}
答案 15 :(得分：2)
在我们的方法中使用string.Create()并避免使用throw关键字（是的，您没看错），我们可以将Marcell's answer进一步向前迈进。另外，我的方法可以处理任意长度的字符串（例如，几兆字节的文本）。
public static string L33t(this string s)
{
static void ThrowError() => throw new ArgumentException("There is no first letter");
if (string.IsNullOrEmpty(s))
ThrowError(); // No "throw" keyword to avoid costly IL
return string.Create(s.Length, s, (chars, state) =>
{
state.AsSpan().CopyTo(chars); // No slicing to save some CPU cycles
chars[0] = char.ToUpper(chars[0]);
});
}
以下是在.NET Core 3.1.7, x64上运行的基准测试的数字。我添加了一个更长的字符串来确定额外副本的成本。
| Method | Data | Mean | Error | StdDev | Median |
|-------- |--------------------- |----------:|----------:|----------:|----------:|
| L33t | red | 8.545 ns | 0.4612 ns | 1.3308 ns | 8.075 ns |
| Marcell | red | 9.153 ns | 0.3377 ns | 0.9471 ns | 8.946 ns |
| L33t | red house | 7.715 ns | 0.1741 ns | 0.4618 ns | 7.793 ns |
| Marcell | red house | 10.537 ns | 0.5002 ns | 1.4351 ns | 10.377 ns |
| L33t | red r(...)house [89] | 11.121 ns | 0.6774 ns | 1.9106 ns | 10.612 ns |
| Marcell | red r(...)house [89] | 16.739 ns | 0.4468 ns | 1.3033 ns | 16.853 ns |
using System;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
namespace CorePerformanceTest
{
class Program
{
static void Main(string[] args)
{
var summary = BenchmarkRunner.Run<StringUpperTest>();
}
}
public class StringUpperTest
{
[Params("red", "red house", "red red red red red red red red red red red red red red red red red red red red red house")]
public string Data;
[Benchmark]
public string Marcell() => Data.Marcell();
[Benchmark]
public string L33t() => Data.L33t();
}
internal static class StringExtensions
{
public static string Marcell(this string s)
{
if (string.IsNullOrEmpty(s))
throw new ArgumentException("There is no first letter");
Span<char> a = stackalloc char[s.Length];
s.AsSpan(1).CopyTo(a.Slice(1));
a[0] = char.ToUpper(s[0]);
return new string(a);
}
public static string L33t(this string s)
{
static void ThrowError() => throw new ArgumentException("There is no first letter");
if (string.IsNullOrEmpty(s))
ThrowError(); // IMPORTANT: Do not "throw" here!
return string.Create(s.Length, s, (chars, state) =>
{
state.AsSpan().CopyTo(chars);
chars[0] = char.ToUpper(chars[0]);
});
}
}
}
请告诉我您是否可以加快速度！
答案 16 :(得分：2)
这样做虽然它也会确保没有错误的大写字母不在单词的开头。
public string(string s)
{
System.Globalization.CultureInfo c = new System.Globalization.CultureInfo("en-us", false)
System.Globalization.TextInfo t = c.TextInfo;
return t.ToTitleCase(s);
}
答案 17 :(得分：2)
当你需要的是：
时，似乎有很多复杂性 /// <summary>
/// Returns the input string with the first character converted to uppercase if a letter
/// </summary>
/// <remarks>Null input returns null</remarks>
public static string FirstLetterToUpperCase(this string s)
{
if (string.IsNullOrWhiteSpace(s))
return s;
return char.ToUpper(s[0]) + s.Substring(1);
}
值得注意的一点：
它是一种扩展方法。
如果输入为null，为空或空格，则输入将按原样返回。
String.IsNullOrWhiteSpace是在.NET Framework 4中引入的。这不适用于旧框架。
答案 18 :(得分：1)
string emp="TENDULKAR";
string output;
output=emp.First().ToString().ToUpper() + String.Join("", emp.Skip(1)).ToLower();
答案 19 :(得分：1)
检查字符串是否不为null，然后将第一个字符转换为大写，并将其余字符转换为小写：
public static string FirstCharToUpper(string str)
{
return str?.First().ToString().ToUpper() + str?.Substring(1).ToLower();
}
答案 20 :(得分：1)
我认为以下方法是最佳解决方案
class Program
{
static string UppercaseWords(string value)
{
char[] array = value.ToCharArray();
// Handle the first letter in the string.
if (array.Length >= 1)
{
if (char.IsLower(array[0]))
{
array[0] = char.ToUpper(array[0]);
}
}
// Scan through the letters, checking for spaces.
// ... Uppercase the lowercase letters following spaces.
for (int i = 1; i < array.Length; i++)
{
if (array[i - 1] == ' ')
{
if (char.IsLower(array[i]))
{
array[i] = char.ToUpper(array[i]);
}
}
}
return new string(array);
}
static void Main()
{
// Uppercase words in these strings.
const string value1 = "something in the way";
const string value2 = "dot net PERLS";
const string value3 = "String_two;three";
const string value4 = " sam";
// ... Compute the uppercase strings.
Console.WriteLine(UppercaseWords(value1));
Console.WriteLine(UppercaseWords(value2));
Console.WriteLine(UppercaseWords(value3));
Console.WriteLine(UppercaseWords(value4));
}
}
Output
Something In The Way
Dot Net PERLS
String_two;three
Sam
答案 21 :(得分：1)
我想提供“最大性能”答案。在我看来，“最大性能”答案捕获了所有场景，并提供了解决这些场景的问题的答案。所以，这是我的答案。出于这些原因：
将它们作为可选参数提供，使得此方法完全可重用，无需每次都输入所选文化。
public static string capString(string instring, string culture = "en-US", bool useSystem = false)
{
string outstring;
if (String.IsNullOrWhiteSpace(instring))
{
return "";
}
instring = instring.Trim();
char thisletter = instring.First();
if (!char.IsLetter(thisletter))
{
return instring;
}
outstring = thisletter.ToString().ToUpper(new CultureInfo(culture, useSystem));
if (instring.Length > 1)
{
outstring += instring.Substring(1);
}
return outstring;
}
答案 22 :(得分：0)
我们可以这样做（C# 8.0、.NET 5）：
input?.Length > 0 ? char.ToUpperInvariant(input[0]) + input[1..] : input
我相信这足以进行内联。
如果 input 是一个空字符串，我们得到一个空字符串。如果 input 是 null，我们得到 null。
否则，代码采用第一个字符 input[0] 并使用 char.ToUpperInvariant 将其转换为大写。并连接其余的 input[1..]。
编译器会将范围访问转换为对 Substring 的调用，此外它还可以利用我们已经获得长度的事实。
与接受的答案相比，这具有不使用 LINQ 的优点。其他一些答案将字符串转换为数组只是为了取第一个字符。这段代码也没有这样做。
如果您更喜欢扩展方法，可以这样做：
public static string FirstCharToUpper(this string input) =>
input?.Length > 0 ? char.ToUpperInvariant(input[0]) + input[1..] : input;
如果你更喜欢扔怎么办？好的，让它抛出：
public static string FirstCharToUpper(this string input) =>
input switch
{
null => throw new ArgumentNullException(nameof(input)),
_ => input.Length > 0 ? char.ToUpperInvariant(input[0]) + input[1..] : input
};
这里大致等效的代码（因为我们正在制作一个扩展方法，我们可以更详细一点）：
public static string FirstCharToUpperEquivalent(this string input)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
var length = input.Length;
if (length == 0)
{
return input;
}
string firstCharacter = char.ToUpperInvariant(input[0]).ToString();
return string.Concat(firstCharacter, input.Substring(1, length - 1));
}
我用 1000 轮 155 个单词做了一个基准测试（所以它们被调用了 155000 次），这是结果：
Benchmarking type Tests
TestAccepted 00:00:00.0465979
TestProposalNoThrow 00:00:00.0092839
TestProposalDoThrow 00:00:00.0092938
TestProposalEquival 00:00:00.0091463
我在 Windows 10、Intel Core i3 上运行它，使用来自 Jon Skeet 的 Simple microbenchmarking in C# 代码。
答案 23 :(得分：0)
将此第一个字母和每个字母后面的空格和小写字母大写为任何其他字母。
public string CapitalizeFirstLetterAfterSpace(string input)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder(input);
bool capitalizeNextLetter = true;
for(int pos = 0; pos < sb.Length; pos++)
{
if(capitalizeNextLetter)
{
sb[pos]=System.Char.ToUpper(sb[pos]);
capitalizeNextLetter = false;
}
else
{
sb[pos]=System.Char.ToLower(sb[pos]);
}
if(sb[pos]=' ')
{
capitalizeNextLetter=true;
}
}
}
答案 24 :(得分：0)
可能的解决方案，您的问题。
public static string FirstToUpper(this string lowerWord)
{
if (string.IsNullOrWhiteSpace(lowerWord) || string.IsNullOrEmpty(lowerWord))
return lowerWord;
return new StringBuilder(lowerWord.Substring(0, 1).ToUpper())
.Append(lowerWord.Substring(1))
.ToString();
}
答案 25 :(得分：0)
最近我有类似的要求，并记得LINQ函数Select（）提供了一个索引：
public static class StringExtensions
{
public static string FirstLetterToUpper(this string input)
{
if (string.IsNullOrEmpty(input))
return string.Empty;
return String.Concat(input.Select((currentChar, index) => index == 0 ? Char.ToUpper(currentChar) : currentChar));
}
}
由于我经常需要，我为字符串类型创建了一个扩展方法：
{{1}}
请注意，只有第一个字母转换为大写字母 - 不会触及所有剩余字符。如果你需要其他字符为小写，你也可以调用Char.ToLower（currentChar）作为索引＆gt; 0或首先在整个字符串上调用ToLower（）。
关于性能，我将代码与Darren的解决方案进行了比较。在我的机器上，Darren的代码大约快2倍，这并不奇怪，因为他只是直接编辑char数组中的第一个字母。 因此，如果您需要最快的解决方案，我建议您使用Darren的代码。如果你想整合其他的字符串操作，那么使用lambda函数的表达能力触及输入字符串的字符可能很方便 - 你可以很容易地扩展这个函数 - 所以我把这个解决方案留在这里。
答案 26 :(得分：0)
扩展Carlos上面的问题，如果你想把多个句子大写，你可以使用这段代码：
/// <summary>
/// Capitalize first letter of every sentence.
/// </summary>
/// <param name="inputSting"></param>
/// <returns></returns>
public string CapitalizeSentences (string inputSting)
{
string result = string.Empty;
if (!string.IsNullOrEmpty(inputSting))
{
string[] sentences = inputSting.Split('.');
foreach (string sentence in sentences)
{
result += string.Format ("{0}{1}.", sentence.First().ToString().ToUpper(), sentence.Substring(1));
}
}
return result;
}
答案 27 :(得分：0)
以下功能适用于所有方式：
static string UppercaseWords(string value)
{
char[] array = value.ToCharArray();
// Handle the first letter in the string.
if (array.Length >= 1)
{
if (char.IsLower(array[0]))
{
array[0] = char.ToUpper(array[0]);
}
}
// Scan through the letters, checking for spaces.
// ... Uppercase the lowercase letters following spaces.
for (int i = 1; i < array.Length; i++)
{
if (array[i - 1] == ' ')
{
if (char.IsLower(array[i]))
{
array[i] = char.ToUpper(array[i]);
}
}
}
return new string(array);
}
我发现here
答案 28 :(得分：0)
这是对我有用的代码：
const webClient = axios.create();
export const FunctionalComponent = ({children}) => {
...
webClient.get(...)
...
}
答案 29 :(得分：0)
资本化冷杉信的最简单方法是：
1-使用Sytem.Globalization;
// Creates a TextInfo based on the "en-US" culture.
TextInfo myTI = new CultureInfo("en-US",false).
myTI.ToTitleCase(textboxname.Text)
`
答案 30 :(得分：0)
这是最快的方式：
public static unsafe void ToUpperFirst(this string str)
{
if (str == null) return;
fixed (char* ptr = str)
*ptr = char.ToUpper(*ptr);
}
不改变原始字符串：
public static unsafe string ToUpperFirst(this string str)
{
if (str == null) return null;
string ret = string.Copy(str);
fixed (char* ptr = ret)
*ptr = char.ToUpper(*ptr);
return ret;
}
答案 31 :(得分：0)
FluentSharp使用lowerCaseFirstLetter方法执行此操作
答案 32 :(得分：0)
似乎这里给出的解决方案都不会在字符串之前处理空格。
只是添加这个想法：
public static string SetFirstCharUpper2(string aValue, bool aIgonreLeadingSpaces = true)
{
if (string.IsNullOrWhiteSpace(aValue))
return aValue;
string trimmed = aIgonreLeadingSpaces
? aValue.TrimStart()
: aValue;
return char.ToUpper(trimmed[0]) + trimmed.Substring(1);
}
它应该处理this won't work on other answers（该句子在开头有空格），如果你不喜欢空间修剪，只需传递false作为第二个参数（或更改默认为false，如果您想处理空间，则传递true
答案 33 :(得分：0)
使用以下代码：
string strtest ="PRASHANT";
strtest.First().ToString().ToUpper() + strtest.Remove(0, 1).ToLower();
答案 34 :(得分：-1)
向此函数发送一个字符串。它会首先检查字符串是空还是空，如果不是字符串将是所有较低的字符。然后返回字符串上部其余部分的第一个字符串。
string FirstUpper(string s)
{
// Check for empty string.
if (string.IsNullOrEmpty(s))
{
return string.Empty;
}
s = s.ToLower();
// Return char and concat substring.
return char.ToUpper(s[0]) + s.Substring(1);
}
答案 35 :(得分：-1)
使用此方法，您可以在每个单词的第一个字符上加上。
实施例 “HeLlo wOrld”=＆gt; “你好世界”
public static string FirstCharToUpper(string input)
{
if (String.IsNullOrEmpty(input))
throw new ArgumentException("Error");
return string.Join(" ", input.Split(' ').Select(d => d.First().ToString().ToUpper() + d.ToLower().Substring(1)));
}
答案 36 :(得分：-2)
我用它来纠正名字。它基本上适用于将字符更改为大写的概念，如果它遵循特定的模式，在这种情况下，我已经去了空间，冲破了＆＃34; Mc＆＃34;。
private String CorrectName(String name)
{
List<String> StringsToCapitalizeAfter = new List<String>() { " ", "-", "Mc" };
StringBuilder NameBuilder = new StringBuilder();
name.Select(c => c.ToString()).ToList().ForEach(c =>
{
c = c.ToLower();
new List<String>() { " ", "-", "Mc" }.ForEach(s =>
{
if(String.IsNullOrEmpty(NameBuilder.ToString()) || NameBuilder.ToString().EndsWith(s))
{
c = c.ToUpper();
}
});
NameBuilder.Append(c);
});
return NameBuilder.ToString();
}
答案 37 :(得分：-2)
正如BobBeechey在his response to this question中建议的那样，以下代码适用于此：
private void txt_fname_TextChanged(object sender, EventArgs e)
{
char[] c = txt_fname.Text.ToCharArray();
int j;
for (j = 0; j < txt_fname.Text.Length; j++)
{
if (j==0) c[j]=c[j].ToString().ToUpper()[0];
else c[j] = c[j].ToString().ToLower()[0];
}
txt_fname.Text = new string(c);
txt_fname.Select(txt_fname.Text.Length, 1);
}
答案 38 :(得分：-3)
string s_Val = "test";
if (s_Val != "")
{
s_Val = char.ToUpper(s_Val[0]);
if (s_Val.Length > 1)
{
s_Val += s_Val.Substring(1);
}
}
答案 39 :(得分：-3)
TextInfo ti = CultureInfo.CurrentCulture.TextInfo;
Console.WriteLine（ti.ToTitleCase（inputString））;
答案 40 :(得分：-3)
string input = "red HOUSE";
System.Text.StringBuilder sb = new System.Text.StringBuilder(input);
for (int j = 0; j < sb.Length; j++)
{
if ( j == 0 ) //catches just the first letter
sb[j] = System.Char.ToUpper(sb[j]);
else //everything else is lower case
sb[j] = System.Char.ToLower(sb[j]);
}
// Store the new string.
string corrected = sb.ToString();
System.Console.WriteLine(corrected);
答案 41 :(得分：-4)
private string capitalizeFirstCharacter(string format)
{
if (string.IsNullOrEmpty(format))
return string.Empty;
else
return char.ToUpper(format[0]) + format.ToLower().Substring(1);
}
答案 42 :(得分：-5)
最简单，最快捷的方法是将字符串的第一个字符串替换为大写字符：
string str = "test";<br>
str = str.Replace(str[0], char.ToUpper(str[0]));