How can I distinct with condition?

Question

Here is class UserArrived:

public class UserArrived{
   public string id{get;set;}
}

Here is class OldUser:

public class OldUser{
   public string id{get;set;}
   public DateTime lastArrived{get;set;}
}

And here is class User:

public class User{
   public string id{get;set;}
   public Boolean newUser{get;set;}
}

Finally, here is two List:

List<UserArrived> UserArrivedList=new List<UserArrived>();
List<OldUser> OldUserList=new List<OldUser>();

All the id in each class is unique.

Now I need to combine UserArrived and OldUser to a brand new List<User>.

As we know, the user arrives the shop may is a new user or an old user. If the user id in UserArrived also contains in OldUser, the property newUser in the new List is false for true.

In my opinion, I will combine two List into one first and then use the distinct method to remove the duplicates.

However, it seems the distinct can not run with a condition.

Although I can use several foreach to solve this while I feel it is so troublesome. I want to use something easy just like lambda or linq. How can I achieve this?

=============================

Here is an example of the input:

List<UserArrived> UserArrivedList=new List<UserArrived>(){new UserArrived(){id="A"},new UserArrived(){id="B"},new UserArrived(){id="C"}};
List<OldUser> OldUserList=new List<OldUser>(){new OldUser(){id="B",lastArrived=DateTime.Now}};

the output is:

A,true
B,false
C,true

Answer 1

If I understand your requirement you're saying that if an id is in both lists then the user is an old user, otherwise it is a new user.

So here's the simplest way that I could come up with to do it:

IEnumerable<User> users =
    Enumerable
        .Concat(
            UserArrivedList.Select(i => i.id),
            OldUserList.Select(i => i.id))
        .ToLookup(x => x)
        .Select(x => new User() { id = x.Key, newUser = x.Count() == 1 });

Let's test with some input:

var UserArrivedList = new List<UserArrived>()
{
    new UserArrived() { id = "A" },
    new UserArrived() { id = "B" },
};

var OldUserList = new List<OldUser>()
{
    new OldUser() { id = "B" },
    new OldUser() { id = "C" },
};

Here are my results:

B is the only user who appears in both lists so should be False.

---

So, there's a bit of confusion about the requirements here.

The OP has added a concrete example of the input data and the expected output.

var UserArrivedList = new List<UserArrived>()
{
    new UserArrived() { id = "A" },
    new UserArrived() { id = "B" },
    new UserArrived() { id = "C" }
};

var OldUserList = new List<OldUser>()
{
    new OldUser() { id = "B", lastArrived = DateTime.Now }
};

With this input the OP is expecting True, False, True for A, B, C respectively.

Here is the code of the four current answers:

var results = new []
{
    new
    {
        answered = "Enigmativity",
        users = Enumerable
            .Concat(
                UserArrivedList.Select(i => i.id),
                OldUserList.Select(i => i.id))
            .ToLookup(x => x)
            .Select(x => new User() { id = x.Key, newUser = x.Count() == 1 })
    },
    new
    {
        answered = "JQSOFT",
        users = UserArrivedList.Select(x => x.id)
            .Concat(OldUserList.Select(y => y.id))
            .Distinct()
            .Select(x => new User
            {
                id = x,
                newUser = OldUserList.Count(o => o.id == x) == 0,
            })
    },
    new
    {
        answered = "Anu Viswan",
        users =
            UserArrivedList
                .Join(OldUserList, ual => ual.id, oul => oul.id, (ual, oul) => new User { id = oul.id, newUser = false })
                .Concat(UserArrivedList.Select(x => x.id).Except(OldUserList.Select(x => x.id))
                .Concat(OldUserList.Select(x => x.id).Except(UserArrivedList.Select(x => x.id)))
                .Select(x=> new User{ id = x, newUser = true}))
    },
    new
    {
        answered = "Barns",
        users =
            UserArrivedList.Select(i => i.id)
                .Union(OldUserList.Select(i => i.id))
                .Select(j => new User
                {
                    id = j,
                    newUser =
                        !(UserArrivedList.Select(i => i.id).Contains(j)
                            && OldUserList.Select(i => i.id).Contains(j))})
    }
};

