BestPractice: trasforma il primo carattere di una stringa in lettere minuscole

Mi piacerebbe avere un metodo che trasforma il primo carattere di una stringa in lettere minuscole.

I miei approcci:

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

Quale sarebbe il tuo approccio?

Vorrei usare la concatenazione semplice:

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

La prima soluzione non è ottimizzata perché string.Formatè lenta e non è necessaria se si dispone di un formato che non cambierà mai. Genera anche una stringa aggiuntiva per convertire la lettera in minuscolo, che non è necessaria.

L'approccio con "+ 32" è brutto / non mantenibile in quanto richiede la conoscenza degli offset dei valori dei caratteri ASCII. Inoltre genererà un output errato con dati Unicode e caratteri simbolo ASCII.

A seconda della situazione, potrebbe essere auspicabile una programmazione difensiva:

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

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

L' ifistruzione impedisce inoltre la creazione di una nuova stringa se non verrà comunque modificata. È possibile che si desideri che il metodo abbia esito negativo sull'input null e generare un ArgumentNullException.

Come è già stato detto, l'utilizzo String.Formatper questo è eccessivo.

Nel caso in cui aiuti qualcuno che si imbatte in questa risposta.

Penso che sarebbe meglio come metodo di estensione, quindi puoi chiamarlo con 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);
    }
}

Il mio è

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

Mi piace la risposta accettata, ma oltre al controllo string.IsNullOrEmptyvorrei anche verificare se Char.IsLower(name[1])nel caso si tratti di abbreviazioni. Ad esempio, non vorresti che "AIDS" diventasse "AIDS".

La soluzione più veloce che conosco senza abusare di 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;
}

Combinato alcuni e ha reso un'estensione concatenabile. Aggiunto corto circuito su spazi bianchi e non lettera.

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;

Questo è un piccolo metodo di estensione che utilizza la sintassi più recente e le convalide corrette

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

Usa questo:

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

È meglio usarlo String.Concatche String.Formatse si sa che il formato non è un cambiamento di dati e si desidera solo la concatenazione.