BestPractice: transforma el primer carácter de una cadena en minúsculas

Me gustaría tener un método que transforme el primer carácter de una cadena en minúsculas.

Mis enfoques:

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

¿Cuál sería tu enfoque?

Yo usaría una concatenación simple:

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

La primera solución no está optimizada porque string.Format es lenta y no la necesita si tiene un formato que nunca cambiará. También genera una cadena adicional para convertir la letra a minúsculas, lo cual no es necesario.

El enfoque con "+ 32" es feo / no se puede mantener, ya que requiere el conocimiento de las compensaciones de valores de caracteres ASCII. También generará resultados incorrectos con datos Unicode y caracteres de símbolos ASCII.

Dependiendo de la situación, una pequeña programación defensiva podría ser deseable:

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

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

La ifdeclaración también evita que se cree una nueva cadena si no se va a cambiar de todos modos. Es posible que desee que el método falle en la entrada nula y arroje un ArgumentNullException.

Como la gente ha mencionado, usar String.Formatpara esto es exagerado.

Por si acaso, ayuda a cualquiera que tropiece con esta respuesta.

Creo que esto sería mejor como método de extensión, entonces puede llamarlo 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);
    }
}

El mio es

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

Me gusta la respuesta aceptada, pero además de verificar string.IsNullOrEmptytambién verificaría si Char.IsLower(name[1])se trata de abreviaturas. Por ejemplo, no querrá que el "SIDA" se convierta en "SIDA".

La solución más rápida que conozco sin abusar de 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;
}

Combinó algunos y lo convirtió en una extensión encadenable. Cortocircuito agregado en espacios en blanco y sin letras.

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;

Este es un pequeño método de extensión que utiliza la sintaxis más reciente y las validaciones correctas

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

Utilizar este:

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

Es mejor usar String.Concatque String.Formatsi sabe que el formato no es cambiar datos, y solo se desea la concatenación.