Como posso fazer uma comparação de cadeias sem distinção entre maiúsculas e minúsculas?

Como faço para que a linha abaixo não diferencie maiúsculas de minúsculas?

drUser["Enrolled"] = 
      (enrolledUsers.FindIndex(x => x.Username == (string)drUser["Username"]) != -1);

Hoje recebi alguns conselhos que sugeriam o uso de:

x.Username.Equals((string)drUser["Username"], StringComparison.OrdinalIgnoreCase)));

o problema é que não consigo fazer isso funcionar, tentei a linha abaixo, compila, mas retorna os resultados errados, retorna usuários inscritos como não inscritos e usuários não inscritos como inscritos.

drUser["Enrolled"] = 
      (enrolledUsers.FindIndex(x => x.Username.Equals((string)drUser["Username"], 
                                 StringComparison.OrdinalIgnoreCase)));

Alguém pode apontar o problema?

Esta não é a melhor prática no .NET framework (4 e +) para verificar a igualdade

String.Compare(x.Username, (string)drUser["Username"], 
                  StringComparison.OrdinalIgnoreCase) == 0

Use o seguinte

String.Equals(x.Username, (string)drUser["Username"], 
                   StringComparison.OrdinalIgnoreCase) 

O MSDN recomenda:

• Use uma sobrecarga do método String.Equals para testar se duas seqüências são iguais.
• Use as String.Compare e String.CompareTo métodos para classificar cordas, não para verificar se há igualdade .

Você deve usar a String.Comparefunção estática como a seguir

x => String.Compare (x.Username, (string)drUser["Username"],
                     StringComparison.OrdinalIgnoreCase) == 0

Por favor, use isso para comparação:

string.Equals(a, b, StringComparison.CurrentCultureIgnoreCase);

Outras respostas são totalmente válidas aqui, mas, de alguma forma, leva algum tempo para digitar StringComparison.OrdinalIgnoreCasee também usar String.Compare.

Eu codifiquei o método simples de extensão String, onde você pode especificar se a comparação diferencia maiúsculas de minúsculas ou sem maiúsculas e minúsculas com booleano, anexando um trecho de código inteiro aqui:

using System;

/// <summary>
/// String helpers.
/// </summary>
public static class StringExtensions
{
    /// <summary>
    /// Compares two strings, set ignoreCase to true to ignore case comparison ('A' == 'a')
    /// </summary>
    public static bool CompareTo(this string strA, string strB, bool ignoreCase)
    {
        return String.Compare(strA, strB, ignoreCase) == 0;
    }
}

Após toda essa comparação, diminui aproximadamente 10 caracteres - compare:

Antes de usar a extensão String:

String.Compare(testFilename, testToStart,true) != 0

Depois de usar a extensão String:

testFilename.CompareTo(testToStart, true)

Você pode (embora polêmico) estender System.Stringpara fornecer um método de extensão de comparação sem distinção entre maiúsculas e minúsculas:

public static bool CIEquals(this String a, String b) {
    return a.Equals(b, StringComparison.CurrentCultureIgnoreCase);
}

e use como tal:

x.Username.CIEquals((string)drUser["Username"]);

O C # permite que você crie métodos de extensão que podem servir como sugadores de sintaxe em seu projeto, bastante útil, eu diria.

Não é a resposta e eu sei que esta pergunta é antiga e resolvida, eu só queria adicionar esses bits.

Eu acho que você encontrará mais informações neste link:

http://codeidol.com/community/dotnet/controlling-case-sensitivity-when-comparing-two-st/8873/

Use o método estático Compare na classe String para comparar as duas seqüências. Se a comparação não diferencia maiúsculas de minúsculas é determinada pelo terceiro parâmetro de uma de suas sobrecargas. Por exemplo:

string lowerCase = "abc";
string upperCase = "AbC";
int caseInsensitiveResult = string.Compare(lowerCase, upperCase,
  StringComparison.CurrentCultureIgnoreCase);
int caseSensitiveResult = string.Compare(lowerCase,
  StringComparison.CurrentCulture);

O valor caseSensitiveResult é -1 (indicando que lowerCase é "menor que" upperCase) e o caseInsensitiveResult é zero (indicando que lowerCase "é igual a" upperCase)).

Que tal usar StringComparison.CurrentCultureIgnoreCase?

Eu gostaria de escrever um método de extensão para EqualsIgnoreCase

public static class StringExtensions
{
    public static bool? EqualsIgnoreCase(this string strA, string strB)
    {
        return strA?.Equals(strB, StringComparison.CurrentCultureIgnoreCase);
    }
}

você sempre pode usar funções: .ToLower (); .ToUpper ();

converta suas cordas e compare-as ...

Boa sorte