Case insensitive 'Contains(string)'

Is there a way to make the following return true?

string title = 'ASTRINGTOTEST';
title.Contains('string');

There doesn't seem to be an overload that allows me to set the case sensitivity.. Currently I UPPERCASE them both, but that's just silly (by which I am referring to the i18n issues that come with up- and down casing).

UPDATE
This question is ancient and since then I have realized I asked for a simple answer for a really vast and difficult topic if you care to investigate it fully.
For most cases, in mono-lingual, English code bases this answer will suffice. I'm suspecting because most people coming here fall in this category this is the most popular answer.
This answer however brings up the inherent problem that we can't compare text case insensitive until we know both texts are the same culture and we know what that culture is. This is maybe a less popular answer, but I think it is more correct and that's why I marked it as such.

Answers:

You could always just up or downcase the strings first.

string title = 'string':
title.ToUpper().Contains('STRING')  // returns true

Oops, just saw that last bit. A case insensitive compare would *probably* do the same anyway, and if performance is not an issue, I don't see a problem with creating uppercase copies and comparing those. I could have sworn that I once saw a case-insensitive compare once...

Answers:

You could use the String.IndexOf Method and pass StringComparison.OrdinalIgnoreCase as the type of search to use:

string title = 'STRING';
bool contains = title.IndexOf('string', StringComparison.OrdinalIgnoreCase) >= 0;

Even better is defining a new extension method for string:

public static class StringExtensions
{
    public static bool Contains(this string source, string toCheck, StringComparison comp)
    {
        return source?.IndexOf(toCheck, comp) >= 0;
    }
}

Note, that null propagation ?. is available since C# 6.0 (VS 2015), for older versions use

if (source == null) return false;
return source.IndexOf(toCheck, comp) >= 0;

USAGE:

string title = 'STRING';
bool contains = title.Contains('string', StringComparison.OrdinalIgnoreCase);

Answers:

You can use IndexOf() like this:

string title = 'STRING';

if (title.IndexOf('string', 0, StringComparison.CurrentCultureIgnoreCase) != -1)
{
    // The string exists in the original
}

Since 0 (zero) can be an index, you check against -1.

MSDN

The zero-based index position of value if that string is found, or -1 if it is not. If value is String.Empty, the return value is 0.

Answers:

Alternative solution using Regex:

bool contains = Regex.IsMatch('StRiNG to search', Regex.Escape('string'), RegexOptions.IgnoreCase);

Answers:

StringExtension class is the way forward, I've combined a couple of the posts above to give a complete code example:

public static class StringExtensions
{
    /// <summary>
    /// Allows case insensitive checks
    /// </summary>
    public static bool Contains(this string source, string toCheck, StringComparison comp)
    {
        return source.IndexOf(toCheck, comp) >= 0;
    }
}

Answers:

One issue with the answer is that it will throw an exception if a string is null. You can add that as a check so it won't:

public static bool Contains(this string source, string toCheck, StringComparison comp)
{
    if (string.IsNullOrEmpty(toCheck) || string.IsNullOrEmpty(source))
        return true;

    return source.IndexOf(toCheck, comp) >= 0;
} 

Answers:

Use this:

string.Compare('string', 'STRING', new System.Globalization.CultureInfo('en-US'), System.Globalization.CompareOptions.IgnoreCase);

Answers:

I know that this is not the C#, but in the framework (VB.NET) there is already such a function

Dim str As String = 'UPPERlower'
Dim b As Boolean = InStr(str, 'UpperLower')

C# variant:

string myString = 'Hello World';
bool contains = Microsoft.VisualBasic.Strings.InStr(myString, 'world');

Answers:

This is clean and simple.

Regex.IsMatch(file, fileNamestr, RegexOptions.IgnoreCase)

Answers:

To test if the string paragraph contains the string word (thanks @QuarterMeister)

culture.CompareInfo.IndexOf(paragraph, word, CompareOptions.IgnoreCase) >= 0

Where culture is the instance of CultureInfo describing the language that the text is written in.

This solution is transparent about the definition of case-insensitivity, which is language dependent. For example, the English language uses the characters I and i for the upper and lower case versions of the ninth letter, whereas the Turkish language uses these characters for the eleventh and twelfth letters of its 29 letter-long alphabet. The Turkish upper case version of 'i' is the unfamiliar character 'İ'.

