24 Soru: Harf büyüklüğüne duyarsız 'Contains (string)'

tarafından oluşturulan soru Wed, Jun 6, 2018 12:00 AM

Aşağıdaki dönüşü gerçekleştirmenin bir yolu var mı?

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

Büyük küçük harf duyarlılığı ayarlamama izin veren bir aşırı yük yok gibi görünüyor. Şu anda ikisini de YUKARIYORUM, ancak bu çok saçma (bundan dolayı i18n , yukarı ve aşağı kasa ile gelen sorunlar).

GÜNCELLEME
Bu soru çok eskidir ve o zamandan beri tamamen araştırmak istemeniz durumunda gerçekten çok büyük ve zor bir konu için basit bir cevap istediğimi farkettim.
Çoğu durumda, tek dilli, İngilizce kod temelleri bu cevabı yeterli olacaktır. Buraya gelen çoğu insan bu kategoriye girdiğinden şüpheleniyorum çünkü bu en popüler cevap.
Bu cevap ancak Her iki metnin de aynı kültür olduğunu ve bu kültürün ne olduğunu bilene kadar, metnin büyük /küçük harf duyarlılığını karşılaştıramayacağımız içsel problemi ortaya çıkarır. Bu belki daha az popüler bir cevaptır, ancak daha doğru olduğunu düşünüyorum ve bu yüzden bunu böyle işaretledim.

    
2686
24 Yanıtlar                              24                         

paragraph dizesinin word dizesini içerip içermediğini test etmek için (thanks @QuarterMeister)

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

Burada culture, Metnin yazıldığı dili açıklayan CultureInfo .

Bu çözüm, dile bağlı olan ve büyük /küçük harfe duyarsızlık tanımı konusunda şeffaftır. Örneğin, İngilizce, dokuzuncu mektubun büyük ve küçük harfleri için I ve i karakterlerini kullanırken, Türkçe dili onbirinci ve onikinci harfleri . 'İ' türküsü büyük harf; 'İ' yabancı karakterdir.

Böylece, tin ve TIN karakterleri İngilizce kelimesiyle aynıdır, fakat farklı kelimeler Türkçe'dir . Anladığım kadarıyla biri "ruh" diğeri onomatopoeia kelimesi. (Türkler, lütfen hatalıysam düzeltin veya daha iyi bir örnek önerin)

Özetlemek gerekirse, yalnızca metnin hangi dilde olduğunu biliyorsanız, 'bu iki dize aynı ancak farklı durumlarda' sorusunu yanıtlayabilirsiniz. Eğer bilmiyorsanız, bir kumar oynamak zorunda kalacaksınız. İngilizcenin yazılımdaki hegemonyası göz önüne alındığında, muhtemelen olacağı için CultureInfo.InvariantCulture adresine başvurmalısınız. tanıdık şekillerde yanlış.

    
1258
2017-08-10 12: 06: 38Z
  1. Neden culture.CompareInfo.IndexOf(paragraph, word, CompareOptions.IgnoreCase) >= 0 değil? Bu, doğru kültürü kullanır ve büyük /küçük harf duyarlı değildir, geçici küçük harfli dizeler ayırmaz ve küçük harfe dönüştürmenin ve karşılaştırmanın her zaman büyük /küçük harf duyarlı olmayan bir karşılaştırmayla aynı olup olmadığı sorusundan kaçınır.
    2013-03-18 15: 32: 39Z
  2. Bu çözüm aynı zamanda bir arama işlevinin ne olması gerektiğine yönelik bir bellek ayırarak da gereksiz yere kirletir
    2013-03-18 16: 09: 38Z
  3. ToLower () ile karşılaştırma, iki farklı harfin aynı küçük harfe sahip olması durumunda, büyük /küçük harf duyarlı bir IndexOf'tan farklı sonuçlar verecektir. Örneğin, U + 0398 "Yunan Büyük Harf Theta" veya U + 03F4 "Yunan Büyük Harf Theta Sembolü" nde ToLower () kullanılması U + 03B8, "Yunan Küçük Harf Theta" ile sonuçlanır, ancak büyük harfler farklı olarak kabul edilir. Her iki çözüm de, U + 0073 "Latin Küçük Harf S" ve U + 017F "Latin Küçük Harfli Uzun S" gibi aynı büyük harfli küçük harfleri dikkate alır, bu nedenle IndexOf çözümü daha tutarlı görünüyor.
    2013-03-18 17:47:27Z
  4. bütünlük için + 1 - uygun bir açıklama biçimiyle cevaplar, kullanıcıların gerçekten SO'dan öğrenmelerinin tek yoludur
    2014-05-05 12: 57: 04Z
  5. Neden "ddddfg" yazmadınız. IndexOf ("Df", StringComparison.OrdinalIgnoreCase)?
    2015-08-23 13: 41: 49Z

