Insensible à la casse 'Contient (string)'

Question

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

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

Il ne semble pas exister de surcharge qui me permette de définir la sensibilité à la casse .. Actuellement, je les MAJUSCULE les deux, mais c'est juste idiot (par lequel je me réfère à la i18n , ainsi que les problèmes liés à la casse).

MISE À JOUR
Cette question est ancienne et je réalise depuis lors que j’ai demandé une réponse simple à un sujet très vaste et difficile, si vous souhaitez approfondir votre recherche.
Dans la plupart des cas, en base , les bases de code anglais sont multilingues et suffisantes. Je soupçonne, car la plupart des gens qui viennent ici tombent dans cette catégorie, c'est la réponse la plus populaire.
Cette réponse soulève toutefois le problème inhérent que nous ne pouvons pas comparer le texte insensible à la casse tant que nous ne savons pas que les deux textes sont de la même culture. et nous savons quelle est cette culture. C’est peut-être une réponse moins populaire, mais je pense que c’est plus correct et c’est pourquoi je l’ai marquée comme telle.

Answer 1

Pour tester si la chaîne paragraphe contient la chaîne mot (merci @QuarterMeister)

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

Où culture est l'instance de CultureInfo décrivant la langue dans laquelle le texte est écrit.

Cette solution est transparente sur la définition de l'insensibilité à la casse, qui dépend de la langue . Par exemple, la langue anglaise utilise les caractères I et i pour les versions majuscules et minuscules de la neuvième lettre, tandis que la langue turque utilise ces caractères pour la onzième et douzième lettres de son alphabet long de 29 lettres. La version turque en majuscule de 'i' est le caractère inconnu 'I'.

Ainsi, les chaînes tin et TIN sont 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, corrigez-moi si je me trompe, ou suggérez un meilleur exemple)

Pour résumer, vous pouvez uniquement répondre à la question "Ces deux chaînes sont-elles identiques, mais dans des cas différents" si vous connaissez la langue dans laquelle le texte est . Si vous ne savez pas, vous devrez prendre une punt. Compte tenu de l'hégémonie anglaise des logiciels, vous devriez probablement recourir à la CultureInfo.InvariantCulture . / a>, parce que ce sera faux de manière familière.

Answer 2

Vous pouvez utiliser la méthode String.IndexOf et transmettez StringComparison.OrdinalIgnoreCase en tant que type de recherche à utiliser:

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

Encore mieux, vous définissez 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 cette propagation nulle ?. est disponible depuis C # 6.0 (VS 2015). Pour les versions plus anciennes, utilisez

.

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

UTILISATION:

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

Answer 3

Vous pouvez utiliser IndexOf () comme ceci:

string title = "STRING";

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

Étant donné que 0 (zéro) peut être un index, vous comparez -1.

MSDN

  

La position d'index de base zéro de la valeur si cette chaîne est trouvée, ou -1   si ce n'est pas le cas. Si value est String.Empty, la valeur renvoyée est 0.

Answer 4

Solution alternative utilisant Regex:

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

Answer 5

Vous pouvez toujours monter et descendre les chaînes en premier.

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

Oups, je viens de voir ce dernier bit. Une comparaison insensible à la casse * ferait probablement de même * , et si les performances ne sont pas un problème, je ne vois pas de problème pour créer des copies majuscules et les comparer. J'aurais juré avoir déjà vu une comparaison insensible à la casse ...

Answer 6

Un problème avec la réponse est qu'il lève une exception si une chaîne est nulle. Vous pouvez ajouter cela comme un chèque pour qu'il ne le soit pas:

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

Answer 7

C'est propre et simple.

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

Answer 8

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

Answer 9

OrdinalIgnoreCase, CurrentCultureIgnoreCase ou InvariantCultureIgnoreCase?

Etant donné que cela manque, voici quelques recommandations sur le moment d'utiliser lequel:

Dos

• Utilisez StringComparison.OrdinalIgnoreCase pour les comparaisons. comme valeur sûre par défaut pour la correspondance de chaînes dépendant de la culture.
• Utiliser les comparaisons StringComparison.OrdinalIgnoreCase pour augmenter la vitesse.
• Utiliser les opérations de chaîne StringComparison.CurrentCulture-based lors de l'affichage du résultat à l'utilisateur.
• Basculez l'utilisation actuelle des opérations sur les chaînes en fonction de l'invariant culture à utiliser le StringComparison.Ordinal ou le StringComparison.OrdinalIgnoreCase non linguistique lorsque la comparaison est
  linguistiquement non pertinent (symbolique, par exemple).
• Utilisez ToUpperInvariant plutôt que ToLowerInvariant lorsque normaliser les chaînes à des fins de comparaison.

À ne pas faire

• Utilisez des surcharges pour les opérations sur les chaînes non explicitement ou spécifiez implicitement le mécanisme de comparaison de chaînes.
• Utiliser la chaîne StringComparison.InvariantCulture
  opérations dans la plupart des cas; une des rares exceptions serait
  données persistantes linguistiquement significatives mais culturellement agnostiques.

Selon ces règles, vous devriez utiliser:

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

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

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

Answer 10

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

.NET Core utilise deux méthodes pour résoudre ce problème depuis la version 2.0:

• String.Contains (Char, Comparaison de chaînes )
• String.Contains (String, Comparaison des chaînes )

Exemple:

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

Avec le temps, ils se retrouveront probablement dans .NET Standard et, à partir de là, dans toutes les autres implémentations de la bibliothèque de classes de base.

Answer 11

Ce sont les solutions les plus faciles.

1. Par index de

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

2. En changeant de casse

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

3. Par regex

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

Answer 12

Je sais que ce n'est pas le C #, mais dans le framework (VB.NET), il existe 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");

Answer 13

La méthode InStr de l'assembly VisualBasic est la meilleure solution si vous avez des problèmes d'internationalisation (ou que vous pouvez le réimplémenter). En y regardant, dotNeetPeek montre que non seulement il prend en compte les majuscules et les minuscules, mais également les caractères de type kana et les caractères pleine largeur et demi-largeur (surtout pour les langues asiatiques, bien qu'il existe également des versions pleine largeur de l'alphabet ). Je saute quelques détails, mais découvrez 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);
}

Answer 14

Juste comme ceci:

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

Answer 15

Utilisez ceci:

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

Answer 16

Utiliser un RegEx est un moyen simple de faire ceci:

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

Answer 17

Ceci est assez similaire aux autres exemples 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 ressemble à quelque chose comme:

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

Answer 18

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

Answer 19

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

Answer 20

Le truc ici est de chercher la chaîne en ignorant la casse, mais de la garder exactement la même chose (avec la même casse).

 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 "Réinitialiser"

Answer 21

Juste pour développer la réponse ici, vous pouvez créer une méthode d'extension de chaîne afin de rendre cette dernière plus conviviale:

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

Answer 22

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
}

Answer 23

si vous voulez vérifier si la chaîne que vous avez passée est une chaîne, il existe une méthode simple pour le faire.

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

Answer 24

Moyen simple pour les débutants:

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