Insensible à la casse 'Contient (chaîne)'

Existe-t-il un moyen de rendre le retour suivant vrai?

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

Il ne semble pas y avoir de surcharge qui me permette de régler la sensibilité à la casse. Actuellement, je les MAJUSCULE les deux, mais c'est juste idiot (par lequel je fais référence aux problèmes i18n qui viennent avec le boîtier de haut en bas).

MISE À JOUR
Cette question est ancienne et depuis lors, je me suis rendu compte que je demandais une réponse simple pour un sujet vraiment vaste et difficile si vous voulez bien l'enquêter.
Dans la plupart des cas, dans les bases de code monolingues et anglaises, cette réponse suffira. Je soupçonne que la plupart des gens qui viennent ici entrent dans cette catégorie, c'est la réponse la plus populaire.
Cette réponse soulève cependant le problème inhérent que nous ne pouvons pas comparer la casse insensible au texte jusqu'à ce que nous sachions que les deux textes sont la même culture et que nous savons ce que cette culture est. C'est peut-être une réponse moins populaire, mais je pense qu'elle est plus correcte et c'est pourquoi je l'ai marquée comme telle.

Pour tester si la chaîne paragraphcontient la chaîne word(merci @QuarterMeister)

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

Où cultureest l'instance de CultureInfodescription de la langue dans laquelle le texte est écrit.

Cette solution est transparente quant à la définition de l'insensibilité à la casse, qui dépend du langage . Par exemple, la langue anglaise utilise les caractères Iet ipour les versions majuscules et minuscules de la neuvième lettre, tandis que la langue turque utilise ces caractères pour les onzième et douzième lettres de son alphabet de 29 lettres. La version turque des majuscules de «i» est le caractère inconnu «İ».

Ainsi, les chaînes tinet TINsont le même mot en anglais , mais des mots différents en turc . Si je comprends bien, l'un signifie «esprit» et l'autre est un mot onomatopée. (Turcs, veuillez me corriger si je me trompe, ou suggérer un meilleur exemple)

Pour résumer, vous ne pouvez répondre à la question `` ces deux chaînes sont-elles identiques mais dans des cas différents '' si vous savez dans quelle langue le texte est . Si vous ne savez pas, vous devrez prendre un botté de dégagement. Étant donné l'hégémonie de l'anglais dans les logiciels, vous devriez probablement y recourir CultureInfo.InvariantCulture, car ce sera faux de manière familière.

Vous pouvez utiliser la méthode String.IndexOf et passer StringComparison.OrdinalIgnoreCasecomme type de recherche à utiliser:

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

Encore mieux est de définir une nouvelle méthode d'extension pour la chaîne:

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

Notez que la propagation nulle ?. est disponible depuis C # 6.0 (VS 2015), pour les anciennes versions, utilisez

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

USAGE:

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

Vous pouvez utiliser IndexOf()comme ceci:

string title = "STRING";

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

Puisque 0 (zéro) peut être un index, vous vérifiez contre -1.

MSDN

Position d'index de base zéro de la valeur si cette chaîne est trouvée, ou -1 si elle ne l'est pas. Si la valeur est String.Empty, la valeur de retour est 0.

Solution alternative utilisant Regex:

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

Vous pouvez toujours monter ou descendre les cordes en premier.

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

Oups, je viens de voir ce dernier morceau. Une comparaison insensible à la casse ferait *probablement de *même de toute façon, et si les performances ne sont pas un problème, je ne vois pas de problème avec la création de copies majuscules et la comparaison. J'aurais juré avoir vu une fois une comparaison insensible à la casse ...

.NET Core 2.0+ uniquement (à partir de maintenant)

.NET Core a eu une paire de méthodes pour gérer cela depuis la version 2.0:

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

Exemple:

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

Avec le temps, ils feront probablement leur chemin dans la norme .NET et, à partir de là, dans toutes les autres implémentations de la bibliothèque de classes de base.

Un problème avec la réponse est qu'elle lèvera une exception si une chaîne est nulle. Vous pouvez ajouter cela comme un chèque afin qu'il ne:

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 classe StringExtension est la voie à suivre, j'ai combiné quelques-uns des articles ci-dessus pour donner un exemple de code complet:

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

C'est propre et simple.

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

OrdinalIgnoreCase, CurrentCultureIgnoreCase ou InvariantCultureIgnoreCase?

Comme cela est manquant, voici quelques recommandations sur le moment de l'utiliser:

Dos

• Utilisation StringComparison.OrdinalIgnoreCase pour les comparaisons votre valeur par défaut pour la correspondance de chaînes indépendante de la culture.
• Utilisez des StringComparison.OrdinalIgnoreCasecomparaisons pour une vitesse accrue.
• Utilisez StringComparison.CurrentCulture-baseddes opérations de chaîne lors de l'affichage de la sortie à l'utilisateur.
• Basculez l'utilisation actuelle des opérations de chaîne basées sur la culture invariante pour utiliser le non-linguistique StringComparison.Ordinalou StringComparison.OrdinalIgnoreCaselorsque la comparaison est
  linguistiquement non pertinente (symbolique, par exemple).
• Utilisez ToUpperInvariantplutôt que ToLowerInvariantlors de la normalisation des chaînes pour la comparaison.

À ne pas faire

• Utilisez des surcharges pour les opérations de chaîne qui ne spécifient pas explicitement ou implicitement le mécanisme de comparaison de chaînes.
• Utilisez StringComparison.InvariantCulturedes
  opérations de chaîne basées sur la plupart des cas; l'une des rares exceptions serait la
  persistance de données linguistiquement significatives mais culturellement agnostiques.

Sur la base de ces règles, vous devez utiliser:

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

tandis que [YourDecision] dépend des recommandations ci-dessus.

lien de la source: http://msdn.microsoft.com/en-us/library/ms973919.aspx

Ce sont les solutions les plus simples.

1. Par indice de

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

2. En changeant de cas

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

3. Par Regex

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

Je sais que ce n'est pas le C #, mais dans le framework (VB.NET) il y a déjà une telle fonction

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

La InStrméthode de l'assembly VisualBasic est la meilleure si vous avez un problème d'internationalisation (ou si vous pouvez la réimplémenter). En y regardant, dotNeetPeek montre que non seulement il tient compte des majuscules et des minuscules, mais aussi du type kana et des caractères pleine vs demi-largeur (surtout pertinent pour les langues asiatiques, bien qu'il existe aussi des versions pleine largeur de l'alphabet romain ). Je saute quelques détails, mais consultez la méthode privée 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);
}

Juste comme ça:

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

Utilisez ceci:

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

C'est assez similaire à un autre exemple ici, mais j'ai décidé de simplifier enum en bool, primaire car d'autres alternatives ne sont normalement pas nécessaires. Voici mon exemple:

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

Et l'utilisation est quelque chose comme:

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

L'utilisation d'un RegEx est un moyen simple de le faire:

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

Juste pour construire sur la réponse ici, vous pouvez créer une méthode d'extension de chaîne pour la rendre un peu plus conviviale:

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

si vous voulez vérifier si votre chaîne passée est dans la chaîne, il existe une méthode simple pour cela.

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

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

Cette valeur booléenne sera renvoyée si la chaîne est contenue ou non

Aussi simple et fonctionne

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

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

Vous pouvez utiliser la string.indexof ()fonction. Ce sera insensible à la casse

L'astuce ici est de rechercher la chaîne, en ignorant la casse, mais de la garder exactement la même (avec le même cas).

 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 sortie est "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
}

Un moyen simple pour les débutants:

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