24 Question: Insensible à la casse 'Contient (string)'

question créée à Wed, Jun 6, 2018 12:00 AM

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 pense que cette réponse est la plus populaire, car la plupart des personnes qui viennent ici rentrent ici.
Cette réponse est cependant soulève le problème inhérent que nous ne pouvons pas comparer un texte insensible à la casse tant que nous ne savons pas que les deux textes appartiennent à la même culture et que 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.

    
2686
24 réponses                              24                         

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

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

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 majuscule et minuscule 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 'İ'.

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 à CultureInfo.InvariantCulture , car ce sera mal de manière familière.

    
1258
2017-08-10 12: 06: 38Z
  1. Pourquoi pas culture.CompareInfo.IndexOf(paragraph, word, CompareOptions.IgnoreCase) >= 0? Cela utilise la bonne culture et ne fait pas la distinction entre les majuscules et les minuscules, il n'alloue pas de chaînes temporaires en minuscules et évite la question de savoir si la conversion en minuscules et la comparaison sont toujours identiques aux comparaisons ne respectant pas la casse.
    2013-03-18 15: 32: 39Z
  2. Cette solution pollue également inutilement le tas en allouant de la mémoire pour ce qui devrait être une fonction de recherche
    2013-03-18 16: 09: 38Z
  3. La comparaison avec ToLower () donnera des résultats différents d'un index non sensible à la casse lorsque deux lettres différentes ont la même lettre minuscule. Par exemple, l'appel de ToLower () sur U + 0398 "Lettre capitale grecque Theta" ou sur U + 03F4 "Symbole Thêta grecque" donne U + 03B8, "Lettre minuscule grecque Theta", mais les lettres majuscules sont considérées différentes. Les deux solutions considèrent les minuscules avec la même lettre majuscule différentes, telles que U + 0073 "Lettre minuscule latine S" et U + 017F "Lettre minuscule latine longue S", de sorte que la solution IndexOf semble plus cohérente.
    2013-03-18 17: 47: 27Z
  4. + 1 pour compléter - les réponses avec une forme d'explication appropriée sont la seule façon pour les utilisateurs d'apprendre de SO
    2014-05-05 12: 57: 04Z
  5. Pourquoi n'avez-vous pas écrit "ddddfg" .IndexOf ("Df", StringComparison.OrdinalIgnoreCase)?
    2015-08-23 13: 41: 49Z

Vous pouvez utiliser la méthode String.IndexOf et transmettez StringComparison.OrdinalIgnoreCase comme 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 antérieures, utilisez

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

UTILISATION:

 
string title = "STRING";
bool contains = title.Contains("string", StringComparison.OrdinalIgnoreCase);
    
2549
2018-05-08 12: 57: 07Z
  1. Grande méthode d'extension de chaîne! J'ai modifié la mienne pour vérifier que la chaîne source n'est pas nulle afin d'éviter toute erreur de référence d'objet lors de l'exécution de .IndexOf ().
    2013-02-08 10: 48: 45Z
  2. Ceci donne la même réponse que paragraph.ToLower(culture).Contains(word.ToLower(culture)) à CultureInfo.InvariantCulture et cela ne résout aucun problème de localisation. Pourquoi trop compliquer les choses? stackoverflow.com/a/15464440/284795
    2013-03-17 18: 52: 43Z
  3. @ ColonelPanic la version ToLower comprend 2 attributions inutiles pour une opération de comparaison /recherche. Pourquoi allouer inutilement dans un scénario qui n'en nécessite pas?
    2013-03-18 16: 09: 08Z
  4. @ Seabiscuit qui ne fonctionnera pas car string est un IEnumerable<char>, vous ne pouvez donc pas l'utiliser pour trouver des sous-chaînes
    2014-11-06 17: 55: 52Z
  5. Avertissement: la valeur par défaut pour string.IndexOf(string) consiste à utiliser la culture actuelle, tandis que celle par défaut pour string.Contains(string) consiste à utiliser le comparateur ordinal. Comme nous le savons, les premières peuvent être modifiées en choisissant une surcharge plus longue, alors que les dernières ne peuvent pas être modifiées. Une des conséquences de cette incohérence est l'exemple de code suivant: 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 */
    2016-02-18 09: 40: 37Z

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.

    
216
2015-09-15 15: 45: 31Z

Solution alternative utilisant Regex:

 
bool contains = Regex.IsMatch("StRiNG to search", Regex.Escape("string"), RegexOptions.IgnoreCase);
    
