Byla nejautrus „Yra (eilutė)“

Ar yra būdas padaryti kitą grąžą teisingą?

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

Atrodo, kad nėra perkrovos, kuri leidžia man nustatyti atvejo jautrumą. Šiuo metu aš abu juos TOP, bet tai tik kvaila (ką aš turiu omenyje su i18n problemomis, su kuriomis susiduria su viršutiniu ir apatiniu kūnu).

UPDATE
Tai senas klausimas, ir nuo tada supratau, kad paprašiau paprasto atsakymo į labai didelę ir sudėtingą temą, jei norite ją visiškai ištirti.
Daugeliu atvejų, mono kalba, anglų kalbos kodais, šis atsakymas bus pakankamas. Įtariu, kad dauguma čia atvykstančių žmonių patenka į šią kategoriją, tai yra populiariausias atsakymas.
Tačiau šis atsakymas sukelia būdingą problemą, kuria negalime palyginti teksto registro, neatsižvelgiant į tai, kol žinome, kad abu tekstai yra ta pati kultūra, ir mes žinome, kokia kultūra yra. Tai galbūt mažiau populiarus atsakymas, bet manau, kad tai yra teisingesnė, todėl aš jį pažymėjau.

2534
15 янв. pateikė Borisas Callensas sausio 15 d 2009-01-15 00:39 '09 0:39 2009-01-15 00:39
@ 24 atsakymai

Jei norite patikrinti, ar paragraph eilutėje yra žodinė eilutė (dėka @QuarterMeister)

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

Kai culture yra „ CultureInfo , apibūdinantis kalbą, kuria parašytas tekstas.

Šis sprendimas yra skaidrus atvejo nejautrumo, kuris priklauso nuo kalbos, apibrėžimui . Pavyzdžiui, anglų kalba naudoja I ir I simbolius devintosios raidės viršutinėje ir apatinėje versijose, o turkai naudoja šiuos simbolius vienuoliktosios ir dvyliktosios raidės 29 raidžių raidėmis. „I“ turkų kalba didžiosiomis raidėmis yra nepažįstamas simbolis „İ“.

Taigi, linijos tin ir tin yra tas pats žodis anglų kalba, bet skirtingi žodžiai turkų kalba. Kiek aš suprantu, tai reiškia „dvasia“, o kita - žodis imitacija. (Turksai, ištaisykite mane, jei aš neteisingai, arba pasiūlykite geriausią pavyzdį)

Apibendrinant galima atsakyti tik į klausimą: „Šios dvi eilutės yra tos pačios, tačiau skirtingais atvejais“, jei žinote, kokia kalba yra tekstas. Jei nežinote, turėsite paimti puntą. Turint omenyje anglišką programinės įrangos hegemoniją, tikriausiai turėtumėte pasinaudoti „ CultureInfo.InvariantCulture , nes tai bus neteisinga draugiškai.

1166
17 марта '13 в 21:22 2013-03-17 21:22 atsakymą pateikė pulkininkas Panikas kovo 17 d. 13 val. 21:22 2013-03-17 21:22

Galite naudoti „String.IndexOf“ metodą ir perduoti „ StringComparison.OrdinalIgnoreCase kaip paieškos tipą:

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

Dar geriau apibrėžti naują eilutės išplėtimo būdą:

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

Atkreipkite dėmesį, kad nulinis plitimas ?. Senesnėms versijoms galima įsigyti C # 6.0 (VS 2015)

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

TAIKYMAS:

 string title = "STRING"; bool contains = title.Contains("string", StringComparison.OrdinalIgnoreCase); 
2439
15 янв. Atsakymą pateikė JaredPar, sausio 15 d 2009-01-15 00:44 '09 0:44 2009-01-15 00:44

IndexOf() galite naudoti taip:

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

Kadangi 0 (nulis) gali būti indeksas, patikrinkite -1. Eik

MSDN

Indekso vertė grindžiama nulinės vertės, jei randama ši eilutė, arba -1, jei ne. Jei reikšmė yra String.Empty, grąžinimo reikšmė yra 0.

209
15 янв. Atsakymas pateikiamas mkchandler sausio 15 d 2009-01-15 00:48 '09 0:48 2009-01-15 00:48

Alternatyvus sprendimas naudojant „Regex“:

 bool contains = Regex.IsMatch("StRiNG to search", Regex.Escape("string"), RegexOptions.IgnoreCase); 
118
28 июля '10 в 20:18 2010-07-28 20:18 Atsakymą pateikė Jedas liepos 28 d. 10 val. 20:18 2010-07-28 20:18

Jūs visada galite tiesiog apversti linijas.

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

Oh, tiesiog pamačiau šį paskutinį bitą. Bylos nejautrumas nebūtų toks pat, kaip ir t21, tikriausiai * , o jei našumas nėra problema, nematau problemų, susijusių su kapitalo kopijomis ir jų palyginimu. Galėčiau prisiekti, kad aš kartą matėu atvejį, kai atvejis yra nejautrus ...