String.IndexOf Yöntem ve StringComparison.OrdinalIgnoreCase kullanılacak arama türü olarak:

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

Daha da iyisi, string için yeni bir uzantı yöntemi tanımlamaktır:

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

Not, null yayılımın olduğunu unutmayın. ?., C # 6.0'dan (VS 2015) beri kullanılabilir, eski sürümlerde kullanım için

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

KULLANIM:

 
string title = "STRING";
bool contains = title.Contains("string", StringComparison.OrdinalIgnoreCase);
    
2549
2018-05-08 12: 57: 07Z
  1. Harika bir dize uzantısı yöntemi! Kaynak dizginin .IndexOf () gerçekleştirilirken herhangi bir nesne referans hatasının oluşmasını önlemek için boş olmadığını kontrol etmek için benimkileri düzenledim.
    2013-02-08 10: 48: 45Z
  2. Bu, paragraph.ToLower(culture).Contains(word.ToLower(culture)) ile CultureInfo.InvariantCulture ile aynı cevabı verir ve herhangi bir yerelleştirme sorununu çözmez. Neden işleri karmaşıklaştırıyorsun? stackoverflow.com/a/15464440/284795
    2013-03-17 18: 52: 43Z
  3. @ ColonelPanic ToLower sürümü, bir karşılaştırma /arama işleminde gereksiz olan 2 ayırma içerir. Neden gerektirmeyen bir senaryoda gereksiz yere tahsis edilsin?
    2013-03-18 16: 09: 08Z
  4. @ Seabiscuit işe yaramaz çünkü string IEnumerable<char> olduğundan, onu alt dizeleri bulmak için kullanamazsınız
    2014-11-06 17: 55: 52Z
  5. Bir uyarı kelimesi: string.IndexOf(string) için varsayılan, geçerli kültürü kullanırken, string.Contains(string) için varsayılan, sıralı karşılaştırıcıyı kullanmaktır. Bildiğimiz gibi, birincisi değiştirilemez, birincisi daha uzun bir aşırı yük seçiyor olabilir. Bu tutarsızlığın bir sonucu aşağıdaki kod örneğidir: 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 */
    2016-02-18 09: 40: 37Z

IndexOf()’u bunun gibi kullanabilirsiniz:

 
string title = "STRING";

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

0 (sıfır) bir dizin olabileceğinden, -1 ile kontrol edilir.

MSDN

  

Bu dize bulunursa değerin sıfır temelli dizin konumu veya -1   ya değilse. Değer String.Empty ise, dönüş değeri 0'dır.

    
216
2015-09-15 15: 45: 31Z

Regex kullanarak alternatif çözüm:

 
bool contains = Regex.IsMatch("StRiNG to search", Regex.Escape("string"), RegexOptions.IgnoreCase);
    
