Tengo un DetailsViewcon TextBox ay quiero que los datos de entrada se guarden siempre con la PRIMERA CARTA EN CAPITAL.

Ejemplo:

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

¿Cómo puedo lograr este rendimiento maximizador ?

NOTA :
Según las respuestas y los comentarios que figuran debajo de las respuestas, muchas personas piensan que se trata de poner en mayúscula todas las palabras de la cadena. Por ejemplo => Red House , no lo es, pero si eso es lo que busca , busque una de las respuestas que utiliza TextInfoel ToTitleCasemétodo. (NOTA: Esas respuestas son incorrectas para la pregunta realmente formulada).
Consulte el documento TextInfo.ToTitleCase para ver las advertencias (no toca las palabras en mayúsculas; se consideran siglas; pueden aparecer letras minúsculas en el medio de las palabras que "no deberían" ser reducido, por ejemplo, "McDonald" => "Mcdonald"; no se garantiza que maneje todas las sutilezas específicas de la cultura con respecto a las reglas de capitalización).

NOTA :
La pregunta es ambigua en cuanto a si las letras después de la primera deben ser forzadas a minúsculas . La respuesta aceptada supone que solo la primera letra debe ser alterada . Si desea forzar todas las letras en la cadena, excepto las primeras en minúsculas, busque una respuesta que contenga ToLowery no contenga ToTitleCase .

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

Respuestas muy viejas

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

EDITAR : Esta versión es más corta. Para una solución más rápida, eche un vistazo a la respuesta de 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 : Probablemente la solución más rápida es la de Darren (incluso hay un punto de referencia), aunque cambiaría su string.IsNullOrEmpty(s)validación para lanzar una excepción, ya que el requisito original espera que exista una primera letra para que pueda ser mayúscula. Tenga en cuenta que este código funciona para una cadena genérica y no particularmente en valores válidos de 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();
}

Respuesta anterior: Esto hace que cada primera letra en mayúscula

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

La forma correcta es usar Cultura:

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

Nota: Esto capitalizará cada palabra dentro de una cadena, por ejemplo, "casa roja" -> "Casa roja". La solución también incluirá mayúsculas en minúsculas en palabras, por ejemplo, "Old McDonald" -> "Old Mcdonald".

Tomé el método más rápido de http://www.dotnetperls.com/uppercase-first-letter y lo convertí al método de extensión:

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

NOTA: La razón por la que el uso ToCharArrayes más rápido que la alternativa char.ToUpper(s[0]) + s.Substring(1)es que solo se asigna una cadena, mientras que el Substringenfoque asigna una cadena para la subcadena, luego una segunda cadena para componer el resultado final.

EDITAR : así es como se ve este enfoque, combinado con la prueba inicial de CarlosMuñoz acepta la respuesta :

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

Puede usar el "método ToTitleCase"

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

Este método de extensión resuelve todos los problemas de título.

fácil de usar

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

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

el método de extensión

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

Para la primera letra, con comprobación de errores:

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

Y esto es lo mismo que una práctica extensión

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 el rendimiento / uso de la memoria es un problema, entonces este solo crea un (1) StringBuilder y una (1) nueva cadena del mismo tamaño que la cadena original.

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étodo más rápido.

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

Las pruebas muestran los siguientes resultados (cadena con símbolos 10000000 como entrada): resultados de la prueba

Prueba esto:

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

Si solo le importa que la primera letra esté en mayúscula y no importa el resto de la cadena, puede seleccionar el primer carácter, ponerlo en mayúscula y concatenarlo con el resto de la cadena sin el primer carácter original.

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

Necesitamos convertir el primer carácter ToString () porque lo estamos leyendo como una matriz Char y el tipo Char no tiene el método ToUpper ().

Aquí hay una manera de hacerlo como un método de extensión:

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

Entonces se puede llamar así:

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

Y aquí hay algunas pruebas unitarias para ello:

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

Ya que estaba trabajando en esto también y estaba buscando ideas, esta es la solución a la que llegué. Utiliza LINQ y podrá poner en mayúscula la primera letra de una cadena, incluso si la primera aparición no es una letra. Aquí está el método de extensión que terminé haciendo.

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

Estoy seguro de que hay una manera de optimizar o limpiar esto un poco.

