Extraia apenas a maioria das letras n de uma string

Como posso extrair uma substring que é composta das seis letras mais à direita de outra string?

Ex: minha string é “PER 343573”. Agora eu quero extrair apenas “343573”.

Como posso fazer isso?

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

Escreva um método de extensão para expressar o Right(n); function. A function 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 a length max retornando o tamanho 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 = "ABCDEPER 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 erro, retorna nulos como string vazia, retorna valores aparados ou base. Use-o como “testx”. Esquerda (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 tamanho da sua string, mas tem certeza de que as palavras contam (sempre duas palavras, como ‘xxx yyyyyy’), é melhor usar split.

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

isso sempre retorna a segunda palavra da sua string.

Isso não é exatamente o que você está pedindo, mas apenas olhando o exemplo, parece que você está procurando pela 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 as suas necessidades, mas a expressão regular a seguir produzirá apenas 6 alfanuméricos antes do final da string e não corresponderá ao contrário.

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

Usa isto:

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

Como você está usando o .NET, que é compilado pelo MSIL , basta fazer referência ao Microsoft.VisualBasic e usar o método Strings.Right 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 é obtido com uma referência e uma linha simples de código.

Como informações adicionais sobre isso, usando methods do Visual Basic com C # foi documentado em outro lugar . Eu, pessoalmente, deparei com isso primeiro ao tentar analisar um arquivo, e encontrei este thread SO em usar a class Microsoft.VisualBasic.FileIO.TextFieldParser para ser extremamente útil para analisar arquivos .csv.

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

Métodos Seguros Nulos:

Strings menores que o comprimento máximo retornando a string original

Método de Extensão de Cadeia Direita

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

Método de Extensão de Cadeia 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 input não é menor do que o comprimento solicitado. As soluções que vejo postadas acima não levam isso em conta, infelizmente, o que pode levar a falhas.

  ///  /// Gets the last x- of characters from the given string. /// If the given string's length is smaller than the requested  the full string is returned. /// If the given  is negative, an empty string will be returned. ///  /// The string from which to extract the last x- of characters. /// The amount of characters to return. /// The last x- of characters from the given string. 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); } } 

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

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

Apenas um pensamento:

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

Sem recorrer ao conversor de bits e à transferência de bits (é necessário ter certeza da codificação), esse é o método mais rápido que uso como um método de extensão ‘Right’.

 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 evitar as situações negativas e também manipular seqüências nulas

 //  /// Returns a string containing a specified number of characters from the right side of a string. ///  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)); } } 

saída é “Word”

 //s - your string //n - maximum number of right characters to take at the end of string (new Regex("^.*?(.{1,n})$")).Replace(s,"$1") 
 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 cadeia null . e o primeiro é mais rápido e o segundo é mais compacto.

Eu prefiro o segundo se conhecer a str contendo string 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"