remove duplicate from list in object c#

Set-based operations like Distinct and DistinctBy need a way of determining whether two values are the same. You're using DistinctBy, so you're already asking MoreLINQ to compare the "inner lists" for equality - but you're not saying how to do that.

List<T> doesn't override Equals or GetHashCode, which means it inherits the reference equality behaviour from System.Object. In other words, if you create two separate List<T> objects, they won't compare as equal, even if they have the same content. For example:

List<int> list1 = new List<int>();
List<int> list2 = new List<int>();
Console.WriteLine(list1.Equals(list2)); // False

You need to tell DistinctBy how you want to compare the two lists, using an IEqualityComparer<T> - where T in this case is List<string> (because that's the type of BoardInformation.positionQueen.

Here's an example of a generic ListEqualityComparer you could use:

using System;
using System.Collections.Generic;
using System.Linq;

public sealed class ListEqualityComparer<T> : IEqualityComparer<List<T>>
{
    private readonly IEqualityComparer<T> elementComparer;

    public ListEqualityComparer(IEqualityComparer<T> elementComparer) =>
        this.elementComparer = elementComparer;

    public ListEqualityComparer() : this(EqualityComparer<T>.Default)
    {
    }

    public bool Equals(List<T> x, List<T> y) =>
        ReferenceEquals(x, y) ? true
        : x is null || y is null ? false
        // Delegate to LINQ's SequenceEqual method
        : x.SequenceEqual(y, elementComparer);

    public int GetHashCode(List<T> obj)
    {
        if (obj is null)
        {
            return 0;
        }
        // Just a very simple hash implementation
        int hash = 23;
        foreach (var item in obj)
        {
            hash = hash * 31 +
                (item is null ? 0
                 : elementComparer.GetHashCode(item));
        }
        return hash;
    }
}

You'd then pass that to DistinctBy, like this:

// We're fine to use the default *element* comparer (string.Equals etc)
var comparer = new ListEqualityComparer<string>();
boardGenerate = boardGenerate.DistinctBy(x => x.positionQueen, comparer).ToList();

Now DistinctBy will call into the comparer, passing in the lists, and will consider your two BoardInformation objects are equal - so only the first will be yielded by DistinctBy, and you'll end up with a list containing a single item.

It comes down to whether a equality check is using referential equality or value equality...you want value equality based on a specific property and that has to be done by hand.

When there is no IEqualityComparer provided which can used to compare individual objects (which is need by the Distinct call), the system determines the equality from each item's references by using their derived object low level service method call of GetHashCode from each reference; hence a reference difference is done and all your values in the list are unique (not equal) regardless of similar property values.

What you are looking for is to have value equality checked specifically for the nbQueenProperty.

To fully utilize Distinct one must create a IEqualityComparer and modify the GetHashCode. By specifing the hash value which can make objects equal...you can weed out the same positionQueen (or other properties) instances out.

Example

public class MyClass
{
    public string Name { get; set; }
    public int nbQueen { get; set; }
}

Equality comparer to weed out all nbQueen similarities:

class ContactEmailComparer : IEqualityComparer < MyClass >
{
    public bool Equals(MyClass x, MyClass y)
    {
      return x.nbQueen.Equals(y.nbQueen); // Compares by calling each `GetHashCode` 
    }

    public int GetHashCode(MyClass obj)
    {
        return obj.nbQueen.GetHashCode(); // Add or remove other properties as needed.
    }
}

Test code

var original = new List<MyClass>()
{
    new MyClass() { nbQueen = 1, Name="Alpha"   },
    new MyClass() { nbQueen = 1, Name="Omega" },
    new MyClass() { nbQueen = 3, Name="Delta" }

};

IEqualityComparer<MyClass> comparer = new ContactEmailComparer();

var newOne = original.Distinct( comparer ).ToList();

Result of the value of newOne :

To be clear...

... .DistinctBy() command should remove one of the two objects.

Does not remove anything. It returns a reference to a new list that should be distinct via the equality operation. The original list (the reference to it) does not change.

LINQ solution

because you have another List inside your class you can not use District or DistrictBy, alternatively, you can use LINQ to filter the list.

     boardGenerate = (from b in boardGenerate
                      from l in b.positionQueen
                      group new { l,b } by l into g
                      select g.First().b
                      ).ToList();
   // this returns just first duplicate item like district