J'ai un DetailsViewavec un TextBox et je veux que les données d'entrée soient toujours enregistrées avec la PREMIÈRE LETTRE EN MAJUSCULE.

Exemple:

"red" --> "Red"
"red house" --> " Red house"

Comment puis-je atteindre ces performances maximales ?

REMARQUE :
Sur la base des réponses et des commentaires sous les réponses, de nombreuses personnes pensent que cela demande de mettre en majuscule tous les mots de la chaîne. Par exemple, => Red House ce n'est pas le cas, mais si c'est ce que vous cherchez , recherchez l'une des réponses qui utilise TextInfola ToTitleCaseméthode de. (REMARQUE: ces réponses sont incorrectes pour la question réellement posée.)
Voir le document TextInfo.ToTitleCase pour les mises en garde (ne touche pas les mots en majuscules - ils sont considérés comme des acronymes; peut minuscules au milieu des mots qui "ne devraient pas" être abaissé, par exemple "McDonald" => "Mcdonald"; il n'est pas garanti de gérer toutes les subtilités propres à la culture concernant les règles de capitalisation.)

REMARQUE :
la question est ambiguë de savoir si les lettres après la première doivent être forcées en minuscules . La réponse acceptée suppose que seule la première lettre doit être modifiée . Si vous souhaitez forcer toutes les lettres de la chaîne, sauf la première à être en minuscules, recherchez une réponse contenant ToLoweret ne contenant pas ToTitleCase .

Mis à jour en C # 8

public static class StringExtensions
{
    public static string FirstCharToUpper(this string input) =>
        input switch
        {
            null => throw new ArgumentNullException(nameof(input)),
            "" => throw new ArgumentException($"{nameof(input)} cannot be empty", nameof(input)),
            _ => input.First().ToString().ToUpper() + input.Substring(1)
        };
}

C # 7

public static class StringExtensions
{
    public static string FirstCharToUpper(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().ToUpper() + input.Substring(1);
        }
    }
}

Vraiment vieilles réponses

public static string FirstCharToUpper(string input)
{
    if (String.IsNullOrEmpty(input))
        throw new ArgumentException("ARGH!");
    return input.First().ToString().ToUpper() + String.Join("", input.Skip(1));
}

EDIT : Cette version est plus courte. Pour une solution plus rapide, jetez un œil à la réponse d'Equiso

public static string FirstCharToUpper(string input)
{
    if (String.IsNullOrEmpty(input))
        throw new ArgumentException("ARGH!");
    return input.First().ToString().ToUpper() + input.Substring(1);
}

EDIT 2 : La solution la plus rapide est probablement celle de Darren (il y a même un point de référence) bien que je changerais sa string.IsNullOrEmpty(s)validation pour lever une exception puisque l'exigence d'origine s'attend à ce qu'une première lettre existe afin qu'elle puisse être mise en majuscule. Notez que ce code fonctionne pour une chaîne générique et pas particulièrement sur les valeurs valides du Textbox.

public string FirstLetterToUpper(string str)
{
    if (str == null)
        return null;

    if (str.Length > 1)
        return char.ToUpper(str[0]) + str.Substring(1);

    return str.ToUpper();
}

Ancienne réponse: chaque première lettre est en majuscule

public string ToTitleCase(string str)
{
    return CultureInfo.CurrentCulture.TextInfo.ToTitleCase(str.ToLower());
}

La bonne façon est d'utiliser Culture:

System.Globalization.CultureInfo.CurrentCulture.TextInfo.ToTitleCase(word.ToLower())

Remarque: Cela mettra en majuscule chaque mot dans une chaîne, par exemple "maison rouge" -> "maison rouge". La solution réduira également les majuscules en lettres minuscules, par exemple «vieux McDonald» -> «Old Mcdonald».

