Distinto no funciona con LINQ to Objects

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

}

Esto se basa en un ejemplo de "LINQ en acción". Listado 4.16.

Esto imprime a Jon Skeet dos veces. ¿Por qué? Incluso he intentado anular el método Equals en la clase Author. Still Distinct no parece funcionar. ¿Qué me estoy perdiendo?

Editar: también he agregado == y! = Sobrecarga del operador. Sigo sin ayuda.

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

LINQ Distinct no es tan inteligente cuando se trata de objetos personalizados.

Todo lo que hace es mirar su lista y ver que tiene dos objetos diferentes (no le importa que tengan los mismos valores para los campos miembros).

Una solución es implementar la interfaz IEquatable como se muestra aquí .

Si modifica su clase Author así, debería funcionar.

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

Pruébelo como DotNetFiddle

El Distinct()método verifica la igualdad de referencia para los tipos de referencia. Esto significa que está buscando literalmente el mismo objeto duplicado, no diferentes objetos que contengan los mismos valores.

Hay una sobrecarga que toma IEqualityComparer , por lo que puede especificar una lógica diferente para determinar si un objeto dado es igual a otro.

Si desea que Author se comporte normalmente como un objeto normal (es decir, solo la igualdad de referencia), pero para los propósitos de Distinct comprobar la igualdad por valores de nombre, use un IEqualityComparer . Si siempre desea que los objetos de Autor se comparen en función de los valores de nombre, anule GetHashCode y Equals , o implemente IEquatable .

Los dos miembros de la IEqualityComparerinterfaz son Equalsy GetHashCode. Su lógica para determinar si dos Authorobjetos son iguales parece ser si las cadenas de nombre y apellido son iguales.

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

Otra solución sin implementar IEquatable, Equalsy GetHashCodees utilizar la LINQs GroupBymétodo y para seleccionar el primer elemento de la IGrouping.

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

Hay una forma más de obtener valores distintos de la lista de tipos de datos definidos por el usuario:

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

Seguramente, dará un conjunto de datos distinto

Distinct()realiza la comparación de igualdad predeterminada en objetos en el enumerable. Si no ha anulado Equals()y GetHashCode(), entonces usa la implementación predeterminada en object, que compara referencias.

La solución simple es agregar una implementación correcta de Equals()ya GetHashCode()todas las clases que participan en el gráfico de objetos que está comparando (es decir, Libro y Autor).

La IEqualityComparerinterfaz es una conveniencia que le permite implementar Equals()y GetHashCode()en una clase separada cuando no tiene acceso a las partes internas de las clases que necesita comparar, o si está utilizando un método de comparación diferente.

Has anulado Equals (), pero asegúrate de anular también GetHashCode ()

¡Las respuestas anteriores son incorrectas! Distinto, como se indica en MSDN, devuelve el Equator predeterminado que, como se indica, la propiedad predeterminada comprueba si el tipo T implementa la interfaz System.IEquatable y, de ser así, devuelve un EqualityComparer que usa esa implementación. De lo contrario, devuelve un EqualityComparer que utiliza las anulaciones de Object.Equals y Object.GetHashCode proporcionadas por T

Lo que significa que siempre que anule Equals, está bien.

La razón por la que su código no funciona es porque marca el nombre == apellido.

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

Puede usar el método de extensión en la lista que verifica la unicidad según el Hash calculado. También puede cambiar el método de extensión para admitir IEnumerable.

Ejemplo:

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. 

Método de extensión:

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

Puede lograr esto de dos formas:

1. Puede implementar la interfaz IEquatable como se muestra en el método Enumerable.Distinct o puede ver la respuesta de @ skalb en esta publicación

2. Si su objeto no tiene una clave única, puede usar el método GroupBy para lograr una lista de objetos distintos, que debe agrupar todas las propiedades del objeto y luego seleccionar el primer objeto.

Por ejemplo, como a continuación y trabajando para mí:

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

La clase MyObject es como la siguiente:

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

3. Si su objeto tiene una clave única, solo puede usarlo en el grupo.

Por ejemplo, la clave única de mi objeto es Id.

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