C# String EndsWith() Method
Last Updated :
05 Mar, 2025
In C#, the EndsWith() is a string method used to check whether the ending of the current string instance matches a specified string. If it matches, it returns true; otherwise, it returns false. Using the foreach loop, we can check multiple strings. This method supports overloading by passing different types and numbers of arguments.
Example 1: Basic Usage of EndsWith() Method
C#
// C# program to demonstrate EndsWith() method
using System.Globalization;
using System;
class Geeks
{
public static void Main(string[] args)
{
// Declare and initialize a string
string s = "GeeksforGeeks";
// Check if s ends with "Geeks"
// and print the result
Console.WriteLine(s.EndsWith("Geeks").ToString());
}
}
Explanation: This example checks if the string “GeeksforGeeks” ends with “Geeks” and prints true.
Syntax of String EndsWith() Method
public bool EndsWith(string value);
public bool EndsWith(string value, StringComparison comparisonType);
public bool EndsWith(string value, bool ignoreCase, CultureInfo culture);
Parameters:
- value: The string to compare with the end of the current string.
- comparisonType: A StringComparison value that determines how strings are compared.
- ignoreCase: A bool value indicating whether to ignore case sensitivity.
- culture: A CultureInfo object specifying culture-specific comparison rules.
Return Type:
- It returns true if the given string matches the end of the current string; otherwise, returns false.
Exceptions:
- ArgumentNullException: Thrown if value is null.
- ArgumentException: Thrown if comparisonType is not a valid StringComparison value.
Example 2: Using String.EndsWith(String)
C#
// C# program to check EndsWith()
// with different strings
using System;
public class Geeks
{
static public void Main()
{
// Declare and initialize two strings
string s1 = "Hello Geek";
string s2 = "GeeksforGeeks";
// Check if strings end with
// specific substrings
bool ans1 = s1.EndsWith("Geek");
bool ans2 = s2.EndsWith("Hello");
Console.WriteLine(ans1.ToString());
Console.WriteLine(ans2.ToString());
}
}
Explanation: The example checks whether s1 ends with “Geek” and s2 ends with “Hello”, printing true and false accordingly.
Example 3: Removing Closing HTML Tags Using EndsWith()
C#
// C# program to remove closing
// HTML tags using EndsWith()
using System;
public class Geeks
{
static public void Main()
{
// Array of HTML-like strings
string[] s1 = {
"<p> GeekforGeeks Computer Science Portal </p>",
"<h1> GeekforGeeks Sudo Placement </h1>",
"<h2> GeekforGeeks Placement Preparation </h2>",
"<h3> GeekforGeeks Contribute </h3>",
};
// Process and remove closing tags
foreach (var n in s1)
Console.WriteLine(HtmlEndTags(n));
}
private static string HtmlEndTags(string s2)
{
// Boolean flag to track if
// an ending tag is found
bool a = false;
// Check if the string ends with '>'
if (s2.Trim().EndsWith('>'))
{
// Find the last occurrence of "</"
// indicating a closing tag
int end = s2.LastIndexOf("</");
// If found, remove the closing tag
if (end >= 0)
{
a = true;
s2 = s2.Substring(0, end);
}
}
// Recursively remove tags if found
if (a)
s2 = HtmlEndTags(s2);
return s2;
}
}
Output<p> GeekforGeeks Computer Science Portal
<h1> GeekforGeeks Sudo Placement
<h2> GeekforGeeks Placement Preparation
<h3> GeekforGeeks Contribute
Explanation: This example iterates through an array of HTML like strings and removes their closing tags using EndsWith().
Example 4: Using Culture-Sensitive Comparison
C#
// C# program to demonstrate
// EndsWith() with CultureInfo
using System.Threading;
using System.Globalization;
using System;
class Geeks
{
public static void Main(string[] args)
{
// Define a test string
string s = "Geeksforgeeks";
// Case-sensitive comparison with different inputs
bool a = s.EndsWith("Geeks", false, CultureInfo.InvariantCulture);
bool b = s.EndsWith("geeks", false, CultureInfo.InvariantCulture);
bool c = s.EndsWith("GEEKS", false, CultureInfo.InvariantCulture);
bool d = s.EndsWith(" ", false, CultureInfo.InvariantCulture);
bool e = s.EndsWith("Hello", false, CultureInfo.InvariantCulture);
Console.WriteLine(a);
Console.WriteLine(b);
Console.WriteLine(c);
Console.WriteLine(d);
Console.WriteLine(e);
}
}
OutputFalse
True
False
False
False
Explanation: This example demonstrates how EndsWith() behaves with case sensitivity and CultureInfo settings.
Example 5: Using Different StringComparison Options
C#
// C# program to demonstrate
// EndsWith() with StringComparison
using System;
class Geeks
{
public static void Main(string[] args)
{
// Declare multiple strings
string s1 = "GeeksforGeeks";
string s2 = "Sudo Placement";
string s3 = "Geeks Article";
// Check if strings end with specific
// substrings using StringComparison
bool a = s1.EndsWith("Geek", StringComparison.CurrentCulture);
bool b = s1.EndsWith("geek", StringComparison.CurrentCulture);
bool c = s2.EndsWith("Placement", StringComparison.CurrentCulture);
bool d = s2.EndsWith("Sudo", StringComparison.CurrentCulture);
bool e = s3.EndsWith("Article", StringComparison.CurrentCulture);
bool f = s3.EndsWith("Geeks", StringComparison.CurrentCulture);
Console.WriteLine(a);
Console.WriteLine(b);
Console.WriteLine(c);
Console.WriteLine(d);
Console.WriteLine(e);
Console.WriteLine(f);
}
}
OutputFalse
False
True
False
True
False
Explanation: This example demonstrates different StringComparison options to determine string endings based on culture and case sensitivity.
Important Points:
- EndsWith() checks whether a string ends with a given substring.
- It supports case-sensitive and case-insensitive comparisons.
- It can use CultureInfo for cultural-specific checks.
- It provides multiple overloads to customize comparisons.
- Using EndsWith() properly allows efficient string validation for filtering and text processing.
Similar Reads
C# | EndsWith() Method
In C#, the EndsWith() is a string method used to check whether the ending of the current string instance matches a specified string. If it matches, it returns true; otherwise, it returns false. Using the foreach loop, we can check multiple strings. This method supports overloading by passing differe
4 min read
C# | String.Contains() Method
In C#, the String.Contains() method is used to check whether a substring exists within a given string. It returns a Boolean value (true or false) indicating whether the substring is found. By default, the method performs a case-sensitive comparison. Example 1: Here, we are using the String.Contains(
3 min read
C# | Trim() Method
C# Trim() is a string class method. This method is used to remove all leading and trailing white-space characters from the current String object and return a new modified string. This method is beneficial for clearing the unwanted extra spaces from the string. Example 1: Using the Trim() method to r
4 min read
C# String StartsWith() Method
In C#, the StartsWith() is a method of String Class. This method is used to check whether the beginning of the current string instance matches with a specified string or not. If it matches, it returns true; otherwise, it returns false. Using the foreach loop, we can check multiple strings. This meth
6 min read
C# | Char.IsSurrogate(String, Int32) Method
This method is used to indicates whether the character at the specified position in a specified string has a surrogate code unit or not. Syntax: public static bool IsSurrogate (string s, int index); Parameters: s: It is a String. index: It is the character position to evaluate in s. Return Value: Th
4 min read
C# String Properties
In C#, a String is an array of characters. The string class represents the text as a series of Unicode characters. It provides various properties and methods so that it becomes easy to work with strings. There are two properties in the string class: Chars[Int32]: Used to get the Char object at a spe
4 min read
C# | Array.FindLast() Method
This method is used to search for an element that matches the conditions defined by the specified predicate and returns the last occurrence within the entire Array. Syntax: public static T FindLast<T> (T[] array, Predicate<T> match); Parameters: array: It is the one-dimensional, zero-bas
3 min read
C# | String class
In C#, a string is a sequence of Unicode characters or an array of characters. The range of Unicode characters will be U+0000 to U+FFFF. The array of characters is also termed as the text. So the string is the representation of the text. A string is represented by a class System.String. The String c
9 min read
C# | TrimStart() and TrimEnd() Method
Prerequisite: Trim() Method in C# In C#, TrimStart() & TrimEnd() are the string methods. TrimStart() method is used to remove the occurrences of a set of characters specified in an array from the starting of the current String object. TrimEnd() method is used to remove the occurrences of a set o
3 min read
C# | Remove() Method
In C#, the Remove() method of the String class is used for removing the characters from the specified position of a string. If the length is not specified, then it will remove all the characters after the specified position. This method can be overloaded by changing the number of arguments passed to
3 min read