130
2018-12-17 09: 18: 03Z
  1. İyi Fikir, RegexOptions'da RegexOptions.IgnoreCase & RegexOptions.IgnorePatternWhitespace & RegexOptions.CultureInvariant; gibi yardımcı olan herkes için bir çok bit biti kombinasyonumuz var.
    2011-08-24 04: 36: 30Z
  2. IsMatch'i düzgünlüğü için kullanırken de bu yöntemi tercih etmeliyim.
    2011-09-07 17: 40: 01Z
  3. Daha da kötüsü, arama dizesi bir regex olarak yorumlandığından, bir dizi noktalama işareti hatalı sonuçlara neden olur (veya geçersiz bir ifade nedeniyle bir istisna tetikler). "."’da "This is a sample string that doesn't contain the search string" aramayı deneyin. Veya bunun için "(invalid"'u aramayı deneyin.
    2011-09-09 13: 28: 56Z
  4. @ cHao: Bu durumda, Regex.Escape yardımcı olabilir. IndexOf /uzatma Contains basit (ve tartışmasız daha net) olduğunda Regex hala gereksiz görünüyor.
    2011-09-09 16: 44: 22Z
  5. Bu Regex çözümünün en iyi yol olduğunu ima etmediğime dikkat edin. Ben sadece "Aşağıdaki dönüşü gerçekleştirmenin bir yolu var mı?" Sorusunun asıl sorusuna verilen cevapların listesine ekliyordum.
    2011-09-13 15: 43: 25Z

İlk önce dizeleri her zaman sadece büyük veya küçük harfle kullanabilirsiniz.

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

Maalesef, şu son parçayı gördüm. Bir durumda duyarsız karşılaştırma, * muhtemelen * yine de aynı şeyi yapardı ve performans bir sorun değilse, büyük harfli kopyalar oluştururken ve bunları karşılaştırırken bir sorun görmüyorum. Bir zamanlar büyük-küçük harfe duyarsız bir karşılaştırma yaptığımı yemin edebilirdim ...

    
73
2009-01-14 21: 54: 21Z
  1. İlginç bir şekilde, bu tür bir senaryoda ToLower () kullanımı üzerinde ToUpper () kullanılmasını tavsiye ettim çünkü görünüşe göre ToLower () kesin olarak "sadakatini kaybedebilir" kültürler - yani, iki farklı büyük harf karakter aynı küçük harf karakterine çevrilir.
    2009-01-14 21: 47: 09Z
  2. "Türkiye testi" için ara :) :)
    2009-01-14 21: 48: 30Z
  3. Bazı Fransız yerel ayarlarında, büyük harflerde diakritik yoktur, bu nedenle ToUpper (), ToLower () öğesinden daha iyi olmayabilir. Varsa uygun araçları kullanın derim - büyük-küçük harf karşılaştırması.
    2009-01-14 22: 03: 59Z
  4. ToUpper veya ToLower'ı kullanmayın ve Jon Skeet'in söylediklerini yapın
    2009-08-21 02: 49: 03Z
  5. Bunu iki yıl sonra tekrar gördüm ve yeni bir oy kullandı ... yine de, dizeleri karşılaştırmanın daha iyi yolları olduğunu kabul ediyorum. Ancak, tüm programlar yerelleştirilmeyecek (çoğu olmayacak) ve birçoğu iç veya dış uygulamalardır. Atılabilir uygulamalar için en iyi öneriler için kredi beklemem zor olduğu için ... Devam ediyorum: D
    2011-01-25 07: 28: 26Z

Yanıtla ilgili bir sorun, bir dize boş olduğunda bunun bir istisna atacağıdır. Bunu bir çek olarak ekleyebilirsiniz, böylece olmayacak:

 
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;
} 
    
