Estrai solo la maggior parte delle n lettere a destra da una stringa

Come posso estrarre un substringche è composto dalle sei lettere più a destra da un altro string?

Es: la mia stringa è "PER 343573". Ora voglio solo estrarre "343573".

Come posso fare questo?

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

Scrivi un metodo di estensione per esprimere la Right(n);funzione. La funzione dovrebbe gestire stringhe nulle o vuote che restituiscono una stringa vuota, stringhe più brevi della lunghezza massima che restituiscono la stringa originale e stringhe più lunghe della lunghezza massima che restituiscono la lunghezza massima dei caratteri più a destra.

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

Probabilmente è più bello usare un metodo di estensione:

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
}

Non dovrebbe generare errori, restituisce valori nulli come stringa vuota, restituisce valori di base o tagliati. Usalo come "testx" .Left (4) o str.Right (12);

MSDN

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

EDIT: troppo lento ...

se non sei sicuro della lunghezza della stringa, ma sei sicuro del conteggio delle parole (sempre 2 parole in questo caso, come "xxx yyyyyy") faresti meglio a usare split.

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

restituisce sempre la seconda parola della stringa.

Non è esattamente quello che stai chiedendo, ma solo guardando l'esempio, sembra che stai cercando la sezione numerica della stringa.

Se è sempre così, allora un buon modo per farlo sarebbe usare un'espressione regolare.

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

Usa questo:

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

Indovinando le tue esigenze, ma la seguente espressione regolare produrrà solo 6 caratteri alfanumerici prima della fine della stringa e altrimenti non corrisponderà.

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

Poiché stai utilizzando .NET, che viene compilato in MSIL , fai riferimento a Microsoft.VisualBasic e utilizza il Strings.Rightmetodo integrato di Microsoft :

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

Non è necessario creare un metodo di estensione personalizzato o altro lavoro. Il risultato si ottiene con un riferimento e una semplice riga di codice.

Come ulteriori informazioni su questo, l'utilizzo di metodi Visual Basic con C # è stato documentato altrove . Personalmente mi sono imbattuto per primo durante il tentativo di analizzare un file e ho trovato questo thread SO sull'utilizzo della Microsoft.VisualBasic.FileIO.TextFieldParserclasse estremamente utile per l'analisi dei file .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"

questo supporta qualsiasi numero di caratteri in str. il codice alternativo non supporta la nullstringa. e, il primo è più veloce e il secondo è più compatto.

preferisco il secondo se si conosce la strbreve stringa contenente. se è lunga la stringa è più adatta.

per esempio

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"

Usa questo:

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

Un'altra soluzione che potrebbe non essere menzionata

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

Metodi nulli sicuri:

Stringhe più corte della lunghezza massima che restituiscono la stringa originale

Metodo di estensione String Right

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

Metodo di estensione a sinistra della stringa

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

Ecco la soluzione che uso ... Controlla che la lunghezza della stringa di input non sia inferiore alla lunghezza richiesta. Le soluzioni che vedo pubblicate sopra non ne tengono conto purtroppo, il che può portare a arresti anomali.

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

Questo è il metodo che utilizzo: mi piace mantenere le cose semplici.

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

Solo un pensiero:

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

Senza ricorrere al convertitore di bit e allo spostamento di bit (è necessario essere sicuri della codifica) questo è il metodo più veloce che uso come metodo di estensione "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);
}

Uso il Min per prevenire le situazioni negative e gestire anche stringhe null

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

l'output è "Word"