67
15 янв. atsakymą pateikė Ed S. Jan 15 2009-01-15 00:42 '09 0:42 2009-01-15 00:42

Viena iš problemų, su kuriomis susiduriama, yra ta, kad ji išmeta išimtį, jei eilutė yra nulinė. Tai galite pridėti kaip čekį, kad:

 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; } 
48
08 дек. Atsakymą pateikė FeiBao 豹 豹 08 dec. 2010-12-08 00:11 '10 - 0:11 2010-12-08 00:11

StringExtension klasė yra kelias į priekį, pridėjau keletą pranešimų, kad pateikčiau visą kodo pavyzdį:

 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
18 нояб. Atsakymą davė Andrew lapkričio 18 d. 2010-11-18 19:48 '10, 19:48, 2010-11-18 19:48

Tai švarus ir paprastas.

 Regex.IsMatch(file, fileNamestr, RegexOptions.IgnoreCase) 
33
09 нояб. atsakymas duotas takirala 09 Lap. 2012-11-09 07:25 '12 at 7:25 2012-11-09 07:25

„OrdinalIgnoreCase“, „CurrentCultureIgnoreCase“ arba „InvariantCultureIgnoreCase“?

Kadangi to nepakanka, čia pateikiamos kelios gairės, kada naudoti:

Dos

  • Naudokite „ StringComparison.OrdinalIgnoreCase kad palygintumėte kaip numatytąjį, kad būtų galima palyginti kultūrą ir agnostiką.
  • Naudokite StringComparison.OrdinalIgnoreCase palyginimus, kad padidintumėte greitį.
  • Naudodami StringComparison.CurrentCulture-based eilutes, kai rodomas išėjimas į vartotoją.
  • Įjunkite dabartinę eilutės operacijų, pagrįstų kultūros invariantu, naudojimą naudoti ne lingvistinę StringComparison.Ordinal .
  • Naudodami ToUpperInvariant , o ne ToLowerInvariant , normalizuodami eilutes palyginimui.

Etiketas

  • Naudokite perkrovą styginių operacijoms, kurios nėra aiškiai naudojamos arba netiesiogiai nurodo eilutės palyginimo mechanizmą.
  • Naudokite StringComparison.InvariantCulture pagrįsta StringComparison.InvariantCulture
    operacijas; viena iš nedaugelio išimčių bus lingvistiškai reikšmingi, bet kultūriniai-agnostiniai duomenys.

Remdamiesi šiomis taisyklėmis, turėtumėte naudoti:

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

kadangi [YourDecision] priklauso nuo pirmiau pateiktų rekomendacijų.

šaltinio nuoroda: http://msdn.microsoft.com/en-us/library/ms973919.aspx

24
17 июня '14 в 13:31 2014-06-17 13:31 atsakymą pateikė Fabianas Bigleris „ Birželio 17 d. 14, 13:31 2014-06-17 13:31

Panašiai:

 string s="AbcdEf"; if(s.ToLower().Contains("def")) { Console.WriteLine("yes"); } 
11
13 июля '14 в 12:54 2014-07-13 12:54 atsakymas pateikiamas cdytoby liepos 13 d. 14 val. 12:54 2014-07-13 12:54

Žinau, kad tai nėra C #, bet sistemoje (VB.NET) jau yra tokia funkcija

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

C variantas:

 string myString = "Hello World"; bool contains = Microsoft.VisualBasic.Strings.InStr(myString, "world"); 
10
09 сент. atsakymas pateikiamas serhio 09 sep . 2011-09-09 16:23 '11 at 16:23 2011-09-09 16:23

„VisualBasic“ surinkimo „ InStr metodas yra geriausias, jei nerimaujate dėl internacionalizacijos (arba galite jį iš naujo apibrėžti). Žvelgiant į jį, dotNeetPeek rodo, kad jis ne tik atsižvelgia į kepurėles ir mažąsias raides, bet ir su kana tipu bei pilnais pusiau pločio simboliais (tai daugiausia taikoma Azijos kalboms, nors yra ir pilno dydžio lotyniškos abėcėlės versijos). Aš praleisiu kai kurias detales, bet žr. Privatų metodą 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); } 
10
06 дек. Casey atsakymas 06 Dec 2013-12-06 17:11 '13, 17:11, 2013-12-06 17:11

Naudokite:

 string.Compare("string", "STRING", new System.Globalization.CultureInfo("en-US"), System.Globalization.CompareOptions.IgnoreCase); 
9
11 июля '11 в 10:53 2011-07-11 10:53 atsakymas pateikiamas mr.martan liepos 11 d. 11 val. 10:53 2011-07-11 10:53

Galiausiai, bendra operacija „yra“ sumažinama iki tokios funkcijos

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

jis gali būti trivialiai suvyniotas į plėtinio versiją, kurioje yra IEnumerable , kaip šis,

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

