Tôi có một DetailsViewvới một TextBox và tôi muốn các dữ liệu đầu vào be luôn lưu với BÀI ĐẦU TIÊN TRONG VỐN.

Thí dụ:

"red" --> "Red"
"red house" --> " Red house"

Làm thế nào tôi có thể đạt được hiệu suất tối đa này ?

LƯU Ý :
Dựa trên các câu trả lời và các ý kiến ​​dưới các câu trả lời, nhiều người nghĩ rằng đây là hỏi về cách viết hoa tất cả các từ trong chuỗi. Ví dụ: => Red House Nó không phải là, nhưng nếu đó là những gì bạn tìm kiếm , xem xét cho một trong những câu trả lời mà công dụng TextInfocủa ToTitleCasephương pháp. (Chú ý: Những câu trả lời là không chính xác . Cho câu hỏi thực sự hỏi)
Xem TextInfo.ToTitleCase doc cho cẩn thận (không chạm vào tất cả mũ từ - họ là coi từ viết tắt; có thể thành chữ thường chữ ở giữa của từ mà "không nên" được hạ xuống, ví dụ "McDonald" => "Mcdonald"; không được bảo đảm để xử lý tất cả các quy tắc viết hoa đặc trưng cho văn hóa.)

Chú ý :
Câu hỏi đặt ra là mơ hồ về việc liệu chữ sau khi người đầu tiên nên được buộc để giảm trường hợp . Câu trả lời được chấp nhận giả định rằng chỉ nên thay đổi chữ cái đầu tiên . Nếu bạn muốn buộc tất cả các chữ cái trong chuỗi ngoại trừ chữ cái đầu tiên thành chữ thường, hãy tìm câu trả lời có chứa ToLowervà không chứa ToTitleCase .

Đã cập nhật lên C # 8

public static class StringExtensions
{
    public static string FirstCharToUpper(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)
        };
}

C # 7

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

Câu trả lời thực sự cũ

public static string FirstCharToUpper(string input)
{
    if (String.IsNullOrEmpty(input))
        throw new ArgumentException("ARGH!");
    return input.First().ToString().ToUpper() + String.Join("", input.Skip(1));
}

EDIT : Phiên bản này ngắn hơn. Để có giải pháp nhanh hơn, hãy xem câu trả lời của Equiso

public static string FirstCharToUpper(string input)
{
    if (String.IsNullOrEmpty(input))
        throw new ArgumentException("ARGH!");
    return input.First().ToString().ToUpper() + input.Substring(1);
}

EDIT 2 : Có lẽ giải pháp nhanh nhất là của Darren (Thậm chí có điểm chuẩn) mặc dù tôi sẽ thay đổi string.IsNullOrEmpty(s)xác nhận của mình để đưa ra một ngoại lệ vì yêu cầu ban đầu mong muốn có một chữ cái đầu tiên tồn tại để nó có thể được viết hoa. Lưu ý rằng mã này hoạt động cho một chuỗi chung và không đặc biệt trên các giá trị hợp lệ từ Textbox.

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

Câu trả lời cũ: Điều này làm cho mỗi chữ cái đầu tiên viết hoa

public string ToTitleCase(string str)
{
    return CultureInfo.CurrentCulture.TextInfo.ToTitleCase(str.ToLower());
}

Cách đúng đắn là sử dụng Văn hóa:

System.Globalization.CultureInfo.CurrentCulture.TextInfo.ToTitleCase(word.ToLower())

Lưu ý: Điều này sẽ viết hoa từng từ trong một chuỗi, ví dụ "nhà đỏ" -> "Nhà đỏ". Giải pháp cũng sẽ viết hoa chữ thường trong các từ, ví dụ "McDonald cũ" -> "Old Mcdonald".

Tôi đã sử dụng phương thức nhanh nhất từ http://www.dotnetperls.com/uppercase-first-letter và chuyển đổi sang phương thức mở rộng:

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

LƯU Ý: Lý do sử dụng ToCharArraynhanh hơn giải pháp thay thế char.ToUpper(s[0]) + s.Substring(1), là chỉ có một chuỗi được phân bổ, trong khi Substringcách tiếp cận phân bổ một chuỗi cho chuỗi con, sau đó là chuỗi thứ hai để tạo kết quả cuối cùng.

EDIT : Đây là cách tiếp cận này, kết hợp với thử nghiệm ban đầu từ câu trả lời được chấp nhận của CarlosMuñoz :

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