J'ai pris la méthode la plus rapide de http://www.dotnetperls.com/uppercase-first-letter et converti en méthode d'extension:

    /// <summary>
    /// Returns the input string with the first character converted to uppercase, or mutates any nulls passed into string.Empty
    /// </summary>
    public static string FirstLetterToUpperCaseOrConvertNullToEmptyString(this string s)
    {
        if (string.IsNullOrEmpty(s))
            return string.Empty;

        char[] a = s.ToCharArray();
        a[0] = char.ToUpper(a[0]);
        return new string(a);
    }

REMARQUE: la raison pour laquelle l'utilisation ToCharArrayest plus rapide que l'alternative char.ToUpper(s[0]) + s.Substring(1)est qu'une seule chaîne est allouée, tandis que l' Substringapproche alloue une chaîne pour la sous-chaîne, puis une deuxième chaîne pour composer le résultat final.

EDIT : Voici à quoi ressemble cette approche, combinée avec le test initial de la réponse acceptée de CarlosMuñoz :

    /// <summary>
    /// Returns the input string with the first character converted to uppercase
    /// </summary>
    public static string FirstLetterToUpperCase(this string s)
    {
        if (string.IsNullOrEmpty(s))
            throw new ArgumentException("There is no first letter");

        char[] a = s.ToCharArray();
        a[0] = char.ToUpper(a[0]);
        return new string(a);
    }

Vous pouvez utiliser la "méthode ToTitleCase"

string s = new CultureInfo("en-US").TextInfo.ToTitleCase("red house");
//result : Red House

cette méthode d'extension résout tous les problèmes de casse.

facile à utiliser

string str = "red house";
str.ToTitleCase();
//result : Red house

string str = "red house";
str.ToTitleCase(TitleCase.All);
//result : Red House

la méthode d'extension

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;

namespace Test
{
    public static class StringHelper
    {
        private static CultureInfo ci = new CultureInfo("en-US");
        //Convert all first latter
        public static string ToTitleCase(this string str)
        {
            str = str.ToLower();
            var strArray = str.Split(' ');
            if (strArray.Length > 1)
            {
                strArray[0] = ci.TextInfo.ToTitleCase(strArray[0]);
                return string.Join(" ", strArray);
            }
            return ci.TextInfo.ToTitleCase(str);
        }
        public static string ToTitleCase(this string str, TitleCase tcase)
        {
            str = str.ToLower();
            switch (tcase)
            {
                case TitleCase.First:
                    var strArray = str.Split(' ');
                    if (strArray.Length > 1)
                    {
                        strArray[0] = ci.TextInfo.ToTitleCase(strArray[0]);
                        return string.Join(" ", strArray);
                    }
                    break;
                case TitleCase.All:
                    return ci.TextInfo.ToTitleCase(str);
                default:
                    break;
            }
            return ci.TextInfo.ToTitleCase(str);
        }
    }

    public enum TitleCase
    {
        First,
        All
    }
}

Pour la première lettre, avec vérification d'erreur:

public string CapitalizeFirstLetter(string s)
{
    if (String.IsNullOrEmpty(s))
        return s;
    if (s.Length == 1)
        return s.ToUpper();
    return s.Remove(1).ToUpper() + s.Substring(1);
}

Et voici la même chose qu'une extension pratique

public static string CapitalizeFirstLetter(this string s)
    {
    if (String.IsNullOrEmpty(s)) return s;
    if (s.Length == 1) return s.ToUpper();
    return s.Remove(1).ToUpper() + s.Substring(1);
    }

public static string ToInvarianTitleCase(this string self)
{
    if (string.IsNullOrWhiteSpace(self))
    {
        return self;
    }

    return CultureInfo.InvariantCulture.TextInfo.ToTitleCase(self);
}

Si les performances / l'utilisation de la mémoire sont un problème, celui-ci ne crée qu'un (1) StringBuilder et une (1) nouvelle chaîne de la même taille que la chaîne d'origine.

public static string ToUpperFirst(this string str) {
  if( !string.IsNullOrEmpty( str ) ) {
    StringBuilder sb = new StringBuilder(str);
    sb[0] = char.ToUpper(sb[0]);

    return sb.ToString();

  } else return str;
}

