¿Cómo obtengo los últimos cuatro caracteres de una cadena en C #?

Supongamos que tengo una cadena:

"34234234d124"

Quiero obtener los últimos cuatro caracteres de esta cadena que es "d124". Puedo usar SubString, pero necesita un par de líneas de código, incluido el nombramiento de una variable.

¿Es posible obtener este resultado en una expresión con C #?

mystring.Substring(Math.Max(0, mystring.Length - 4)); //how many lines is this?

Si está seguro de que la longitud de su cadena es de al menos 4, entonces es aún más corta:

mystring.Substring(mystring.Length - 4);

Puedes usar un método de extensión :

public static class StringExtension
{
    public static string GetLast(this string source, int tail_length)
    {
       if(tail_length >= source.Length)
          return source;
       return source.Substring(source.Length - tail_length);
    }
}

Y luego llame:

string mystring = "34234234d124";
string res = mystring.GetLast(4);

Todo lo que tienes que hacer es..

String result = mystring.Substring(mystring.Length - 4);

Ok, entonces veo que esta es una publicación antigua, pero ¿por qué estamos reescribiendo el código que ya se proporciona en el marco?

Sugeriría que agregue una referencia a la DLL del marco "Microsoft.VisualBasic"

using Microsoft.VisualBasic;
//...

string value = Strings.Right("34234234d124", 4);

string mystring = "34234234d124";
mystring = mystring.Substring(mystring.Length-4)

Usar Substring es en realidad bastante corto y legible:

 var result = mystring.Substring(mystring.Length - Math.Min(4, mystring.Length));
 // result == "d124"

Aquí hay otra alternativa que no debería funcionar demasiado mal (debido a la ejecución diferida ):

new string(mystring.Reverse().Take(4).Reverse().ToArray());

Aunque un método de extensión para este propósito mystring.Last(4)es claramente la solución más limpia, aunque un poco más de trabajo.

Simplemente puede usar el Substringmétodo de C #. Por ej.

string str = "1110000";
string lastFourDigits = str.Substring((str.Length - 4), 4);

Devolverá el resultado 0000.

Una solución simple sería:

string mystring = "34234234d124";
string last4 = mystring.Substring(mystring.Length - 4, 4);

mystring = mystring.Length > 4 ? mystring.Substring(mystring.Length - 4, 4) : mystring;

Es solo esto:

int count = 4;
string sub = mystring.Substring(mystring.Length - count, count);

En comparación con algunas respuestas anteriores, la principal diferencia es que este código tiene en cuenta cuando la cadena de entrada es:

1. Nulo
2. Más largo o que coincida con la longitud solicitada
3. Más corta que la longitud solicitada.

Aquí está:

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

    public static string MyLast(this string str, int length)
    {
        if (str == null)
            return null;
        else if (str.Length >= length)
            return str.Substring(str.Length - length, length);
        else
            return str;
    }
}

Definición:

public static string GetLast(string source, int last)
{
     return last >= source.Length ? source : source.Substring(source.Length - last);
}

Uso:

GetLast("string of", 2);

Resultado:

de

Esto no fallará para cualquier cadena de longitud.

string mystring = "34234234d124";
string last4 = Regex.Match(mystring, "(?!.{5}).*").Value;
// last4 = "d124"
last4 = Regex.Match("d12", "(?!.{5}).*").Value;
// last4 = "d12"

Probablemente esto sea excesivo para la tarea en cuestión, pero si necesita una validación adicional, posiblemente se pueda agregar a la expresión regular.

Editar: creo que esta expresión regular sería más eficiente:

@".{4}\Z"

Utiliza un genérico Last<T>. Eso funcionará con CUALQUIERA IEnumerable, incluida la cadena.

public static IEnumerable<T> Last<T>(this IEnumerable<T> enumerable, int nLastElements)
{
    int count = Math.Min(enumerable.Count(), nLastElements);
    for (int i = enumerable.Count() - count; i < enumerable.Count(); i++)
    {
        yield return enumerable.ElementAt(i);
    }
}

Y uno específico para cadena:

public static string Right(this string str, int nLastElements)
{
    return new string(str.Last(nLastElements).ToArray());
}