Thus the strings tin and TIN are the same word in English, but different words in Turkish. As I understand, one means 'spirit' and the other is an onomatopoeia word. (Turks, please correct me if I'm wrong, or suggest a better example)

To summarise, you can only answer the question 'are these two strings the same but in different cases' if you know what language the text is in. If you don't know, you'll have to take a punt. Given English's hegemony in software, you should probably resort to CultureInfo.InvariantCulture, because it'll be wrong in familiar ways.

Answers:

Using a RegEx is a straight way to do this:

Regex.IsMatch(title, 'string', RegexOptions.IgnoreCase);

Answers:

The InStr method from the VisualBasic assembly is the best if you have a concern about internationalization (or you could reimplement it). Looking at in it dotNeetPeek shows that not only does it account for caps and lowercase, but also for kana type and full- vs. half-width characters (mostly relevant for Asian languages, although there are full-width versions of the Roman alphabet too). I'm skipping over some details, but check out the private method InternalInStrText:

private static int InternalInStrText(int lStartPos, string sSrc, string sFind)
{
  int num = sSrc == null ? 0 : sSrc.Length;
  if (lStartPos > num || num == 0)
    return -1;
  if (sFind == null || sFind.Length == 0)
    return lStartPos;
  else
    return Utils.GetCultureInfo().CompareInfo.IndexOf(sSrc, sFind, lStartPos, CompareOptions.IgnoreCase | CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth);
}

Answers:

OrdinalIgnoreCase, CurrentCultureIgnoreCase or InvariantCultureIgnoreCase?

Since this is missing, here are some recommendations about when to use which one:

Dos

• Use StringComparison.OrdinalIgnoreCase for comparisons as your safe default for culture-agnostic string matching.
• Use StringComparison.OrdinalIgnoreCase comparisons for increased speed.
• Use StringComparison.CurrentCulture-based string operations when displaying the output to the user.
• Switch current use of string operations based on the invariant culture to use the non-linguistic StringComparison.Ordinal or StringComparison.OrdinalIgnoreCase when the comparison is
  linguistically irrelevant (symbolic, for example).
• Use ToUpperInvariant rather than ToLowerInvariant when normalizing strings for comparison.

Don'ts

• Use overloads for string operations that don't explicitly or implicitly specify the string comparison mechanism.
• Use StringComparison.InvariantCulture -based string
  operations in most cases; one of the few exceptions would be
  persisting linguistically meaningful but culturally-agnostic data.

---

Based on these rules you should use:

string title = 'STRING';
if (title.IndexOf('string', 0, StringComparison.[YourDecision]) != -1)
{
    // The string exists in the original
}

whereas [YourDecision] depends on the recommendations from above.

link of source: http://msdn.microsoft.com/en-us/library/ms973919.aspx

Answers:

Just like this:

string s='AbcdEf';
if(s.ToLower().Contains('def'))
{
    Console.WriteLine('yes');
}

Answers:

This is quite similar to other example here, but I've decided to simplify enum to bool, primary because other alternatives are normally not needed. Here is my example:

public static class StringExtensions
{
    public static bool Contains(this string source, string toCheck, bool bCaseInsensitive )
    {
        return source.IndexOf(toCheck, bCaseInsensitive ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal) >= 0;
    }
}

And usage is something like:

if( 'main String substring'.Contains('SUBSTRING', true) )
....

Answers:

The trick here is to look for the string, ignoring case, but to keep it exactly the same (with the same case).

 var s='Factory Reset';
 var txt='reset';
 int first = s.IndexOf(txt, StringComparison.InvariantCultureIgnoreCase) + txt.Length;
 var subString = s.Substring(first - txt.Length, txt.Length);

Output is 'Reset'

Answers:

if ('strcmpstring1'.IndexOf(Convert.ToString('strcmpstring2'), StringComparison.CurrentCultureIgnoreCase) >= 0){return true;}else{return false;}

Answers:

You can use string.indexof () function. This will be case insensitive

Answers:

Simple way for newbie:

title.ToLower().Contains('string');//of course 'string' is lowercase.

Answers:

public static class StringExtension
{
    #region Public Methods

    public static bool ExContains(this string fullText, string value)
    {
        return ExIndexOf(fullText, value) > -1;
    }

    public static bool ExEquals(this string text, string textToCompare)
    {
        return text.Equals(textToCompare, StringComparison.OrdinalIgnoreCase);
    }

    public static bool ExHasAllEquals(this string text, params string[] textArgs)
    {
        for (int index = 0; index < textArgs.Length; index++)
            if (ExEquals(text, textArgs[index]) == false) return false;
        return true;
    }

    public static bool ExHasEquals(this string text, params string[] textArgs)
    {
        for (int index = 0; index < textArgs.Length; index++)
            if (ExEquals(text, textArgs[index])) return true;
        return false;
    }

    public static bool ExHasNoEquals(this string text, params string[] textArgs)
    {
        return ExHasEquals(text, textArgs) == false;
    }

    public static bool ExHasNotAllEquals(this string text, params string[] textArgs)
    {
        for (int index = 0; index < textArgs.Length; index++)
            if (ExEquals(text, textArgs[index])) return false;
        return true;
    }

    /// <summary>
    /// Reports the zero-based index of the first occurrence of the specified string
    /// in the current System.String object using StringComparison.InvariantCultureIgnoreCase.
    /// A parameter specifies the type of search to use for the specified string.
    /// </summary>
    /// <param name='fullText'>
    /// The string to search inside.
    /// </param>
    /// <param name='value'>
    /// The string to seek.
    /// </param>
    /// <returns>
    /// The index position of the value parameter if that string is found, or -1 if it
    /// is not. If value is System.String.Empty, the return value is 0.
    /// </returns>
    /// <exception cref='ArgumentNullException'>
    /// fullText or value is null.
    /// </exception>
    public static int ExIndexOf(this string fullText, string value)
    {
        return fullText.IndexOf(value, StringComparison.OrdinalIgnoreCase);
    }

    public static bool ExNotEquals(this string text, string textToCompare)
    {
        return ExEquals(text, textToCompare) == false;
    }

    #endregion Public Methods
}

Answers:

if you want to check if your passed string is in string then there is a simple method for that.

string yourStringForCheck= 'abc';
string stringInWhichWeCheck= 'Test abc abc';

bool isContained = stringInWhichWeCheck.ToLower().IndexOf(yourStringForCheck.ToLower()) > -1;

This boolean value will return if the string is contained or not

Answers:

These are the easiest solutions.

1. By Index of

   string title = 'STRING';
   
   if (title.IndexOf('string', 0, StringComparison.CurrentCultureIgnoreCase) != -1)
   {
       // contains 
   }
   

2. By Changing case

   string title = 'STRING';
   
   bool contains = title.ToLower().Contains('string')
   

3. By Regex

   Regex.IsMatch(title, 'string', RegexOptions.IgnoreCase);
   

Answers:

.NET Core 2.0+ only (as of now)

.NET Core has had a pair of methods to deal with this since version 2.0 :

• String.Contains(Char, StringComparison)
• String.Contains(String, StringComparison)

Example:

'Test'.Contains('test', System.StringComparison.CurrentCultureIgnoreCase);

In time, they will probably make their way into the .NET Standard and, from there, into all the other implementations of the Base Class Library.

Answers:

Just to build on the answer here, you can create a string extension method to make this a little more user-friendly:

    public static bool ContainsIgnoreCase(this string paragraph, string word)
    {
        return CultureInfo.CurrentCulture.CompareInfo.IndexOf(paragraph, word, CompareOptions.IgnoreCase) >= 0;
    }

Answers:

As simple and works

title.ToLower().Contains('String'.ToLower())

Answers:

Similar to previous answers (using an extension method) but with two simple null checks (C# 6.0 and above):

public static bool ContainsIgnoreCase(this string source, string substring)
{
    return source?.IndexOf(substring ?? "", StringComparison.OrdinalIgnoreCase) >= 0;
}

If source is null, return false (via null-propagation operator ?.)

If substring is null, treat as an empty string and return true (via null-coalescing operator ??)

The StringComparison can of course be sent as a parameter if needed.

Answers: