validar - textbox mayusculas c#

Método.NET para convertir una cadena a sentencia caso

Question

Estoy buscando una función para convertir una cadena de texto que está en UpperCase a SentenceCase. Todos los ejemplos que puedo encontrar convierten el texto en TitleCase.

El caso de la oración en un sentido general describe la forma en que se usa el uso de mayúsculas dentro de una oración. El caso de la oración también describe la capitalización estándar de una oración en inglés, es decir, la primera letra de la oración está en mayúscula, mientras que el resto está en minúscula (a menos que se requiera una mayúscula por una razón específica, por ejemplo, nombres propios, siglas, etc.)

¿Alguien me puede indicar la dirección de un guión o función para Sentencia de caso?

Answer 1

Encontré esta muestra en MSDN .

Answer 2

Esto es lo que uso (VB.NET). Funciona en la mayoría de las situaciones, incluyendo:

• oraciones multiples
• Oraciones que comienzan y terminan con espacios

• oraciones que comiencen con caracteres que no sean AZ. Por ejemplo, funcionará para: "si quieres $ 100.00, solo pregúntame".

  <Extension()>
  Public Function ToSentanceCase(ByVal s As String) As String
      '' Written by Jason. Inspired from: http://www.access-programmers.co.uk/forums/showthread.php?t=147680
  
      Dim SplitSentence() As String = s.Split(".")
  
      For i = 0 To SplitSentence.Count - 1
          Dim st = SplitSentence(i)
  
          If st.Trim = "" Or st.Trim.Count = 1 Then Continue For '' ignore empty sentences or sentences with only 1 character.
  
          '' skip past characters that are not A-Z, 0-9 (ASCII) at start of sentence.
          Dim y As Integer = 1
          Do Until y > st.Count
              If (Asc(Mid(st, y, 1)) >= 65 And Asc(Mid(st, y, 1)) <= 90) Or _
                    (Asc(Mid(st, y, 1)) >= 97 And Asc(Mid(st, y, 1)) <= 122) Or _
                   (Asc(Mid(st, y, 1)) >= 48 And Asc(Mid(st, y, 1)) <= 57) Then
                  GoTo Process
              Else
                  Dim w = Asc(Mid(st, y, 1))
                  y += 1
              End If
          Loop
          Continue For
  
  Process:
          Dim sStart As String = ""
          If y > 1 Then sStart = Left(st, 0 + (y - 1))
  
          Dim sMid As String = UCase(st(y - 1)) '' capitalise the first non-space character in sentence.
  
          Dim sEnd As String = Mid(st, y + 1, st.Length)
  
          SplitSentence(i) = sStart & sMid & sEnd
  
      Next
  
      '' rejoin sentances back together:
      Dim concat As String = ""
      For Each st As String In SplitSentence
          concat &= st & "."
      Next
  
      concat = concat.TrimEnd(1)
  
      Return concat
  
  End Function

Pero en cuanto a los nombres y acrónimos propios, bueno ... siempre habrá situaciones en el idioma inglés donde la puntuación no es tan simple. Por ejemplo, este script no detectará puntos suspensivos ("...") o abreviaturas (por ejemplo: "El Sr. Jones vivió en Magnolia Blvd. cerca de la casa de Chris").

Para resolver el problema por completo, deberá producir un diccionario con todas las abreviaturas / puntuaciones posibles para el idioma y mantener el diccionario actualizado. Después de considerar esto, la mayoría estará contenta con un compromiso, de lo contrario solo use Microsoft Word.

Answer 3

Esto funciona para mí.

/// <summary>
/// Converts a string to sentence case.
/// </summary>
/// <param name="input">The string to convert.</param>
/// <returns>A string</returns>
public static string SentenceCase(string input)
{
    if (input.Length < 1)
        return input;

    string sentence = input.ToLower();
    return sentence[0].ToString().ToUpper() +
       sentence.Substring(1);
}

Answer 4

Hay una función integrada en ToTitleCase que se ampliará para admitir múltiples culturas en el futuro.

http://msdn.microsoft.com/en-us/library/system.globalization.textinfo.totitlecase.aspx

Answer 5

Si desea sentenciar una cadena con puntuación que no sea solo puntos:

string input = "THIS IS YELLING! WHY ARE WE YELLING? BECAUSE WE CAN. THAT IS ALL.";
var sentenceRegex = new Regex(@"(^[a-z])|[?!.:,;]/s+(.)", RegexOptions.ExplicitCapture);
input = sentenceRegex.Replace(input.ToLower(), s => s.Value.ToUpper());

Answer 6

Si su cadena de entrada no es una oración, sino muchas oraciones, esto se convierte en un problema muy difícil.

Las expresiones regulares resultarán ser una herramienta invaluable, pero (1) tendrá que conocerlas bastante bien para que sean efectivas, y (2) es posible que no estén listas para hacer el trabajo por su cuenta.

Considera esta oración

"Quién es el primero", respondió el Sr. Smith, que no se estaba riendo.

Esta oración no comienza con una letra, tiene un dígito, varios signos de puntuación, un nombre propio y a . en el medio.

Las complejidades son enormes, y esta es una frase.

Una de las cosas más importantes al usar RegEx es "conocer sus datos". Si conoce la amplitud de los tipos de oraciones con las que tratará, su tarea será más manejable.

En cualquier caso, tendrás que jugar con tu implementación hasta que estés satisfecho con tus resultados. Le sugiero que escriba algunas pruebas automatizadas con algunos datos de muestra: a medida que trabaja en su implementación, puede ejecutar las pruebas con regularidad para ver dónde se está acercando y dónde aún falta la marca.

Answer 7

No hay nada integrado en .NET; sin embargo, este es uno de esos casos en los que el procesamiento de expresiones regulares puede funcionar bien. Comenzaría por convertir primero la cadena completa a minúsculas, y luego, como primera aproximación, podría usar expresiones regulares para encontrar todas las secuencias como [az]/./s+(.) , Y usar ToUpper() para convertir los capturados Grupo a mayúsculas. La clase RegEx tiene un método Replace() sobrecargado que acepta un delegado de MatchEvaluator , que le permite definir cómo reemplazar el valor coincidente.

Aquí hay un ejemplo de código de esto en el trabajo:

var sourcestring = "THIS IS A GROUP. OF CAPITALIZED. LETTERS.";
// start by converting entire string to lower case
var lowerCase = sourcestring.ToLower();
// matches the first sentence of a string, as well as subsequent sentences
var r = new Regex(@"(^[a-z])|/./s+(.)", RegexOptions.ExplicitCapture);
// MatchEvaluator delegate defines replacement of setence starts to uppercase
var result = r.Replace(lowerCase, s => s.Value.ToUpper());

// result is: "This is a group. Of uncapitalized. Letters."

Esto podría ser refinado de varias maneras diferentes para que coincida mejor con una variedad más amplia de patrones de oraciones (no solo los que terminan en una letra + período).

Answer 8

public string GetSentenceCase(string ReqdString) {
    string StrInSentCase = "";
    for (int j = 0; j < ReqdString.Length; j++) {
        if (j == 0) {
           StrInSentCase = ReqdString.ToString().Substring(j, 1).ToUpper();
        }
        else {
            StrInSentCase = StrInSentCase + ReqdString.ToString().Substring(j, 1).ToLower();
        }
    }
    return StrInSentCase.ToString();
}