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

¿Hay alguna forma de hacer que la siguiente devolución sea verdadera?

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

No parece haber una sobrecarga que me permita establecer la distinción entre mayúsculas y minúsculas. i18n problemas que vienen con la carcasa hacia arriba y hacia abajo).

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

preguntado el 14 de enero de 09 a las 19:01

28 Respuestas

Para probar si la cuerda paragraph contiene la cadena word (gracias @QuarterMeister)

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

Dónde culture es la instancia de CultureInfo describiendo el idioma en el que está escrito el texto.

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

Así las cuerdas tin y TIN son 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 ejemplo mejor)

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

Respondido 10 ago 17, 13:08

Por qué no culture.CompareInfo.IndexOf(paragraph, word, CompareOptions.IgnoreCase) >= 0? Eso usa la cultura correcta y no distingue entre mayúsculas y minúsculas, no asigna cadenas temporales en minúsculas y evita la pregunta de si convertir a minúsculas y comparar es siempre lo mismo que una comparación que no distingue entre mayúsculas y minúsculas. - intendente

Esta solución también contamina innecesariamente el montón al asignar memoria para lo que debería ser una función de búsqueda: jaredpar

La comparación con ToLower () dará resultados diferentes de un IndexOf que no distingue entre mayúsculas y minúsculas cuando dos letras diferentes tienen la misma letra minúscula. Por ejemplo, llamar a ToLower () en U + 0398 "Letra griega mayúscula Theta" o U + 03F4 "Símbolo griego en letra mayúscula Theta" da como resultado U + 03B8, "Letra griega minúscula Theta", pero las letras mayúsculas se consideran diferentes. Ambas soluciones consideran diferentes letras minúsculas con la misma letra mayúscula, como U + 0073 "Letra latina minúscula S" y U + 017F "Letra latina minúscula S larga", por lo que la solución IndexOf parece más consistente. - intendente

@Quartermeister - y por cierto, creo que .NET 2 y .NET4 se comportan de manera diferente en esto, ya que .NET 4 siempre usa NORM_LINGUISTIC_CASING mientras que .NET 2 no lo hizo (estas banderas han aparecido con Windows Vista). - Simón Mourier

¿Por qué no escribiste "ddddfg" .IndexOf ("Df", StringComparison.OrdinalIgnoreCase)? - Chen

Podrías usar el Método String.IndexOf y pasar StringComparison.OrdinalIgnoreCase como el tipo de búsqueda a utilizar:

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

Aún mejor es definir un nuevo método de extensión para 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 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);

contestado el 08 de mayo de 18 a las 13:05

¡Gran método de extensión de cadena! He editado el mío para verificar que la cadena de origen no sea nula para evitar que se produzcan errores de referencia de objeto al realizar .IndexOf (). - Richard monedero

Esto da la misma respuesta que paragraph.ToLower(culture).Contains(word.ToLower(culture)) con CultureInfo.InvariantCulture y no resuelve ningún problema de localización. ¿Por qué complicar demasiado las cosas? stackoverflow.com/a/15464440/284795 - Coronel Panic

@ColonelPanic el ToLower la versión incluye 2 asignaciones que son innecesarias en una operación de comparación / búsqueda. ¿Por qué asignar innecesariamente en un escenario que no lo requiere? - jaredpar

@Seabiscuit que no funcionará porque string es un IEnumerable<char> por lo tanto, no puede usarlo para encontrar subcadenas - jaredpar

Una advertencia: el valor predeterminado para string.IndexOf(string) es utilizar la cultura actual, mientras que la predeterminada para string.Contains(string) es utilizar el comparador ordinal. Como sabemos, el primero se puede cambiar eligiendo una sobrecarga más larga, mientras que el segundo no se puede cambiar. Una consecuencia de esta incoherencia es el siguiente ejemplo de código: Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; string self = "Waldstrasse"; string value = "straße"; Console.WriteLine(self.Contains(value));/* False */ Console.WriteLine(self.IndexOf(value) >= 0);/* True */ - Jeppe Stig Nielsen

