केस असंवेदनशील 'सम्‍मिलित (स्ट्रिंग)'

2907

क्या निम्नलिखित वापसी को सच करने का एक तरीका है?

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

ऐसा प्रतीत नहीं होता है कि मुझे मामला संवेदनशीलता सेट करने की अनुमति मिलती है .. वर्तमान में मैं उन दोनों को अपडेट करता हूं, लेकिन यह सिर्फ मूर्खतापूर्ण है (जिसके द्वारा मैं i18n मुद्दों का उल्लेख कर रहा हूं जो ऊपर और नीचे आवरण के साथ आते हैं)।

अद्यतन
यह प्रश्न प्राचीन है और तब से मैंने महसूस किया है कि मैंने वास्तव में विशाल और कठिन विषय के लिए एक सरल उत्तर मांगा है यदि आप पूरी तरह से जांच करना चाहते हैं।
अधिकांश मामलों के लिए, मोनो-लिंगुअल में, अंग्रेजी कोड आधार यह उत्तर पर्याप्त होगा। मुझे संदेह है क्योंकि यहां आने वाले अधिकांश लोग इस श्रेणी में आते हैं यह सबसे लोकप्रिय उत्तर है।
यह जवाब हालांकि अंतर्निहित समस्या को सामने लाता है कि हम पाठ मामले की तुलना असंवेदनशील नहीं कर सकते हैं जब तक कि हम जानते हैं कि दोनों ग्रंथ एक ही संस्कृति नहीं हैं और हम जानते हैं कि संस्कृति क्या है। यह शायद एक कम लोकप्रिय उत्तर है, लेकिन मुझे लगता है कि यह अधिक सही है और इसलिए मैंने इसे इस तरह से चिह्नित किया है।

c# string contains case-insensitive

— बोरिस कॉलेंस
स्रोत

1398

यह जांचने के लिए कि क्या स्ट्रिंग paragraphमें स्ट्रिंग है word(धन्यवाद @QuarterMeister)

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

पाठ में लिखी गई भाषा cultureका CultureInfoवर्णन करने का उदाहरण कहां है ।

यह समाधान केस-असंवेदनशीलता की परिभाषा के बारे में पारदर्शी है, जो भाषा पर निर्भर है । उदाहरण के लिए, अंग्रेजी भाषा अक्षरों का उपयोग करती है Iऔर iनौवें अक्षर के ऊपरी और निचले केस संस्करणों के लिए, जबकि तुर्की भाषा इन अक्षरों का उपयोग अपने 29 अक्षर-लंबे वर्णमाला के ग्यारहवें और बारहवें अक्षरों के लिए करती है। 'I' का तुर्की ऊपरी मामला संस्करण अपरिचित चरित्र 'of' है।

इस प्रकार तार tinऔर अंग्रेजी मेंTIN एक ही शब्द हैं , लेकिन तुर्की में अलग-अलग शब्द । जैसा कि मैं समझता हूं, एक का अर्थ है 'आत्मा' और दूसरा एक ओनोमेटोपोइया शब्द है। (तुर्क, कृपया मुझे सही करें अगर मैं गलत हूं, या बेहतर उदाहरण सुझाता हूं)

संक्षेप में, आप केवल प्रश्न का उत्तर दे सकते हैं 'ये दो तार एक ही हैं लेकिन विभिन्न मामलों में' यदि आप जानते हैं कि पाठ किस भाषा में है । यदि आप नहीं जानते हैं, तो आपको एक पंट लेना होगा। सॉफ्टवेयर में अंग्रेजी के आधिपत्य को देखते हुए, आपको संभवतः इसका सहारा लेना चाहिए CultureInfo.InvariantCulture, क्योंकि यह परिचित तरीकों से गलत होगा।

— कर्नल आतंक
स्रोत

67

क्यों नहीं culture.CompareInfo.IndexOf(paragraph, word, CompareOptions.IgnoreCase) >= 0? यह सही संस्कृति का उपयोग करता है और केस-असंवेदनशील है, यह अस्थायी लोअरकेस स्ट्रिंग्स को आवंटित नहीं करता है, और यह इस सवाल से बचता है कि क्या लोअरकेस में तुलना करना और तुलना करना हमेशा केस-असंवेदनशील तुलना के समान है।

— क्वार्टरमाइस्टर

9

यह समाधान अनावश्यक रूप से उस ढेर को प्रदूषित करता है जो एक खोज कार्य के लिए मेमोरी आवंटित करके करता है

— JaredPar

15

ToLower () के साथ तुलना करने पर केस-असंवेदनशील IndexOf से अलग-अलग परिणाम मिलेंगे जब दो अलग-अलग अक्षरों में एक ही निचला अक्षर होगा। उदाहरण के लिए, यू + 0398 "ग्रीक कैपिटल लेटर थीटा" या यू + 03 एफ 4 "ग्रीक कैपिटल लेटर थीटा सिंबल" को यू + 03 बी 8, "ग्रीक स्मॉल लेटर थेटा" में परिणाम देने पर कॉल किया जाता है, लेकिन कैपिटल अक्षरों को अलग माना जाता है। दोनों समाधान समान कैपिटल अक्षर के साथ लोअरकेस अक्षरों को अलग-अलग मानते हैं, जैसे कि U + 0073 "लैटिन स्मॉल लेटर S" और U + 017F "लैटिन स्मॉल लेटर लॉन्ग S", इसलिए इंडेक्सऑफ समाधान अधिक सुसंगत लगता है।

— क्वार्टरमेस्टर

3

@Quartermeister - और BTW, मेरा मानना है कि .NET 2 और .NET 4 इस पर अलग-अलग व्यवहार करते हैं। .NET 4 हमेशा NORM_LINGUISTIC_CASING का उपयोग करता है जबकि .NET 2 नहीं किया था (यह झंडे विंडोज विस्टा के साथ दिखाई दिए हैं)।

— साइमन मूरियर

10

आपने "ddddfg" .IndexOf ("Df", StringComparison.OrdinalIgnoreCase) क्यों नहीं लिखा?

— चेन

2712

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

— JaredPar
स्रोत

3

महान स्ट्रिंग विस्तार विधि! मैंने स्रोत स्ट्रिंग की जाँच करने के लिए मेरा संपादन किया है, किसी भी ऑब्जेक्ट संदर्भ त्रुटियों को प्रदर्शन करते समय होने से रोकने के लिए अशक्त नहीं है। IndexOf ()।

— रिचर्ड पर्सहाउस

8

यह paragraph.ToLower(culture).Contains(word.ToLower(culture))साथ ही जवाब देता है CultureInfo.InvariantCultureऔर यह किसी भी स्थानीयकरण मुद्दों को हल नहीं करता है। क्यों उलझी बातें? stackoverflow.com/a/15464440/284795

— कर्नल पैनिक

60

@ColonelPanic ToLowerसंस्करण में 2 आवंटन शामिल हैं जो एक तुलना / खोज ऑपरेशन में अनावश्यक हैं। अनावश्यक रूप से ऐसे परिदृश्य में क्यों आवंटित किया जाता है जिसकी आवश्यकता नहीं है?

— जारेदपार

4

@Seabiscuit कि नहीं होगा काम क्योंकि stringहै एक IEnumerable<char>इसलिए आप इसका इस्तेमाल नहीं कर सकते सबस्ट्रिंग खोजने के लिए

— JaredPar

6

चेतावनी का एक शब्द: string.IndexOf(string)वर्तमान संस्कृति string.Contains(string)का उपयोग करने के लिए डिफ़ॉल्ट है, जबकि डिफ़ॉल्ट के लिए क्रमिक तुलनित्र का उपयोग करना है। जैसा कि हम जानते हैं, पूर्व को लंबे समय तक अधिभारित किया जा सकता है, जबकि बाद को बदला नहीं जा सकता। इस असंगति का एक परिणाम निम्नलिखित कोड नमूना है:

Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;        string self = "Waldstrasse";       string value = "straße";        Console.WriteLine(self.Contains(value));/* False */       Console.WriteLine(self.IndexOf(value) >= 0);/* True */

— जेपी स्टिग नीलसन

231

आप 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 है।

— mkchandler
स्रोत

148

रेगेक्स का उपयोग करके वैकल्पिक समाधान:

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

— जेड
स्रोत

6

अच्छा विचार, RegexOptions.IgnoreCase & RegexOptions.IgnorePatternWhitespace & RegexOptions.CultureInvariant;अगर हम मदद करता है, तो किसी के लिए भी RegexOptions में बहुत से बिटवाइज़ संयोजन हैं ।

