Recorta el último carácter de una cadena

Tengo una cuerda que decir

"Hello! world!" 

¡Quiero hacer un recorte o una eliminación para sacar el! fuera del mundo pero no fuera Hola.

"Hello! world!".TrimEnd('!');

Lee mas

EDITAR:

Lo que he notado en este tipo de preguntas es que todo el mundo sugiere eliminar el último carácter de una cadena dada. Pero esto no cumple con la definición del método Trim.

Recortar: elimina todas las apariciones de caracteres de espacio en blanco desde el principio y el final de esta instancia.

MSDN-Trim

Según esta definición, eliminar solo el último carácter de la cadena es una mala solución.

Entonces, si queremos "Recortar el último carácter de la cadena", deberíamos hacer algo como esto

Ejemplo como método de extensión:

public static class MyExtensions
{
  public static string TrimLastCharacter(this String str)
  {
     if(String.IsNullOrEmpty(str)){
        return str;
     } else {
        return str.TrimEnd(str[str.Length - 1]);
     }
  }
}

Tenga en cuenta que si desea eliminar todos los caracteres del mismo valor, es decir (!!!!), el método anterior elimina todas las existencias de '!' desde el final de la cadena, pero si desea eliminar solo el último carácter, debe usar esto:

else { return str.Remove(str.Length - 1); }

String withoutLast = yourString.Substring(0,(yourString.Length - 1));

if (yourString.Length > 1)
    withoutLast = yourString.Substring(0, yourString.Length - 1);

o

if (yourString.Length > 1)
    withoutLast = yourString.TrimEnd().Substring(0, yourString.Length - 1);

... en caso de que desee eliminar un carácter que no sea un espacio en blanco del final.

        string s1 = "Hello! world!";
        string s2 = s1.Trim('!');

Prueba esto:

return( (str).Remove(str.Length-1) );

string helloOriginal = "Hello! World!";
string newString = helloOriginal.Substring(0,helloOriginal.LastIndexOf('!'));

El otro ejemplo de recortar el último carácter de una cadena:

string outputText = inputText.Remove(inputText.Length - 1, 1);

Puede ponerlo en un método de extensión y evitar que sea una cadena nula, etc.

string s1 = "Hello! world!"
string s2 = s1.Substring(0, s1.Length - 1);
Console.WriteLine(s1);
Console.WriteLine(s2);

también puedes usar esto:

public static class Extensions
 {

        public static string RemovePrefix(this string o, string prefix)
        {
            if (prefix == null) return o;
            return !o.StartsWith(prefix) ? o : o.Remove(0, prefix.Length);
        }

        public static string RemoveSuffix(this string o, string suffix)
        {
            if(suffix == null) return o;
            return !o.EndsWith(suffix) ? o : o.Remove(o.Length - suffix.Length, suffix.Length);
        }

    }

Muy fácil y simple:

str = str.Remove (str.Length - 1);

Versión ligeramente modificada de @Damian Leszczyński - Vash que se asegurará de que solo se elimine un personaje específico.

public static class StringExtensions
{
    public static string TrimLastCharacter(this string str, char character)
    {
        if (string.IsNullOrEmpty(str) || str[str.Length - 1] != character)
        {
            return str;
        }
        return str.Substring(0, str.Length - 1);
    }
}

Tomé el camino de escribir una extensión usando TrimEnd solo porque ya lo estaba usando en línea y estaba contento con él ... es decir:

static class Extensions
{
        public static string RemoveLastChars(this String text, string suffix)
        {            
            char[] trailingChars = suffix.ToCharArray();

            if (suffix == null) return text;
            return text.TrimEnd(trailingChars);
        }

}

Asegúrese de incluir el espacio de nombres en sus clases usando la clase estática; P y el uso es:

string _ManagedLocationsOLAP = string.Empty;
_ManagedLocationsOLAP = _validManagedLocationIDs.RemoveLastChars(",");          

Un ejemplo de clase de extensión para simplificar esto: -

internal static class String
{
    public static string TrimEndsCharacter(this string target, char character) => target?.TrimLeadingCharacter(character).TrimTrailingCharacter(character);
    public static string TrimLeadingCharacter(this string target, char character) => Match(target?.Substring(0, 1), character) ? target.Remove(0,1) : target;
    public static string TrimTrailingCharacter(this string target, char character) => Match(target?.Substring(target.Length - 1, 1), character) ? target.Substring(0, target.Length - 1) : target;

    private static bool Match(string value, char character) => !string.IsNullOrEmpty(value) && value[0] == character;
}

Uso

"!Something!".TrimLeadingCharacter('X'); // Result '!Something!' (No Change)
"!Something!".TrimTrailingCharacter('S'); // Result '!Something!' (No Change)
"!Something!".TrimEndsCharacter('g'); // Result '!Something!' (No Change)

"!Something!".TrimLeadingCharacter('!'); // Result 'Something!' (1st Character removed)
"!Something!".TrimTrailingCharacter('!'); // Result '!Something' (Last Character removed)
"!Something!".TrimEndsCharacter('!'); // Result 'Something'  (End Characters removed)

"!!Something!!".TrimLeadingCharacter('!'); // Result '!Something!!' (Only 1st instance removed)
"!!Something!!".TrimTrailingCharacter('!'); // Result '!!Something!' (Only Last instance removed)
"!!Something!!".TrimEndsCharacter('!'); // Result '!Something!'  (Only End instances removed)

Si quieres eliminar el '!' carácter de una expresión específica ("mundo" en su caso), entonces puede usar esta expresión regular

string input = "Hello! world!";

string output = Regex.Replace(input, "(world)!", "$1", RegexOptions.Multiline | RegexOptions.Singleline);

// result: "Hello! world"

el carácter especial de $ 1 contiene todas las expresiones de "mundo" coincidentes, y se usa para reemplazar el "mundo" original. expresión