Méthode la plus rapide.

  private string Capitalize(string s){
        if (string.IsNullOrEmpty(s))
        {
            return string.Empty;
        }
        char[] a = s.ToCharArray();
        a[0] = char.ToUpper(a[0]);
        return new string(a);
}

Les tests montrent les résultats suivants (chaîne avec 10000000 symboles en entrée): Résultats des tests

Essaye ça:

static public string UpperCaseFirstCharacter(this string text) {
    return Regex.Replace(text, "^[a-z]", m => m.Value.ToUpper());
}

Si vous ne vous souciez que de la première lettre en majuscule et que le reste de la chaîne importe peu, vous pouvez simplement sélectionner le premier caractère, le mettre en majuscule et le concaténer avec le reste de la chaîne sans le premier caractère d'origine.

String word ="red house";
word = word[0].ToString().ToUpper() + word.Substring(1, word.length -1);
//result: word = "Red house"

Nous devons convertir le premier caractère ToString () car nous le lisons en tant que tableau Char, et le type Char n'a pas de méthode ToUpper ().

Voici un moyen de le faire comme méthode d'extension:

static public string UpperCaseFirstCharacter(this string text)
{
    if (!string.IsNullOrEmpty(text))
    {
        return string.Format(
            "{0}{1}",
            text.Substring(0, 1).ToUpper(),
            text.Substring(1));
    }

    return text;
}

Peut alors être appelé comme:

//yields "This is Brian's test.":
"this is Brian's test.".UpperCaseFirstCharacter(); 

Et voici quelques tests unitaires pour cela:

[Test]
public void UpperCaseFirstCharacter_ZeroLength_ReturnsOriginal()
{
    string orig = "";
    string result = orig.UpperCaseFirstCharacter();

    Assert.AreEqual(orig, result);
}

[Test]
public void UpperCaseFirstCharacter_SingleCharacter_ReturnsCapital()
{
    string orig = "c";
    string result = orig.UpperCaseFirstCharacter();

    Assert.AreEqual("C", result);
}

[Test]
public void UpperCaseFirstCharacter_StandardInput_CapitalizeOnlyFirstLetter()
{
    string orig = "this is Brian's test.";
    string result = orig.UpperCaseFirstCharacter();

    Assert.AreEqual("This is Brian's test.", result);
}

Comme il m'arrivait de travailler là-dessus également et que je cherchais des idées, c'est la solution à laquelle je suis parvenu. Il utilise LINQ et pourra mettre en majuscule la première lettre d'une chaîne, même si la première occurrence n'est pas une lettre. Voici la méthode d'extension que j'ai fini par faire.

public static string CaptalizeFirstLetter(this string data)
{
    var chars = data.ToCharArray();

    // Find the Index of the first letter
    var charac = data.First(char.IsLetter);
    var i = data.IndexOf(charac);

    // capitalize that letter
    chars[i] = char.ToUpper(chars[i]);

    return new string(chars);
}

Je suis sûr qu'il existe un moyen d'optimiser ou de nettoyer un peu cela.

J'ai trouvé quelque chose ici http://www.dotnetperls.com/uppercase-first-letter :

static string UppercaseFirst(string s)
{
// Check for empty string.
if (string.IsNullOrEmpty(s))
{
    return string.Empty;
}
// Return char and concat substring.
return char.ToUpper(s[0]) + s.Substring(1);
}

peut-être que cela aide !!

Vérifiez si la chaîne n'est pas nulle, puis convertissez le premier caractère en majuscules et le reste en minuscules:

public static string FirstCharToUpper(string str)
{
    return str?.First().ToString().ToUpper() + str?.Substring(1).ToLower();
}

Cela le fera bien qu'il s'assurera également qu'il n'y a pas de majuscules errantes qui ne sont pas au début du mot.

public string(string s)
{
System.Globalization.CultureInfo c = new System.Globalization.CultureInfo("en-us", false)
System.Globalization.TextInfo t = c.TextInfo;

return t.ToTitleCase(s);
}

