Extraia apenas a maioria das n letras corretas de uma string

Como posso extrair um substringcomposto das seis letras mais à direita de outrostring ?

Ex: minha string é "PER 343573". Agora quero extrair apenas "343573".

Como posso fazer isso?

string SubString = MyString.Substring(MyString.Length-6);

Escreva um método de extensão para expressar a Right(n);função. A função deve lidar com strings nulas ou vazias retornando uma string vazia, strings menores que o comprimento máximo retornando a string original e strings maiores que o comprimento máximo retornando o comprimento máximo dos caracteres mais à direita.

public static string Right(this string sValue, int iMaxLength)
{
  //Check if the value is valid
  if (string.IsNullOrEmpty(sValue))
  {
    //Set valid empty string as string could be null
    sValue = string.Empty;
  }
  else if (sValue.Length > iMaxLength)
  {
    //Make the string no longer than the max length
    sValue = sValue.Substring(sValue.Length - iMaxLength, iMaxLength);
  }

  //Return the string
  return sValue;
}

Provavelmente melhor usar um método de extensão:

public static class StringExtensions
{
    public static string Right(this string str, int length)
    {
        return str.Substring(str.Length - length, length);
    }
}

Uso

string myStr = "PER 343573";
string subStr = myStr.Right(6);

using System;

public static class DataTypeExtensions
{
    #region Methods

    public static string Left(this string str, int length)
    {
        str = (str ?? string.Empty);
        return str.Substring(0, Math.Min(length, str.Length));
    }

    public static string Right(this string str, int length)
    {
        str = (str ?? string.Empty);
        return (str.Length >= length)
            ? str.Substring(str.Length - length, length)
            : str;
    }

    #endregion
}

Não deve dar erro, retorna nulos como string vazia, retorna valores aparados ou básicos. Use-o como "testx" .Left (4) ou str.Right (12);

MSDN

String mystr = "PER 343573";
String number = mystr.Substring(mystr.Length-6);

EDIT: muito lento ...

se você não tem certeza do comprimento de sua string, mas tem certeza da contagem de palavras (sempre 2 palavras neste caso, como 'xxx yyyyyy'), é melhor usar dividir.

string Result = "PER 343573".Split(" ")[1];

isso sempre retorna a segunda palavra de sua string.

Não é exatamente isso que você está pedindo, mas apenas olhando para o exemplo, parece que você está procurando a seção numérica da string.

Se esse for sempre o caso, uma boa maneira de fazer isso seria usar uma expressão regular.

var regex= new Regex("\n+");
string numberString = regex.Match(page).Value;

Usa isto:

String text = "PER 343573";
String numbers = text;
if (text.Length > 6)
{
    numbers = text.Substring(text.Length - 6);
}

Adivinhando seus requisitos, mas a seguinte expressão regular produzirá apenas 6 alfanuméricos antes do final da string e nenhuma correspondência de outra forma.

string result = Regex.Match("PER 343573", @"[a-zA-Z\d]{6}$").Value;

Como você está usando .NET, que é compilado em MSIL , basta fazer referência a Microsoft.VisualBasic e usar o Strings.Rightmétodo integrado da Microsoft :

using Microsoft.VisualBasic;
...
string input = "PER 343573";
string output = Strings.Right(input, 6);

Não há necessidade de criar um método de extensão personalizado ou outro trabalho. O resultado é alcançado com uma referência e uma linha simples de código.

Como mais informações sobre isso, o uso de métodos do Visual Basic com C # foi documentado em outro lugar . Eu pessoalmente tropecei nele primeiro ao tentar analisar um arquivo, e descobri que este tópico do SO sobre o uso da Microsoft.VisualBasic.FileIO.TextFieldParserclasse é extremamente útil para analisar arquivos .csv.

var str = "PER 343573";
var right6 = string.IsNullOrWhiteSpace(str) ? string.Empty 
             : str.Length < 6 ? str 
             : str.Substring(str.Length - 6); // "343573"
// alternative
var alt_right6 = new string(str.Reverse().Take(6).Reverse().ToArray()); // "343573"