— सरवनन

7

मुझे कहना चाहिए कि मैं इस विधि को पसंद करता हूं, हालांकि इस्मैच फॉर नीटनेस का उपयोग कर रहा हूं।

— 10

31

क्या बुरा है, क्योंकि खोज स्ट्रिंग को रेगेक्स के रूप में व्याख्या किया गया है, कई विराम चिह्नों के कारण गलत परिणाम होंगे (या एक अमान्य अभिव्यक्ति के कारण अपवाद को ट्रिगर किया जाएगा)। के लिए खोज का प्रयास करें "."में"This is a sample string that doesn't contain the search string" । या "(invalid"उस मामले के लिए खोज करने का प्रयास करें ।

— cHao

17

@cHao: उस मामले में, Regex.Escapeमदद कर सकता है। रेगेक्स अभी भी अनावश्यक लगता है जब IndexOf/ विस्तार Containsसरल होता है (और यकीनन अधिक स्पष्ट)।

— दान मँगरेली

6

ध्यान दें कि मैं नहीं कह रहा था कि यह रेगेक्स समाधान जाने का सबसे अच्छा तरीका था। मैं मूल पोस्ट किए गए प्रश्न के उत्तर की सूची में जोड़ रहा था "क्या निम्नलिखित वापसी को सच बनाने का एक तरीका है?"।

— जेड

79

आप हमेशा पहले तारों को ऊपर या नीचे कर सकते हैं।

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

उफ़, बस उस आखिरी बिट को देखा। असंवेदनशील तुलना का मामला वैसे भी *शायद *ऐसा ही होगा , और यदि प्रदर्शन कोई समस्या नहीं है, तो मुझे अपरकेस कॉपी बनाने और उन लोगों की तुलना करने में कोई समस्या नहीं दिखती है। मैं कसम खा सकता था कि मैंने एक बार केस-असंवेदनशील की तुलना एक बार देखी थी ...

— एड एस।
स्रोत

122

"तुर्की परीक्षण" के लिए खोजें :)

— जॉन स्कीट

7

कुछ फ्रांसीसी स्थानों में, अपरकेस अक्षरों में डियाट्रिक्टिक्स नहीं हैं, इसलिए ToUpper () ToLower () से बेहतर नहीं हो सकता है। यदि वे उपलब्ध हैं तो मैं कहूंगा कि वे उचित उपकरण का उपयोग करेंगे - केस-इनसेंटिव तुलना।

— ब्लेयर कॉनरैड

5

ToUpper या ToLower का उपयोग न करें, और जो जॉन स्कीट ने कहा, उसे करें

— पीटर Gfader

14

बस इसे दो साल बाद फिर से देखा और एक नया पतन ... वैसे भी, मैं मानता हूं कि तार की तुलना करने के लिए बेहतर तरीके हैं। हालांकि, सभी प्रोग्राम स्थानीय नहीं होंगे (अधिकांश नहीं होंगे) और कई आंतरिक या फेक ऐप हैं। के बाद से मैं शायद ही सलाह के लिए श्रेय की उम्मीद कर सकता हूँ सबसे अच्छी बात यह है कि मैं भगोड़ा ऐप्स के लिए छोड़ रहा हूँ ... मैं आगे बढ़ रहा हूँ: D

— Ed S.

8

क्या "तुर्की परीक्षण" के लिए खोज "तुर्की टेस्ट" के लिए समान है?

— जैकसन

54

.NET कोर 2.0+ केवल (अब के रूप में)

.NET कोर के पास संस्करण 2.0 से इससे निपटने के लिए कई तरीके हैं:

String.Contains (चार, StringComparison) )
String.Contains (स्ट्रिंग, StringComparison )

उदाहरण:

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

समय के साथ, वे शायद .NET क्लास लाइब्रेरी के अन्य सभी कार्यान्वयनों में .NET मानक और वहाँ से अपना रास्ता बना लेंगे।

— मैथ्यू रेंडा
स्रोत

1

अब .NET मानक 2.1

— Paweł Bulwan

52

उत्तर के साथ एक मुद्दा यह है कि यह एक अपवाद को फेंक देगा यदि एक स्ट्रिंग अशक्त है। आप इसे चेक के रूप में जोड़ सकते हैं ताकि यह न हो:

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