Il semble y avoir beaucoup de complexité ici quand tout ce dont vous avez besoin est:

    /// <summary>
    /// Returns the input string with the first character converted to uppercase if a letter
    /// </summary>
    /// <remarks>Null input returns null</remarks>
    public static string FirstLetterToUpperCase(this string s)
    {
        if (string.IsNullOrWhiteSpace(s))
            return s;

        return char.ToUpper(s[0]) + s.Substring(1);
    }

Points remarquables:

1. C'est une méthode d'extension.

2. Si l'entrée est nulle, vide ou en blanc, l'entrée est renvoyée telle quelle.

3. String.IsNullOrWhiteSpace a été introduit avec .NET Framework 4. Cela ne fonctionnera pas avec les anciens frameworks.

string emp="TENDULKAR";
string output;
output=emp.First().ToString().ToUpper() + String.Join("", emp.Skip(1)).ToLower();

Je voulais apporter une réponse "PERFORMANCE MAXIMALE". Dans mon esprit, une réponse "PERFORMANCE MAXIMALE" capture tous les scénarios et fournit la réponse à la question expliquant ces scénarios. Alors, voici ma réponse. Pour ces raisons:

1. IsNullOrWhiteSpace représente les chaînes qui ne sont que des espaces ou null / vide.
2. .Trim () supprime les espaces à l'avant et à l'arrière de la chaîne.
3. .First () prend le premier caractère d'un ienumerable (ou d'une chaîne).
4. Nous devons vérifier si c'est une lettre qui peut / devrait être en majuscule.
5. Nous ajoutons ensuite le reste de la chaîne, uniquement si la longueur indique que nous le devrions.
6. Selon les meilleures pratiques .Net, nous devrions fournir une culture sous System.Globalization.CultureInfo.

7. Les fournir en tant que paramètres facultatifs rend cette méthode totalement réutilisable, sans avoir à taper à chaque fois la culture choisie.

   public static string capString(string instring, string culture = "en-US", bool useSystem = false)
   {
       string outstring;
       if (String.IsNullOrWhiteSpace(instring))
       {
           return "";
       }
       instring = instring.Trim();
       char thisletter = instring.First();
       if (!char.IsLetter(thisletter))
       {
           return instring;   
       }
       outstring = thisletter.ToString().ToUpper(new CultureInfo(culture, useSystem));
       if (instring.Length > 1)
       {
           outstring += instring.Substring(1);
       }
       return outstring;
   }

Récemment, j'avais une exigence similaire et je me suis souvenu que la fonction LINQ Select () fournit un index:

string input;
string output;

input = "red house";
output = String.Concat(input.Select((currentChar, index) => index == 0 ? Char.ToUpper(currentChar) : currentChar));
//output = "Red house"

Comme j'en ai besoin très souvent, j'ai créé une méthode d'extension pour le type de chaîne:

public static class StringExtensions
{
    public static string FirstLetterToUpper(this string input)
    {
        if (string.IsNullOrEmpty(input))
            return string.Empty;
        return String.Concat(input.Select((currentChar, index) => index == 0 ? Char.ToUpper(currentChar) : currentChar));
    }
}

Veuillez noter que seule la première lettre est convertie en majuscules - tous les caractères restants ne sont pas touchés. Si vous avez besoin que les autres caractères soient en minuscules, vous pouvez également appeler Char.ToLower (currentChar) pour index> 0 ou appeler ToLower () sur la chaîne entière en premier lieu.

En ce qui concerne les performances, j'ai comparé le code avec la solution de Darren. Sur ma machine, le code de Darren est environ 2 fois plus rapide, ce qui n'est pas surprenant puisqu'il n'édite directement que la première lettre d'un tableau de caractères. Je vous suggère donc de prendre le code de Darren si vous avez besoin de la solution la plus rapide disponible. Si vous souhaitez également intégrer d'autres manipulations de chaînes, il peut être pratique d'avoir la puissance expressive d'une fonction lambda touchant les caractères de la chaîne d'entrée - vous pouvez facilement étendre cette fonction - alors je laisse cette solution ici.

