c# - учета - Нечувствительный к регистру «Содержит(строка)»




первое вхождение символа в строку c# (16)

.NET Core 2.0+ только (на данный момент)

У .NET Core было несколько методов для решения этой проблемы с версии 2.0:

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

Пример:

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

Со временем они, вероятно, войдут в стандарт .NET и, оттуда, во все другие реализации библиотеки базового класса.

Есть ли способ сделать следующее возвращение истинным?

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

Кажется, что нет перегрузки, которая позволяет мне установить чувствительность к регистру. В настоящее время я ВЕРХНИЙ их обоих, но это просто глупо (я имею в виду проблемы i18n которые поставляются с корпусом вверх и вниз).

ОБНОВИТЬ
Этот вопрос древний, и с тех пор я понял, что попросил простой ответ на очень обширную и трудную тему, если вы хотите изучить ее полностью.
В большинстве случаев в моноязычных, английских кодовых базах this ответ будет достаточным. Я подозреваю, что большинство людей, приезжающих сюда, попадают в эту категорию, это самый популярный ответ.
This ответ порождает неотъемлемую проблему, по которой мы не можем сравнивать текстовый регистр без учета, пока мы не узнаем, что оба текста являются одной и той же культурой, и мы знаем, что это за культура. Это, возможно, менее популярный ответ, но я думаю, что это более правильно, и именно поэтому я отметил его как таковой.


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

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

уведомление

Как отметил @cHao в своем комментарии, есть сценарии, которые заставят это решение возвращать неверные результаты. Убедитесь, что вы знаете, что делаете, прежде чем реализовать это решение случайным образом.


Вначале вы всегда можете просто перевернуть строки.

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

Ой, просто увидел последний бит. Нечувствительное к регистру сравнение могло бы * вероятно, сделать то же самое в любом случае, и если производительность не является проблемой, я не вижу проблемы с созданием заглавных копий и их сравнением. Я мог бы поклясться, что когда-то видел случайный анализ ...


Вы можете использовать метод 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);

Вы можете использовать string.indexof () . Это будет нечувствительным к регистру


Именно так:

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

Класс 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;
    }
}

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

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

Хитрость здесь заключается в том, чтобы искать строку, игнорируя случай, но держать ее в точности одинаковой (с тем же случаем).

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

Выход «Сброс»


Это довольно похоже на другой пример здесь, но я решил упростить перечисление для 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) )
....

Это самые простые решения.

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

если вы хотите проверить, находится ли ваша строка в строке, тогда для этого существует простой метод.

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

OrdinalIgnoreCase, CurrentCultureIgnoreCase или InvariantCultureIgnoreCase?

Поскольку этого не хватает, вот несколько рекомендаций о том, когда использовать тот, который:

ДОС

  • Используйте StringComparison.OrdinalIgnoreCase для сравнения в качестве безопасного по умолчанию для сопоставления с 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


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




case-insensitive