Encontré algo aquí 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);
}

tal vez esto ayude !!

Compruebe si la cadena no es nula y luego convierta el primer carácter a mayúsculas y el resto a minúsculas:

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

Esto lo hará aunque también se asegurará de que no haya mayúsculas errantes que no estén al principio de la palabra.

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

Parece que hay mucha complejidad aquí cuando todo lo que necesitas es:

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

Puntos dignos de mención:

1. Es un método de extensión.

2. Si la entrada es nula, vacía o en blanco, la entrada se devuelve tal cual.

3. String.IsNullOrWhiteSpace se introdujo con .NET Framework 4. Esto no funcionará con marcos más antiguos.

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

Quería proporcionar una respuesta de "RENDIMIENTO MÁXIMO". En mi opinión, una respuesta de "RENDIMIENTO MÁXIMO" capta todos los escenarios y proporciona la respuesta a la pregunta que explica esos escenarios. Entonces, aquí está mi respuesta. Con estos motivos:

1. IsNullOrWhiteSpace representa cadenas que son solo espacios o nulas / vacías.
2. .Trim () elimina los espacios en blanco de la parte frontal y posterior de la cadena.
3. .First () toma el primer carácter de un número (o cadena) numerable.
4. Deberíamos verificar si es una letra que puede / debe estar en mayúscula.
5. Luego agregamos el resto de la cadena, solo si la longitud indica que deberíamos.
6. Según las mejores prácticas de .Net, debemos proporcionar una cultura en System.Globalization.CultureInfo.

7. Proporcionarlos como parámetros opcionales hace que este método sea totalmente reutilizable, sin tener que escribir la cultura elegida cada vez.

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

Recientemente tuve un requisito similar y recordé que la función LINQ Select () proporciona un índice:

string input;
string output;

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

Como necesito eso muy a menudo, hice un método de extensión para el tipo de cadena:

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

Tenga en cuenta que solo la primera letra se convierte a mayúscula; no se tocan todos los caracteres restantes. Si necesita que los otros caracteres estén en minúsculas, también puede llamar a Char.ToLower (currentChar) para index> 0 o llamar a ToLower () en toda la cadena en primer lugar.

En cuanto al rendimiento, comparé el código con la solución de Darren. En mi máquina, el código de Darren es aproximadamente 2 veces más rápido, lo cual no es sorprendente, ya que está editando directamente solo la primera letra dentro de una matriz de caracteres. Así que le sugiero que tome el código de Darren si necesita la solución más rápida disponible. Si desea integrar también otras manipulaciones de cadenas, puede ser conveniente tener el poder expresivo de una función lambda tocando los caracteres de la cadena de entrada, puede extender fácilmente esta función, así que dejo esta solución aquí.

Creo que el siguiente método es la mejor solución.

    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

árbitro

Como esta pregunta se trata de maximizar el rendimiento , adopté la versión de Darren para usar Spans, que reduce la basura y mejora la velocidad en aproximadamente un 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);
        }

Actuación

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

Código de prueba completo

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

}

Editar: Hubo un typeo, en lugar de s [0], fue un [0] - esto da como resultado el encapsulado del mismo valor vacío al Span asignado a.

Esto pone en mayúscula esta primera letra y cada letra después de un espacio y en minúsculas cualquier otra letra.

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

Utiliza el siguiente código:

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

Parece que ninguna de las soluciones dadas aquí tratará con un espacio en blanco antes de la cadena.

Solo agrego esto como un pensamiento:

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

Debe manejar this won't work on other answers(esa oración tiene un espacio al principio), y si no le gusta el recorte de espacio, simplemente pase un falsesegundo parámetro (o cambie el valor predeterminado a false, y pase truesi desea tratar con espacio)

FluentSharp tiene el lowerCaseFirstLettermétodo que hace esto

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

La forma más fácil de capitalizar la primera letra es:

1- Usando Sytem.Globalization;

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

  myTI.ToTitleCase(textboxname.Text)

``

La siguiente función es correcta en todos los sentidos:

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

Encontré eso aquí

Ampliando la pregunta de Carlos anterior, si desea capitalizar varias oraciones, puede usar este código:

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

Posible solución para resolver su problema.

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