Bạn có thể sử dụng "phương thức ToTitleCase"

string s = new CultureInfo("en-US").TextInfo.ToTitleCase("red house");
//result : Red House

phương pháp mở rộng này giải quyết mọi vấn đề về Titlecase.

dễ sử dụng

string str = "red house";
str.ToTitleCase();
//result : Red house

string str = "red house";
str.ToTitleCase(TitleCase.All);
//result : Red House

phương pháp mở rộng

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

Đối với chữ cái đầu tiên, với kiểm tra lỗi:

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

Và đây là một phần mở rộng tiện dụng

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

public static string ToInvarianTitleCase(this string self)
{
    if (string.IsNullOrWhiteSpace(self))
    {
        return self;
    }

    return CultureInfo.InvariantCulture.TextInfo.ToTitleCase(self);
}

Nếu việc sử dụng hiệu năng / bộ nhớ là một vấn đề thì cái này chỉ tạo một (1) StringBuilder và một (1) Chuỗi mới có cùng kích thước với chuỗi gốc.

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

Phương pháp nhanh nhất.

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

Các thử nghiệm hiển thị kết quả tiếp theo (chuỗi có 10000000 ký hiệu làm đầu vào): Kết quả thử nghiệm

Thử cái này:

static public string UpperCaseFirstCharacter(this string text) {
    return Regex.Replace(text, "^[a-z]", m => m.Value.ToUpper());
}

Nếu bạn chỉ quan tâm đến chữ cái đầu tiên được viết hoa và nó không quan trọng với phần còn lại của chuỗi, bạn chỉ có thể chọn ký tự đầu tiên, đặt chữ hoa và nối nó với phần còn lại của chuỗi mà không có ký tự đầu tiên.

String word ="red house";
word = word[0].ToString().ToUpper() + word.Substring(1, word.length -1);
//result: word = "Red house"

Chúng ta cần chuyển đổi ký tự đầu tiên ToString () vì chúng ta đang đọc nó dưới dạng mảng Char và loại Char không có phương thức ToUpper ().

Đây là một cách để làm điều đó như một phương thức mở rộng:

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

Sau đó có thể được gọi là:

//yields "This is Brian's test.":
"this is Brian's test.".UpperCaseFirstCharacter(); 

Và đây là một số bài kiểm tra đơn vị cho nó:

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

Vì tôi cũng tình cờ làm việc này và đang tìm kiếm bất kỳ ý tưởng nào, đây là giải pháp tôi đã tìm đến. Nó sử dụng LINQ và sẽ có thể viết hoa chữ cái đầu tiên của chuỗi, ngay cả khi lần xuất hiện đầu tiên không phải là chữ cái. Đây là phương pháp mở rộng mà tôi đã kết thúc.

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

Tôi chắc chắn có một cách để tối ưu hóa hoặc dọn dẹp điều này một chút.

Tôi đã tìm thấy một cái gì đó ở đây 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);
}

có lẽ điều này giúp !!

Kiểm tra xem chuỗi có phải là null không, sau đó chuyển ký tự đầu tiên thành chữ hoa và phần còn lại của chúng thành chữ thường:

public static string FirstCharToUpper(string str)
{
    return str?.First().ToString().ToUpper() + str?.Substring(1).ToLower();
}

Điều này sẽ làm điều đó mặc dù nó cũng sẽ đảm bảo rằng không có thủ đô sai lầm nào không ở đầu từ.

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

Dường như có rất nhiều điều phức tạp ở đây khi tất cả những gì bạn cần là:

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

Điểm đáng chú ý:

1. Đây là một phương pháp mở rộng.

2. Nếu đầu vào là null, trống hoặc khoảng trắng, đầu vào được trả về.

3. String.IsNullOrWhiteSpace được giới thiệu với .NET Framework 4. Điều này sẽ không hoạt động với các khung cũ hơn.

string emp="TENDULKAR";
string output;
output=emp.First().ToString().ToUpper() + String.Join("", emp.Skip(1)).ToLower();

Tôi muốn cung cấp câu trả lời "HIỆU SUẤT TỐI ĐA". Trong tâm trí của tôi, một câu trả lời "HIỆU SUẤT TỐI ĐA" nắm bắt tất cả các kịch bản và cung cấp câu trả lời cho kế toán câu hỏi cho các kịch bản đó. Vì vậy, đây là câu trả lời của tôi. Với những lý do sau:

