Trường hợp không nhạy cảm 'Chứa (chuỗi)'

Có cách nào để làm cho sự trở lại sau đây đúng không?

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

Dường như không có sự quá tải cho phép tôi thiết lập độ nhạy trường hợp .. Hiện tại tôi TĂNG CƯỜNG cả hai, nhưng điều đó thật ngớ ngẩn (trong đó tôi đang đề cập đến các vấn đề i18n đi kèm với vỏ lên xuống).

CẬP NHẬT
Câu hỏi này là cổ xưa và kể từ đó tôi nhận ra rằng tôi đã yêu cầu một câu trả lời đơn giản cho một chủ đề thực sự rộng lớn và khó khăn nếu bạn quan tâm điều tra nó đầy đủ.
Đối với hầu hết các trường hợp, trong ngôn ngữ đơn ngữ, mã tiếng Anh dựa trên câu trả lời này sẽ đủ. Tôi nghi ngờ bởi vì hầu hết mọi người đến đây đều thuộc loại này, đây là câu trả lời phổ biến nhất. Tuy nhiên, câu trả lời
này đưa ra một vấn đề cố hữu là chúng ta không thể so sánh trường hợp văn bản không nhạy cảm cho đến khi chúng ta biết cả hai văn bản là cùng một nền văn hóa và chúng ta biết văn hóa đó là gì. Đây có thể là một câu trả lời ít phổ biến hơn, nhưng tôi nghĩ nó đúng hơn và đó là lý do tại sao tôi đánh dấu nó như vậy.

Để kiểm tra xem chuỗi paragraphcó chứa chuỗi không word(cảm ơn @QuarterMeister)

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

Trong trường hợp culturelà thể hiện của CultureInfomô tả ngôn ngữ mà văn bản được viết bằng.

Giải pháp này minh bạch về định nghĩa không phân biệt chữ hoa chữ thường, phụ thuộc vào ngôn ngữ . Ví dụ, ngôn ngữ tiếng Anh sử dụng các ký tự Ivà icho các phiên bản chữ hoa và chữ thường của chữ thứ chín, trong khi ngôn ngữ Thổ Nhĩ Kỳ sử dụng các ký tự này cho các chữ cái thứ mười một và mười hai của bảng chữ cái dài 29 chữ cái. Phiên bản chữ hoa của tiếng Thổ Nhĩ Kỳ 'i' là ký tự lạ '' '.

Do đó, các chuỗi tinvà TINlà cùng một từ trong tiếng Anh , nhưng các từ khác nhau trong tiếng Thổ Nhĩ Kỳ . Theo tôi hiểu, một nghĩa là "tinh thần" và cái còn lại là một từ onomatopoeia. (Turks, xin vui lòng sửa cho tôi nếu tôi sai, hoặc đề xuất một ví dụ tốt hơn)

Để tóm tắt, bạn chỉ có thể trả lời câu hỏi 'hai chuỗi này giống nhau nhưng trong các trường hợp khác nhau' nếu bạn biết văn bản đó thuộc ngôn ngữ nào . Nếu bạn không biết, bạn sẽ phải mất một thời gian. Với quyền bá chủ của tiếng Anh trong phần mềm, có lẽ bạn nên dùng đến CultureInfo.InvariantCulture, vì nó sẽ sai theo những cách quen thuộc.

Bạn có thể sử dụng Phương thức String.IndexOf và chuyển qua StringComparison.OrdinalIgnoreCaselàm loại tìm kiếm để sử dụng:

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

Thậm chí tốt hơn là xác định một phương thức mở rộng mới cho chuỗi:

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

Lưu ý, việc truyền bá null ?. có sẵn kể từ C # 6.0 (VS 2015), cho các phiên bản cũ hơn sử dụng

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

SỬ DỤNG:

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

Bạn có thể sử dụng IndexOf()như thế này:

string title = "STRING";

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

Vì 0 (không) có thể là một chỉ mục, bạn kiểm tra so với -1.

MSDN

Vị trí chỉ mục dựa trên giá trị 0 nếu chuỗi đó được tìm thấy hoặc -1 nếu không. Nếu giá trị là String.Empty, giá trị trả về là 0.

Giải pháp thay thế bằng Regex:

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

Bạn luôn có thể chỉ cần tăng hoặc giảm các chuỗi đầu tiên.

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

Rất tiếc, chỉ cần nhìn thấy chút cuối cùng. Một trường hợp so sánh không nhạy cảm *có thể sẽ *làm điều tương tự và dù sao hiệu suất không phải là vấn đề, tôi không thấy vấn đề gì với việc tạo các bản sao in hoa và so sánh chúng. Tôi có thể đã thề rằng tôi đã từng thấy một so sánh không nhạy cảm một lần ...

Chỉ .NET Core 2.0+ (tính đến thời điểm hiện tại)

