c# - palabra - Hacer la primera letra de una cadena en mayúsculas(con el máximo rendimiento)

primera letra de cada palabra en mayuscula c#

Question

Tengo un DetailsView con un TextBox y quiero que los datos de entrada se guarden siempre con la PRIMERA LETRA EN CAPITAL.

Ejemplo:

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

¿Cómo puedo lograr este máximo rendimiento ?

NOTA :
Basado en las respuestas y los comentarios debajo de las respuestas, muchas personas piensan que se trata de poner en mayúsculas 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 el método ToTitleCase . (NOTA: Esas respuestas son incorrectas para la pregunta realmente hecha).
Consulte el documento TextInfo.ToTitleCase para ver las advertencias (no toca las palabras en mayúsculas, se consideran acrónimos; pueden escribirse en minúsculas en medio de las palabras que "no deben" disminuirse, por ejemplo, "McDonald" => "Mcdonald"; no está garantizado para manejar todas las sutilezas específicas de la cultura en relación con las reglas de uso de mayúsculas.)

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

Answer 1

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

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

Answer 2

El 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 10000000 símbolos como entrada): Resultados de la prueba

Answer 3

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

Answer 4

Es la forma más rápida:

public static unsafe void ToUpperFirst(this string str)
{
    if (str == null) return;
    fixed (char* ptr = str) 
        *ptr = char.ToUpper(*ptr);
}

Sin cambiar la cadena original:

public static unsafe string ToUpperFirst(this string str)
{
    if (str == null) return null;
    string ret = string.Copy(str);
    fixed (char* ptr = ret) 
        *ptr = char.ToUpper(*ptr);
    return ret;
}

Answer 5

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

Answer 6

Esto pone en mayúscula esta primera letra y todas las letras que siguen a un espacio y en minúsculas a 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;
        }
    }
}

Answer 7

FluentSharp tiene el método lowerCaseFirstLetter que hace esto

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

Answer 8

La forma correcta es usar la cultura:

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

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

Answer 9

La forma más fácil de poner mayúsculas en una 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)

`

Answer 10

La siguiente función es correcta para todas las formas:

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 here

Answer 11

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 aquí es lo mismo que una extensión práctica

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

Answer 12

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

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

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

3. String.IsNullOrWhiteSpace se introdujo con .NET Framework 4. Esto no funcionará con los marcos anteriores.

Answer 13

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

Solo añadiendo 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);
}   

Debería manejar this won''t work on other answers (esa oración tiene un espacio al principio), y si no te gusta el recorte de espacio, simplemente pasa un false como segundo parámetro (o cambia el valor predeterminado a false , y pasa true si quieres lidiar con el espacio)

Answer 14

Prueba esto:

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

Answer 15

Puedes 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 titlecase.

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

Answer 16

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 estas razones:

1. IsNullOrWhiteSpace cuenta para cadenas que son solo espacios o null / empty.
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 ienumerable (o cadena).
4. Deberíamos verificar si es una letra que puede / debe estar en mayúsculas.
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, deberíamos proporcionar una cultura bajo System.Globalization.CultureInfo.

7. Proporcionándolos 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;
   }

Answer 17

Si el rendimiento o el uso de la memoria es un problema, este solo creará 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;
}

Answer 18

Si solo le importa que la primera letra esté en mayúscula y no importa el resto de la cadena, solo puede seleccionar el primer carácter, ponerla en mayúsculas y concatenarla 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 ().

Answer 19

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: El motivo por el que ToCharArray es más rápido que la alternativa char.ToUpper(s[0]) + s.Substring(1) , es que solo se asigna una cadena, mientras que el enfoque de Substring 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 Carlos Muñoz aceptó 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);
    }

Answer 20

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.

Answer 21

EDITAR: Actualizado a una sintaxis más nueva (y una respuesta más correcta), también como un método de extensión.

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

Viejas respuestas

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 sea la de Darren''s (incluso hay un punto de referencia), aunque cambiaría su string.IsNullOrEmpty(s) validación de string.IsNullOrEmpty(s) arrojará una excepción, ya que el requisito original espera que exista una primera letra para que se pueda realizar una mayúscula. Tenga en cuenta que este código funciona para una cadena genérica y no particularmente en valores válidos del Textbox .

Answer 22

Usa el siguiente código:

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

Answer 23

Ampliando la pregunta de Carlos de arriba, si quieres poner en mayúsculas varias oraciones, puedes 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; 
    }

Answer 24

Con este método puedes superar el primer carácter de cada palabra.

Ejemplo "HeLlo wOrld" => "Hello World"

public static string FirstCharToUpper(string input)
{
    if (String.IsNullOrEmpty(input))
        throw new ArgumentException("Error");
    return string.Join(" ", input.Split('' '').Select(d => d.First().ToString().ToUpper() +  d.ToLower().Substring(1)));
}

Answer 25

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

here

Answer 26

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 lo necesito 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úsculas, no se tocan todos los caracteres restantes. Si necesita que los otros caracteres estén en minúscula, también puede llamar a Char.ToLower (currentChar) para el índice> 0 o llamar a ToLower () en toda la cadena en primer lugar.

Respecto 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. Por eso le sugiero que tome el código de Darren si necesita la solución más rápida disponible. Si también desea integrar otras manipulaciones de cadena, puede ser conveniente tener el poder expresivo de una función lambda tocando los caracteres de la cadena de entrada (puede extender esta función fácilmente), por lo que dejo esta solución aquí.

Answer 27

enviar una cadena a esta función. primero verificará que la cadena esté vacía o sea nula, si no la cadena será todas las letras más bajas. Luego regresa la primera char de la cuerda superior del resto de las inferiores.

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

Answer 28

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

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

Answer 29

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

Antigua respuesta: Esto hace que cada primera letra a mayúsculas.

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

Answer 30

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