Extrae solo a la derecha la mayoría de las n letras de una cadena

¿Cómo puedo extraer un substring que se compone de las seis letras más a la derecha de otra string?

Ej: mi cadena es "PER 343573" . Ahora solo quiero extraer "343573".

¿Cómo puedo hacer esto?

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

Escribe un método de extensión para expresar la Right(n);función. La función debe tratar con cadenas nulas o vacías que devuelven una cadena vacía, cadenas más cortas que la longitud máxima que devuelven la cadena original y cadenas más largas que la longitud máxima que devuelven la longitud máxima de los caracteres más a la derecha.

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

Probablemente sea más agradable usar un método de extensión:

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
}

No debe producirse un error, devuelve nulos como una cadena vacía, devuelve valores recortados o base. Úselo como "testx" .Left (4) o str.Right (12);

MSDN

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

EDITAR: demasiado lento ...

si no está seguro de la longitud de su cadena, pero está seguro del recuento de palabras (siempre 2 palabras en este caso, como 'xxx yyyyyy'), será mejor que use split.

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

esto siempre devuelve la segunda palabra de su cadena.

Esto no es exactamente lo que está pidiendo, pero con solo mirar el ejemplo, parece que está buscando la sección numérica de la cadena.

Si este es siempre el caso, entonces una buena forma de hacerlo sería usando una expresión regular.

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

Utilizar este:

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

Adivinando sus requisitos, pero la siguiente expresión regular arrojará solo 6 caracteres alfanuméricos antes del final de la cadena y ninguna coincidencia de lo contrario.

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

Dado que está utilizando .NET, que se compila en MSIL , solo haga referencia a Microsoft.VisualBasic y use el Strings.Rightmétodo integrado de Microsoft :

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

No es necesario crear un método de extensión personalizado u otro trabajo. El resultado se logra con una referencia y una simple línea de código.

Como información adicional sobre esto, el uso de métodos de Visual Basic con C # se ha documentado en otra parte . Personalmente, me topé con él primero al intentar analizar un archivo, y encontré que este hilo SO sobre el uso de la Microsoft.VisualBasic.FileIO.TextFieldParserclase es extremadamente útil para analizar archivos .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"

esto admite cualquier número de caracteres en el str. el código alternativo no admite nullcadena. y el primero es más rápido y el segundo es más compacto.

Prefiero el segundo si conozco la strcadena corta que contiene. si es una cuerda larga, la primera es más adecuada.

p.ej

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()); // ""

o

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"

Utilizar este:

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

Otra solución que puede no mencionarse

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

Métodos seguros nulos:

Cadenas más cortas que la longitud máxima que devuelven la cadena original

Método de extensión de cadena a la derecha

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

Método de extensión de cadena a la izquierda

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

Aquí está la solución que uso ... Comprueba que la longitud de la cadena de entrada no sea menor que la longitud solicitada. Desafortunadamente, las soluciones que veo publicadas anteriormente no tienen esto en cuenta, lo que puede provocar fallas.

    /// <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 es el método que utilizo: me gusta simplificar las cosas.

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

Solo un pensamiento:

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

Sin recurrir al convertidor de bits y al cambio de bits (es necesario estar seguro de la codificación), este es el método más rápido que utilizo como método de extensión 'Derecha'.

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

Utilizo Min para prevenir situaciones negativas y también manejo cadenas 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));
  }
 }

la salida es "Word"