Fatal编程技术网
  • csharp/
  • C# 我怎样才能区分条件？

C# 我怎样才能区分条件？

c# linq lambda

C# 我怎样才能区分条件？,c#,linq,lambda,C#,Linq,Lambda,下面是classUserArrived： public class UserArrived{ public string id{get;set;} } 下面是classOldUser： public class OldUser{ public string id{get;set;} public DateTime lastArrived{get;set;} } public class User{ public string id{get;set;} publi

下面是class
UserArrived
：

public class UserArrived{
   public string id{get;set;}
}
下面是class
OldUser
：

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

public class User{
   public string id{get;set;}
   public Boolean newUser{get;set;}
}
下面是class
User
：

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

public class User{
   public string id{get;set;}
   public Boolean newUser{get;set;}
}
最后，这里有两个
列表
：

List<UserArrived> UserArrivedList=new List<UserArrived>();
List<OldUser> OldUserList=new List<OldUser>();
输出为：

A,true
B,false
C,true
我希望我理解你的疑问。使用Linq实现这一点的一种方法是

    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}));
我希望我理解你的疑问。使用Linq实现这一点的一种方法是

    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}));
现在，您需要从两个不同类型的列表中创建一个不同的
User
类型列表
UserArrived
和
OldUser
对象。用户由字符串类型的唯一
id
标识

因此，我建议：

var users=UserArrivedList.Select（x=>x.id）
.Concat（OldUserList.Select（y=>y.id））
.Distinct（）
.选择（x=>新用户
{
id=x，
newUser=OldUserList.Count（o=>o.id==x）==0，
}).ToList（）；
它从
UserArrivedList
和
OldUserList
获取唯一ID，并为每个ID创建新的
User
对象。
OldUserList.Count（o=>o.id==x）==0，
如果用户
id
存在于
OldUserList
中，则将
false
分配给
newUser
属性，否则
true
现在需要从两个不同类型的列表中创建一个不同的
user
类型列表
UserArrived
和
OldUser
对象。用户由字符串类型的唯一
id
标识

因此，我建议：

var users=UserArrivedList.Select（x=>x.id）
.Concat（OldUserList.Select（y=>y.id））
.Distinct（）
.选择（x=>新用户
{
id=x，
newUser=OldUserList.Count（o=>o.id==x）==0，
}).ToList（）；
它从
UserArrivedList
和
OldUserList
获取唯一ID，并为每个ID创建新的
User
对象。
OldUserList.Count（o=>o.id==x）==0，
如果用户
id
存在于
OldUserList
中，则将
false
分配给
newUser
属性，否则
true
关于LINQ的事情并不总是那么容易。事实上，它会变得杂乱无章。在我读到的问题陈述中

我想用一些简单的东西，比如lambda或linq

嗯，这是相对的。但是，我认为在使用LINQ时，应该尽量保持简单。如果需要，甚至可以将语句分解为多个语句。因此，我提出了此解决方案（在控制台应用程序中演示）：

static void Main（字符串[]args）
{
Console.WriteLine（）；
Console.WriteLine（“-------------------测试此代码-----------------”；
var combined=TestUserCombined（）；
//以下只是为了证明列表已正确填充
combined.OrderBy（s=>s.id.PadLeft（4，'0'））.ToList（）.ForEach（k=>Console.WriteLine（$“X id:{k.id}| isNew:{k.newUser}”）；
}
私有静态IEnumerable TestUserCombined（）
{
List userArrivedList=新列表（）；
List oldUserList=新列表（）；
//填充列表。。。
对于（int i=0；i<20；i+=2）
{
var userarrized=new userarrized（）；
userArrized.id=i.ToString（）；
userArrivedList.Add（userArrivedList）；
}
对于（int i=0；i<20；i+=3）
{
var oldUser=new oldUser（）；
oldUser.id=i.ToString（）；
添加（oldUser）；
}
//现在是解决方案。。。
var selectedUserArrived=userArrivedList.Select（i=>i.id）；
var selectedOldUser=oldUserList.Select（i=>i.id）；
var users=selectedUserArrived
.Union（selectedOldUser）
.Select（j=>newUser{id=j，newUser=！（selectedUserArrived.Contains（j）&&selectedOldUser.Contains（j））；
返回用户；
}

当然，这一切本可以在一份声明中完成，但我相信这使它更具可读性和可理解性

编辑：
在发布解决方案的编码人员之间已经进行了一些讨论，讨论了为了将值“newUser”设置为“true”，必须满足哪些条件。我从最初发布的问题中了解到，“id”必须出现在“UserArrivedList”和“OldUserList”两个列表中，但我倾向于同意@JQSOFT的观点，即必须满足的唯一条件是“id”只需要出现在“OldUserList”中。如果确实是这样，那么上面的
Select（）
表达式应该是
.Select（j=>newUser{id=j，newUser=！selectedOldUser.Contains（j）}）
关于LINQ的事情——它并不总是那么容易。事实上，它会变得杂乱无章。在我读到的问题陈述中

我想用一些简单的东西，比如lambda或linq

嗯，这是相对的。但是，我认为在使用LINQ时，应该尽量保持简单。如果需要，甚至可以将语句分解为多个语句。因此，我提出了此解决方案（在控制台应用程序中演示）：


static void Main（字符串[]args）
{
Console.WriteLine（）；
Console.WriteLine（“-------------------测试此代码-----------------”；
var combined=TestUserCombined（）；
//以下只是为了证明列表已正确填充
combined.OrderBy（s=>s.id.PadLeft（4，'0'））.ToList（）.ForEach（k=>Console.WriteLine（$“X id:{k.id}| isNew:{k.newUser}”）；
}
私有静态IEnumerable TestUserCombined（）
{
List userArrivedList=新列表（）；
List oldUserList=新列表（）；
//填充列表。。。
对于（int i=0；i<20；i+=2）
{
var userarrized=new userarrized（）；
userArrized.id=i.ToString（）；
userArrivedList.Add（userArrivedList）；
}

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



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



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



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