Aparar o último caractere de uma sequência

Eu tenho uma string dizer

"Hello! world!" 

Eu quero fazer um corte ou uma remoção para tirar o! fora do mundo, mas não fora Olá.

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

consulte Mais informação

EDITAR:

O que eu notei neste tipo de perguntas que todo mundo sugere para remover o último caractere de uma determinada string. Mas isso não atende à definição do método Trim.

Aparar - Remove todas as ocorrências de caracteres de espaço em branco do início e do final desta instância.

MSDN-Trim

Sob essa definição, remover apenas o último caractere da string é uma solução ruim.

Portanto, se queremos "aparar o último caractere da string", devemos fazer algo como isto

Exemplo como método de extensão:

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

Observe que se você deseja remover todos os caracteres do mesmo valor, ou seja, (!!!!) o método acima remove todas as existências de '!' a partir do final da string, mas se você deseja remover apenas o último caractere, use este:

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

ou

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

... caso deseje remover um caractere que não seja um espaço em branco do final.

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

Tente o seguinte:

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

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

O outro exemplo de corte do último caractere de uma sequência:

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

Você pode colocá-lo em um método de extensão e impedir que ele seja nulo, etc.

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

você também pode usar isso:

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

    }

Muito fácil e simples:

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

Versão ligeiramente modificada de @Damian Leszczyński - Vash que garante que apenas um caractere específico seja removido.

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

Peguei o caminho de escrever uma extensão usando o TrimEnd só porque eu já estava usando inline e estava feliz com isso ... ou seja:

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

}

Certifique-se de incluir o espaço para nome em suas classes usando a classe estática; P e uso são:

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

Um exemplo da classe Extension para simplificar isso: -

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)

Se você deseja remover o '!' caractere de uma expressão específica ("mundo" no seu caso), você pode usar essa expressão regular

string input = "Hello! world!";

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

// result: "Hello! world"

o caractere especial $ 1 contém todas as expressões correspondentes do "mundo" e é usado para substituir o "mundo!" original expressão