No distingue entre mayúsculas y minúsculas 'Contiene (cadena)'

¿Hay alguna manera de hacer que el siguiente retorno sea verdadero?

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

No parece haber una sobrecarga que me permita establecer la sensibilidad a mayúsculas y minúsculas. Actualmente, MAYÚSCULAS a ambos, pero eso es una tontería (por lo que me estoy refiriendo a los problemas de i18n que vienen con mayúsculas y minúsculas ).

ACTUALIZACIÓN
Esta pregunta es antigua y desde entonces me di cuenta de que pedí una respuesta simple para un tema realmente vasto y difícil si te interesa investigarlo a fondo.
Para la mayoría de los casos, en bases de código en inglés, monolingües, esta respuesta será suficiente. Sospecho que porque la mayoría de las personas que vienen aquí entran en esta categoría, esta es la respuesta más popular.
Sin embargo, esta respuesta plantea el problema inherente de que no podemos comparar las mayúsculas y minúsculas del texto hasta que sepamos que ambos textos son de la misma cultura y sabemos cuál es esa cultura. Esta es quizás una respuesta menos popular, pero creo que es más correcta y es por eso que la marqué como tal.

Para probar si la cadena paragraphcontiene la cadena word(gracias @QuarterMeister)

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

¿Dónde cultureestá la instancia de CultureInfodescribir el idioma en que está escrito el texto?

Esta solución es transparente sobre la definición de mayúsculas y minúsculas, que depende del idioma . Por ejemplo, el idioma inglés usa los caracteres Iy ipara las versiones en mayúsculas y minúsculas de la novena letra, mientras que el idioma turco usa estos caracteres para las letras once y doce de su alfabeto de 29 letras. La versión mayúscula turca de 'i' es el carácter desconocido 'İ'.

Por lo tanto, las cadenas tiny TINson la misma palabra en inglés , pero diferentes palabras en turco . Según tengo entendido, uno significa "espíritu" y el otro es una palabra onomatopeya. (Turcos, corríjanme si me equivoco o sugieran un mejor ejemplo)

Para resumir, solo puede responder la pregunta 'si estas dos cadenas son iguales pero en diferentes casos' si sabe en qué idioma está el texto . Si no lo sabe, tendrá que tomar un despeje. Dada la hegemonía del inglés en el software, probablemente debería recurrir CultureInfo.InvariantCulture, porque estará mal de maneras familiares.

Puede usar el método String.IndexOf y pasarStringComparison.OrdinalIgnoreCase como el tipo de búsqueda a usar:

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

Aún mejor es definir un nuevo método de extensión para la cadena:

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

Tenga en cuenta que esa propagación nula ?. está disponible desde C # 6.0 (VS 2015), para versiones anteriores use

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

USO:

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

Puedes usar IndexOf()así:

string title = "STRING";

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

Como 0 (cero) puede ser un índice, verifica con -1.

MSDN

La posición de valor de índice basada en cero si se encuentra esa cadena, o -1 si no se encuentra. Si el valor es String.Empty, el valor de retorno es 0.

Solución alternativa usando Regex:

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

Siempre puedes subir o bajar las cuerdas primero.

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

Vaya, acabo de ver eso último. Una comparación que no distinga entre mayúsculas y minúsculas *probablemente *haría lo mismo de todos modos, y si el rendimiento no es un problema, no veo un problema al crear copias en mayúsculas y compararlas. Podría haber jurado que una vez vi una comparación entre mayúsculas y minúsculas una vez ...

.NET Core 2.0+ solamente (a partir de ahora)

.NET Core ha tenido un par de métodos para lidiar con esto desde la versión 2.0:

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

Ejemplo:

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

Con el tiempo, probablemente llegarán al estándar .NET y, a partir de ahí, a todas las demás implementaciones de la biblioteca de clases base.

Un problema con la respuesta es que arrojará una excepción si una cadena es nula. Puede agregar eso como un cheque para que no:

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

La clase StringExtension es el camino a seguir, he combinado un par de las publicaciones anteriores para dar un ejemplo 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;
    }
}

Esto es limpio y simple.

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

OrdinalIgnoreCase, CurrentCultureIgnoreCase o InvariantCultureIgnoreCase?

Como esto falta, aquí hay algunas recomendaciones sobre cuándo usar cuál:

Dos

• Utilizar StringComparison.OrdinalIgnoreCase para las comparaciones como su valor predeterminado seguro para la coincidencia de cadenas independiente de la cultura.
• Use StringComparison.OrdinalIgnoreCasecomparaciones para aumentar la velocidad.
• Utilizar StringComparison.CurrentCulture-based operaciones de cadena cuando muestre la salida al usuario.
• Cambie el uso actual de las operaciones de cadena en función de la cultura invariante para usar la no lingüística StringComparison.Ordinalo StringComparison.OrdinalIgnoreCasecuando la comparación sea
  lingüísticamente irrelevante (simbólica, por ejemplo).
• Use en ToUpperInvariantlugar de ToLowerInvariantnormalizar cadenas para comparar.

No hacer

• Use sobrecargas para operaciones de cadenas que no especifiquen explícita o implícitamente el mecanismo de comparación de cadenas.
• Utilice operaciones de StringComparison.InvariantCulturecadena basadas
  en la mayoría de los casos; Una de las pocas excepciones sería la
  persistencia de datos lingüísticamente significativos pero culturalmente agnósticos.

Según estas reglas, debe usar:

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

mientras que [YourDecision] depende de las recomendaciones de arriba.

enlace de fuente: http://msdn.microsoft.com/en-us/library/ms973919.aspx

Estas son las soluciones más fáciles.

1. Por índice de

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

2. Al cambiar de caso

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

3. Por Regex

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

Sé que este no es el C #, pero en el marco (VB.NET) ya existe tal función

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

El InStrmétodo del ensamblado VisualBasic es el mejor si le preocupa la internacionalización (o podría volver a implementarla). Al observarlo, dotNeetPeek muestra que no solo tiene en cuenta mayúsculas y minúsculas, sino también el tipo kana y los caracteres de ancho completo y medio (principalmente relevantes para los idiomas asiáticos, aunque también hay versiones de ancho completo del alfabeto romano) ) Me estoy saltando algunos detalles, pero mira el 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);
}

Solo así:

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

Utilizar este:

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

Esto es bastante similar a otro ejemplo aquí, pero he decidido simplificar enum to bool, primario porque normalmente no se necesitan otras alternativas. Aquí está mi ejemplo:

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

Y el uso es algo como:

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

Usar un RegEx es una forma directa de hacer esto:

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

Solo para construir sobre la respuesta aquí, puede crear un método de extensión de cadena para que esto sea un poco más fácil de usar:

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

si desea verificar si su cadena pasada está en cadena, entonces hay un método simple para eso.

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

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

Este valor booleano devolverá si la cadena está contenida o no

Tan simple y funciona

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

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

Puedes usar la string.indexof ()función. Esto será insensible a mayúsculas y minúsculas

El truco aquí es buscar la cadena, ignorando el caso, pero mantenerla exactamente igual (con el mismo caso).

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

La salida es "Restablecer"

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
}

Manera simple para novato:

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