LINQ to Objects ile çalışmayan ayırt edici

class Program
{
    static void Main(string[] args)
    {
        List<Book> books = new List<Book> 
        {
            new Book
            {
                Name="C# in Depth",
                Authors = new List<Author>
                {
                    new Author 
                    {
                        FirstName = "Jon", LastName="Skeet"
                    },
                     new Author 
                    {
                        FirstName = "Jon", LastName="Skeet"
                    },                       
                }
            },
            new Book
            {
                Name="LINQ in Action",
                Authors = new List<Author>
                {
                    new Author 
                    {
                        FirstName = "Fabrice", LastName="Marguerie"
                    },
                     new Author 
                    {
                        FirstName = "Steve", LastName="Eichert"
                    },
                     new Author 
                    {
                        FirstName = "Jim", LastName="Wooley"
                    },
                }
            },
        };


        var temp = books.SelectMany(book => book.Authors).Distinct();
        foreach (var author in temp)
        {
            Console.WriteLine(author.FirstName + " " + author.LastName);
        }

        Console.Read();
    }

}
public class Book
{
    public string Name { get; set; }
    public List<Author> Authors { get; set; }
}
public class Author
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public override bool Equals(object obj)
    {
        return true;
        //if (obj.GetType() != typeof(Author)) return false;
        //else return ((Author)obj).FirstName == this.FirstName && ((Author)obj).FirstName == this.LastName;
    }

}

Bu, "LINQ in Action" daki bir örneğe dayanmaktadır. 4.16 listesi.

Bu, Jon Skeet'i iki kez basar. Neden? Yazar sınıfında Eşittir yöntemini geçersiz kılmayı bile denedim. Yine de Distinct işe yaramıyor gibi görünüyor. Neyi kaçırıyorum?

Düzenleme: == ve! = Operatör aşırı yüklemesini de ekledim. Hala yardım yok.

 public static bool operator ==(Author a, Author b)
    {
        return true;
    }
    public static bool operator !=(Author a, Author b)
    {
        return false;
    }

LINQ Distinct, özel nesneler söz konusu olduğunda o kadar akıllı değildir.

Tek yaptığı listeye bakmak ve iki farklı nesneye sahip olduğunu görmektir (üye alanları için aynı değerlere sahip olmaları umurunda değildir).

Çözümlerden biri, burada gösterildiği gibi IEquatable arabirimini uygulamaktır .

Yazar sınıfınızı böyle değiştirirseniz çalışmalıdır.

public class Author : IEquatable<Author>
{
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public bool Equals(Author other)
    {
        if (FirstName == other.FirstName && LastName == other.LastName)
            return true;

        return false;
    }

    public override int GetHashCode()
    {
        int hashFirstName = FirstName == null ? 0 : FirstName.GetHashCode();
        int hashLastName = LastName == null ? 0 : LastName.GetHashCode();

        return hashFirstName ^ hashLastName;
    }
}

DotNetFiddle olarak deneyin

Distinct()Başvuru türleri için bir yöntem kontrol referans eşitliği. Bu, aynı değerleri içeren farklı nesneleri değil, tam anlamıyla aynı nesneyi aradığı anlamına gelir.

IEqualityComparer alan bir aşırı yükleme vardır , bu nedenle belirli bir nesnenin diğerine eşit olup olmadığını belirlemek için farklı mantık belirleyebilirsiniz.

Yazarın normalde normal bir nesne gibi davranmasını istiyorsanız (yani yalnızca referans eşitliği), ancak ad değerlerine göre Eşitlik Eşitliğini Ayırmak amacıyla bir IEqualityComparer kullanın . Yazar nesnelerinin her zaman ad değerlerine göre karşılaştırılmasını istiyorsanız, GetHashCode ve Equals'ı geçersiz kılın veya IEquatable'ı uygulayın .

IEqualityComparerArayüzdeki iki üye Equalsve GetHashCode. İki Authornesnenin eşit olup olmadığını belirleme mantığınız, Ad ve Soyad dizelerinin aynı olması gibi görünür.

public class AuthorEquals : IEqualityComparer<Author>
{
    public bool Equals(Author left, Author right)
    {
        if((object)left == null && (object)right == null)
        {
            return true;
        }
        if((object)left == null || (object)right == null)
        {
            return false;
        }
        return left.FirstName == right.FirstName && left.LastName == right.LastName;
    }

    public int GetHashCode(Author author)
    {
        return (author.FirstName + author.LastName).GetHashCode();
    }
}

Uygulamadan Başka bir çözüm IEquatable, Equalsve GetHashCodeLINQs kullanmaktır GroupByyöntem ve IGrouping gelen ilk öğeyi seçin.

var temp = books.SelectMany(book => book.Authors)
                .GroupBy (y => y.FirstName + y.LastName )
                .Select (y => y.First ());

foreach (var author in temp){
  Console.WriteLine(author.FirstName + " " + author.LastName);
}