50
2015-06-05 06: 02: 45Z
  1. toCheck boş dize ise, Belgelere göre doğru değerini döndürmesi gerekiyorsa: "value parametresi bu dize içinde gerçekleşirse veya değer boş dize ise (true ""); aksi takdirde, yanlış. "
    2011-02-16 16: 13: 42Z
  2. Yukarıdaki amurra'nın yorumuna dayanarak, önerilen kodun düzeltilmesi gerekmiyor mu? Ve bu kabul kabul edilmemelidired cevap, böylece en iyi yanıt ilk olur?
    2011-08-30 03: 43: 38Z
  3. Kaynak, boş bir dize veya null ne olursa olsun boş olursa, bu doğru olacaktır. Bu doğru olamaz. Ayrıca eğer toCheck boş bir dizge ise ve Source boş değilse, IndexOf zaten true değerini döndürür. Burada ihtiyaç duyulan şey boş bir çek. Ben öneririm (kaynak == null || değer == null) false döndürür;
    2013-07-01 12: 21: 20Z
  4. Kaynak boş olamaz
    2016-12-14 16: 55: 26Z
  5. if (string.IsNullOrEmpty(source)) return string.IsNullOrEmpty(toCheck);
    2018-04-04 13: 39: 04Z

Bu temiz ve basittir.

 
Regex.IsMatch(file, fileNamestr, RegexOptions.IgnoreCase)
    
35
2018-06-06 14: 54: 20Z
  1. Bu, bir kalıpla eşleşecek. Örneğinizde, fileNamestr herhangi bir özel regex karakterine (örneğin, *, +, ., vb.) Sahipse, oldukça sürpriz yapacaksınız. Bu çözümü Contains gibi düzgün bir şekilde çalışmasını sağlamanın tek yolu fileNamestr yaparak Regex.Escape(fileNamestr)'dan kaçmaktır.
    2013-02-03 15: 18: 36Z

StringExtension sınıfı ileri bir yoldur, tam bir kod örneği vermek için yukarıdaki birkaç yazıyı birleştirdim:

 
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;
    }
}
    
34
2011-01-25 06: 58: 32Z
  1. neden StringComparison üzerinde başka bir soyutlama katmanına izin veriyorsunuz?
    2019-06-20 18: 37: 30Z

OrdinalIgnoreCase, CurrentCultureIgnoreCase veya InvariantCultureIgnoreCase?

Bu eksik olduğundan, hangisinin ne zaman kullanılacağına ilişkin bazı öneriler:

Dos

  • Karşılaştırmalar için StringComparison.OrdinalIgnoreCase kullanın kültür-agnostik dize eşlemesi için güvenli varsayılan olarak.
  • StringComparison.OrdinalIgnoreCase karşılaştırma kullan arttırılmış hız için.
  • StringComparison.CurrentCulture-based string işlemi kullan kullanıcıya çıktıyı görüntülerken.
  • Değişmeyene göre dize işlemlerinin geçerli kullanımını değiştirme Dilbilimsel olmayan StringComparison.Ordinal veya StringComparison.OrdinalIgnoreCase'u kullanarak karşılaştırma yapmak için kültür dilsel olarak alakasız (örneğin sembolik).
  • Ne zaman ToUpperInvariant yerine ToLowerInvariant kullanın. Karşılaştırma için normalleştirme dizeleri.

Yapılmaması Gerekenler

  • Açıkça çalışmayan dizgi işlemleri için aşırı yükler kullanın veya dize karşılaştırma mekanizmasını örtük olarak belirtin.
  • StringComparison.InvariantCulture tabanlı dize kullan
    çoğu durumda işlemler; birkaç istisnadan biri,
    dilsel olarak anlamlı ancak kültürel açıdan agnostik verileri sürdürmek.

Kullanmanız gereken bu kurallara göre:

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

oysa [Kararınız] yukarıdan gelen tavsiyelere bağlıdır.

kaynak bağlantısı: http://msdn.microsoft.com/en-us/library/ms973919 .aspx

    
24
2015-07-23 10: 30: 30Z
  1. eğer her zaman bir ingilizce dize alacağınızı biliyorsanız. hangisini kullanmalı?
    2017-03-23 ​​23: 43: 53Z
  2. @ BKSpurgeon Eğer durum önemli değilse, OrdinalIgnoreCase kullanırdım
    2017-03-24 08: 09: 08Z

