web-dev-qa-db-fra.com

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?

c#.netstring
121
Rookian

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 lent 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 minuscule, ce qui n'est pas nécessaire.

L'approche avec "+ 32" est laide/non maintenable car elle nécessite la connaissance des décalages de valeur de caractère ASCII Il générera également une sortie incorrecte avec des données Unicode et des caractères de symbole ASCII.

205
onof

Selon la situation, un peu de programmation défensive peut ê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'instruction if empêche également la création d'une nouvelle chaîne si elle ne sera pas modifiée de toute façon. Vous voudrez peut-être que la méthode échoue avec une entrée nulle et jette une ArgumentNullException.

Comme on l'a déjà mentionné, utiliser String.Format pour cela est excessif.

56
Thorarin

Juste au cas où cela aiderait quelqu'un qui tombe par hasard 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);
    }
}
5
carlcheel

Le mien est 

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

J'aime la réponse acceptée, mais en plus de cocher string.IsNullOrEmpty, j'aimerais également vérifier si Char.IsLower(name[1]) au cas où vous auriez affaire à une abréviation. Par exemple. vous ne voudriez pas que "le SIDA" devienne "le SIDA".

2
Slobodan Savkovic

Combiné quelques-uns et fait une extension chaînable. Ajout d'un court-circuit sur les espaces et les 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;
0
Randy Buchholz

Utilisez ceci: 

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

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);
        }
    }
}
0
Carlos Muñoz

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;
}
0
Rjz