Dabar bus galima lyginti bet kokias sekas, įskaitant eilutes, nes string įgyvendina „ IEnumerable<char> ,

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

Tačiau, kaip žinote, stygos nėra įprastos, jos yra specializuotos. Žaidime yra du pagrindiniai veiksniai.

  • „Korpuso“ problema, kuri pati turi įvairių atvejų, priklausomai nuo kalbos.
  • Labai sudėtinga problema yra tai, kaip „teksto elementų“ (raidžių / skaičių / simbolių ir kt.) Rinkinį vaizduoja Unicode kodo taškai, o faktinės simbolių sekos gali atstovauti tam tikrą eilutę, detalės išplėsti į šiuos atsakymus .

Grynasis poveikis yra tas pats. Stygos, kurias galite ginčytis, yra lingvistinės, vienodos, jas gali atstovauti skirtingi simbolių deriniai. Be to, realybės taisyklės įvairiose kultūrose skiriasi.

Visa tai veda prie specializuotos eilutės, paremtos „Contains“, kaip šis, įgyvendinimas.

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

Šią funkciją galima panaudoti tam, kad būtų atliktas neatpažįstamas kultūros specifinis „turintis“, kuris veiks nepriklausomai nuo styginių normalizavimo. Pavyzdžiui.

 "testable".Contains("EST", StringComparer.CurrentCultureIgnoreCase) 
8
03 дек. Atsakymą pateikė Jodrell 03 dec. 2014-12-03 18:50 '14 at 18:50 2014-12-03 18:50

Tai paprasčiausias sprendimas.

  1. Pagal indeksą

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

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

     Regex.IsMatch(title, "string", RegexOptions.IgnoreCase); 
6
12 июля '18 в 12:25 2018-07-12 12:25 atsakymas pateikiamas LAV VISHWAKARMA liepos 12 d., 18 val. 12:25 2018-07-12 12:25

RegEx naudojimas yra tiesioginis būdas tai padaryti:

 Regex.IsMatch(title, "string", RegexOptions.IgnoreCase); 
6
18 сент. Atsakymas pateikiamas Stend Sep 18. 2013-09-18 16:08 '13, 16:08, 2013-09-18 16:08

Tai labai panašus į kitą čia pateiktą pavyzdį, tačiau nusprendžiau supaprastinti „bool“, nes paprastai kitos alternatyvos nereikalingos. Štai mano pavyzdys:

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

Ir naudojimas yra kažkas panašaus:

 if( "main String substring".Contains("SUBSTRING", true) ) .... 
5
17 окт. atsakymas suteiktas TarmoPikaro 17 okt. 2015-10-17 10:46 '15, 10:46, 2015-10-17 10:46

Tik .NET Core 2. 0+ (dabar)

.NET Core turi keletą būdų, kaip išspręsti šią problemą nuo 2.0 versijos:

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

Pavyzdys:

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

Laikui bėgant jie greičiausiai pereis prie .NET standarto ir iš ten į visas kitas bazinės klasės bibliotekos programas.

3
13 окт. Mathieu Renda atsakymas, pateiktas spalio 13 d 2018-10-13 12:26 '18 12:26 pm 2018-10-13 12:26

Čia apgauti yra ieškoti eilutės, ignoruojant atvejį, bet išlaikyti tą patį (su tuo pačiu atveju).

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

Išeiti iš „Reset“

2
03 мая '16 в 17:36 2016-05-03 17:36 atsakymas pateiktas p. B. 03 gegužės 16 d. 17:36 2016-05-03 17:36

Galite naudoti funkciją string.indexof () . Tai bus nejautrus atvejis.

2
11 дек. Atsakymą pateikė Okan SARICA 11 d. 2016-12-11 16:39 '16, 16:39 pm 2016-12-11 16:39
 if ("strcmpstring1".IndexOf(Convert.ToString("strcmpstring2"), StringComparison.CurrentCultureIgnoreCase) >= 0){return true;}else{return false;} 
2
26 окт. Atsakymą pateikė Tamilselvan K spalio 26 d 2016-10-26 17:34 '16 at 17:34 pm 2016-10-26 17:34

jei norite patikrinti, ar jūsų eilutė yra eilutėje, tai yra paprastas būdas tai padaryti.

 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
16 нояб. atsakymą pateikė shaishav shukla . 2017-11-16 15:23 '17 15:23 PM 2017-11-16 15:23
 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
14 июня '17 в 6:16 2017-06-14 06:16 galutinį dangų atsakymas buvo pateiktas birželio 14 d. 17, 16:16 2017-06-14 06:16

Lengvas būdas naujokams:

 title.ToLower().Contains("string");//of course "string" is lowercase. 
-4
17 апр. Atsakymas pateikiamas O Thạnh Ldt 17 Bal. 2017-04-17 11:04 '17, 11:04, 2017-04-17 11:04

Kiti klausimai apie žymių arba Užduoti klausimą