Existe um operador igual a maiúsculas e minúsculas em C #?

Eu sei que o seguinte diferencia maiúsculas de minúsculas:

if (StringA == StringB) {

Então, existe um operador que compare duas strings de maneira insensível?

Tente o seguinte:

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

A melhor maneira de comparar duas cadeias de caracteres ignorando as letras maiúsculas e minúsculas é usar o método estático String.Equals , especificando uma comparação ordinal de letras de maiúsculas e minúsculas . Essa também é a maneira mais rápida, muito mais rápida do que converter as seqüências para minúsculas ou maiúsculas e compará-las depois disso.

Testei o desempenho de ambas as abordagens e a comparação ordinal da cadeia de caracteres ignorar maiúsculas e minúsculas foi 9 vezes mais rápida ! Também é mais confiável do que converter seqüências de caracteres para maiúsculas ou minúsculas (confira o problema do i turco). Portanto, sempre use o método String.Equals para comparar seqüências de caracteres para igualdade:

String.Equals(string1, string2, StringComparison.OrdinalIgnoreCase);

Se você deseja executar uma comparação de cadeias específicas da cultura, pode usar o seguinte código:

String.Equals(string1, string2, StringComparison.CurrentCultureIgnoreCase);

Observe que o segundo exemplo usa a lógica de comparação de strings da cultura atual, o que o torna mais lento que a comparação "caso de ignição ordinal" no primeiro exemplo, portanto, se você não precisar de nenhuma lógica de comparação de strings específica da cultura e estiver após o desempenho máximo, use a comparação "ignorar caso ordinal".

Para mais informações, leia a história completa no meu blog .

Existem várias propriedades na StringComparerclasse estática que retornam comparadores para qualquer tipo de distinção entre maiúsculas e minúsculas que você queira:

StringComparer Propriedades

Por exemplo, você pode ligar

StringComparer.CurrentCultureIgnoreCase.Equals(string1, string2)

ou

StringComparer.CurrentCultureIgnoreCase.Compare(string1, string2)

É um pouco mais limpo do que os string.Equalsou string.Comparesobrecargas que levam um StringComparisonargumento.

System.Collections.CaseInsensitiveComparer

ou

System.StringComparer.OrdinalIgnoreCase

string.Equals(StringA, StringB, StringComparison.CurrentCultureIgnoreCase);

ou

if (StringA.Equals(StringB, StringComparison.CurrentCultureIgnoreCase)) {

mas você precisa ter certeza de que StringA não é nulo. Então provavelmente é melhor usar:

string.Equals(StringA , StringB, StringComparison.CurrentCultureIgnoreCase);

como John sugeriu

EDIT: corrigido o erro

Você pode usar

if (stringA.equals(StringB, StringComparison.CurrentCultureIgnoreCase))

Operador? NÃO, mas acho que você pode mudar sua cultura para que a comparação de cadeias não faça distinção entre maiúsculas e minúsculas.

// you'll want to change this...
System.Threading.Thread.CurrentThread.CurrentCulture
// and you'll want to custimize this
System.Globalization.CultureInfo.CompareInfo

Estou confiante de que isso mudará a maneira como as strings estão sendo comparadas pelo operador igual.

Aqui está uma idéia para simplificar a sintaxe:

public class IgnoreCase
{
    private readonly string _value;

    public IgnoreCase(string s)
    {
        _value = s;
    }

    protected bool Equals(IgnoreCase other)
    {
        return this == other;
    }

    public override bool Equals(object obj)
    {
        return obj != null &&
               (ReferenceEquals(this, obj) || (obj.GetType() == GetType() && this == (IgnoreCase) obj));
    }

    public override int GetHashCode()
    {
        return _value?.GetHashCode() ?? 0;
    }

    public static bool operator ==(IgnoreCase a, IgnoreCase b)
    {
        return string.Equals(a, b, StringComparison.OrdinalIgnoreCase);
    }

    public static bool operator !=(IgnoreCase a, IgnoreCase b)
    {
        return !(a == b);
    }

    public static implicit operator string(IgnoreCase s)
    {
        return s._value;
    }

    public static implicit operator IgnoreCase(string s)
    {
        return new IgnoreCase(s);
    }
}

Utilizável como:

Console.WriteLine((IgnoreCase) "a" == "b"); // false
Console.WriteLine((IgnoreCase) "abc" == "abC"); // true
Console.WriteLine((IgnoreCase) "Abc" == "aBc"); // true
Console.WriteLine((IgnoreCase) "ABC" == "ABC"); // true

Estou tão acostumado a digitar no final desses métodos de comparação: , StringComparison.

Então eu fiz uma extensão.

namespace System
{   public static class StringExtension
    {
        public static bool Equals(this string thisString, string compareString,
             StringComparison stringComparison)
        {
            return string.Equals(thisString, compareString, stringComparison);
        }
    }
}

Observe que você precisará verificar se há nulo thisStringantes de chamar o ext.

string.Compare(string1, string2, true)

if (StringA.ToUpperInvariant() == StringB.ToUpperInvariant()) {

As pessoas relatam que ToUpperInvariant () é mais rápido que ToLowerInvariant ().

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 de extensão String simples, onde você pode especificar se a comparação diferencia maiúsculas de minúsculas ou sem maiúsculas e minúsculas com booleano - veja a resposta a seguir:

https://stackoverflow.com/a/49208128/2338477