How do I get the last four characters from a string in C#?

Update 2020: C# 8.0 finally makes this easy:

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

You can also slice arrays in the same way, see Indices and ranges.

All you have to do is..

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

string var = "12345678";

var = var[^4..];

// var = "5678"

This is index operator that literally means "take last four chars from end (^4) until the end (..)"

I would like to extend the existing answer mentioning using new ranges in C# 8 or higher: To make the code usable for all possible strings, even those shorter than 4, there is some form of condition needed! If you want to copy code, I suggest example 5 or 6.

string mystring ="C# 8.0 finally makes slicing possible";

1: Slicing taking the end part- by specifying how many characters to omit from the beginning- this is, what VS 2019 suggests:

string example1 = mystring[Math.Max(0, mystring.Length - 4)..] ;

2: Slicing taking the end part- by specifying how many characters to take from the end:

string example2 = mystring[^Math.Min(mystring.Length, 4)..] ;

3: Slicing taking the end part- by replacing Max/Min with the ?: operator:

string example3 = (mystring.length > 4)? mystring[^4..] : mystring); 

Personally, I like the second and third variant more than the first.

MS doc reference for Indices and ranges:

Null? But we are not done yet concerning universality. Every example so far will throw an exception for null strings. To consider null (if you don´t use non-nullable strings with C# 8 or higher), and to do it without 'if' (classic example 'with if' already given in another answer) we need:

4: Slicing considering null- by specifying how many characters to omit:

string example4 = mystring?[Math.Max(0, mystring.Length - 4)..] ?? string.Empty;

5: Slicing considering null- by specifying how many characters to take:

string example5 = mystring?[^Math.Min(mystring.Length, 4)..] ?? string.Empty;

6: Slicing considering null with the ?: operator (and two other '?' operators ;-) :
(You cannot put that in a whole in a string interpolation e.g. for WriteLine.)

string example6 = (mystring?.Length > 4) ? filePath[^4..] : mystring ?? string.Empty;

7: Equivalent variant with good old Substring() for C# 6 or 7.x:
(You cannot put that in a whole in a string interpolation e.g. for WriteLine.)

string example7 = (mystring?.Length > 4) ? mystring.Substring(mystring.Length- 4) : mystring ?? string.Empty;

Graceful degradation? I like the new features of C#. Putting them on one line like in the last examples maybe looks a bit excessive. We ended up a little perl´ish didn´t we? But it´s a good example for learning and ok for me to use it once in a tested library method. Even better that we can get rid of null in modern C# if we want and avoid all this null-specific handling.

Such a library/extension method as a shortcut is really useful. Despite the advances in C# you have to write your own to get something easier to use than repeating the code above for every small string manipulation need.

I am one of those who began with BASIC, and 40 years ago there was already Right$(,). Funny, that it is possible to use Strings.Right(,) from VB with C# still too as was shown in another answer.

C# has chosen precision over graceful degradation (in opposite to old BASIC). So copy any appropriate variant you like in these answers and define a graceful shortcut function for yourself, mine is an extension function called RightChars(int).

Using the range operator is the easiest way for me. No many codes is required.

In your case, you can get what you want like this:

// the ^ operator indicates the element position from the end of a sequence
string str = "34234234d124"[^4..] 

This works nice, as there are no errors if there are less characters in the string than the requested amount.

using System.Linq;

string.Concat("123".TakeLast(4));

Suggest using TakeLast method, for example: new String(text.TakeLast(4).ToArray())

            string x = "34234234d124";

            string y = x.Substring(x.Length - 4);

assuming you wanted the strings in between a string which is located 10 characters from the last character and you need only 3 characters.

Let's say StreamSelected = "rtsp://72.142.0.230:80/SMIL-CHAN-273/4CIF-273.stream"

In the above, I need to extract the "273" that I will use in database query

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

public static string Last(this string source, int tailLength)
{
  return tailLength >= source.Length ? source : source[^tailLength..];
}

This is a bit more than the OP question, but is an example of how to use the last 3 of a string for a specific purpose. In my case, I wanted to do a numerical sort (LINQ OrderBy) on a number field that is stored as a string (1 to 3 digit numbers.) So, to get the string numbers to sort like numeric numbers, I need to left-pad the string numbers with zeros and then take the last 3. The resulting OrderBy statement is:

myList = myList.OrderBy(x => string.Concat("00",x.Id)[^3..])

The string.Concat() used in the OrderBy statement results in strings like "001", "002", "011", "021", "114" which sort the way they would if they were stored as numbers.