130
2018-12-17 09: 18: 03Z
  1. Bonne idée, nous avons aussi beaucoup de combinaisons au niveau du bit dans RegexOptions comme RegexOptions.IgnoreCase & RegexOptions.IgnorePatternWhitespace & RegexOptions.CultureInvariant; pour quiconque if aide.
    2011-08-24 04: 36: 30Z
  2. Je dois dire que je préfère cette méthode bien que j'utilise IsMatch pour la propreté.
    2011-09-07 17: 40: 01Z
  3. Pire, puisque la chaîne de recherche est interprétée comme une expression régulière, un nombre de caractères de ponctuation entraînera des résultats incorrects (ou déclenchera une exception en raison d'une expression non valide). Essayez de rechercher "." à "This is a sample string that doesn't contain the search string". Ou essayez de rechercher "(invalid", d'ailleurs.
    2011-09-09 13: 28: 56Z
  4. @ cHao: Dans ce cas, Regex.Escape pourrait aider. Regex semble toujours inutile lorsque IndexOf /extension Contains est simple (et peut-être plus claire).
    2011-09-09 16: 44: 22Z
  5. Notez que je n'insinuais pas que cette solution Regex était la meilleure solution. J'ajoutais simplement à la liste des réponses à la question initiale "Y a-t-il un moyen de rendre le retour suivant vrai?"
    2011-09-13 15: 43: 25Z

    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 la même chose de toute façon, 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 ...

        
    73
    2009-01-14 21: 54: 21Z
    1. Fait intéressant, j'ai vu ToUpper () recommandé pour l'utilisation de ToLower () dans ce type de scénario, car apparemment, ToLower () peut "perdre la fidélité" dans certains cultures, c’est-à-dire que deux caractères majuscules différents se traduisent par le même caractère minuscule.
      2009-01-14 21: 47: 09Z
    2. Recherchez "Test Turquie":)
      2009-01-14 21: 48: 30Z
    3. Dans certains environnements locaux français, les lettres majuscules ne comportent pas de signes diacritiques. Par conséquent, ToUpper () peut ne pas être meilleur que ToLower (). Je dirais que vous devez utiliser les outils appropriés, le cas échéant, sans distinction de casse.
      2009-01-14 22: 03: 59Z
    4. N'utilisez pas ToUpper ou ToLower, et faites ce que Jon Skeet a dit
      2009-08-21 02: 49: 03Z
    5. Nous venons de le voir après deux ans et un nouveau vote négatif ... de toute façon, je conviens qu'il existe de meilleurs moyens de comparer les chaînes. Cependant, tous les programmes ne seront pas localisés (la plupart ne le seront pas) et beaucoup sont des applications internes ou jetables. Comme je ne peux pas espérer que les conseils seront mieux crédités pour les applications jetables ... je passe à autre chose: D
      2011-01-25 07: 28: 26Z

    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;
    } 
    
        
    50
    2015-06-05 06: 02: 45Z
    1. Si toCheck est la chaîne vide, il doit renvoyer true conformément à la documentation de Contains: "true si le paramètre value se trouve dans cette chaîne ou si valeur est la chaîne vide ( ""); sinon, faux. "
      2011-02-16 16: 13: 42Z
    2. D'après le commentaire d'amurra ci-dessus, le code suggéré ne doit-il pas être corrigé? Et cela ne devrait-il pas être ajouté à la réponse acceptée, de sorte que la meilleure réponse soit la première?
    2011-08-30 03: 43: 38Z
  6. Maintenant, cela retournera true si la source est une chaîne vide ou null, peu importe ce que toCheck est. Cela ne peut pas être correct. De plus, IndexOf renvoie déjà la valeur true si toCheck est une chaîne vide et que la source n'est pas null. Ce qu'il faut ici, c'est un contrôle de null. Je suggère si (source == null || valeur == null) renvoie false;
    2013-07-01 12: 21: 20Z
  7. La source ne peut pas être nulle
    2016-12-14 16: 55: 26Z
  8. if (string.IsNullOrEmpty(source)) return string.IsNullOrEmpty(toCheck);
    2018-04-04 13: 39: 04Z

C'est propre et simple.

 
Regex.IsMatch(file, fileNamestr, RegexOptions.IgnoreCase)
    
35
2018-06-06 14: 54: 20Z
  1. Cela correspond toutefois à un modèle. Dans votre exemple, si fileNamestr a des caractères de regex spéciaux (par exemple, *, +, ., etc.), vous serez surpris. Le seul moyen de faire fonctionner cette solution comme une fonction Contains appropriée consiste à échapper à fileNamestr en exécutant Regex.Escape(fileNamestr).
    2013-02-03 15: 18: 36Z

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;
    }
}
    
34
2011-01-25 06: 58: 32Z
  1. pourquoi autorisez-vous UNE AUTRE couche d'abstraction sur StringComparison?
    2019-06-20 18: 37: 30Z

OrdinalIgnoreCase, CurrentCultureIgnoreCase ou InvariantCultureIgnoreCase?

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

Dos

  • Utilisez StringComparison.OrdinalIgnoreCase pour des comparaisons comme valeur sûre par défaut pour la correspondance de chaînes dépendant de la culture.
  • Utilisez 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 d'utiliser le non-linguistique StringComparison.Ordinal ou StringComparison.OrdinalIgnoreCase lorsque la comparaison est
    linguistiquement non pertinent (symbolique, par exemple).
  • Utilisez ToUpperInvariant au lieu de 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.
  • Utilisez une chaîne basée sur 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

    