Puede usar el IndexOf() Me gusta esto:

string title = "STRING";

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

Dado que 0 (cero) puede ser un índice, contrasta con -1.

MSDN

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

Respondido el 15 de Septiembre de 15 a las 16:09

Solución alternativa usando Regex:

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

Respondido el 17 de diciembre de 18 a las 09:12

Buena idea, también tenemos muchas combinaciones bit a bit en RegexOptions como RegexOptions.IgnoreCase & RegexOptions.IgnorePatternWhitespace & RegexOptions.CultureInvariant; para cualquiera si ayuda. - Saravanan

Debo decir que prefiero este método aunque utilizo IsMatch para mayor claridad. - wonea

Lo que es peor, dado que la cadena de búsqueda se interpreta como una expresión regular, varios caracteres de puntuación provocarán resultados incorrectos (o activarán una excepción debido a una expresión no válida). Intenta buscar "." in "This is a sample string that doesn't contain the search string". O intenta buscar "(invalid", para esa materia. - chao

@cHao: En ese caso, Regex.Escape podría ayudar. Regex todavía parece innecesario cuando IndexOf / extensión Contains es simple (y posiblemente más claro). - Dan Mangiarelli

Tenga en cuenta que no estaba insinuando que esta solución Regex fuera la mejor manera de hacerlo. Simplemente estaba agregando a la lista de respuestas a la pregunta original publicada "¿Hay alguna manera de hacer que la siguiente devolución sea verdadera?". - Jed

Siempre puedes subir o bajar las cuerdas primero.

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

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

Respondido el 14 de enero de 09 a las 21:01

Busque "prueba de Turquía" :) - jon skeet

En algunas configuraciones regionales francesas, las letras mayúsculas no tienen signos diacríticos, por lo que ToUpper () puede no ser mejor que ToLower (). Yo diría que use las herramientas adecuadas si están disponibles; compare sin distinción entre mayúsculas y minúsculas. - Blair Conrado

No use ToUpper o ToLower, y haga lo que dijo Jon Skeet: Pedro Gfader

Acabo de ver esto nuevamente después de dos años y un nuevo voto negativo ... de todos modos, estoy de acuerdo en que hay mejores formas de comparar cadenas. Sin embargo, no todos los programas estarán localizados (la mayoría no lo harán) y muchos son aplicaciones internas o desechables. Dado que no puedo esperar crédito por los consejos que es mejor dejar para las aplicaciones desechables ... sigo adelante: D - Ed s.

¿Buscar "prueba de Turquía" es lo mismo que buscar "prueba de Turquía"? - Jack Ace

Solo .NET Core 2.0+ (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, Comparación de cadenas)
  • String.Contains (String, Comparación de cadenas)

Ejemplo:

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

Con el tiempo, probablemente llegarán a .NET Standard y, desde allí, a todas las demás implementaciones de Base Class Library.

respondido 08 nov., 18:14

Ahora también disponible en .NET estándar 2.1 - Paweł Bulwan

Disponible en .NET 5.0 también. - Dariusz Woźniak

Un problema con la respuesta es que generará 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;
} 

Respondido el 05 de junio de 15 a las 07:06

Si toCheck es la cadena vacía, debe devolver verdadero según la documentación de Contiene: "verdadero si el parámetro de valor aparece dentro de esta cadena, o si el valor es la cadena vacía (" "); de lo contrario, falso". - amurra

Según el comentario de amurra anterior, ¿no es necesario corregir el código sugerido? ¿Y no debería agregarse esto a la respuesta aceptada, de modo que la mejor respuesta sea la primera? - David Blanco

Ahora, esto devolverá verdadero si la fuente es una cadena vacía o nula sin importar lo que sea toCheck. Eso no puede ser correcto. Además, IndexOf ya devuelve verdadero si toCheck es una cadena vacía y la fuente no es nula. Lo que se necesita aquí es una verificación de nulo. Sugiero si (fuente == nulo || valor == nulo) devolver falso; - Colin