That gives the output of:

So, currently all of the answers presented match the OP's example.

I'd be interested in the OP commenting on this as the input data:

    var UserArrivedList = new List<UserArrived>()
    {
        new UserArrived() { id = "A" },
        new UserArrived() { id = "B" },
    };

    var OldUserList = new List<OldUser>()
    {
        new OldUser() { id = "B" },
        new OldUser() { id = "C" },
    };

When I run this I get this output:

Here three users match and one does not.

This all boils down to what the description means:

As we know, the user arrives the shop may is a new user or an old user. If the user id in UserArrived also contains in OldUser, the property newUser in the new List is false for true.

Answer 2

The thing about LINQ--it isn't always easy. In fact it can get quit cluttered. In the question statement I read,

I want to use something easy just like lambda or linq.

Well, that is relative. But, I think that when using LINQ, one should try to keep it simple. Even break the statement down into multiple statements if necessary. For that reason I propose this solution (demonstrated in a console app):

    static void Main(string[] args)
    {

        Console.WriteLine();
        Console.WriteLine("--------------------Test This Code -----------------------");

        var combined = TestUserCombined();

        //The following is just to demonstrate the list is populated properly
        combined.OrderBy(s => s.id.PadLeft(4, '0')).ToList().ForEach(k => Console.WriteLine($"X id: {k.id} | isNew:{k.newUser}"));
    }

    private static IEnumerable<User> TestUserCombined()
    {
        List<UserArrived> userArrivedList=new List<UserArrived>();
        List<OldUser> oldUserList=new List<OldUser>();

        //populate the lists...
        for(int i = 0; i < 20; i+=2)
        {
            var userArrived = new UserArrived();
            userArrived.id = i.ToString();
            userArrivedList.Add(userArrived);
        }

        for(int i = 0; i < 20; i+=3)
        {
            var oldUser = new OldUser();
            oldUser.id = i.ToString();
            oldUserList.Add(oldUser);
        }

        //Now for the solution...
        var selectedUserArrived = userArrivedList.Select(i => i.id);
        var selectedOldUser = oldUserList.Select(i => i.id);
        var users = selectedUserArrived
                             .Union(selectedOldUser)
                             .Select(j => new User{id=j,newUser=!(selectedUserArrived.Contains(j) && selectedOldUser.Contains(j))});
        return users;
    }

Certainly, this all could have been done in one statement, but I believe this makes it more readable and understandable.

---

EDIT:
There has been some discussion amongst the coders posting solutions as to exactly what conditions must be met in order for the value "newUser" to be set to "true". It was my understanding from the initial posted question that the "id" must be present in both lists "UserArrivedList" AND "OldUserList", but I tend to agree with @JQSOFT that it makes more sense that the only condition that must be met should be that the "id" need only be present in "OldUserList". If that is indeed the case than the Select() expression above should be .Select(j => new User{id=j,newUser=!selectedOldUser.Contains(j)});

Answer 3

Now you need to create a distinct list of User type from two lists of different types; UserArrived and OldUser objects. A user is identified by a unique id of string type.

Accordingly, I'd suggest this:

var users = UserArrivedList.Select(x => x.id)
    .Concat(OldUserList.Select(y => y.id))
    .Distinct()
    .Select(x => new User
    {
        id = x,
        newUser = OldUserList.Count(o => o.id == x) == 0,
    }).ToList();

Which gets the unique ids from both UserArrivedList and OldUserList and creates new User object for each. The OldUserList.Count(o => o.id == x) == 0, assigns false to the newUser property if the user id exists in the OldUserList otherwise true.

Answer 4

I hope I understood your query. One way to achieve this using Linq would be

    var users = UserArrivedList.Join(OldUserList,ual=>ual.id,oul=>oul.id,(ual,oul)=>new User{id=oul.id,newUser=false})
                               .Concat(UserArrivedList.Select(x=>x.id).Except(OldUserList.Select(x=>x.id))
                               .Concat(OldUserList.Select(x=>x.id).Except(UserArrivedList.Select(x=>x.id)))
                               .Select(x=> new User{id=x,newUser=true}));