.NET Core đã có một cặp phương pháp để giải quyết vấn đề này kể từ phiên bản 2.0:

• String.Contains (Char, StringComparison )
• String.Contains (Chuỗi, StringComparison )

Thí dụ:

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

Theo thời gian, họ có thể sẽ tìm đường đến .NET Standard và từ đó, vào tất cả các triển khai khác của Thư viện lớp cơ sở.

Một vấn đề với câu trả lời là nó sẽ đưa ra một ngoại lệ nếu một chuỗi là null. Bạn có thể thêm nó dưới dạng kiểm tra để nó không bị:

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

Lớp StringExtension là con đường phía trước, tôi đã kết hợp một vài bài viết ở trên để đưa ra một ví dụ mã hoàn chỉnh:

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

Điều này là sạch sẽ và đơn giản.

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

OrdinalIgnoreCase, CurrentCARMIgnoreCase hoặc InvariantCARMIgnoreCase?

Vì điều này bị thiếu, đây là một số khuyến nghị về thời điểm sử dụng cái nào:

Liều dùng

• Sử dụng StringComparison.OrdinalIgnoreCaseđể so sánh làm mặc định an toàn của bạn để khớp chuỗi không liên quan đến văn hóa.
• Sử dụng StringComparison.OrdinalIgnoreCaseso sánh để tăng tốc độ.
• Sử dụng StringComparison.CurrentCulture-basedcác thao tác chuỗi khi hiển thị đầu ra cho người dùng.
• Chuyển đổi sử dụng hiện tại của các hoạt động chuỗi dựa trên văn hóa bất biến để sử dụng phi ngôn ngữ StringComparison.Ordinalhoặc StringComparison.OrdinalIgnoreCasekhi so sánh là
  không liên quan về mặt ngôn ngữ (ví dụ tượng trưng).
• Sử dụng ToUpperInvariantthay vì ToLowerInvariantkhi bình thường hóa chuỗi để so sánh.

Không

• Sử dụng quá tải cho các hoạt động chuỗi không chỉ định rõ ràng hoặc ngầm định cơ chế so sánh chuỗi.
• Sử dụng StringComparison.InvariantCulturecác
  hoạt động chuỗi dựa trên hầu hết các trường hợp; một trong số ít trường hợp ngoại lệ sẽ
  tồn tại dữ liệu có ý nghĩa về mặt ngôn ngữ nhưng không liên quan đến văn hóa.

Dựa trên những quy tắc này bạn nên sử dụng:

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

trong khi [YourDecision] phụ thuộc vào các khuyến nghị từ phía trên.

liên kết của nguồn: http://msdn.microsoft.com/en-us/l Library / ms973919.aspx

Đây là những giải pháp dễ nhất.

1. Theo chỉ số của

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

2. Bằng cách thay đổi trường hợp

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

3. Bởi Regex

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

Tôi biết rằng đây không phải là C #, nhưng trong khung (VB.NET) đã có chức năng như vậy

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

Biến thể C #:

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

Các InStrphương pháp từ VisualBasic lắp ráp là tốt nhất nếu bạn có một mối quan tâm về quốc tế hóa (hoặc bạn có thể reimplement nó). Nhìn vào nó, dotNeetPeek cho thấy rằng nó không chỉ chiếm mũ và chữ thường mà còn cho các loại kana và các ký tự đầy đủ so với nửa chiều rộng (chủ yếu liên quan đến các ngôn ngữ châu Á, mặc dù cũng có các phiên bản đầy đủ của bảng chữ cái La Mã ). Tôi đang bỏ qua một số chi tiết, nhưng hãy kiểm tra phương pháp riêng tư 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);
}

Chỉ như thế này:

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

Dùng cái này:

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

Điều này khá giống với ví dụ khác ở đây, nhưng tôi đã quyết định đơn giản hóa enum thành bool, vì các lựa chọn thay thế khác thường không cần thiết. Đây là ví dụ của tôi:

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

Và cách sử dụng là một cái gì đó như:

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

Sử dụng RegEx là một cách đơn giản để làm điều này:

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

Chỉ cần xây dựng câu trả lời ở đây, bạn có thể tạo một phương thức mở rộng chuỗi để làm cho nó thân thiện hơn với người dùng một chút:

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

Nếu bạn muốn kiểm tra xem chuỗi đã qua của bạn có nằm trong chuỗi hay không thì có một phương pháp đơn giản cho việc đó.

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

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

Giá trị boolean này sẽ trả về nếu chuỗi có chứa hay không

Đơn giản và hiệu quả

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

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

Bạn có thể sử dụng string.indexof ()chức năng. Đây sẽ là trường hợp không nhạy cảm

Mẹo ở đây là tìm kiếm chuỗi, bỏ qua trường hợp, nhưng để giữ cho nó chính xác như nhau (với cùng một trường hợp).

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

Đầu ra là "Đặt lại"

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
}

Cách đơn giản cho người mới:

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