Yalnızca .NET Core 2.0+ (şu andan itibaren)

.NET Core, sürüm 2.0'dan bu yana bununla ilgilenmek için bir çift yöntem kullandı:

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

Örnek:

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

Zamanla, muhtemelen .NET Standard’a ve oradan da Temel Sınıf Kütüphanesinin diğer tüm uygulamalarına gireceklerdir.

    
19
2018-11-08 14: 49: 03Z
  1. Sonunda! Kullanılabilir olması uzun zaman aldı ...
    2019-02-12 16: 33: 08Z

Bunlar en kolay çözümlerdir.

  1. Dizine Göre

     
    string title = "STRING";
    
    if (title.IndexOf("string", 0, StringComparison.CurrentCultureIgnoreCase) != -1)
    {
        // contains 
    }
    
  2. Davayı Değiştirerek

     
    string title = "STRING";
    
    bool contains = title.ToLower().Contains("string")
    
  3. Regex'e Göre

     
    Regex.IsMatch(title, "string", RegexOptions.IgnoreCase);
    
12
2018-07-12 09: 25: 53Z
  1. İlk örnek sayesinde greate !!!
    2019-02-26 12: 43: 36Z

Bunun C # olmadığını biliyorum, ancak çerçevede (VB.NET) zaten böyle bir işlev var

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

C # varyantı:

 
string myString = "Hello World";
bool contains = Microsoft.VisualBasic.Strings.InStr(myString, "world");
    
10
2011-09-09 13: 55: 07Z
  1. Dahili olarak nasıl çalıştığını da biliyor musunuz?
    2013-03-18 08: 12: 42Z

Uluslararasılaştırma konusunda endişeniz varsa (veya onu yeniden uygulayabilirseniz), VisualBasic meclisinin InStr yöntemi en iyisidir. DotNeetPeek, sadece büyük harfleri ve küçük harfleri değil, aynı zamanda kana türü ve tam ve yarım genişlikli karakterleri (özellikle Asya dilleri için de geçerli olmasına rağmen, Roma alfabesinin tam sürümleri olmasına rağmen) gösterdiğini gösteriyor ). Bazı ayrıntıları geçiyorum, ancak InternalInStrText özel yöntemine göz atın:

 
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);
}
    
10
2013-12-06 14: 11: 23Z

Aynen böyle:

 
string s="AbcdEf";
if(s.ToLower().Contains("def"))
{
    Console.WriteLine("yes");
}
    
10
2016-07-19 19: 23: 43Z
  1. Bu kültüre özgü değildir ve bazı durumlar için başarısız olabilir. culture.CompareInfo.IndexOf (paragraf, kelime, CompareOptions.IgnoreCase) kullanılmalıdır.
    2014-07-22 07: 50: 47Z
  2. Neden string.ToLower () 'a büyük harf duyarsız dize karşılaştırmaları yapılırken? kaçınılmalıdır? Tl; Dr Bu yeni bir dize" üretildiğinden "maliyetlidir.
    2016-10-10 10: 00: 29Z

Bunu kullan:

 
string.Compare("string", "STRING", new System.Globalization.CultureInfo("en-US"), System.Globalization.CompareOptions.IgnoreCase);
    
9
2013-07-08 08: 10: 58Z
  1. Sorgulayıcı Contains değil Compare'u arıyor.
    2011-07-11 08: 05: 29Z
  2. @ DuckMaestro, kabul edilen cevap Contains ile IndexOf'u uyguluyor. Yani bu yaklaşım eşit derecede faydalıdır! bu sayfadaki C # kodu örneği string.Compare () kullanıyor . SharePoint ekibinin tercihi bu!
    2013-01-05 10: 07: 01Z