— फेयबाओ ei 飞
स्रोत

8

यदि ToCheck वह खाली स्ट्रिंग है, जिसमें Contains दस्तावेज़ीकरण के अनुसार सही लौटना है: "सही अगर मान इस स्ट्रिंग के भीतर होता है, या यदि मान रिक्त स्ट्रिंग (" ") है, अन्यथा, गलत है।"

— आमरा

3

ऊपर अमुरा की टिप्पणी के आधार पर, सुझाए गए कोड को ठीक करने की आवश्यकता नहीं है? और क्या इसे स्वीकृत उत्तर में नहीं जोड़ा जाना चाहिए, ताकि सबसे अच्छी प्रतिक्रिया पहली हो?

— डेविड व्हाइट

13

अब यह सच हो जाएगा अगर स्रोत एक खाली स्ट्रिंग या अशक्त है कोई फर्क नहीं पड़ता कि क्या जाँच है। यह सही नहीं हो सकता। इंडेक्सऑफ पहले ही सच हो जाता है यदि चेकचेक एक खाली स्ट्रिंग है और स्रोत शून्य नहीं है। यहाँ क्या जरूरत है, अशक्त के लिए एक जाँच है। मेरा सुझाव है कि अगर (स्रोत == null || value == null) गलत है;

— कॉलिन

2

स्रोत कठबोली हो सकता है

— लुकास

1

if (string.IsNullOrEmpty(source)) return string.IsNullOrEmpty(toCheck);

— काइल डेलाने

35

स्ट्रिंगटेक्स्टेंशन क्लास आगे का रास्ता है, मैंने ऊपर दिए गए पदों में से एक जोड़े को एक पूरा कोड उदाहरण दिया है:

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

— एंड्रयू
स्रोत

आप एबट्रस परत को खत्म करने की अनुमति क्यों दे रहे हैं StringComparison?

— l -'''''''--------- '' '' '' '' '' '' '

35

यह साफ और सरल है।

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

— takirala
स्रोत

31

यह एक पैटर्न के खिलाफ मैच करेगा, हालांकि। अपने उदाहरण में, यदि fileNamestrकिसी विशेष regex कैरेक्टर हैं (उदाहरण के लिए *, +, ., आदि) तो आप में काफी एक आश्चर्य के लिए किया जाएगा। इस समाधान को एक उचित Containsकार्य की तरह बनाने का एकमात्र तरीका यह है fileNamestrकि ऐसा करने से बच जाए Regex.Escape(fileNamestr)।

— XåpplI'-I0llwlg'I -

इसके अलावा, एक

— रेक्सक्स को

29

ऑर्डिनलइग्नोरकैस, करंट कल्चर इग्नोरकैस या इनवेरिएंटकल्चरइग्नोरकैस?

चूंकि यह गायब है, यहां कुछ सिफारिशें दी गई हैं कि किसका उपयोग कब किया जाए:

करने योग्य

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

— फेबियन बिगलर
स्रोत

क्या होगा यदि आप जानते हैं कि आपको हमेशा एक अंग्रेजी स्ट्रिंग मिलने वाली है। कौन सा उपयोग करना है?

— BKSpurgeon

1

@BKSpurgeon अगर मुझे कोई फर्क नहीं पड़ता तो मैं OrdinalIgnoreCase का इस्तेमाल करूंगा

— Fabian Bigler

20

ये सबसे आसान उपाय हैं।

के सूचकांक द्वारा

string title = "STRING";

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

मामला बदलकर

string title = "STRING";

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

रेगेक्स द्वारा

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

— लव वशवकरम
स्रोत

11

मुझे पता है कि यह 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");

— Serhio
स्रोत

11

InStrVisualBasic से विधि विधानसभा सबसे अच्छा है अगर आप अंतर्राष्ट्रीयकरण को लेकर चिंतित हैं (या आप इसे reimplement सकता है)। इसे देखते हुए 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);
}

— केसी
स्रोत

11

सिर्फ इस तरह:

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

— cdytoby
स्रोत

3

यह संस्कृति-विशिष्ट नहीं है और कुछ मामलों में विफल हो सकता है। culture.CompareInfo.IndexOf (पैराग्राफ, शब्द, तुलनाओ.इगोरकोरकेस) का उपयोग किया जाना चाहिए।

