C# 我可以对字符串进行条件检查，看看它是否以“结束”结尾吗；00“；在LINQ表达式中？

我正在尝试填充Objective和ObjectiveDetail对象。以下是我的课程：

partial class Objective
{
    public Objective() {
        this.ObjectiveDetails = new List<ObjectiveDetail>();
    }
    public int ObjectiveId { get; set; }
    public string Name { get; set; }
    public string Text { get; set; }
    public virtual ICollection<ObjectiveDetail> ObjectiveDetails { get; set; }
}
public partial class ObjectiveDetail
{
    public int ObjectiveDetailId { get; set; }
    public int ObjectiveId { get; set; }
    public string Text { get; set; }
    public virtual Objective Objective { get; set; }
}

数据如下所示：

 Name   Text 
 0600   header 1 
 0601   detail abc 
 0602   detail def 
 0603   detail ghi 
 0700   header 2 
 0701 detail xyz

是否有一种方法可以修改我的LINQ，以便只有

名称

字段内容以“00”结尾的数据进入目标对象（现在就是这样），当

名称

字段内容以“01”结尾的数据进入

文本

字段时，它会创建一个新的ObjectiveDetail对象，其中包含“详细信息abc”等

这是一张最终结果的图片：

A collection of Objectives
     new Objective { name = "header 1",
                        ObjectiveDetails = A collection of ObjectiveDetails 
                                  name = "detail abc" 
                                  name = "detail def" etc.

---

使用[string.EndsWith]方法确实可以做到这一点，如：

将查询修改为：

 var objectives = objectiveData
                    .Where(r => r.Name.EndsWith("00"))
                    .Select(o => new Objective {
                                               Name = o.Name,
                                               Text = o.Text}
 );

---

使用[string.EndsWith]方法确实可以做到这一点，如：

将查询修改为：

 var objectives = objectiveData
                    .Where(r => r.Name.EndsWith("00"))
                    .Select(o => new Objective {
                                               Name = o.Name,
                                               Text = o.Text}
 );

---

有些人不清楚你在问什么，但如果需要，你可以在

Select（）

中放入复杂的逻辑：

var objectives = objectiveData.Select(o =>
{
    var result = new Objective
    {
        Name = o.Name,
        Text = o.Text
    };

    if (o.Name != null && o.Name.EndsWith("01"))
    {
        result.ObjectiveDetails.Add
        (
            new ObjectiveDetail
            {
                ObjectiveDetailId = o.ObjectiveId,
                Name = o.Name,
                Text = o.Text,
                Objective = result
            }
        );
    }

    return result;
});

---

（请注意，我在猜测您需要什么；您需要更正逻辑以完成真正需要的操作。）

您的要求有些不清楚，但如果需要，您可以将复杂的逻辑放入

Select（）

：

var objectives = objectiveData.Select(o =>
{
    var result = new Objective
    {
        Name = o.Name,
        Text = o.Text
    };

    if (o.Name != null && o.Name.EndsWith("01"))
    {
        result.ObjectiveDetails.Add
        (
            new ObjectiveDetail
            {
                ObjectiveDetailId = o.ObjectiveId,
                Name = o.Name,
                Text = o.Text,
                Objective = result
            }
        );
    }

    return result;
});

---

（请注意，我在猜测您需要什么；您需要更正逻辑以执行真正需要的操作。）

看起来您需要执行某种条件映射。我喜欢，但有点不清楚为什么他每次都要创建一个

目标

实例。下面是一些我认为更可读的LINQ-less代码，并以我认为您希望的方式映射：

公共类映射器
{
公共列表目标=新列表（）；
公共阶级目标
{
public int ObjectiveId{get；set；}
公共字符串名称{get；set；}
公共字符串文本{get；set；}
公共ICollection ObjectiveDetails{get；set；}
公共目标（）
{
ObjectiveDetails=新列表（）；
}
}
公共类ObjectiveDetail
{
public int ObjectiveDetailId{get；set；}
public int ObjectiveId{get；set；}
公共字符串文本{get；set；}
公共虚拟目标{get；set；}
}
公开无效分配（）
{
var objectiveData=new[]//硬编码测试数据。我们不知道此列表中每个项目的类型，因此我使用匿名类型
{
新的{Name=“0600”，Text=“Header 06”}，
新的{Name=“0601”，Text=“06 Detail 01”}，
新的{Name=“0602”，Text=“06 Detail 02”}，
新的{Name=“0603”，Text=“06 Detail 03”}，
新的{Name=“0700”，Text=“Header 07”}，
新的{Name=“0701”，Text=“07 Detail 01”}，
新建{Name=“0702”，Text=“07 Detail 02”}
};
//首先制定目标
var-id=1；
foreach（objectiveData.Where（i=>i.Name.EndsWith（“00”））中的变量项）
{
添加（新目标{ObjectiveId=id，Name=item.Name，Text=item.Text}）；
id++；
}
//创建客观的细节
id=1；
foreach（objectiveData.Where（i=>！i.Name.EndsWith（“00”））中的变量项）
{
var itemLocal=项目；
var matchingObjective=Objectives.FirstOrDefault（o=>o.Name.StartsWith（itemLocal.Name.Substring（0,2））；
var objectiveDetail=新objectiveDetail
{
ObjectiveDetailId=id，
Text=项目。Text，
ObjectiveId=matchingObjective！=null？matchingObjective.ObjectiveId:0，
目标=匹配目标
};
if（匹配对象！=null）
{
匹配Objective.ObjectiveDetails.Add（objectiveDetail）；
}
id++；
}
//在这个方法的末尾，你应该有一个目标列表，每个目标都有其ObjectiveDetails子项
}
}

输出：

---

希望这能有所帮助。

看起来您需要进行某种条件映射。我喜欢，但有点不清楚为什么他每次都要创建一个

目标

实例。下面是一些我认为更可读的LINQ-less代码，并以我认为您希望的方式映射：

公共类映射器
{
公共列表目标=新列表（）；
公共阶级目标
{
public int ObjectiveId{get；set；}
公共字符串名称{get；set；}
公共字符串文本{get；set；}
公共ICollection ObjectiveDetails{get；set；}
公共目标（）
{
ObjectiveDetails=新列表（）；
}
}
公共类ObjectiveDetail
{
public int ObjectiveDetailId{get；set；}
public int ObjectiveId{get；set；}
公共字符串文本{get；set；}
公共虚拟目标{get；set；}
}
公开无效分配（）
{
var objectiveData=new[]//硬编码测试数据。我们不知道此列表中每个项目的类型，因此我使用匿名类型
{
新的{Name=“0600”，Text=“Header 06”}，
新的{Name=“0601”，Text=“06 Detail 01”}，
新的{Name=“0602”，Text=“06 Detail 02”}，
新的{Name=“0603”，Text=“06 Detail 03”}，
新的{Name=“0700”，Text=“Header 07”}，
新的{Name=“0701”，Text=“07 Detail 01”}，
新建{Name=“0702”，Text=“07 Detail 02”}
};
//首先制定目标
var-id=1；
foreach（objectiveData.Where（i=>i.Name.EndsWith（“00”））中的变量项）
{
添加（新目标{ObjectiveId=id，Name=item.Name，Text=item.Text}）；
id++；
}
//创建客观的细节
id=1；
foreach（objectiveData.Where（i=>！i.Name.EndsWith（“00”））中的变量项）
{
var itemLocal=项目；
var matchingObjective=Objectives.FirstOrDefault（o=>o.Name.StartsWith（itemLocal.Name.Substring（0,2））；
var objectiveDetail=新objectiveDetail
{
ObjectiveDetailId=id，
Text=项目。Text，
ObjectiveId=matchingObjective！=null？matchingObjective.ObjectiveId:0，
目标=匹配目标
};
if（匹配对象！=null）
{
匹配Objective.ObjectiveDetails.Add（objectiveDetail）；
}
id++；
}