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




строке вхождение (21)

Одна из проблем с ответом заключается в том, что он будет генерировать исключение, если строка равна 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;
} 

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

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

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

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


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


В конечном счете, общая операция «содержит» сводится к такой функции, как эта,

/// <summary>
/// Determines whether the source contains the sequence.
/// </summary>
/// <typeparam name="T">The type of the items in the sequences.</typeparam>
/// <param name="sourceEnumerator">The source enumerator.</param>
/// <param name="sequenceEnumerator">The sequence enumerator.</param>
/// <param name="equalityComparer">An equality comparer.</param>
/// <remarks>
/// An empty sequence will return <c>true</c>.
/// The sequence must support <see cref="IEnumerator.Reset"/>
/// if it does not begin the source.
/// </remarks>
/// <returns>
/// <c>true</c> if the source contains the sequence;
/// otherwise <c>false</c>.
/// </returns>
public static bool Contains<T>(
    IEnumerator<T> sourceEnumerator,
    IEnumerator<T> sequenceEnumerator,
    IEqualityComparer<T> equalityComparer)
{
    if (equalityComparer == null)
    {
        equalityComparer = EqualityComparer<T>.Default;
    }

    while (sequenceEnumerator.MoveNext())
    {
        if (sourceEnumerator.MoveNext())
        {
            if (!equalityComparer.Equals(
                sourceEnumerator.Current,
                sequenceEnumerator.Current))
            {
                sequenceEnumerator.Reset();
            }
        }
        else
        {
            return false;
        }
    }

    return true;
}

это может быть тривиально завернуто в версию расширения, принимающую IEnumerable как это,

public static bool Contains<T>(
        this IEnumerable<T> source,
        IEnumerable<T> sequence,
        IEqualityComparer<T> equalityComparer = null)
{
    if (sequence == null)
    {
        throw new ArgumentNullException("sequence");
    }

    using(var sequenceEnumerator = sequence.GetEnumerator())
    using(var sourceEnumerator = source.GetEnumerator())
    {
        return Contains(
            sourceEnumerator,
            sequenceEnumerator,
            equalityComparer);
    }
}

Теперь это будет работать для порядкового сравнения любых последовательностей, включая строки, поскольку string реализует IEnumerable<char> ,

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

Однако, как мы знаем, строки не являются общими, они специализированы. В игре есть два ключевых фактора.

  1. Проблема «обсадной колонны», которая сама по себе имеет различные языковые случаи.
  2. Скорее всего, вопрос о том, как набор «текстовых элементов» (буквы / цифры / символы и т. Д.) Представлены кодами Юникода и какие действительные последовательности символов могут представлять заданную строку, в these answers подробно раскрываются детали.

Чистый эффект тот же. Строки, которые вы можете утверждать, являются лингвистически равными, могут быть справедливо представлены различными комбинациями символов. Более того, правила действительности изменяются между культурами.

Все это приводит к реализации специализированной строки на основе «Содержит».

using System.Globalization;

public static bool Contains(
         this string source,
         string 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 = StringInfo.GetTextElementEnumerator(source);
    var sequenceEnumerator = StringInfo.GetTextElementEnumerator(value);

    while (sequenceEnumerator.MoveNext())
    {
        if (sourceEnumerator.MoveNext())
        {
            if (!(compareInfo.Compare(
                    sourceEnumerator.Current,
                    sequenceEnumerator.Current,
                    options) == 0))
            {
                sequenceEnumerator.Reset();
            }
        }
        else
        {
            return false;
        }
    }

    return true;
}

Эта функция может использоваться для выполнения нечувствительного к регистру, специфического для культуры «содержит», который будет работать, независимо от нормализации строк. например

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

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

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

уведомление

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


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

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

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

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


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


Использовать этот:

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

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
}

Именно так:

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

Я знаю, что это не 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");

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

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

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


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

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

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

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

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

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

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

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

Использование RegEx - это прямой способ сделать это:

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

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


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

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

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

Пример:

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

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


Это можно сделать тремя способами:

 $a = 'How are you?';

1- stristr ()

 if (strlen(stristr($a,"are"))>0) {
    echo "true"; // are Found
 } 

2- strpos ()

 if (strpos($a, "are") !== false) {
   echo "true"; // are Found
 }

3- preg_match ()

 if( preg_match("are",$a) === 1) {
   echo "true"; // are Found
 }




c# string contains case-insensitive