La fuente no puede ser nula. Lucas

if (string.IsNullOrEmpty(source)) return string.IsNullOrEmpty(toCheck); - kyle delaney

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

Respondido el 25 de enero de 11 a las 06:01

¿Por qué estás permitiendo OTRA capa de abstracción sobre StringComparison ? - Alex Gordon

Porque esto simplifica tanto la lectura como la escritura del código. Básicamente, está imitando lo que las versiones posteriores de .Net agregaron directamente a la clase. Hay mucho que decir sobre los métodos simples de conveniencia que facilitan su vida y la de los demás, incluso si agregan un poco de abstracción. - Josh

Esto es limpio y sencillo.

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

Respondido el 06 de junio de 18 a las 15:06

Sin embargo, esto coincidirá con un patrón. En tu ejemplo, si fileNamestr tiene caracteres especiales de expresión regular (p. ej. *, +, ., etc.) entonces te llevarás una gran sorpresa. La única forma de hacer que esta solución funcione correctamente Contains la función es escapar fileNamestr haciendo Regex.Escape(fileNamestr). - XåpplI'-I0llwlg'I -

además, analizar y hacer coincidir una expresión regular requiere muchos más recursos que una simple comparación que no distingue entre mayúsculas y minúsculas: phuclv

OrdinalIgnoreCase, CurrentCultureIgnoreCase o InvariantCultureIgnoreCase?

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

Espalda

  • Utiliza StringComparison.OrdinalIgnoreCase para comparaciones como su valor predeterminado seguro para la coincidencia de cadenas independiente de la cultura.
  • Utiliza StringComparison.OrdinalIgnoreCase comparaciones para mayor velocidad.
  • Utiliza StringComparison.CurrentCulture-based operaciones de cadena al mostrar la salida al usuario.
  • Cambiar el uso actual de las operaciones de cadenas basadas en la cultura invariante para usar la no lingüística StringComparison.Ordinal or StringComparison.OrdinalIgnoreCase cuando la comparación es
    lingüísticamente irrelevante (simbólico, por ejemplo).
  • Utiliza ToUpperInvariant más bien que ToLowerInvariant al normalizar cadenas para comparar.

No hacer

  • Utilice sobrecargas para operaciones de cadenas que no especifiquen explícita o implícitamente el mecanismo de comparación de cadenas.
  • Utiliza StringComparison.InvariantCulture -cadena a base de
    operaciones en la mayoría de los casos; una de las pocas excepciones sería
    persistiendo datos lingüísticamente significativos pero culturalmente agnósticos.

Según estas reglas, debe utilizar:

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

mientras que [YourDecision] depende de las recomendaciones anteriores.

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

Respondido 23 Jul 15, 11:07

¿Qué pasa si sabes que siempre obtendrás una cadena en inglés? cual usar? - BKSpurgeon

@BKSpurgeon Usaría OrdinalIgnoreCase, si el caso no importa - Fabián Bigler

Éstas son las soluciones más sencillas.

  1. Por índice de

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

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

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

Respondido 12 Jul 18, 10:07

Tan simple y funciona

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

Respondido el 10 de diciembre de 19 a las 22:12

Así:

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

Respondido 19 Jul 16, 20:07

Esto no es específico de la cultura y puede fallar en algunos casos. culture.CompareInfo.IndexOf (párrafo, palabra, CompareOptions.IgnoreCase) debe usarse. - hikalkan

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 de C #:

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

Respondido el 09 de Septiembre de 11 a las 14:09

La InStr El método del ensamblado de VisualBasic es el mejor si le preocupa la internacionalización (o podría volver a implementarlo). Al observarlo, dotNeetPeek muestra que no solo tiene en cuenta las mayúsculas y las minúsculas, sino también el tipo kana y los caracteres de ancho completo frente a medio (principalmente relevante 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);
}

Respondido el 06 de diciembre de 13 a las 14:12

Utilizar esta:

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

