Não contém maiúsculas de minúsculas 'Contém (string)'

Existe uma maneira de tornar o seguinte retorno verdadeiro?

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

Não parece haver uma sobrecarga que permita definir a distinção entre maiúsculas e minúsculas. Atualmente, eu supero os dois, mas isso é simplesmente bobo (pelo qual estou me referindo aos problemas da i18n que vêm com a caixa para cima e para baixo).

ATUALIZAÇÃO
Esta pergunta é antiga e, desde então, percebi que pedi uma resposta simples para um tópico realmente vasto e difícil, se você quiser investigá-lo completamente.
Para a maioria dos casos, em bases de código monolíngües e inglesas, essa resposta será suficiente. Eu suspeito que porque a maioria das pessoas que vem aqui se enquadre nessa categoria, essa é a resposta mais popular.
Essa resposta, no entanto, traz à tona o problema inerente de que não podemos comparar maiúsculas e minúsculas até que saibamos que os dois textos são da mesma cultura e sabemos o que é essa cultura. Talvez essa seja uma resposta menos popular, mas acho que é mais correta e foi por isso que a marquei como tal.

Para testar se a string paragraphcontém a string word(obrigado @QuarterMeister)

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

Onde cultureé a instância deCultureInfo descrição do idioma em que o texto está escrito.

Esta solução é transparente sobre a definição de distinção entre maiúsculas e minúsculas, que depende do idioma . Por exemplo, o idioma inglês usa os caracteres Ie ipara as versões maiúsculas e minúsculas da nona letra, enquanto o idioma turco usa esses caracteres para a décima primeira e décima segunda letras do de 29 letras. A versão em maiúscula turca de 'i' é o caractere desconhecido 'İ'.

Assim, as strings tine TINsão a mesma palavra em inglês , mas palavras diferentes em turco . Pelo que entendi, um significa "espírito" e o outro é uma palavra de onomatopéia. (Turcos, corrija-me se estiver errado ou sugira um exemplo melhor)

Para resumir, você só pode responder à pergunta 'essas duas strings são iguais, mas em casos diferentes', se souber em qual idioma o texto está . Se você não sabe, terá que dar um pontapé. Dada a hegemonia do inglês em software, você provavelmente deve recorrer CultureInfo.InvariantCulture, porque estará errado de maneiras familiares.

Você pode usar o método String.IndexOf e passar StringComparison.OrdinalIgnoreCasecomo o tipo de pesquisa a ser usado:

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

Melhor ainda é definir um novo método de extensão para string:

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

Observe que a propagação nula ?. está disponível desde C # 6.0 (VS 2015), para versões mais antigas use

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

USO:

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

Você pode usar IndexOf()assim:

string title = "STRING";

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

Como 0 (zero) pode ser um índice, você verifica com -1.

MSDN

A posição do valor com base em zero do valor, se essa sequência for encontrada, ou -1, se não for. Se o valor for String.Empty, o valor de retorno é 0.

Solução alternativa usando Regex:

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

Você sempre pode subir ou baixar as strings primeiro.

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

Opa, acabei de ver essa última parte. Uma comparação sem distinção entre maiúsculas e minúsculas *provavelmente *faria o mesmo de qualquer maneira, e se o desempenho não for um problema, não vejo problema em criar cópias em maiúsculas e compará-las. Eu poderia jurar que uma vez vi uma comparação que não diferencia maiúsculas de minúsculas ...

Somente .NET Core 2.0+ (a partir de agora)

O .NET Core possui um par de métodos para lidar com isso desde a versão 2.0:

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

Exemplo:

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

Com o tempo, eles provavelmente entrarão no .NET Standard e, a partir daí, em todas as outras implementações da Base Class Library.

Um problema com a resposta é que ele lançará uma exceção se uma string for nula. Você pode adicionar isso como uma verificação para que não:

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;
} 

A classe StringExtension é o caminho a seguir. Combinei algumas das postagens acima para dar um exemplo de código completo:

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;
    }
}

Isso é limpo e simples.

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

OrdinalIgnoreCase, CurrentCultureIgnoreCase ou InvariantCultureIgnoreCase?

Como isso está faltando, aqui estão algumas recomendações sobre quando usar qual:

Dos

• Usar StringComparison.OrdinalIgnoreCase para comparações como seu padrão seguro para correspondência de sequência independente de cultura.
• Use StringComparison.OrdinalIgnoreCasecomparações para aumentar a velocidade.
• Use StringComparison.CurrentCulture-basedoperações de cadeia ao exibir a saída para o usuário.
• Alterne o uso atual de operações de cadeia de caracteres com base na cultura invariável para usar o não-linguístico StringComparison.Ordinalou StringComparison.OrdinalIgnoreCasequando a comparação for
  linguisticamente irrelevante (simbólica, por exemplo).
• Use em ToUpperInvariantvez de ToLowerInvariantnormalizar seqüências de caracteres para comparação.

Não é

• Use sobrecargas para operações de cadeia que não especifiquem explícita ou implicitamente o mecanismo de comparação de cadeia.
• Operações de StringComparison.InvariantCulturestring baseadas em uso
  na maioria dos casos; uma das poucas exceções seria a
  persistência de dados linguísticos, mas culturalmente agnósticos.

Com base nessas regras, você deve usar:

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

enquanto [YourDecision] depende das recomendações acima.

link da fonte: http://msdn.microsoft.com/en-us/library/ms973919.aspx

Estas são as soluções mais fáceis.

1. Por índice de

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

2. Alterando maiúsculas e minúsculas

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

3. Por Regex

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

Eu sei que esse não é o C #, mas no framework (VB.NET) já existe essa função

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

Variante C #:

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

O InStrmétodo do assembly VisualBasic é o melhor se você tiver uma preocupação com a internacionalização (ou você pode reimplementá-lo). Olhando para ele, o dotNeetPeek mostra que não apenas conta maiúsculas e minúsculas, mas também caracteres do tipo kana e caracteres de largura total vs. meia largura (principalmente relevantes para os idiomas asiáticos, embora também existam versões em largura total do alfabeto romano). ) Estou pulando alguns detalhes, mas confira o método privado 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);
}

Bem assim:

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

Usa isto:

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

Isso é bastante semelhante a outro exemplo aqui, mas eu decidi simplificar enum para bool, primário porque outras alternativas normalmente não são necessárias. Aqui está o meu exemplo:

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;
    }
}

E o uso é algo como:

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

Usar um RegEx é uma maneira direta de fazer isso:

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

Apenas para desenvolver a resposta aqui, você pode criar um método de extensão de string para tornar isso um pouco mais amigável:

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

se você quiser verificar se sua sequência passada está na sequência, existe um método simples para isso.

string yourStringForCheck= "abc";
string stringInWhichWeCheck= "Test abc abc";

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

Este valor booleano retornará se a string estiver contida ou não

Tão simples e funciona

title.ToLower().Contains("String".ToLower())

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

Você pode usar a string.indexof ()função Isso não diferencia maiúsculas de minúsculas

O truque aqui é procurar a string, ignorando maiúsculas e minúsculas, mas mantê-la exatamente a mesma (com a mesma maiúscula).

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

A saída é "Reset"

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
}

Maneira simples para iniciantes:

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