isso suporta qualquer número de caracteres no str. o código alternativo não suporta nullstring. e, o primeiro é mais rápido e o segundo é mais compacto.

Eu prefiro o segundo se conhecer a strstring curta. se for uma string longa, a primeira é mais adequada.

por exemplo

var str = "";
var right6 = string.IsNullOrWhiteSpace(str) ? string.Empty 
             : str.Length < 6 ? str 
             : str.Substring(str.Length - 6); // ""
// alternative
var alt_right6 = new string(str.Reverse().Take(6).Reverse().ToArray()); // ""

ou

var str = "123";
var right6 = string.IsNullOrWhiteSpace(str) ? string.Empty 
             : str.Length < 6 ? str 
             : str.Substring(str.Length - 6); // "123"
// alternative
var alt_right6 = new string(str.Reverse().Take(6).Reverse().ToArray()); // "123"

Usa isto:

string mystr = "PER 343573"; int number = Convert.ToInt32(mystr.Replace("PER ",""));

Outra solução que não pode ser mencionada

S.Substring(S.Length < 6 ? 0 : S.Length - 6)

Métodos de segurança nulos:

Strings mais curtos que o comprimento máximo retornando a string original

Método de extensão da string direita

public static string Right(this string input, int count) =>
    String.Join("", (input + "").ToCharArray().Reverse().Take(count).Reverse());

Método de extensão da string esquerda

public static string Left(this string input, int count) =>
    String.Join("", (input + "").ToCharArray().Take(count));

Aqui está a solução que eu uso ... Ele verifica se o comprimento da string de entrada não é menor do que o comprimento solicitado. As soluções que vejo postadas acima não levam isso em consideração, infelizmente - o que pode levar a travamentos.

    /// <summary>
    /// Gets the last x-<paramref name="amount"/> of characters from the given string.
    /// If the given string's length is smaller than the requested <see cref="amount"/> the full string is returned.
    /// If the given <paramref name="amount"/> is negative, an empty string will be returned.
    /// </summary>
    /// <param name="string">The string from which to extract the last x-<paramref name="amount"/> of characters.</param>
    /// <param name="amount">The amount of characters to return.</param>
    /// <returns>The last x-<paramref name="amount"/> of characters from the given string.</returns>
    public static string GetLast(this string @string, int amount)
    {
        if (@string == null) {
            return @string;
        }

        if (amount < 0) {
            return String.Empty;
        }

        if (amount >= @string.Length) {
            return @string;
        } else {
            return @string.Substring(@string.Length - amount);
        }
    }

Este é o método que uso: gosto de manter as coisas simples.

private string TakeLast(string input, int num)
{
    if (num > input.Length)
    {
        num = input.Length;
    }
    return input.Substring(input.Length - num);
}

Apenas um pensamento:

public static string Right(this string @this, int length) {
    return @this.Substring(Math.Max(@this.Length - length, 0));
}

//s - your string
//n - maximum number of right characters to take at the end of string
(new Regex("^.*?(.{1,n})$")).Replace(s,"$1")

Sem recorrer ao conversor de bits e ao deslocamento de bits (é preciso ter certeza da codificação), este é o método mais rápido que uso como método de extensão 'Certo'.

string myString = "123456789123456789";

if (myString > 6)
{

        char[] cString = myString.ToCharArray();
        Array.Reverse(myString);
        Array.Resize(ref myString, 6);
        Array.Reverse(myString);
        string val = new string(myString);
}

Eu uso o Min para prevenir as situações negativas e também lidar com strings nulas

// <summary>
    /// Returns a string containing a specified number of characters from the right side of a string.
    /// </summary>
    public static string Right(this string value, int length)
    {
        string result = value;
        if (value != null)
            result = value.Substring(0, Math.Min(value.Length, length));
        return result;
    }

using Microsoft.visualBasic;

 public class test{
  public void main(){
   string randomString = "Random Word";
   print (Strings.right(randomString,4));
  }
 }

a saída é "Word"