1. Tài khoản IsNullOrWhiteSpace cho các chuỗi chỉ là khoảng trắng hoặc null / trống.
2. .Trim () xóa khoảng trắng từ mặt trước và mặt sau của chuỗi.
3. .First () lấy ký tự đầu tiên của một ienumerable (hoặc chuỗi).
4. Chúng ta nên kiểm tra xem đó có phải là chữ cái có thể / nên viết hoa không.
5. Sau đó chúng ta thêm phần còn lại của chuỗi, chỉ khi độ dài cho biết chúng ta nên.
6. Bằng cách thực hành tốt nhất .Net, chúng tôi sẽ cung cấp một nền văn hóa trong System.Globalization.CARMInfo.

7. Việc cung cấp cho họ dưới dạng tham số tùy chọn làm cho phương thức này hoàn toàn có thể sử dụng lại mà không phải gõ văn hóa đã chọn mỗi lần.

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

Gần đây tôi có một yêu cầu tương tự và nhớ rằng hàm LINQ Chọn () cung cấp một chỉ mục:

string input;
string output;

input = "red house";
output = String.Concat(input.Select((currentChar, index) => index == 0 ? Char.ToUpper(currentChar) : currentChar));
//output = "Red house"

Vì tôi rất cần điều đó nên tôi đã tạo một phương thức mở rộng cho kiểu chuỗi:

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

Xin lưu ý rằng chỉ chữ cái đầu tiên được chuyển thành chữ hoa - tất cả các ký tự còn lại không được chạm vào. Nếu bạn cần các ký tự khác viết thường, bạn cũng có thể gọi Char.ToLower (currentChar) cho chỉ mục> 0 hoặc gọi ToLower () trên toàn bộ chuỗi ở vị trí đầu tiên.

Về hiệu suất tôi đã so sánh mã với giải pháp từ Darren. Trên máy của tôi, mã của Darren nhanh hơn khoảng 2 lần, điều này không có gì đáng ngạc nhiên vì anh ta chỉ chỉnh sửa trực tiếp chữ cái đầu tiên trong một mảng char. Vì vậy, tôi khuyên bạn nên lấy mã của Darren nếu bạn cần giải pháp nhanh nhất hiện có. Nếu bạn muốn tích hợp các thao tác chuỗi khác cũng có thể thuận tiện khi có sức mạnh biểu cảm của hàm lambda chạm vào các ký tự của chuỗi đầu vào - bạn có thể dễ dàng mở rộng chức năng này - vì vậy tôi để giải pháp này ở đây.

Tôi nghĩ rằng phương pháp dưới đây là giải pháp tốt nhất

    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

tham chiếu

Vì câu hỏi này là về tối đa hóa hiệu suất, tôi đã sử dụng phiên bản của Darren để sử dụng Spans, giúp giảm rác và cải thiện tốc độ khoảng 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);
        }

Hiệu suất

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

Mã kiểm tra đầy đủ

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

}

Chỉnh sửa: Có một loại, thay vì s [0], là [0] - kết quả này với giá trị cupying giống nhau, trống cho Span được phân bổ a.

Chữ này viết hoa chữ cái đầu tiên này và mỗi chữ cái theo sau một khoảng trắng và chữ thường bất kỳ chữ cái nào khác.

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

Sử dụng mã sau đây:

string  strtest ="PRASHANT";
strtest.First().ToString().ToUpper() + strtest.Remove(0, 1).ToLower();

Có vẻ như không có giải pháp nào được đưa ra ở đây sẽ xử lý một khoảng trắng trước chuỗi.

Chỉ cần thêm điều này như một suy nghĩ:

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

Nó sẽ xử lý this won't work on other answers(câu đó có khoảng trắng ở đầu) và nếu bạn không thích cắt xén không gian, chỉ cần chuyển falsetham số thứ hai (hoặc thay đổi mặc định thành falsevà chuyển truenếu bạn muốn xử lý khoảng trắng)

FluentSharp có lowerCaseFirstLetter phương thức thực hiện điều này

https: //ggith

Cách dễ nhất để viết hoa chữ cái linh sam là:

1- Sử dụng Sytem.Globalization;

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

  myTI.ToTitleCase(textboxname.Text)

`

chức năng sau đây là chính xác cho tất cả các cách:

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

Tôi thấy rằng ở đây

Mở rộng câu hỏi của Carlos ở trên, nếu bạn muốn viết hoa nhiều câu, bạn có thể sử dụng mã này:

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

Giải pháp có thể để giải quyết vấn đề của bạn.

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