C# String EndsWith() Method

What You’ll Learn

The instance method EndsWith() checks whether a string’s trailing characters match a given suffix. It returns true or false—ideal for file extensions, URL paths, domain checks, and any logic that depends on how text finishes.

Definition and Usage

In C#, EndsWith() determines whether a string ends with a specified substring (or single character). It is an instance method, so you call it on the text being tested: path.EndsWith(".json").

Unlike Contains(), which searches anywhere in the string, EndsWith() only compares the final characters. That makes it perfect when the suffix position matters—such as verifying a filename ends with .cs or a URL ends with /.

📝 Syntax

Common overloads on System.String:

public bool EndsWith(string value);
public bool EndsWith(string value, StringComparison comparisonType);
public bool EndsWith(char value);  // .NET 5+

Parameters

• value — the suffix to match at the end of the string. Must not be null for string overloads.
• comparisonType — how to compare: e.g. Ordinal, OrdinalIgnoreCase, CurrentCultureIgnoreCase.

Return Value

true if the string ends with the suffix; false otherwise. An empty suffix "" always returns true.

Examples Gallery

Run with dotnet run. Each example shows a practical way to use EndsWith()—from basic suffix checks to case rules, file filtering, and comparison with StartsWith().

using System;

class Program {
    static void Main() {
        string sampleString = "Hello, World";

        bool endsWithWorld = sampleString.EndsWith("World");

        Console.WriteLine($"Ends with 'World'? {endsWithWorld}");
    }
}

Ends with 'World'? True

using System;

class Program {
    static void Main() {
        string text = "Hello, World";

        Console.WriteLine(text.EndsWith("world"));  // false — case mismatch
        Console.WriteLine(text.EndsWith("World"));  // true  — exact match
        Console.WriteLine(text.EndsWith("ld"));     // true  — valid suffix
    }
}

False
True
True

using System;

class Program {
    static void Main() {
        string sampleString = "Hello, World";

        bool caseSensitive = sampleString.EndsWith("world");
        bool ignoreCase    = sampleString.EndsWith(
            "world",
            StringComparison.OrdinalIgnoreCase);

        Console.WriteLine($"Case-sensitive:   {caseSensitive}");
        Console.WriteLine($"Ignore case:      {ignoreCase}");
    }
}

Case-sensitive:   False
Ignore case:      True

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        string[] files = {
            "report.pdf",
            "notes.txt",
            "photo.PDF",
            "draft.docx"
        };

        List<string> pdfs = new List<string>();

        foreach (string file in files) {
            if (file.EndsWith(".pdf", StringComparison.OrdinalIgnoreCase)) {
                pdfs.Add(file);
            }
        }

        Console.WriteLine("PDF files:");
        foreach (string name in pdfs) {
            Console.WriteLine("  - " + name);
        }
    }
}

PDF files:
  - report.pdf
  - photo.PDF

using System;

class Program {
    static void Main() {
        string url = "https://codetofun.com/docs/";

        bool startsHttps = url.StartsWith("https://");
        bool endsSlash   = url.EndsWith("/");
        bool endsCom     = url.EndsWith(".com");  // false — .com is not the suffix

        Console.WriteLine($"Starts with https:// : {startsHttps}");
        Console.WriteLine($"Ends with /          : {endsSlash}");
        Console.WriteLine($"Ends with .com       : {endsCom}");
    }
}

Starts with https:// : True
Ends with /          : True
Ends with .com       : False

🚀 Common Use Cases

• File extension checks — filter or validate .json, .csv, .exe files.
• URL path validation — ensure paths end with / or a specific segment.
• Domain suffix rules — detect .edu, .gov, or regional TLDs at the end.
• Input validation — require usernames or codes to end with a digit or pattern.
• Guard clauses — skip processing when a required suffix is missing.

📝 Notes

• Default EndsWith(string) is ordinal and case-sensitive.
• Passing null as the suffix throws ArgumentNullException.
• An empty suffix "" always returns true.
• If the suffix is longer than the string, the method returns false.
• EndsWith(char) is available in .NET 5+ for single-character suffix checks.
• For middle-of-string matches, use Contains() instead of EndsWith().

⚡ Optimization

EndsWith() is efficient because it only compares the trailing portion of the string—not the entire content. If you test the same suffix repeatedly in a loop, store the boolean result in a local variable. For many file paths, Path.GetExtension() can be an alternative, but EndsWith remains clear and fast for typical suffix checks.

💡 Best Practices