Je pense que la méthode ci-dessous est la meilleure solution

    class Program
{
    static string UppercaseWords(string value)
    {
        char[] array = value.ToCharArray();
        // Handle the first letter in the string.
        if (array.Length >= 1)
        {
            if (char.IsLower(array[0]))
            {
                array[0] = char.ToUpper(array[0]);
            }
        }
        // Scan through the letters, checking for spaces.
        // ... Uppercase the lowercase letters following spaces.
        for (int i = 1; i < array.Length; i++)
        {
            if (array[i - 1] == ' ')
            {
                if (char.IsLower(array[i]))
                {
                    array[i] = char.ToUpper(array[i]);
                }
            }
        }
        return new string(array);
    }

    static void Main()
    {
        // Uppercase words in these strings.
        const string value1 = "something in the way";
        const string value2 = "dot net PERLS";
        const string value3 = "String_two;three";
        const string value4 = " sam";
        // ... Compute the uppercase strings.
        Console.WriteLine(UppercaseWords(value1));
        Console.WriteLine(UppercaseWords(value2));
        Console.WriteLine(UppercaseWords(value3));
        Console.WriteLine(UppercaseWords(value4));
    }
}

Output

Something In The Way
Dot Net PERLS
String_two;three
 Sam

ref

Comme cette question concerne la maximisation des performances, j'ai adopté la version de Darren pour utiliser Spans, ce qui réduit les déchets et améliore la vitesse d'environ 10%.

        /// <summary>
        /// Returns the input string with the first character converted to uppercase
        /// </summary>
        public static string ToUpperFirst(this string s)
        {
            if (string.IsNullOrEmpty(s))
                throw new ArgumentException("There is no first letter");

            Span<char> a = stackalloc char[s.Length];
            s.AsSpan(1).CopyTo(a.Slice(1));
            a[0] = char.ToUpper(s[0]);
            return new string(a);
        }

Performance

|  Method |      Data |      Mean |     Error |    StdDev |
|-------- |---------- |----------:|----------:|----------:|
|  Carlos |       red | 107.29 ns | 2.2401 ns | 3.9234 ns |
|  Darren |       red |  30.93 ns | 0.9228 ns | 0.8632 ns |
| Marcell |       red |  26.99 ns | 0.3902 ns | 0.3459 ns |
|  Carlos | red house | 106.78 ns | 1.9713 ns | 1.8439 ns |
|  Darren | red house |  32.49 ns | 0.4253 ns | 0.3978 ns |
| Marcell | red house |  27.37 ns | 0.3888 ns | 0.3637 ns |

Code de test complet

using System;
using System.Linq;

using BenchmarkDotNet.Attributes;

namespace CorePerformanceTest
{
    public class StringUpperTest
    {
        [Params("red", "red house")]
        public string Data;

        [Benchmark]
        public string Carlos() => Data.Carlos();

        [Benchmark]
        public string Darren() => Data.Darren();

        [Benchmark]
        public string Marcell() => Data.Marcell();
    }

    internal static class StringExtensions
    {
        public static string Carlos(this string input) =>
            input switch
            {
                null => throw new ArgumentNullException(nameof(input)),
                "" => throw new ArgumentException($"{nameof(input)} cannot be empty", nameof(input)),
                _ => input.First().ToString().ToUpper() + input.Substring(1)
            };

        public static string Darren(this string s)
        {
            if (string.IsNullOrEmpty(s))
                throw new ArgumentException("There is no first letter");

            char[] a = s.ToCharArray();
            a[0] = char.ToUpper(a[0]);
            return new string(a);
        }

        public static string Marcell(this string s)
        {
            if (string.IsNullOrEmpty(s))
                throw new ArgumentException("There is no first letter");

            Span<char> a = stackalloc char[s.Length];
            s.AsSpan(1).CopyTo(a.Slice(1));
            a[0] = char.ToUpper(s[0]);
            return new string(a);
        }
    }

}

Edit: il y avait un typeo, au lieu de s [0], il y avait un [0] - cela donne la même valeur vide à la plage allouée a.