Kullanıcı tanımlı veri türü listesinden farklı değerler almanın bir yolu daha vardır:

YourList.GroupBy(i => i.Id).Select(i => i.FirstOrDefault()).ToList();

Elbette, farklı bir veri kümesi verecektir.

Distinct()numaralandırılabilir nesneler üzerinde varsayılan eşitlik karşılaştırmasını gerçekleştirir. Eğer geçersiz kılmadıysanız Equals()ve GetHashCode(), o zaman objectreferansları karşılaştıran varsayılan uygulamayı kullanır .

Basit bir çözüm bir eklemektir doğru uygulanmasını Equals()ve GetHashCode()sen (yani Kitap ve Yazar) karşılaştırdığınız nesne grafiğinde katılan tüm sınıflara.

IEqualityComparerArayüzü uygulamaya izin veren bir kolaylık Equals()ve GetHashCode()ayrı bir sınıfta size karşılaştırmanın farklı bir yöntem kullanıyorsanız, karşılaştırmak gerekir, ya da sınıfların iç yapısına erişimi yoktur zaman.

Eşittir () öğesini geçersiz kıldınız, ancak GetHashCode () öğesini de geçersiz kıldığınızdan emin olun.

Yukarıdaki cevaplar yanlış !!! MSDN'de belirtildiği gibi farklı, belirtildiği gibi varsayılan Equator'u döndürür Varsayılan özellik, T türünün System.IEquatable arabirimini uygulayıp uygulamadığını kontrol eder ve eğer öyleyse, bu uygulamayı kullanan bir EqualityComparer döndürür. Aksi takdirde, T tarafından sağlanan Object.Equals ve Object.GetHashCode geçersiz kılmalarını kullanan bir EqualityComparer döndürür.

Bu demek oluyor ki, üstesinden geldiğin sürece Eşittir iyisin.

Kodunuzun çalışmamasının nedeni, ad == soyad'ı kontrol etmenizdir.

bkz. https://msdn.microsoft.com/library/bb348436(v=vs.100).aspx ve https://msdn.microsoft.com/en-us/library/ms224763(v=vs.100).aspx

Hesaplanan Hash'e göre benzersizliği kontrol eden listede uzantı yöntemini kullanabilirsiniz. IEnumerable'ı desteklemek için uzantı yöntemini de değiştirebilirsiniz.

Misal:

public class Employee{
public string Name{get;set;}
public int Age{get;set;}
}

List<Employee> employees = new List<Employee>();
employees.Add(new Employee{Name="XYZ", Age=30});
employees.Add(new Employee{Name="XYZ", Age=30});

employees = employees.Unique(); //Gives list which contains unique objects. 

Uzatma Yöntemi:

    public static class LinqExtension
        {
            public static List<T> Unique<T>(this List<T> input)
            {
                HashSet<string> uniqueHashes = new HashSet<string>();
                List<T> uniqueItems = new List<T>();

                input.ForEach(x =>
                {
                    string hashCode = ComputeHash(x);

                    if (uniqueHashes.Contains(hashCode))
                    {
                        return;
                    }

                    uniqueHashes.Add(hashCode);
                    uniqueItems.Add(x);
                });

                return uniqueItems;
            }

            private static string ComputeHash<T>(T entity)
            {
                System.Security.Cryptography.SHA1CryptoServiceProvider sh = new System.Security.Cryptography.SHA1CryptoServiceProvider();
                string input = JsonConvert.SerializeObject(entity);

                byte[] originalBytes = ASCIIEncoding.Default.GetBytes(input);
                byte[] encodedBytes = sh.ComputeHash(originalBytes);

                return BitConverter.ToString(encodedBytes).Replace("-", "");
            }

Bunu iki yolla başarabilirsiniz:

1. IEquatable arayüzünü Enumerable.Distinct Metodu'nda gösterildiği gibi uygulayabilir veya bu yazıda @ skalb'ın cevabını görebilirsiniz.

2. Nesnenizin benzersiz anahtarı yoksa, nesnenin tüm özelliklerini gruplamanız gereken ve ilk nesneyi seçtikten sonra, farklı nesne listesi elde etmek için GroupBy yöntemini kullanabilirsiniz.

Örneğin aşağıdaki gibi ve benim için çalışıyor:

var distinctList= list.GroupBy(x => new {
                            Name= x.Name,
                            Phone= x.Phone,
                            Email= x.Email,
                            Country= x.Country
                        }, y=> y)
                       .Select(x => x.First())
                       .ToList()

MyObject sınıfı aşağıdaki gibidir:

public class MyClass{
       public string Name{get;set;}
       public string Phone{get;set;}
       public string Email{get;set;}
       public string Country{get;set;}
}

3. Nesnenizin benzersiz anahtarı varsa, onu yalnızca grup halinde kullanabilirsiniz.

Örneğin, nesnemin benzersiz anahtarı Id'dir.

var distinctList= list.GroupBy(x =>x.Id)
                      .Select(x => x.First())
                      .ToList()