සිද්ධි සංවේදී නොවන 'අඩංගු වේ (නූල්)'

පහත දැක්වෙන ප්‍රතිලාභ සැබෑ කර ගැනීමට ක්‍රමයක් තිබේද?

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

සිද්ධි සංවේදීතාව සැකසීමට මට ඉඩ සලසන අධික බරක් ඇති බවක් නොපෙනේ .. දැනට මම ඔවුන් දෙදෙනාම අභිබවා යමි, නමුත් එය මෝඩකමකි (එයින් මම සඳහන් කරන්නේ ඉහළ හා පහළ ආවරණ සහිත i18n ගැටළු ගැන ය).

යාවත්කාලීන කිරීම
මෙම ප්‍රශ්නය පුරාණ වන අතර එතැන් සිට මම තේරුම් ගත්තා ඔබ එය සම්පූර්ණයෙන් විමර්ශනය කිරීමට කැමති නම් සැබවින්ම විශාල හා දුෂ්කර මාතෘකාවක් සඳහා සරල පිළිතුරක් ඉල්ලා ඇති බව.
බොහෝ අවස්ථාවන්හීදී, ඒකභාෂා, ඉංග්‍රීසි කේත පදනම් කරගෙන මෙම පිළිතුර ප්‍රමාණවත් වේ. මම සැක කරන්නේ මෙහි පැමිණෙන බොහෝ දෙනා මෙම ගණයට වැටෙන නිසා මෙය වඩාත්ම ජනප්‍රිය පිළිතුරයි. කෙසේවෙතත්,
මෙම පිළිතුර මගින් පෙළ දෙකම එකම සංස්කෘතියක් බව දැනගෙන එම සංස්කෘතිය යනු කුමක්දැයි අප දැන ගන්නා තෙක් අපට පෙළ නඩුව සංවේදී නොවන ලෙස සංසන්දනය කළ නොහැකි සහජ ගැටලුව මතු කරයි. මෙය සමහර විට අඩු ජනප්‍රිය පිළිතුරක් විය හැකි නමුත් මම සිතන්නේ එය වඩාත් නිවැරදියි, ඒ නිසා මම එය එසේ සලකුණු කළෙමි.

නූලෙහි නූල් paragraphඅඩංගු දැයි පරීක්ෂා කිරීමට word(ස්තූතියි uQuarterMeister)

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

පා written ය ලියා ඇති භාෂාව විස්තර cultureකිරීමේ අවස්ථාව කොහිද?CultureInfo

මෙම විසඳුම භාෂාව මත රඳා පවතින සිද්ධි-සංවේදීතාවයේ අර්ථ දැක්වීම පිළිබඳව විනිවිද පෙනෙන ය . උදාහරණයක් ලෙස, ඉංග්රීසි භාෂාවේ අකුරු භාවිතා කරයි Iසහ iනවවන ලිපිය ඉහළ හා පහළ නඩුව සංස්කරණ තුර්කි භාෂා සඳහා මෙම අක්ෂර භාවිතා කරයි බැවින්ද සඳහා එකොළොස් සහ දොළොස්වන ලිපි එහි 29 ලිපිය දිගු හෝඩියේ. 'I' හි තුර්කි ඉහළ අකුරු අනුවාදය 'İ' නුහුරු චරිතයකි.

මේ අනුව නූල් tinසහ ඉංග්‍රීසියෙන්TIN එකම වචනය , නමුත් තුර්කි භාෂාවෙන් වෙනස් වචන . මා තේරුම් ගත් පරිදි, එක් අර්ථයක් 'ආත්මය' වන අතර අනෙක ඔනෝමැටෝපියා වචනයකි. (ටර්ක්ස්, කරුණාකර මා වැරදියි නම් මාව නිවැරදි කරන්න, නැතහොත් වඩා හොඳ උදාහරණයක් යෝජනා කරන්න)

සාරාංශගත කිරීම සඳහා, ඔබට පිළිතුරු දිය හැක්කේ 'මෙම නූල් දෙක එක හා සමාන නමුත් විවිධ අවස්ථා වලදී' යන පා text ය කුමක්දැයි ඔබ දන්නේ නම් පමණි . ඔබ නොදන්නේ නම්, ඔබට පන්ච් එකක් ගැනීමට සිදුවේ. මෘදුකාංග පිළිබඳ ඉංග්‍රීසි ආධිපත්‍යය සැලකිල්ලට ගෙන, ඔබ බොහෝ විට යොමුවිය යුත්තේ 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, StringComparison )
• String.Contains (String, StringComparison )