Cela met en majuscule cette première lettre et chaque lettre suivant un espace et les minuscules toute autre lettre.

public string CapitalizeFirstLetterAfterSpace(string input)
{
    System.Text.StringBuilder sb = new System.Text.StringBuilder(input);
    bool capitalizeNextLetter = true;
    for(int pos = 0; pos < sb.Length; pos++)
    {
        if(capitalizeNextLetter)
        {
            sb[pos]=System.Char.ToUpper(sb[pos]);
            capitalizeNextLetter = false;
        }
        else
        {
            sb[pos]=System.Char.ToLower(sb[pos]);
        }

        if(sb[pos]=' ')
        {
            capitalizeNextLetter=true;
        }
    }
}

Utilisez le code suivant:

string  strtest ="PRASHANT";
strtest.First().ToString().ToUpper() + strtest.Remove(0, 1).ToLower();

Il semble qu'aucune des solutions données ici ne traite d'un espace blanc avant la chaîne.

Ajouter juste ceci comme une pensée:

public static string SetFirstCharUpper2(string aValue, bool aIgonreLeadingSpaces = true)
{
    if (string.IsNullOrWhiteSpace(aValue))
        return aValue;

    string trimmed = aIgonreLeadingSpaces 
           ? aValue.TrimStart() 
           : aValue;

    return char.ToUpper(trimmed[0]) + trimmed.Substring(1);
}   

Il devrait gérer this won't work on other answers(cette phrase a un espace au début), et si vous n'aimez pas le découpage de l'espace, passez simplement un falsesecond paramètre (ou changez la valeur par défaut en false, et passez truesi vous voulez gérer l'espace)

FluentSharp a le lowerCaseFirstLetter méthode qui le fait

https://github.com/o2platform/FluentSharp/blob/700dc35759db8e2164771a71f73a801aa9379074/FluentSharp.CoreLib/ExtensionMethods/System/String_ExtensionMethods.cs#L575

Le moyen le plus simple de mettre en majuscule sa première lettre est:

1- Utilisation de Sytem.Globalization;

  // Creates a TextInfo based on the "en-US" culture.
  TextInfo myTI = new CultureInfo("en-US",false).

  myTI.ToTitleCase(textboxname.Text)

"

la fonction suivante est correcte dans tous les cas:

static string UppercaseWords(string value)
{
    char[] array = value.ToCharArray();
    // Handle the first letter in the string.
    if (array.Length >= 1)
    {
        if (char.IsLower(array[0]))
        {
            array[0] = char.ToUpper(array[0]);
        }
    }
    // Scan through the letters, checking for spaces.
    // ... Uppercase the lowercase letters following spaces.
    for (int i = 1; i < array.Length; i++)
    {
        if (array[i - 1] == ' ')
        {
            if (char.IsLower(array[i]))
            {
                array[i] = char.ToUpper(array[i]);
            }
        }
    }
    return new string(array);
}

J'ai trouvé ça ici

En développant la question de Carlos ci-dessus, si vous souhaitez mettre en majuscule plusieurs phrases, vous pouvez utiliser ce code:

    /// <summary>
    /// Capitalize first letter of every sentence. 
    /// </summary>
    /// <param name="inputSting"></param>
    /// <returns></returns>
    public string CapitalizeSentences (string inputSting)
    {
        string result = string.Empty;
        if (!string.IsNullOrEmpty(inputSting))
        {
            string[] sentences = inputSting.Split('.');

            foreach (string sentence in sentences)
            {
                result += string.Format ("{0}{1}.", sentence.First().ToString().ToUpper(), sentence.Substring(1)); 
            }
        }

        return result; 
    }

Solution possible pour résoudre votre problème.

   public static string FirstToUpper(this string lowerWord)
   {
       if (string.IsNullOrWhiteSpace(lowerWord) || string.IsNullOrEmpty(lowerWord))
            return lowerWord;
       return new StringBuilder(lowerWord.Substring(0, 1).ToUpper())
                 .Append(lowerWord.Substring(1))
                 .ToString();
   }