BestPractice - Transforme le premier caractère d'une chaîne en minuscules

J'aimerais avoir une méthode qui transforme le premier caractère d'une chaîne en minuscules.

Mes approches:

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

Quelle serait votre approche?

J'utiliserais une concaténation simple:

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

La première solution n'est pas optimisée car string.Format est lente et vous n'en avez pas besoin si vous avez un format qui ne changera jamais. Il génère également une chaîne supplémentaire pour convertir la lettre en minuscules, ce qui n'est pas nécessaire.

L'approche avec "+ 32" est moche / ne peut pas être maintenue car elle nécessite une connaissance des décalages de valeurs de caractères ASCII. Il générera également une sortie incorrecte avec des données Unicode et des caractères de symbole ASCII.

Selon la situation, une petite programmation défensive pourrait être souhaitable:

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' ifinstruction empêche également une nouvelle chaîne d'être construite si elle ne va pas être modifiée de toute façon. Vous voudrez peut-être que la méthode échoue sur une entrée nulle à la place et lance un ArgumentNullException.

Comme les gens l'ont mentionné, utiliser String.Formatpour cela est excessif.

Juste au cas où cela aiderait quiconque tomberait sur cette réponse.

Je pense que ce serait mieux comme méthode d'extension, alors vous pouvez l'appeler avec 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);
    }
}

Le mien est

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

J'aime la réponse acceptée, mais à côté de la vérification, string.IsNullOrEmptyje vérifierais également si Char.IsLower(name[1])vous avez affaire à une abréviation. Par exemple, vous ne voudriez pas que le «sida» devienne «sida».

La solution la plus rapide que je connaisse sans abuser 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é quelques-uns et en a fait une extension chaînable. Ajout d'un court-circuit sur les espaces et les non-lettres.

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;

C'est une petite méthode d'extension utilisant la dernière syntaxe et les validations correctes

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

Utilisez ceci:

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

Il est préférable d'utiliser String.Concatque String.Formatsi vous savez que le format n'est pas une modification des données et qu'une concaténation est souhaitée.