උදාහරණයක්:

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

කාලයාගේ ඇවෑමෙන්, ඔවුන් බොහෝ විට .NET ප්‍රමිතියට සහ එතැන් සිට මූලික පන්ති පුස්තකාලයේ අනෙකුත් සියලුම ක්‍රියාත්මක කිරීම් වලට පිවිසෙනු ඇත.

පිළිතුර සමඟ ඇති එක් ගැටළුවක් නම්, නූලක් ශුන්‍ය නම් එය ව්‍යතිරේකයක් විසි කරයි. ඔබට එය චෙක්පතක් ලෙස එකතු කළ හැකි බැවින් එය එසේ නොවේ:

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සංස්කෘතික-අ nost ෙයවාදී නූල් ගැලපීම සඳහා ඔබගේ ආරක්ෂිත පෙරනිමිය ලෙස සැසඳීම් සඳහා .
• StringComparison.OrdinalIgnoreCaseවැඩි වේගය සඳහා සැසඳීම් භාවිතා කරන්න .
• භාවිත StringComparison.CurrentCulture-basedප්‍රතිදානය පරිශීලකයාට පෙන්වන විට සංගීත මෙහෙයුම් .
• භාෂාමය නොවන StringComparison.Ordinalහෝ StringComparison.OrdinalIgnoreCaseසංසන්දනය කරන විට භාවිතා කිරීම සඳහා ආක්‍රමණික සංස්කෘතිය මත පදනම් වූ නූල් මෙහෙයුම් වල වර්තමාන භාවිතය මාරු කරන්න
  භාෂාමය වශයෙන් අදාළ නොවන විට (සංකේතාත්මක, උදාහරණයක් ලෙස).
• භාවිතා ToUpperInvariantකරනවාට වඩා ToLowerInvariantසැසඳීම් සඳහා විට සාමාන්ය අගයකට නූල්.

නොකළ යුතු දේ

• නූල් සංසන්දනය කිරීමේ යාන්ත්‍රණය පැහැදිලිව හෝ ව්‍යංගයෙන් නිශ්චිතව දක්වා නැති නූල් මෙහෙයුම් සඳහා අධි බර භාවිතා කරන්න.
• බොහෝ අවස්ථාවන්හි StringComparison.InvariantCultureපාදක නූල්
  මෙහෙයුම් භාවිතා කරන්න ; ව්යතිරේක කිහිපයෙන් එකක් වන්නේ
  භාෂාමය අර්ථවත් නමුත් සංස්කෘතික-අ nost ෙයවාදී දත්ත දිගටම පැවතීමයි.

මෙම නීති මත පදනම්ව ඔබ භාවිතා කළ යුත්තේ:

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.IsMatch(title, "string", RegexOptions.IgnoreCase);

මෙය C # නොවන බව මම දනිමි, නමුත් රාමුව තුළ (VB.NET) දැනටමත් එවැනි ශ්‍රිතයක් ඇත

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

සී # ප්‍රභේදය:

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

මෙම InStrඔබ ජාත්යන්තරකරණය (හෝ ඔබ එය reimplement හැකි) ගැන සැලකිල්ලක් නම් 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);

මෙය මෙහි ඇති අනෙක් උදාහරණයට බෙහෙවින් සමාන ය, නමුත් වෙනත් විකල්ප සාමාන්‍යයෙන් අවශ්‍ය නොවන නිසා ප්‍රාථමිකව එනුම් බූල් කිරීමට සරල කිරීමට මම තීරණය කර ඇත්තෙමි. මෙන්න මගේ උදාහරණය:

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

සරල හා ක්රියාකාරී ලෙස

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

ඔබේ සම්මත නූල් නූල් වලින් තිබේදැයි පරීක්ෂා කිරීමට ඔබට අවශ්‍ය නම් ඒ සඳහා සරල ක්‍රමයක් ඇත.

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

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

මෙම බූලියන් අගය නූල් අඩංගුද නැද්ද යන්න නැවත ලබා දෙනු ඇත

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.