BestPractice - Chuyển đổi ký tự đầu tiên của chuỗi thành chữ thường

Tôi muốn có một phương thức biến đổi ký tự đầu tiên của chuỗi thành chữ thường.

Cách tiếp cận của tôi:

1.

public static string ReplaceFirstCharacterToLowerVariant(string name)
{
    return String.Format("{0}{1}", name.First().ToString().ToLowerInvariant(), name.Substring(1));
}

2.

public static IEnumerable<char> FirstLetterToLowerCase(string value)
{
    var firstChar = (byte)value.First();
    return string.Format("{0}{1}", (char)(firstChar + 32), value.Substring(1));
}

Cách tiếp cận của bạn là gì?

Tôi sẽ sử dụng cách ghép đơn giản:

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

Giải pháp đầu tiên không được tối ưu hóa vì string.Format chậm và bạn không cần nó nếu bạn có định dạng sẽ không bao giờ thay đổi. Nó cũng tạo ra một chuỗi bổ sung để chuyển đổi chữ cái thành chữ thường, không cần thiết.

Cách tiếp cận với "+ 32" là xấu / không thể duy trì được vì nó đòi hỏi kiến ​​thức về các giá trị bù của ký tự ASCII. Nó cũng sẽ tạo đầu ra không chính xác với dữ liệu Unicode và các ký tự ký hiệu ASCII.

Tùy thuộc vào tình huống, một chút lập trình phòng thủ có thể được mong muốn:

public static string FirstCharacterToLower(string str)
{
    if (String.IsNullOrEmpty(str) || Char.IsLower(str, 0))
        return str;

    return Char.ToLowerInvariant(str[0]) + str.Substring(1);
}

Các iftuyên bố cũng ngăn cản một chuỗi mới được xây dựng nếu nó sẽ không được thay đổi anyway. Thay vào đó, bạn có thể muốn phương thức bị lỗi khi nhập null và ném một ArgumentNullException.

Như mọi người đã đề cập, sử dụng String.Formatcho việc này là quá mức cần thiết.

Chỉ trong trường hợp nó giúp bất cứ ai tình cờ vấp phải câu trả lời này.

Tôi nghĩ rằng đây sẽ là phương thức mở rộng tốt nhất, sau đó bạn có thể gọi nó bằng yourString.FirstCharacterToLower ();

public static class StringExtensions
{
    public static string FirstCharacterToLower(this string str)
    {
        if (String.IsNullOrEmpty(str) || Char.IsLower(str, 0))
        {
            return str;
        }

        return Char.ToLowerInvariant(str[0]) + str.Substring(1);
    }
}

Của tôi là

if (!string.IsNullOrEmpty (val) && val.Length > 0)
{
    return val[0].ToString().ToLowerInvariant() + val.Remove (0,1);   
}

Tôi thích câu trả lời được chấp nhận, nhưng bên cạnh việc kiểm tra string.IsNullOrEmptytôi cũng sẽ kiểm tra xem Char.IsLower(name[1])trong trường hợp bạn đang xử lý từ viết tắt. Ví dụ, bạn sẽ không muốn "AIDS" trở thành "aIDS".

Giải pháp nhanh nhất tôi biết mà không lạm dụng c #:

public static string LowerCaseFirstLetter(string value)
{
    if (value?.Length > 0)
    {
        var letters = value.ToCharArray();
        letters[0] = char.ToLowerInvariant(letters[0]);
        return new string(letters);
    }
    return value;
}

Kết hợp một vài và làm cho nó một phần mở rộng chuỗi. Đã thêm ngắn mạch trên khoảng trắng và không chữ.

public static string FirstLower(this string input) => 
    (!string.IsNullOrWhiteSpace(input) && input.Length > 0 
        && char.IsLetter(input[0]) && !char.IsLower(input[0]))
    ? input[0].ToString().ToLowerInvariant() + input.Remove(0, 1) : input;

Đây là một phương pháp mở rộng nhỏ bằng cách sử dụng cú pháp mới nhất và xác nhận chính xác

public static class StringExtensions
{
    public static string FirstCharToLower(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().ToLower() + input.Substring(1);
        }
    }
}

Dùng cái này:

string newName= name[0].ToString().ToLower() + name.Substring(1);

Nó là tốt hơn để sử dụng String.Concathơn String.Formatnếu bạn biết rằng định dạng không thay đổi dữ liệu, và chỉ cần ghép nối là mong muốn.