— हिक्कलन

3

केस-असंवेदनशील स्ट्रिंग तुलना करते समय स्ट्रिंग से बचें। () क्यों? टीएल; डॉ। यह महंगा है क्योंकि एक नया तार "निर्मित" है।

— लियाम

8

इसे इस्तेमाल करो:

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

— mr.martan
स्रोत

26

प्रश्नकर्ता की तलाश Containsनहीं है Compare।

— डकमास्ट्रो

@DuckMaestro, स्वीकृत उत्तर लागू Containsकर रहा है IndexOf। तो यह दृष्टिकोण भी उतना ही सहायक है! इस पृष्ठ पर C # कोड उदाहरण string.Compare () का उपयोग कर रहा है। SharePoint टीम की पसंद!

— वल्केन रैवेन

6

यह यहाँ अन्य उदाहरण के समान है, लेकिन मैंने बूल, प्राथमिक को सरल बनाने का फैसला किया है क्योंकि अन्य विकल्पों की सामान्य रूप से आवश्यकता नहीं है। यहाँ मेरा उदाहरण है:

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

— TarmoPikaro
स्रोत

6

RegEx का उपयोग करना ऐसा करने का एक सीधा तरीका है:

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

— Stend
स्रोत

4

आपका उत्तर बिल्कुल गुप्त के समान है लेकिन, जैसा कि उनके उत्तर पर बताया गया था, यह एक नियमित अभिव्यक्ति से मेल खाएगा, इसलिए यदि आप जिस स्ट्रिंग का परीक्षण कर रहे हैं, उसमें कोई विशेष रेगेक्स वर्ण हैं, तो यह वांछित परिणाम नहीं देगा।

— केसी

2

यह इस उत्तर की एक सीधी प्रतिलिपि है और उसी मुद्दे से ग्रस्त है जैसा कि उस उत्तर में उल्लेखित है

— लियाम

माना। नियमित अभिव्यक्ति का अध्ययन करें

— जेरेड

5

बस यहाँ उत्तर पर निर्माण करने के लिए, आप इसे थोड़ा और अधिक उपयोगकर्ता के अनुकूल बनाने के लिए एक स्ट्रिंग एक्सटेंशन विधि बना सकते हैं:

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

— मेलबर्न डेवलपर
स्रोत

1

मान लीजिए कि आपका पैराग्राफ और शब्द हमेशा एन-यूएस में

— रहेगा

3

एन-यूएस के लिए संस्कृति को मजबूर करने के साथ मुद्दों से बचने के लिए, return CultureInfo.CurrentCulture.CompareInfo.IndexOf(paragraph, word, CompareOptions.IgnoreCase) >= 0;इसके बजाय का उपयोग करें ।

— एंड्रयूवेलन

3

यदि आप जांचना चाहते हैं कि क्या आपका पास स्ट्रिंग स्ट्रिंग में है तो उसके लिए एक सरल विधि है।

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

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

यह बूलियन मान वापस आ जाएगा यदि स्ट्रिंग समाहित है या नहीं

— shaishav शुक्ला
स्रोत

3

सरल और काम करता है

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

— प्रदीप असंका
स्रोत

2

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

— तमिलसेल्वन के
स्रोत

2

आप string.indexof ()फ़ंक्शन का उपयोग कर सकते हैं । यह केस असंवेदनशील होगा

— ओकन सरिका
स्रोत

2

मामले को नज़रअंदाज़ करने के लिए यहाँ ट्रिक को देखना है, लेकिन इसे बिल्कुल उसी (उसी मामले के साथ) रखना है।

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

आउटपुट "रीसेट" है

— Mr.B
स्रोत

-1

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
}

— अंतिम स्वर्ग
स्रोत

-4

नौसिखिया के लिए सरल तरीका:

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

— हे थान लद
स्रोत

केवल गलत होने के लिए डाउनवोट करें। क्या होगा अगर शीर्षक = StRiNg? StRiNg! = String और StRiNg! = STRING

— berniefitz

मैं गलत था। उत्तर को निम्नानुसार संपादित करें, बहुत सरल सरल: <br/> शीर्षक। फोटो ()। इसमें शामिल हैं ("स्ट्रिंग") // बेशक "स्ट्रिंग" लोअरकेस है

— हे Thhnh Ldt