Cadena de PascalCase dividida a excepción de los acrónimos

Question

Tengo una lista de palabras que deben ser legibles por el ser humano, como Nombre al primer nombre, Apellido al apellido y, en algunos casos, acrónimos como ARB para que permanezcan como están. Este último fue introducido recientemente y ha causado un problema de visualización ya que nuestra expresión regular devuelve AR Bs. Esto es lo que tenemos, que sé que es insuficiente para acrónimos:

([A-Z][a-z]+) 

que he encontrado otras expresiones de SO y en otros sitios que son capaces de trabajar con las siglas, sin embargo, que trabajan en las cadenas donde el acrónimo está dentro de la cadena en lugar de ser la cadena completa. Puedo hacer expresiones regulares simples, pero esto es demasiado complicado para mis habilidades. Proporcionaría otros ejemplos para probar si los tuviera, pero todas las cadenas funcionan bien, excepto la nueva, ARB. Gracias.

Actualización: Aquí está el uso de código de

string friendlyName = Regex.Replace(field.Name, "([A-Z][a-z]+)", " $1", RegexOptions.Compiled).Trim(); 

Answer 1

No sería [A-Z]+[a-z]* hacerlo? Eso debería coincidir con una o más letras mayúsculas seguidas de cero o más letras minúsculas. Entonces ARBs seguiría siendo una entidad única, pero CamelCase se dividiría en Camel Case.

Answer 2

¿Qué tal esto?

[A-Z][a-z]+|[A-Z] 

Answer 3

Una cadena/párrafo/frase que incluye acrónimos se puede convertir en Oraciones/secuencia legibles en humanos. Solo estaba tratando de formatear la cadena de Pascal Cased, investigué más e intenté incluso convertir Acrónimos en un formato comprensible.

de datos de prueba:

de entrada: "QWERTYSomeThing OmitTRYSomeThing MayBeWorkingFYI"

Salida: "QWERTY algo Omitir probar algunas cosa puede estar trabajando FYI"

Código: Pase la cadena de entrada al método indicado a continuación.

private static string FormatPascalAndAcronym(string input) 
    { 
     var builder = new StringBuilder(input[0].ToString()); 
     if (builder.Length > 0) 
     { 
      for (var index = 1; index < input.Length; index++) 
      { 
       char prevChar = input[index - 1]; 
       char nextChar = index + 1 < input.Length ? input[index + 1] : '\0'; 

       bool isNextLower = Char.IsLower(nextChar); 
       bool isNextUpper = Char.IsUpper(nextChar); 
       bool isPresentUpper = Char.IsUpper(input[index]); 
       bool isPrevLower = Char.IsLower(prevChar); 
       bool isPrevUpper = Char.IsUpper(prevChar); 

       if(!string.IsNullOrWhiteSpace(prevChar.ToString()) && 
        ((isPrevUpper&& isPresentUpper && isNextLower) || 
        (isPrevLower&&isPresentUpper&&isNextLower)|| 
        (isPrevLower&&isPresentUpper&&isNextUpper))) 
       { 
        builder.Append(' '); 
        builder.Append(input[index]); 
       } 
       else{ 
       builder.Append(input[index]); 
       } 
      } 
     } 
     return builder.ToString(); 
    }