BestPractice - Transforme o primeiro caractere de uma string em minúsculas

Eu gostaria de ter um método que transforma o primeiro caractere de uma string em minúsculas.

Minhas abordagens:

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

Qual seria sua abordagem?

Eu usaria concatenação simples:

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

A primeira solução não é otimizada porque string.Formaté lenta e você não precisa se tiver um formato que nunca será alterado. Ele também gera uma sequência extra para converter a letra em minúscula, o que não é necessário.

A abordagem com "+ 32" é feia / não pode ser mantida, pois requer conhecimento de compensações de valor de caracteres ASCII. Também irá gerar uma saída incorreta com dados Unicode e caracteres de símbolo ASCII.

Dependendo da situação, um pouco de programação defensiva pode ser desejável:

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

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

A ifinstrução também evita que uma nova string seja criada se não for alterada. Você pode querer que o método falhe na entrada nula e ative um ArgumentNullException.

Como as pessoas mencionaram, usar String.Formatpara isso é um exagero.

Apenas no caso de ajudar alguém que tropeçar nessa resposta.

Eu acho que isso seria melhor como um método de extensão, então você pode chamá-lo com 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);
    }
}

O meu é

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

Eu gosto da resposta aceita, mas, além de marcar string.IsNullOrEmpty, também verificaria se Char.IsLower(name[1])você está lidando com abreviação. Por exemplo, você não gostaria que "AIDS" se tornasse "AIDS".

A solução mais rápida que conheço sem abusar do 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;
}

Combinou alguns e tornou uma extensão encadeada. Adicionado curto-circuito em espaço em branco e sem letra.

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 é um pequeno método de extensão usando a sintaxe mais recente e as validações corretas

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

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

É melhor usar do String.Concatque String.Formatse você souber que o formato não é alterar dados e se deseja apenas concatenação.