RegEx kullanmak, bunu yapmanın düz bir yoludur:

 
Regex.IsMatch(title, "string", RegexOptions.IgnoreCase);
    
6
2016-07-19 19: 23: 19Z
  1. Cevabınız, tam olarak guptat59'ınkiyle aynıdır, ancak, cevabında da belirtildiği gibi, bu, normal bir ifadeyle eşleşir, bu nedenle test ettiğiniz dize, özel regex karakterleri istenen sonucu vermeyecektir.
    2013-12-09 22: 55: 24Z
  2. Bu, bu cevabın düz bir kopyası ve bu sorunun giderilmesi bu cevapta belirtildiği gibi aynı konulardan
    2016-10-10 10: 04: 01Z
  3. @Liam'in vermiş olduğu aynı nedenden dolayı aşağı oy verin
    2017-10-21 04: 28: 02Z
  4. Kabul edildi. Düzenli ifadeleri inceleyin
    2017-12-26 05: 14: 32Z

Bu, buradaki diğer örneğe oldukça benzer, ancak normalde diğer alternatiflere gerek olmadığından, enum'u bool için basitleştirmeye karar verdim. İşte benim örnek:

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

Kullanım ise şöyle bir şey:  

if( "main String substring".Contains("SUBSTRING", true) )
....
    
5
2015-10-17 07: 46: 58Z
 
if ("strcmpstring1".IndexOf(Convert.ToString("strcmpstring2"), StringComparison.CurrentCultureIgnoreCase) >= 0){return true;}else{return false;}
    
2
2016-10-26 14: 34: 14Z

string.indexof () işlevini kullanabilirsiniz. Bu büyük /küçük harf duyarsız olacak

    
2
2016-12-11 13: 41: 20Z

İşin püf noktası ipi aramak, büyük /küçük harfleri görmezden gelmek, ancak tamamen aynı kalmasıdır (aynı durumda).

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

Çıktı "Sıfırla"

    
2
2017-10-31 15: 16: 18Z

Yalnızca buradaki cevabı oluşturmak için, daha küçük bir kullanıcı dostu hale getirmek için bir dize uzantısı yöntemi oluşturabilirsiniz:

 
    public static bool ContainsIgnoreCase(this string paragraph, string word)
    {
        return new CultureInfo("en-US").CompareInfo.IndexOf(paragraph, word, CompareOptions.IgnoreCase) >= 0;
    }
    
1
2019-02-14 08: 53: 57Z
  1. Paragrafınızın ve kelimenizin her zaman en-ABD'de olacağı varsayımıyla
    2019-02-15 13: 42: 59Z
  2. Kültürü ABD'ye zorlamakla ilgili sorunlardan kaçınmak için bunun yerine return CultureInfo.CurrentCulture.CompareInfo.IndexOf(paragraph, word, CompareOptions.IgnoreCase) >= 0;'u kullanın.
    2019-06-13 21: 42: 44Z
 
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
}
    
0
2017-06-14 03: 16: 07Z

aktarılan dizenin dizede olup olmadığını kontrol etmek istiyorsanız, bunun için basit bir yöntem vardır.

 
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
    
0
2017-11-16 12: 23: 46Z

Acemi için basit yol:

 
title.ToLower().Contains("string");//of course "string" is lowercase.
    
- 4
2018-03-23 ​​03: 33: 44Z
  1. Hayır, bu sorunu tamamen çözmez.
    2017-06-23 12: 49: 26Z
  2. Sadece yanlış olduğu için oy verin. Ya eğer başlık = StRiNg? StRiNg! = String ve StRiNg! = STRING
    2017-10-21 04: 30: 54Z
  3. Yanılmışım. Cevabı aşağıdaki gibi çok basit bir şekilde düzenleyin: < br /> title.ToLower () .Tümler ("string") //elbette "string" küçük harfli
    2018-03-23 ​​03: 28: 07Z
kaynak yerleştirildi İşte