LINQ Seleccione distinto con tipos anónimos

Entonces tengo una colección de objetos. El tipo exacto no es importante. De él quiero extraer todos los pares únicos de un par de propiedades particulares, por lo tanto:

myObjectCollection.Select(item=>new
                                {
                                     Alpha = item.propOne,
                                     Bravo = item.propTwo
                                }
                 ).Distinct();

Entonces mi pregunta es: ¿Distinct en este caso usará el objeto predeterminado igual (que será inútil para mí, ya que cada objeto es nuevo) o se le puede pedir que haga un igual diferente (en este caso, valores iguales de Alpha y Bravo => instancias iguales)? ¿Hay alguna forma de lograr ese resultado, si esto no lo hace?

Lee aquí la excelente publicación de K. Scott Allen:

E igualdad para todos ... Tipos anónimos

La respuesta corta (y cito):

Resulta que el compilador de C # anula Equals y GetHashCode para los tipos anónimos. La implementación de los dos métodos anulados utiliza todas las propiedades públicas del tipo para calcular el código hash de un objeto y probar la igualdad. Si dos objetos del mismo tipo anónimo tienen los mismos valores para sus propiedades, los objetos son iguales.

Por lo tanto, es totalmente seguro usar el método Distinct () en una consulta que devuelve tipos anónimos.

public class DelegateComparer<T> : IEqualityComparer<T>
{
    private Func<T, T, bool> _equals;
    private Func<T, int> _hashCode;
    public DelegateComparer(Func<T, T, bool> equals, Func<T, int> hashCode)
    {
        _equals= equals;
        _hashCode = hashCode;
    }
    public bool Equals(T x, T y)
    {
        return _equals(x, y);
    }

    public int GetHashCode(T obj)
    {
        if(_hashCode!=null)
            return _hashCode(obj);
        return obj.GetHashCode();
    }       
}

public static class Extensions
{
    public static IEnumerable<T> Distinct<T>(this IEnumerable<T> items, 
        Func<T, T, bool> equals, Func<T,int> hashCode)
    {
        return items.Distinct(new DelegateComparer<T>(equals, hashCode));    
    }
    public static IEnumerable<T> Distinct<T>(this IEnumerable<T> items,
        Func<T, T, bool> equals)
    {
        return items.Distinct(new DelegateComparer<T>(equals,null));
    }
}

var uniqueItems=students.Select(s=> new {FirstName=s.FirstName, LastName=s.LastName})
            .Distinct((a,b) => a.FirstName==b.FirstName, c => c.FirstName.GetHashCode()).ToList();

Perdón por el mal formato anterior

Interesante que funcione en C # pero no en VB

Devuelve las 26 letras:

var MyBet = "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ";
MyBet.ToCharArray()
.Select(x => new {lower = x.ToString().ToLower(), upper = x.ToString().ToUpper()})
.Distinct()
.Dump();

Devuelve 52 ...

Dim MyBet = "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ"
MyBet.ToCharArray() _
.Select(Function(x) New With {.lower = x.ToString.ToLower(), .upper = x.ToString.ToUpper()}) _
.Distinct() _
.Dump()

Ejecuté una pequeña prueba y descubrí que si las propiedades son tipos de valor, parece funcionar bien. Si no son tipos de valor, entonces el tipo necesita proporcionar sus propias implementaciones Equals y GetHashCode para que funcione. Las cuerdas, creo, funcionarían.

Puede crear su propio método de extensión distinta que toma la expresión lambda. Aquí hay un ejemplo

Cree una clase que se derive de la interfaz IEqualityComparer

public class DelegateComparer<T> : IEqualityComparer<T>
{
    private Func<T, T, bool> _equals;
    private Func<T, int> _hashCode;
    public DelegateComparer(Func<T, T, bool> equals, Func<T, int> hashCode)
    {
        _equals= equals;
        _hashCode = hashCode;
    }
    public bool Equals(T x, T y)
    {
        return _equals(x, y);
    }

    public int GetHashCode(T obj)
    {
        if(_hashCode!=null)
            return _hashCode(obj);
        return obj.GetHashCode();
    }       
}

Luego cree su método de extensión distinta

public static class Extensions
{
    public static IEnumerable<T> Distinct<T>(this IEnumerable<T> items, 
        Func<T, T, bool> equals, Func<T,int> hashCode)
    {
        return items.Distinct(new DelegateComparer<T>(equals, hashCode));    
    }
    public static IEnumerable<T> Distinct<T>(this IEnumerable<T> items,
        Func<T, T, bool> equals)
    {
        return items.Distinct(new DelegateComparer<T>(equals,null));
    }
}

y puedes usar este método para encontrar elementos distintos

var uniqueItems=students.Select(s=> new {FirstName=s.FirstName, LastName=s.LastName})
            .Distinct((a,b) => a.FirstName==b.FirstName, c => c.FirstName.GetHashCode()).ToList();

Si Alphay Bravotanto heredar de una clase común, usted será capaz de dictar la comprobación de la igualdad en la clase padre mediante la implementación IEquatable<T>.

Por ejemplo:

public class CommonClass : IEquatable<CommonClass>
{
    // needed for Distinct()
    public override int GetHashCode() 
    {
        return base.GetHashCode();
    }

    public bool Equals(CommonClass other)
    {
        if (other == null) return false;
        return [equality test];
    }
}

Hola, tuve el mismo problema y encontré una solución. Debe implementar la interfaz IEquatable o simplemente anular los métodos (Equals & GetHashCode). Pero este no es el truco, el truco que viene en el Método GetHashCode. No debe devolver el código hash del objeto de su clase, pero debe devolver el hash de la propiedad que desea comparar de esa manera.

public override bool Equals(object obj)
    {
        Person p = obj as Person;
        if ( obj == null )
            return false;
        if ( object.ReferenceEquals( p , this ) )
            return true;
        if ( p.Age == this.Age && p.Name == this.Name && p.IsEgyptian == this.IsEgyptian )
            return true;
        return false;
        //return base.Equals( obj );
    }
    public override int GetHashCode()
    {
        return Name.GetHashCode();
    }

Como puede ver, obtuve una clase llamada persona que obtuvo 3 propiedades (Nombre, Edad, IsEgyptian "Porque lo soy") En el GetHashCode devolví el hash de la propiedad Nombre, no el objeto Persona.

Pruébalo y funcionará ISA. Gracias Modather Sadik.

Para que funcione en VB.NET, debe especificar la Keypalabra clave antes de cada propiedad en el tipo anónimo, así:

myObjectCollection.Select(Function(item) New With
{
    Key .Alpha = item.propOne,
    Key .Bravo = item.propTwo
}).Distinct()

Estaba luchando con esto, pensé que VB.NET no era compatible con este tipo de característica, pero en realidad lo hace.