LINQ operador Distinct, ignorar caso?

Dado el siguiente ejemplo sencillo:

    List<string> list = new List<string>() { "One", "Two", "Three", "three", "Four", "Five" };

    CaseInsensitiveComparer ignoreCaseComparer = new CaseInsensitiveComparer();

    var distinctList = list.Distinct(ignoreCaseComparer as IEqualityComparer<string>).ToList();

Parece que el CaseInsensitiveComparer no está siendo utilizado para hacer una mayúsculas y minúsculas comparación.

En otras palabras distinctList contiene el mismo número de elementos que lista. En lugar de eso me sería de esperar, por ejemplo, «Tres» y «tres» se consideran iguales.

Que me estoy perdiendo algo o esto es un problema con el operador Distinct?

InformationsquelleAutor Ash | 2008-11-12

4 Kommentare

211

StringComparer hace lo que usted necesita:

List<string> list = new List<string>() {
    "One", "Two", "Three", "three", "Four", "Five" };

var distinctList = list.Distinct(
    StringComparer.CurrentCultureIgnoreCase).ToList();

(o invariante /ordinal /etc dependiendo de los datos que se comparan)

InformationsquelleAutor Marc Gravell

5

[Marc Gravells respuesta si desea que el más conciso de enfoque]

Después de algunas investigaciones y buenos comentarios de Bradley Grainger he implementado las siguientes IEqualityComparer. Es suports un insensible a mayúsculas-minúsculas Distintas() instrucción (acaba de pasar una instancia de este para el operador Distinct) :
```
class IgnoreCaseComparer : IEqualityComparer<string>
{
    public CaseInsensitiveComparer myComparer;

    public IgnoreCaseComparer()
    {
        myComparer = CaseInsensitiveComparer.DefaultInvariant;
    }

    public IgnoreCaseComparer(CultureInfo myCulture)
    {
        myComparer = new CaseInsensitiveComparer(myCulture);
    }

    #region IEqualityComparer<string> Members

    public bool Equals(string x, string y)
    {
        if (myComparer.Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public int GetHashCode(string obj)
    {
        return obj.ToLower().GetHashCode();
    }

    #endregion
}
```
- Usted simplemente no necesita esto. Ver mi respuesta.
- Sí, su respuesta llegó justo cuando yo estaba haciendo click en «Publicar Su Respuesta».
- Ellos fueron, sin duda, con <20 segundos cada uno, creo recordar. Aún así, la implementación de algo como IEqualityComparer<T> todavía es un ejercicio útil, si sólo para la comprensión de cómo funciona…
- Gracias de nuevo, voy a dejar que esto esta respuesta en vivo luego, a menos de que alguien se opone firmemente.
- Este ejemplo produce un error cuando se inicializa para el tr-TR de la cultura si la cultura actual es en-US, porque GetHashCode se reportan diferentes valores de I (U+0049) y ı (U+0131), mientras que Equivale se consideran iguales.
InformationsquelleAutor Ash

Aquí es una versión más simple.

List<string> list = new List<string>() { "One", "Two", "Three", "three", "Four", "Five" };

var z = (from x in list select new { item = x.ToLower()}).Distinct();

z.Dump();

InformationsquelleAutor

 ## Distinct Operator( Ignoring Case) ##
  string[] countries = {"USA","usa","INDIA","UK","UK" };

  var result = countries.Distinct(StringComparer.OrdinalIgnoreCase);

  foreach (var v in result) 
  { 
  Console.WriteLine(v);
  }

De salida será

   USA 
   INDIA
   UK

Por favor, evitar el desplazamiento de fragmentos de código sin explicación. Edita tu respuesta y añadir un cuerpo a ella. Gracias.

InformationsquelleAutor Javed Ahmad

Kommentieren Sie den Artikel Antwort abbrechen

Bitte geben Sie Ihren Kommentar ein!

Bitte geben Sie hier Ihren Namen ein

Sie haben eine falsche E-Mail-Adresse eingegeben!

Bitte geben Sie hier Ihre E-Mail-Adresse ein

Pruebas en línea

Java Core

PHP

LINQ operador Distinct, ignorar caso?

4 Kommentare

Kommentieren Sie den Artikel Antwort abbrechen

Pruebas en línea

Preguntas relacionadas

Expresión regular de patrón de números seguidos de un carácter

Desplácese TreeView seleccionado nodo en la vista

La sustitución de «==» con operadores bit a bit