Insensible à la casse “Contient (chaîne)”

Pour tester si le paragraph chaîne contient le word chaîne (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 quant à 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 les onzième et douzième lettres de son alphabet de 29 lettres. La version turque en majuscule de «i» est le caractère inconnu «İ».

Ainsi, les cordes 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éique. (Turcs, corrigez-moi si je me trompe, ou suggérez un meilleur exemple)

Pour résumer, vous ne pouvez répondre à la question ” Est-ce que ces deux chaînes sont identiques mais dans des cas différents” si vous connaissez la langue du texte ? Si vous ne le savez pas, vous devrez prendre un punt. Compte tenu de l’hégémonie de l’anglais dans les logiciels, vous devriez probablement avoir recours à CultureInfo.InvariantCulture , car cela ne va pas du tout.

Vous pouvez utiliser la méthode Ssortingng.IndexOf et transmettre SsortingngComparison.OrdinalIgnoreCase comme type de recherche à utiliser:

 ssortingng title = "STRING"; bool contains = title.IndexOf("ssortingng", SsortingngComparison.OrdinalIgnoreCase) >= 0; 

Encore mieux, définir une nouvelle méthode d’extension pour ssortingng:

 public static class SsortingngExtensions { public static bool Contains(this ssortingng source, ssortingng toCheck, SsortingngComparison comp) { return source?.IndexOf(toCheck, comp) >= 0; } } 

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

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

USAGE:

 ssortingng title = "STRING"; bool contains = title.Contains("ssortingng", SsortingngComparison.OrdinalIgnoreCase); 

Vous pouvez utiliser IndexOf() comme ceci:

 ssortingng title = "STRING"; if (title.IndexOf("ssortingng", 0, SsortingngComparison.CurrentCultureIgnoreCase) != -1) { // The ssortingng exists in the original } 

Puisque 0 (zéro) peut être un index, vous vérifiez avec -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 Ssortingng.Empty, la valeur renvoyée est 0.

Solution alternative utilisant Regex:

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

Remarquer

Comme @cHao l’a souligné dans son commentaire, il existe des scénarios qui font que cette solution renvoie des résultats incorrects. Assurez-vous de savoir ce que vous faites avant d’implémenter cette solution au hasard.

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

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

Oups, juste vu ce dernier morceau. Une comparaison insensible à la casse ferait probablement la même chose de toute façon, et si la performance ne pose pas de problème, je ne vois aucun problème à créer des copies majuscules et à les comparer. J’aurais pu jurer qu’une fois, j’ai vu une comparaison insensible à la casse …

Un problème avec la réponse est qu’il va lancer une exception si une chaîne est null. Vous pouvez append cela comme un chèque pour qu’il ne soit pas:

 public static bool Contains(this ssortingng source, ssortingng toCheck, SsortingngComparison comp) { if (ssortingng.IsNullOrEmpty(toCheck) || ssortingng.IsNullOrEmpty(source)) return true; return source.IndexOf(toCheck, comp) >= 0; } 

La classe SsortingngExtension est la voie à suivre, j’ai combiné quelques articles ci-dessus pour donner un exemple de code complet:

 public static class SsortingngExtensions { /// 
 /// Allows case insensitive checks /// 
 public static bool Contains(this ssortingng source, ssortingng toCheck, SsortingngComparison comp) { return source.IndexOf(toCheck, comp) >= 0; } } 

C’est propre et simple.

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

OrdinalIgnoreCase, CurrentCultureIgnoreCase ou InvariantCultureIgnoreCase?

Comme cela manque, voici quelques recommandations sur le moment d’utiliser lequel:

Dos

• Utilisez SsortingngComparison.OrdinalIgnoreCase pour SsortingngComparison.OrdinalIgnoreCase des comparaisons en tant que vos SsortingngComparison.OrdinalIgnoreCase par défaut sûres pour la correspondance de chaîne SsortingngComparison.OrdinalIgnoreCase de la culture.
• Utilisez les comparaisons SsortingngComparison.OrdinalIgnoreCase pour augmenter la vitesse.
• Utilisez les opérations de chaîne SsortingngComparison.CurrentCulture-based lors de l’affichage de la sortie pour l’utilisateur.
• Changer l’utilisation actuelle des opérations de chaîne en fonction de la culture invariante pour utiliser la SsortingngComparison.Ordinal non linguistique SsortingngComparison.Ordinal ou SsortingngComparison.OrdinalIgnoreCase lorsque la comparaison est effectuée
  linguistiquement non pertinent (symbolique, par exemple).
• Utilisez ToUpperInvariant plutôt que ToLowerInvariant lors de la normalisation des chaînes à des fins de comparaison.

A 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 la SsortingngComparison.InvariantCulture basée sur SsortingngComparison.InvariantCulture
  opérations dans la plupart des cas; l’une des rares exceptions serait
  des données persistantes sur le plan linguistique, mais culturellement agnostiques.

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

 ssortingng title = "STRING"; if (title.IndexOf("ssortingng", 0, SsortingngComparison.[YourDecision]) != -1) { // The ssortingng 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

Juste comme ça:

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

La méthode InStr de l’assembly VisualBasic est la meilleure si vous avez un problème d’internationalisation (ou si vous pouvez le réimplémenter). DotNeetPeek montre que cela ne concerne pas seulement les majuscules et les minuscules, mais aussi le type kana et les caractères pleins et demi-largeur (surtout pour les langues asiatiques, bien qu’il existe également des versions en largeur de l’alphabet romain) ). Je passe quelques détails, mais consultez la méthode privée InternalInStrText :

 private static int InternalInStrText(int lStartPos, ssortingng sSrc, ssortingng 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); } 

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 Ssortingng = "UPPERlower" Dim b As Boolean = InStr(str, "UpperLower") 

Variante C #:

 ssortingng mySsortingng = "Hello World"; bool contains = Microsoft.VisualBasic.Ssortingngs.InStr(mySsortingng, "world"); 

Utilisez ceci:

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

En fin de compte, une opération générique “contient” se résume à une fonction comme celle-ci,

 /// 
 /// Determines whether the source contains the sequence. /// 
 /// The type of the items in the sequences. /// The source enumerator. /// The sequence enumerator. /// An equality comparer. ///  /// An empty sequence will return true. /// The sequence must support  /// if it does not begin the source. ///  ///  /// true if the source contains the sequence; /// otherwise false. ///  public static bool Contains( IEnumerator sourceEnumerator, IEnumerator sequenceEnumerator, IEqualityComparer equalityComparer) { if (equalityComparer == null) { equalityComparer = EqualityComparer.Default; } while (sequenceEnumerator.MoveNext()) { if (sourceEnumerator.MoveNext()) { if (!equalityComparer.Equals( sourceEnumerator.Current, sequenceEnumerator.Current)) { sequenceEnumerator.Reset(); } } else { return false; } } return true; } 

cela peut être sortingvialement enveloppé dans une version d’extension acceptant IEnumerable comme ça,

 public static bool Contains( this IEnumerable source, IEnumerable sequence, IEqualityComparer equalityComparer = null) { if (sequence == null) { throw new ArgumentNullException("sequence"); } using(var sequenceEnumerator = sequence.GetEnumerator()) using(var sourceEnumerator = source.GetEnumerator()) { return Contains( sourceEnumerator, sequenceEnumerator, equalityComparer); } } 

Maintenant, cela fonctionnera pour la comparaison ordinale de toutes les séquences, y compris les chaînes, puisque la ssortingng implémente IEnumerable ,

 // The optional parameter ensures the generic overload is invoked // not the ssortingng.Contains() implementation. "testable".Contains("est", EqualityComparer.Default) 

Cependant, comme nous le soaps, les chaînes de caractères ne sont pas génériques, elles sont spécialisées. Il y a deux facteurs clés en jeu.

1. Le problème de “casing” qui a lui-même plusieurs cas de bord dépendant de la langue.
2. La question plutôt complexe de la manière dont un ensemble d’éléments de texte (lettres / chiffres / symboles, etc.) sont représentés par des points de code Unicode et des séquences de caractères valides pouvant représenter une chaîne donnée, les détails sont développés dans ces réponses .

L’effet net est le même. Les chaînes que vous pouvez affirmer être linguistiquement égales peuvent être valablement représentées par différentes combinaisons de caractères. Quoi de plus, les règles de changement de validité entre les cultures.

Tout cela conduit à une implémentation spécialisée “Contient” basée sur des chaînes comme celle-ci.

 using System.Globalization; public static bool Contains( this ssortingng source, ssortingng value, CultureInfo culture = null, CompareOptions options = CompareOptions.None) { if (value == null) { throw new ArgumentNullException("value"); } var compareInfo = culture == null ? CultureInfo.CurrentCulture.CompareInfo : culture.CompareInfo; var sourceEnumerator = SsortingngInfo.GetTextElementEnumerator(source); var sequenceEnumerator = SsortingngInfo.GetTextElementEnumerator(value); while (sequenceEnumerator.MoveNext()) { if (sourceEnumerator.MoveNext()) { if (!(compareInfo.Compare( sourceEnumerator.Current, sequenceEnumerator.Current, options) == 0)) { sequenceEnumerator.Reset(); } } else { return false; } } return true; } 

Cette fonction peut être utilisée pour effectuer une casse insensible à la culture, “contient” spécifique qui fonctionnera, quelle que soit la normalisation des chaînes. par exemple

 "testable".Contains("EST", SsortingngComparer.CurrentCultureIgnoreCase) 

Utiliser un RegEx est un moyen simple de le faire:

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

Ceci est assez similaire à d’autres exemples ici, mais j’ai décidé de simplifier enum to bool, primaire car d’autres alternatives ne sont normalement pas nécessaires. Voici mon exemple:

 public static class SsortingngExtensions { public static bool Contains(this ssortingng source, ssortingng toCheck, bool bCaseInsensitive ) { return source.IndexOf(toCheck, bCaseInsensitive ? SsortingngComparison.OrdinalIgnoreCase : SsortingngComparison.Ordinal) >= 0; } } 

Et l’utilisation est quelque chose comme:

 if( "main Ssortingng subssortingng".Contains("SUBSTRING", true) ) .... 

 if ("strcmpssortingng1".IndexOf(Convert.ToSsortingng("strcmpssortingng2"), SsortingngComparison.CurrentCultureIgnoreCase) >= 0){return true;}else{return false;} 

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

L’astuce consiste ici à rechercher la chaîne, en ignorant la casse, mais à la conserver exactement (avec le même cas).

  var s="Factory Reset"; var txt="reset"; int first = s.IndexOf(txt, SsortingngComparison.InvariantCultureIgnoreCase) + txt.Length; var subSsortingng = s.Subssortingng(first - txt.Length, txt.Length); 

La sortie est “Reset”

Ce sont les solutions les plus faciles.

1. Par index de

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

2. En changeant de cas

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

3. Par regex

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

 public static class SsortingngExtension { #region Public Methods public static bool ExContains(this ssortingng fullText, ssortingng value) { return ExIndexOf(fullText, value) > -1; } public static bool ExEquals(this ssortingng text, ssortingng textToCompare) { return text.Equals(textToCompare, SsortingngComparison.OrdinalIgnoreCase); } public static bool ExHasAllEquals(this ssortingng text, params ssortingng[] 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; } /// 
 /// Reports the zero-based index of the first occurrence of the specified ssortingng /// in the current System.Ssortingng object using SsortingngComparison.InvariantCultureIgnoreCase. /// A parameter specifies the type of search to use for the specified ssortingng. /// 
 ///  /// The ssortingng to search inside. ///  ///  /// The ssortingng to seek. ///  ///  /// The index position of the value parameter if that ssortingng is found, or -1 if it /// is not. If value is System.Ssortingng.Empty, the return value is 0. ///  ///  /// fullText or value is null. ///  public static int ExIndexOf(this ssortingng fullText, ssortingng value) { return fullText.IndexOf(value, SsortingngComparison.OrdinalIgnoreCase); } public static bool ExNotEquals(this ssortingng text, ssortingng textToCompare) { return ExEquals(text, textToCompare) == false; } #endregion Public Methods } 

Si vous voulez vérifier si votre chaîne est en chaîne, il existe une méthode simple pour cela.

 ssortingng yourSsortingngForCheck= "abc"; ssortingng ssortingngInWhichWeCheck= "Test abc abc"; bool isContaines = ssortingngInWhichWeCheck.ToLower().IndexOf(yourSsortingngForCheck.ToLower()) > -1; This boolean value will return if ssortingng contains or not 

Moyen simple pour les débutants:

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