Insensibile alle maiuscole 'Contiene (stringa)'

C'è un modo per rendere vero il seguente ritorno?

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

Sembra che non ci sia un sovraccarico che mi permetta di impostare la distinzione tra maiuscole e minuscole. Attualmente li AGGIORNO entrambi, ma è solo sciocco (con il quale mi riferisco ai problemi di i18n che derivano dal case su e giù).

AGGIORNAMENTO
Questa domanda è antica e da allora mi sono reso conto di aver chiesto una risposta semplice per un argomento davvero vasto e difficile se ti interessa indagare a fondo.
Nella maggior parte dei casi, nelle basi di codice inglese monolingue questa risposta sarà sufficiente. Sospetto perché la maggior parte delle persone che vengono qui rientrano in questa categoria, questa è la risposta più popolare.
Questa risposta, tuttavia, solleva il problema intrinseco che non possiamo confrontare l'insensibilità alle maiuscole e minuscole fino a quando non sappiamo che entrambi i testi sono la stessa cultura e sappiamo cos'è quella cultura. Questa è forse una risposta meno popolare, ma penso che sia più corretta ed è per questo che l'ho contrassegnata come tale.

Per verificare se la stringa paragraphcontiene la stringa word(grazie @QuarterMeister)

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

Dov'è culturel'istanza di CultureInfodescrivere la lingua in cui è scritto il testo.

Questa soluzione è trasparente sulla definizione di insensibilità al maiuscolo / minuscolo, che dipende dalla lingua . Ad esempio, la lingua inglese utilizza i caratteri Ie iper le versioni maiuscole e minuscole della nona lettera, mentre la lingua turca utilizza questi caratteri per l' undicesima e la dodicesima lettera del suo alfabeto di 29 lettere. La versione turca di "i" è il personaggio sconosciuto "İ".

Quindi le stringhe tine TINsono la stessa parola in inglese , ma parole diverse in turco . A quanto ho capito, uno significa "spirito" e l'altro è una parola di onomatopea. (Turchi, per favore correggetemi se sbaglio, o suggerite un esempio migliore)

Per riassumere, puoi solo rispondere alla domanda "queste due stringhe sono uguali ma in casi diversi" se sai in quale lingua è il testo . Se non lo sai, dovrai prendere un punto. Data l'egemonia inglese nel software, dovresti probabilmente ricorrere a CultureInfo.InvariantCulture, perché sarà sbagliato in modi familiari.

È possibile utilizzare il metodo String.IndexOf e passare StringComparison.OrdinalIgnoreCasecome tipo di ricerca da utilizzare:

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

Ancora meglio sta definendo un nuovo metodo di estensione per stringa:

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

Si noti che la propagazione nulla ?. è disponibile da C # 6.0 (VS 2015), per l'utilizzo con versioni precedenti

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

USO:

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

Puoi usare IndexOf()così:

string title = "STRING";

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

Poiché 0 (zero) può essere un indice, si controlla contro -1.

MSDN

La posizione dell'indice in base zero del valore se viene trovata quella stringa o -1 se non lo è. Se value è String.Empty, il valore restituito è 0.

Soluzione alternativa che utilizza Regex:

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

Puoi sempre solo alzare o ridurre le stringhe prima.

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

Oops, ho appena visto l'ultimo pezzo. Un confronto senza distinzione tra maiuscole e minuscole *probabilmente *farebbe comunque lo stesso, e se le prestazioni non sono un problema, non vedo un problema con la creazione di copie maiuscole e il confronto di quelle. Avrei potuto giurare di aver visto una volta un confronto senza distinzione tra maiuscole e minuscole una volta ...

Solo .NET Core 2.0+ (a partire da ora)

.NET Core ha avuto un paio di metodi per gestirlo dalla versione 2.0:

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

Esempio:

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

Con il passare del tempo, probabilmente entreranno nello standard .NET e, da lì, in tutte le altre implementazioni della libreria di classi base.

Un problema con la risposta è che genererà un'eccezione se una stringa è nulla. Puoi aggiungerlo come segno di spunta in modo che non:

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

La classe StringExtension è la strada da percorrere, ho combinato un paio di post sopra per dare un esempio di codice completo:

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

Questo è pulito e semplice.

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

OrdinalIgnoreCase, CurrentCultureIgnoreCase o InvariantCultureIgnoreCase?

Dato che manca questo, ecco alcuni consigli su quando usare quale:

dos

• Uso StringComparison.OrdinalIgnoreCase per i confronti come valore predefinito sicuro per la corrispondenza di stringhe cultura-agnostiche.
• Usa i StringComparison.OrdinalIgnoreCaseconfronti per aumentare la velocità.
• Utilizzare le StringComparison.CurrentCulture-basedoperazioni di stringa quando si visualizza l'output per l'utente.
• Cambia l'uso corrente delle operazioni di stringa in base alla cultura invariante per usare il non linguistico StringComparison.Ordinalo StringComparison.OrdinalIgnoreCasequando il confronto è
  linguisticamente irrilevante (simbolico, ad esempio).
• Utilizzare ToUpperInvariantpiuttosto che ToLowerInvariantquando si normalizzano le stringhe per il confronto.

cosa non fare

• Utilizzare gli overload per operazioni su stringhe che non specificano in modo esplicito o implicito il meccanismo di confronto delle stringhe.
• Utilizzare le operazioni di StringComparison.InvariantCulturestringa basate
  sulla maggior parte dei casi; una delle poche eccezioni sarebbe il
  persistere di dati linguisticamente significativi ma culturalmente agnostici.

Sulla base di queste regole dovresti usare:

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

mentre [YourDecision] dipende dalle raccomandazioni di cui sopra.

collegamento della fonte: http://msdn.microsoft.com/en-us/library/ms973919.aspx

Queste sono le soluzioni più semplici.

1. Per indice di

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

2. Cambiando caso

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

3. Di Regex

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

So che questo non è il C #, ma nel framework (VB.NET) esiste già una tale funzione

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

Variante C #:

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

Il InStrmetodo dall'assembly VisualBasic è il migliore se si ha una preoccupazione per l'internazionalizzazione (o si potrebbe reimplementarla). Osservandolo, dotNeetPeek mostra che non solo tiene conto di maiuscole e minuscole, ma anche di caratteri kana e caratteri a larghezza intera o a mezza larghezza (principalmente rilevanti per le lingue asiatiche, sebbene esistano anche versioni a larghezza intera dell'alfabeto romano ). Sto saltando alcuni dettagli, ma controlla il metodo privato 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);
}

Proprio come questo:

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

Usa questo:

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

Questo è abbastanza simile ad altri esempi qui, ma ho deciso di semplificare enum to bool, primario perché normalmente non sono necessarie altre alternative. Ecco il mio esempio:

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

E l'uso è qualcosa del tipo:

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

L'uso di un RegEx è un modo semplice per farlo:

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

Solo per basarsi sulla risposta qui, puoi creare un metodo di estensione stringa per renderlo un po 'più user-friendly:

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

se si desidera verificare se la stringa passata è in stringa, esiste un metodo semplice per farlo.

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

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

Questo valore booleano verrà restituito se la stringa è contenuta o meno

Semplice e funziona

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

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

Puoi usare la string.indexof ()funzione. Questo non farà distinzione tra maiuscole e minuscole

Il trucco qui è cercare la stringa, ignorando il caso, ma per mantenerlo esattamente lo stesso (con lo stesso caso).

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

L'output è "Ripristina"

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
}

Modo semplice per i principianti:

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