c# contains without - "No contiene mayúsculas y minúsculas" Contiene (cadena)




12 Answers

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

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

Donde culture es la instancia de CultureInfo describe el idioma en el que está escrito el texto.

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

Así, las cadenas 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 sugiera un ejemplo mejor)

Para resumir, solo puede responder a la pregunta "estas dos cadenas son iguales pero en casos diferentes" si sabe en qué idioma se encuentra el texto . Si no lo sabes, tendrás que hacer una patada de despeje. Dada la hegemonía del software en inglés, probablemente deberías recurrir a CultureInfo.InvariantCulture , porque estará equivocado en formas familiares.

case sensitive

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

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

Parece que no hay una sobrecarga que me permita configurar la sensibilidad del caso. Actualmente, ME MAYOR MEJORO a ambos, pero eso es una tontería (por lo que me refiero a los problemas de i18n que vienen con la cubierta hacia arriba y hacia abajo).

ACTUALIZAR
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 por completo.
Para la mayoría de los casos, en el lenguaje monolingual, el código en inglés basará this respuesta. Sospecho que la mayoría de las personas que vienen aquí están en esta categoría, esta es la respuesta más popular.
This embargo, This respuesta plantea el problema inherente de que no podemos comparar el texto sin distinción de mayúsculas y minúsculas hasta que sepamos que ambos textos son de la misma cultura y sabemos qué 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.




Puedes usar IndexOf() esta manera:

string title = "STRING";

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

Como 0 (cero) puede ser un índice, verifique contra -1.

MSDN

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




Siempre puedes subir o bajar las cuerdas primero.

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

Vaya, acabo de ver ese último bit. Una comparación que no distingue 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 con la creación de copias en mayúsculas y la comparación. Podría haber jurado que una vez vi una comparación entre mayúsculas y minúsculas una vez ...




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



OrdinalIgnoreCase, CurrentCultureIgnoreCase o InvariantCultureIgnoreCase?

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

Dos

  • Use StringComparison.OrdinalIgnoreCase para las comparaciones como su valor predeterminado seguro para la coincidencia de cadenas cultural-agnostic.
  • Utilice StringComparison.OrdinalIgnoreCase comparaciones de StringComparison.OrdinalIgnoreCase para aumentar la velocidad.
  • Utilice las operaciones de cadena StringComparison.CurrentCulture-based cuando muestre la salida al usuario.
  • Cambie el uso actual de las operaciones de cadena basadas en la cultura invariable para usar el StringComparison.Ordinal o StringComparison.OrdinalIgnoreCase no lingüístico cuando la comparación es
    lingüísticamente irrelevante (simbólico, por ejemplo).
  • Use ToUpperInvariant lugar de ToLowerInvariant cuando normalice cadenas para la comparación.

No hacer

  • Utilice sobrecargas para operaciones de cadena que no especifican explícita o implícitamente el mecanismo de comparación de cadena.
  • Utilice StringComparison.InvariantCulture string basado en
    operaciones en la mayoría de los casos; una de las pocas excepciones seria
    Persistiendo datos lingüísticamente significativos pero culturalmente agnósticos.

Basado en estas reglas debes 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 la fuente: http://msdn.microsoft.com/en-us/library/ms973919.aspx




El método InStr del ensamblaje VisualBasic es el mejor si tiene alguna inquietud acerca de la internacionalización (o podría volver a implementarla). Al mirar en él, dotNeetPeek muestra que no solo tiene mayúsculas y minúsculas, sino también caracteres de tipo kana y de ancho completo vs. medio ancho (en su mayoría relevantes para idiomas asiáticos, aunque también existen versiones de ancho completo del alfabeto romano ). Me estoy saltando algunos detalles, pero echa un vistazo al 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);
}



Utilizar esta:

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



Usar un RegEx es una forma directa de hacer esto:

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



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. Cambiando caso

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

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



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




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, StringComparison )
  • String.Contains (String, StringComparison )

Ejemplo:

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

Con el tiempo, probablemente ingresarán al estándar .NET y, a partir de ahí, a todas las otras implementaciones de la Biblioteca de clases base.




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 isContaines = stringInWhichWeCheck.ToLower().IndexOf(yourStringForCheck.ToLower()) > -1;

This boolean value will return if string contains or not



Related