Respondido 08 Jul 13, 09:07

El interrogador está buscando Contains no Compare. - PatoMaestro

@DuckMaestro, la respuesta aceptada es implementar Contains con IndexOf. ¡Así que este enfoque es igualmente útil! El ejemplo de código C # en esta página está usando string.Compare (). ¡La elección del equipo de SharePoint, eso es! - cuervo vulcano

Esto es bastante similar a otro ejemplo aquí, pero he decidido simplificar la enumeración a bool, principal 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) )
....

Respondido 17 Oct 15, 08:10

Usar una expresión regular es una forma directa de hacer esto:

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

Respondido 19 Jul 16, 20:07

Su respuesta es exactamente la misma que la de guptat59 pero, como se señaló en su respuesta, coincidirá con una expresión regular, por lo que si la cadena que está probando contiene caracteres especiales de expresión regular, no producirá el resultado deseado. - Casey

Esta es una copia directa de esta respuesta y sufre los mismos problemas que se señalan en esa respuesta: Liam

Acordado. Estudiar expresiones regulares - Jared

Solo para aprovechar 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;
    }

Respondido el 22 de Septiembre de 19 a las 05:09

Suponiendo que su párrafo y palabra siempre estarán en en-US - Boris Callens

Para evitar problemas con forzar la cultura a en-US, use return CultureInfo.CurrentCulture.CompareInfo.IndexOf(paragraph, word, CompareOptions.IgnoreCase) >= 0; en lugar de. - andreswhalan

Puede utilizar un parámetro de comparación de cadenas (disponible en .net 2.1 y superior) Método String.Contains.

public bool Contains (string value, StringComparison comparisonType);

Ejemplo:

string title = "ASTRINGTOTEST";
title.Contains("string", StringComparison.InvariantCultureIgnoreCase);

Respondido el 23 de enero de 21 a las 20:01

sí, está disponible en .net Standard 2.1 y .Net Core 5.0 docs.microsoft.com/en-us/dotnet/api/… Se arregló como parte de ... github.com/dotnet/runtime/issues/22198 - Rendirse Singh Malik

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 regresará si la cadena está contenida o no

Respondido 12 Oct 19, 09:10

Similar a las respuestas anteriores (usando un método de extensión) pero con dos verificaciones nulas simples (C # 6.0 y superior):

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

Si la fuente es nula, devuelve falso (¿a través del operador de propagación nula?).

Si la subcadena es nula, trátelo como una cadena vacía y devuelva verdadero (¿a través del operador de fusión nula?)

Por supuesto, StringComparison se puede enviar como parámetro si es necesario.

Respondido 13 Jul 20, 13:07

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

Respondido 26 Oct 16, 15:10

Puede usar el string.indexof () función. Esto no distingue entre mayúsculas y minúsculas

Respondido el 11 de diciembre de 16 a las 13:12

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 "Reset"

Respondido 31 Oct 17, 15:10

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
}

Respondido el 14 de junio de 17 a las 04:06

Basado en las respuestas existentes y en la documentación del método Contains, recomendaría la creación de la siguiente extensión que también se encarga de los casos de esquina:

public static class VStringExtensions 
{
    public static bool Contains(this string source, string toCheck, StringComparison comp) 
    {
        if (toCheck == null) 
        {
            throw new ArgumentNullException(nameof(toCheck));
        }

        if (source.Equals(string.Empty)) 
        {
            return false;
        }

        if (toCheck.Equals(string.Empty)) 
        {
            return true;
        }

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

Respondido 29 Oct 20, 10:10

Manera simple para novatos:

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

respondido 23 mar '18, 03:03

Votar en contra por ser incorrecto. ¿Qué pasa si title = StRiNg? StRiNg! = String y StRiNg! = STRING - bernieslearning

Estaba equivocado. Edite la respuesta de la siguiente manera, demasiado simple: title.ToLower (). Contains ("cadena") // por supuesto, "cadena" está en minúsculas - O Thạnh Ldt

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.