24
2015-07-23 10: 30: 30Z
  1. Et si vous savez que vous allez toujours obtenir une chaîne en anglais. lequel utiliser?
    2017-03-23 ​​23: 43: 53Z
  2. @ BKSpurgeon J'utiliserais OrdinalIgnoreCase, si la casse importait peu
    2017-03-24 08: 09: 08Z

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.

    
19
2018-11-08 14: 49: 03Z
  1. Enfin! Il a fallu beaucoup de temps pour être disponible ...
    2019-02-12 16: 33: 08Z

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);
    
12
2018-07-12 09: 25: 53Z
  1. Merci, premier exemple !!!
    2019-02-26 12: 43: 36Z

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");
    
10
2011-09-09 13: 55: 07Z
  1. Savez-vous également comment cela fonctionne en interne?
    2013-03-18 08: 12: 42Z

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 certains détails, mais jetez un coup d'œil à 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);
}
    
10
2013-12-06 14: 11: 23Z

Juste comme ceci:

 
string s="AbcdEf";
if(s.ToLower().Contains("def"))
{
    Console.WriteLine("yes");
}
    
10
2016-07-19 19: 23: 43Z
  1. Ceci n'est pas spécifique à la culture et peut échouer dans certains cas. culture.CompareInfo.IndexOf (paragraphe, mot, CompareOptions.IgnoreCase) doit être utilisé.
    2014-07-22 07: 50: 47Z
  2. Pourquoi éviter string.ToLower () lors de comparaisons de chaînes ne respectant pas la casse? Tl; Dr C'est coûteux, car une nouvelle chaîne est" fabriquée ".
    2016-10-10 10: 00: 29Z

Utilisez ceci:

 
string.Compare("string", "STRING", new System.Globalization.CultureInfo("en-US"), System.Globalization.CompareOptions.IgnoreCase);
    
9
2013-07-08 08: 10: 58Z
  1. Le questionneur recherche Contains et non Compare.
    2011-07-11 08: 05: 29Z
  2. @ DuckMaestro, la réponse acceptée implémente Contains avec IndexOf. Donc, cette approche est tout aussi utile! L'exemple de code C # sur cette page utilise string.Compare (). . Le choix de l'équipe SharePoint, c'est-à-dire!
    2013-01-05 10: 07: 01Z

Utiliser un RegEx est un moyen simple de faire ceci:

 
Regex.IsMatch(title, "string", RegexOptions.IgnoreCase);
    
6
2016-07-19 19: 23: 19Z
  1. Votre réponse est exactement la même que celle de guptat59 mais, comme indiqué dans sa réponse, cela correspond à une expression régulière. Ainsi, la chaîne que vous testez en contient caractères regex spéciaux, il ne donnera pas le résultat souhaité.
    2013-12-09 22: 55: 24Z
  2. Ceci est une copie directe de cette réponse et souffre des mêmes problèmes que ceux notés dans cette réponse
    2016-10-10 10: 04: 01Z
  3. Un vote négatif pour la même raison que @Liam a donnée
    2017-10-21 04: 28: 02Z
  4. D'accord. Étudier les expressions régulières
    2017-12-26 05: 14: 32Z

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) )
....
    
5
2015-10-17 07: 46: 58Z
 
if ("strcmpstring1".IndexOf(Convert.ToString("strcmpstring2"), StringComparison.CurrentCultureIgnoreCase) >= 0){return true;}else{return false;}
    
2
2016-10-26 14: 34: 14Z

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

    
2
2016-12-11 13: 41: 20Z

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"

    
2
2017-10-31 15: 16: 18Z

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;
    }
    
1
2019-02-14 08: 53: 57Z
  1. En supposant que votre paragraphe et votre mot seront toujours en en-US
    2019-02-15 13: 42: 59Z
  2. Pour éviter les problèmes liés au forçage de la culture en-US, utilisez plutôt return CultureInfo.CurrentCulture.CompareInfo.IndexOf(paragraph, word, CompareOptions.IgnoreCase) >= 0;.
    2019-06-13 21: 42: 44Z
 
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
}
    
0
2017-06-14 03: 16: 07Z

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
    
0
2017-11-16 12: 23: 46Z

Moyen simple pour les débutants:

 
title.ToLower().Contains("string");//of course "string" is lowercase.
    
- 4
2018-03-23 ​​03: 33: 44Z
  1. Non, cela ne résout pas complètement le problème.
    2017-06-23 12: 49: 26Z
  2. Un vote négatif pour une erreur. Que se passe-t-il si title = StRiNg? StRiNg! = Chaîne et StRiNg! = CHAÎNE
    2017-10-21 04: 30: 54Z
  3. J'avais tort. Modifiez la réponse comme suit, trop simple: < br /> title.ToLower (). Contains ("string") //bien sûr, "string" est en minuscule
    2018-03-23 ​​03: 28: 07Z
source placée ici
D\'autres questions