Нечутливий до регістру "Містить (рядок)"

Чи є спосіб здійснити таке повернення?

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

Здається, не існує перевантаження, яка дозволяє мені встановити чутливість регістру. В даний час я ПІДТРИМАТИ їх обох, але це просто нерозумно (під яким я маю на увазі проблеми i18n, які поставляються з корпусом вгору та вниз).

ОНОВЛЕННЯ
Це питання давнє, і з тих пір я зрозумів, що я попросив просту відповідь на дійсно обширну і складну тему, якщо ви хочете її повністю вивчити.
У більшості випадків в одномовної, англійській кодовій базі цієї відповіді буде достатньо. Я підозрюю, оскільки більшість людей, які приїжджають сюди, потрапляють до цієї категорії, це найпопулярніша відповідь. Однак
ця відповідь викликає притаманну проблему, що ми не можемо порівнювати текстові регістри, нечутливі до тих пір, поки не знаємо, що обидва тексти є однаковою культурою, і ми не знаємо, що це за культура. Це, можливо, менш популярна відповідь, але я вважаю, що вона більш правильна, і тому я позначив її як таку.

Щоб перевірити, чи paragraphмістить рядок рядок word(спасибі @QuarterMeister)

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

Де cultureє примірник CultureInfoопису мови, якою написаний текст.

Це рішення є прозорим щодо визначення чутливості до регістру, яке залежить від мови . Наприклад, англійська мова використовує символи Iта iдля верхніх та малих версій дев'ятої літери, тоді як турецька мова використовує ці символи для одинадцятої та дванадцятої літер свого 29-літерного алфавіту. Версія турецького верхнього регістру "i" - незнайомий символ "İ".

Таким чином, рядки tinі TINявляють собою те саме слово англійською мовою , але різні слова турецькою . Як я розумію, один означає «дух», а інший - слово ономатопеї. (Турки, будь ласка, виправте мене, якщо я помиляюся, або запропонуйте кращий приклад)

Підводячи підсумок, ви можете відповісти на запитання "чи ці два рядки однакові, але в різних випадках", якщо ви знаєте, на якій мові йде текст . Якщо ви цього не знаєте, вам доведеться взяти шайбу. Зважаючи на гегемонію англійської мови в програмному забезпеченні, ви, ймовірно, можете вдатися CultureInfo.InvariantCulture, оскільки це буде неправильно звичними способами.

Ви можете використовувати метод String.IndexOf і пройти StringComparison.OrdinalIgnoreCaseяк тип пошуку для використання:

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

Ще кращим є визначення нового методу розширення для рядка:

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

Зауважте, що нульове поширення ?. доступне з C # 6.0 (VS 2015) для використання в старих версіях

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

ВИКОРИСТАННЯ:

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

Ви можете використовувати IndexOf()так:

string title = "STRING";

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

Оскільки 0 (нуль) може бути індексом, ви перевіряєте -1.

MSDN

Нульова позиція індексу значення, якщо знайдено цей рядок, або -1, якщо його немає. Якщо значення String.Empty, значення повернення дорівнює 0.

Альтернативне рішення з використанням Regex:

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

Ви завжди зможете спершу підняти або зменшити рядки.

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

Ой, щойно побачив цей останній шматочок. Справа, нечутливе до випадку, порівняло б* ймовірно, *зробить те саме, і якщо продуктивність не є проблемою, я не бачу проблем із створенням великих копій та порівнянням їх. Я міг присягнути, що одного разу побачив порівняння, яке не враховує регістр,

Тільки .NET Core 2.0+ (станом на даний момент)

.NET Core має пару методів для вирішення цього питання з версії 2.0:

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

Приклад:

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

З часом вони, мабуть, пробиться до .NET Standard і, звідти, у всі інші реалізації Бібліотеки базових класів.

Одне питання з відповіддю полягає в тому, що він видасть виняток, якщо рядок є нульовим. Ви можете додати це як чек, щоб він не:

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

Клас StringExtension - це шлях вперед, я поєднав кілька публікацій вище, щоб дати повний приклад коду:

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

Це чисто і просто.

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

OrdinalIgnoreCase, CurrentCultureIgnoreCase або InvariantCultureIgnoreCase?

Оскільки цього немає, ось кілька рекомендацій щодо того, коли використовувати:

Дос

• Використовуйте StringComparison.OrdinalIgnoreCase для порівнянь як безпечного за замовчуванням для порівняння між культурою та агностиками.
• Використовуйте StringComparison.OrdinalIgnoreCaseпорівняння для збільшення швидкості.
• Використовуйте StringComparison.CurrentCulture-based рядкові операції під час відображення результату для користувача.
• Переключіть поточне використання струнних операцій на основі інваріантної культури на використання нелінгвістичних StringComparison.Ordinalабо StringComparison.OrdinalIgnoreCaseколи відбувається порівняння
  мовно нерелевантним (наприклад, символічним).
• Використовуйте, ToUpperInvariantа не ToLowerInvariantдля нормалізації рядків для порівняння.

Не треба

• Використовуйте перевантаження для рядкових операцій, які чітко або неявно не задають механізм порівняння рядків.
• Використовувати StringComparison.InvariantCultureрядкові
  операції на основі більшості випадків; одним з небагатьох винятків є
  збереження лінгвістично значущих, але культурно-агностичних даних.

На основі цих правил слід використовувати:

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

тоді як [YourDecision] залежить від рекомендацій зверху.

посилання на джерело: http://msdn.microsoft.com/en-us/library/ms973919.aspx

Це найпростіші рішення.

1. За індексом

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

2. За зміною справи

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

3. За Regex

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

Я знаю, що це не C #, але в рамках (VB.NET) вже є така функція

Dim str As String = "UPPERlower"
Dim b As Boolean = InStr(str, "UpperLower")

C # варіант:

string myString = "Hello World";
bool contains = Microsoft.VisualBasic.Strings.InStr(myString, "world");

InStrМетод з VisualBasic збірки краще всього, якщо у вас є занепокоєння щодо приводу інтернаціоналізації (або ви можете перевизначити його). Поглянувши на це, dotNeetPeek показує, що він не лише містить великі і малі літери, але й тип кана та символи повної ширини порівняно з половиною ширини (в основному стосується азіатських мов, хоча є й повні ширини версій римського алфавіту) ). Я пропускаю деякі деталі, але перевіряю приватний метод 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);
}

Просто так:

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

Використовуй це:

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

Це досить схоже на інший приклад тут, але я вирішив спростити перерахунок до bool, головного, оскільки інші альтернативи зазвичай не потрібні. Ось мій приклад:

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

А використання - це щось на зразок:

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

Використання RegEx - це прямий спосіб зробити це:

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

Просто будуючи відповідь тут, ви можете створити метод розширення рядків, щоб зробити це трохи більш зручним у користуванні:

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

якщо ви хочете перевірити, чи передана вами рядок є рядком, то для цього є простий метод.

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

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

Це булеве значення повернеться, якщо рядок міститься чи ні

Як просто і працює

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

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

Ви можете використовувати string.indexof ()функцію. Це буде нечутливим до випадку

Хитрість тут полягає в тому, щоб шукати рядок, ігноруючи регістр, але зберігати його точно так само (з тим самим випадком).

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

Вихід "Скидання"

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
}

Простий спосіб для новачків:

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