Reuní algunos códigos modificados de varias fuentes que obtendrán los resultados que deseas y además harás mucho más. He permitido valores int negativos, valores int que exceden la longitud de la cadena y para que el índice final sea menor que el índice inicial. En ese último caso, el método devuelve una subcadena de orden inverso. Hay muchos comentarios, pero avíseme si algo no está claro o simplemente es una locura. Estaba jugando con esto para ver para qué podría usarlo.

    /// <summary>
    /// Returns characters slices from string between two indexes.
    /// 
    /// If start or end are negative, their indexes will be calculated counting 
    /// back from the end of the source string. 
    /// If the end param is less than the start param, the Slice will return a 
    /// substring in reverse order.
    /// 
    /// <param name="source">String the extension method will operate upon.</param>
    /// <param name="startIndex">Starting index, may be negative.</param>
    /// <param name="endIndex">Ending index, may be negative).</param>
    /// </summary>
    public static string Slice(this string source, int startIndex, int endIndex = int.MaxValue)
    {
        // If startIndex or endIndex exceeds the length of the string they will be set 
        // to zero if negative, or source.Length if positive.
        if (source.ExceedsLength(startIndex)) startIndex = startIndex < 0 ? 0 : source.Length;
        if (source.ExceedsLength(endIndex)) endIndex = endIndex < 0 ? 0 : source.Length;

        // Negative values count back from the end of the source string.
        if (startIndex < 0) startIndex = source.Length + startIndex;
        if (endIndex < 0) endIndex = source.Length + endIndex;         

        // Calculate length of characters to slice from string.
        int length = Math.Abs(endIndex - startIndex);
        // If the endIndex is less than the startIndex, return a reversed substring.
        if (endIndex < startIndex) return source.Substring(endIndex, length).Reverse();

        return source.Substring(startIndex, length);
    }

    /// <summary>
    /// Reverses character order in a string.
    /// </summary>
    /// <param name="source"></param>
    /// <returns>string</returns>
    public static string Reverse(this string source)
    {
        char[] charArray = source.ToCharArray();
        Array.Reverse(charArray);
        return new string(charArray);
    }

    /// <summary>
    /// Verifies that the index is within the range of the string source.
    /// </summary>
    /// <param name="source"></param>
    /// <param name="index"></param>
    /// <returns>bool</returns>
    public static bool ExceedsLength(this string source, int index)
    {
        return Math.Abs(index) > source.Length ? true : false;
    }

Entonces, si tiene una cadena como "Este es un método de extensión", aquí hay algunos ejemplos y resultados que puede esperar.

var s = "This is an extension method";
// If you want to slice off end characters, just supply a negative startIndex value
// but no endIndex value (or an endIndex value >= to the source string length).
Console.WriteLine(s.Slice(-5));
// Returns "ethod".
Console.WriteLine(s.Slice(-5, 10));
// Results in a startIndex of 22 (counting 5 back from the end).
// Since that is greater than the endIndex of 10, the result is reversed.
// Returns "m noisnetxe"
Console.WriteLine(s.Slice(2, 15));
// Returns "is is an exte"

Esperemos que esta versión sea útil para alguien. Funciona de manera normal si no usa números negativos y proporciona valores predeterminados para parámetros fuera de rango.

string var = "12345678";

if (var.Length >= 4)
{
    var = var.substring(var.Length - 4, 4)
}

// result = "5678"

suponiendo que desea las cadenas entre una cadena que se encuentra a 10 caracteres del último carácter y necesita solo 3 caracteres.

Digamos StreamSelected = "rtsp://72.142.0.230:80/SMIL-CHAN-273/4CIF-273.stream"

En lo anterior, necesito extraer el "273"que usaré en la consulta de la base de datos

        //find the length of the string            
        int streamLen=StreamSelected.Length;

        //now remove all characters except the last 10 characters
        string streamLessTen = StreamSelected.Remove(0,(streamLen - 10));   

        //extract the 3 characters using substring starting from index 0
        //show Result is a TextBox (txtStreamSubs) with 
        txtStreamSubs.Text = streamLessTen.Substring(0, 3);

La actualización 2020 : C # 8.0 finalmente lo hace fácil:

> "C# 8.0 finally makes this easy"[^4..]
"easy"

También puede dividir matrices de la misma manera, ver Índices y rangos .