LINQ Select Distinct с анонимными типами

Итак, у меня есть коллекция предметов. Точный тип не важен. Из него я хочу извлечь все уникальные пары пары определенных свойств, таким образом:

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

Итак, мой вопрос: будет ли Distinct в этом случае использовать объект по умолчанию, равный (что будет бесполезно для меня, поскольку каждый объект является новым), или можно сказать, что он должен делать разные равенства (в данном случае, равные значения Alpha и Bravo => равные случаи)? Есть ли способ достичь этого результата, если он этого не делает?

Прочитайте отличный пост К. Скотта Аллена здесь:

И Равенство для Всех ... Анонимные Типы

Краткий ответ (и я цитирую):

Оказывается, компилятор C # переопределяет Equals и GetHashCode для анонимных типов. Реализация двух переопределенных методов использует все открытые свойства типа для вычисления хеш-кода объекта и проверки на равенство. Если два объекта одного и того же анонимного типа имеют одинаковые значения для своих свойств - объекты равны.

Поэтому совершенно безопасно использовать метод Distinct () в запросе, который возвращает анонимные типы.

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

Извините за испорченное форматирование ранее

Интересно, что это работает в C #, но не в VB

Возвращает 26 букв:

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

Возвращает 52 ...

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

Я выполнил небольшой тест и обнаружил, что если свойства являются типами значений, похоже, все работает нормально. Если они не являются типами значений, тогда типу необходимо предоставить собственные реализации Equals и GetHashCode, чтобы он работал. Я думаю, что струны будут работать.

Вы можете создать свой собственный метод Distinct Extension, который принимает лямбда-выражения. Вот пример

Создайте класс, производный от интерфейса 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();
    }       
}

Затем создайте свой метод Distinct Extension

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

Если Alphaи Bravoоба наследуют от общего класса, вы сможете диктовать проверку на равенство в родительском классе путем реализации IEquatable<T>.

Например:

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

Привет, у меня та же проблема, и я нашел решение. Вы должны реализовать интерфейс IEquatable или просто переопределить методы (Equals & GetHashCode). Но это не уловка, уловка в методе GetHashCode. Вы не должны возвращать хеш-код объекта вашего класса, но вы должны возвращать хэш свойства, которое вы хотите сравнить таким образом.

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

Как вы видите, у меня есть класс с именем person, который получил 3 свойства (Name, Age, IsEgyptian «Потому что я есть»). В GetHashCode я вернул хэш свойства Name, а не объекта Person.

Попробуйте, и это будет работать ISA. Спасибо, Модер Садик

Чтобы это работало в VB.NET, вам нужно указать Keyключевое слово перед каждым свойством в анонимном типе, вот так:

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

Я боролся с этим, я думал, что VB.NET не поддерживает этот тип функций, но на самом деле это так.