BestPractice - Przekształć pierwszy znak ciągu w małe litery

Chciałbym mieć metodę, która przekształca pierwszy znak ciągu w małe litery.

Moje podejścia:

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

Jakie byłoby Twoje podejście?

Użyłbym prostej konkatenacji:

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

Pierwsze rozwiązanie nie jest zoptymalizowane, ponieważ string.Formatjest wolne i nie potrzebujesz go, jeśli masz format, który nigdy się nie zmieni. Generuje również dodatkowy ciąg, który zamienia literę na małe litery, co nie jest potrzebne.

Podejście z „+ 32” jest brzydkie / niemożliwe do utrzymania, ponieważ wymaga znajomości przesunięć wartości znaków ASCII. Będzie również generować nieprawidłowe dane wyjściowe z danymi Unicode i znakami symboli ASCII.

W zależności od sytuacji może być potrzebne trochę programowania obronnego:

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

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

ifOświadczenie zapobiega także nowy ciąg z budowane jeśli nie będzie zresztą zmieniło. Zamiast tego możesz chcieć, aby metoda zakończyła się niepowodzeniem przy zerowym wejściu i wyrzucić ArgumentNullException.

Jak już wspomnieli ludzie, używanie String.Formatdo tego jest przesadą.

Na wszelki wypadek pomoże to każdemu, kto natknie się na tę odpowiedź.

Myślę, że byłoby to najlepsze jako metoda rozszerzająca, wtedy możesz ją wywołać za pomocą 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);
    }
}

Mój jest

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

Podoba mi się zaakceptowana odpowiedź, ale oprócz sprawdzenia string.IsNullOrEmptychciałbym również sprawdzić, czy Char.IsLower(name[1])na wypadek, gdybyś miał do czynienia ze skrótem. Np. Nie chciałbyś, aby „AIDS” stał się „AIDS”.

Najszybsze rozwiązanie, jakie znam, bez nadużywania 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;
}

Połączyłem kilka i uczyniłem z niego przedłużenie łańcuchowe. Dodano zwarcie na białych znakach i nieliterach.

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;

Jest to mała metoda rozszerzenia wykorzystująca najnowszą składnię i poprawne walidacje

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

Użyj tego:

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

Lepiej jest używać, String.Concatniż String.Formatjeśli wiesz, że format nie jest zmianą danych, a pożądane jest po prostu połączenie.