Question

我有三个对象列表，每个对象都通过以下层次结构中的单个公共属性Parent和Node链接到另一个列表：模型 - ＆gt;中级 - ＆gt;结果。我有以下代码：

class Result
{
    public string Name { get; set; }
    public int Node{ get; set; }
    public int Parent{ get; set; }
}
class Intermediate
{
    public int Node{ get; set; }
    public int Parent{ get; set; }
}
class Model
{
    public string Name { get; set; }
    public int Node{ get; set; }
    public int Parent{ get; set; }
}

public class Example
{
    public static void Main()
    {
        List<Result> results = new List<Result>();
        List<Intermediate> intermediates = new List<Intermediate>();
        List<Model> models = new List<Model>();

        // Example objects in the list
        results.Add(new Result() { Name = "", Parent = 21, Node = 101 });
        intermediates.Add(new Part() { Parent = 11, Node = 21 });
        models.Add(new Part() { Name = "ABCD", Parent = 1, Node = 11 });
        ...
    }
}

可以看出Model对象通过Intermediate和model.Node与intermediate.Parent对象相关联，Intermediate对象链接到Results通过intermediate.Node和results.Parent对象。请注意，列表可以包含数千个项目，每个项目使用与上面类似的格式添加。

我希望能够做的是将列表中Model个对象的名称添加到Results列表中匹配的results个对象。

我的想法是，我可以循环遍历Intermediate列表中的每个对象，并找到（使用LINQ）Result intermediate.Node = result.Parent对象，然后替换{的值使用result.Parent {1}}，或将新intermediate.Parent属性添加到要放置Grandparent的{{1}}对象。然后重复循环遍历Result列表中每个对象的过程，找到匹配的intermediate.Parent对象并添加models。

所以我想我的问题是，这是最好的方法，还是有更有效的方式？我有许多列表，其中必须重复相同，所以想知道是否有更好的方法，因为它可以非常慢地循环每个对象。还有一种方法可以从第一个列表直接到达第三个列表。

我希望这个解释得很好。对于C＃来说，我是一个初学者。

Answer 1

你实际上有结果 - ＆gt;中级 - ＆gt;模型而不是模型 - ＆gt;中级 - ＆gt;结果

要加快删除中级的过程，请构建一个字典。然后，您可以使用要转换的字典对结果进行简单的选择。

<div class="col-xs-8">
<div class="req">
 <select name="bid" class="form-control">
<option value="" default style="color:gray;">Branch</option>
<option value="brancha">Branch A</option>
<option value="branchb">Branch B</option>
<option value="branchc">Branch C</option>
</select>
</div>
</div>

   <div class="col-xs-8">
	<div class="req">
     <select name="brcat" class="form-control">
	<option value="" default style="color:gray;">Category</option>
	<option value="Stock">Stock</option>
	<option value="Sales">Sales</option>
	<option value="Stock Transfer">Stock Transfer</option>
	</select>
	</div>
	</div>

<button type="submit" class="btn btn-default bt" style="align:right;">Go</button>

您也可以进行加入以获得最终答案。

Answer 2

看起来foreach循环可用于获取结果（叶）节点并将模型名称分配给结果节点：

var theModel = models.First(); // select a model

foreach (var interm in intermediates.Where(x => x.Parent == theModel.Node))
{
    foreach (var res in results.Where(x => x.Parent == interm.Node))
    {
        res.Name = theModel.Name;
    }
}

Answer 3

闻起来像Composite Pattern你在这里谈论的内容。

您可以使用HashSet来保持您的值以快速执行它。

public class Item
{
    public Item(int itemNode)
    {
        Node = itemNode;
        Children = new HashSet<Item>();
    }

    public int Node { get; set; }
    public Item Parent { get; set; }
    private HashSet<Item> Children { get; set; }

    public bool Add(Item item)
    {
        item.Parent = this;
        return Children.Add(item);
    }

    public List<Item> Find(Func<Item, bool> predicate)
    {
        var found = new List<Item>();
        if (predicate(this)) found.Add(this);
        Collect(predicate, found);
        return found;
    }

    public void Collect(Func<Item, bool> predicate, List<Item> collected = null)
    {
        collected = collected ?? new List<Item>();
        collected.AddRange(Children.Where(predicate).ToList());

        foreach (var child in Children)
        {
            child.Collect(predicate, collected);
        }
    }
}

public class Model : Item //this is your model
{
    public string Name { get; set; }
    public Model(int itemNode, string name) : base(itemNode)
    {
        Name = name;
    }

    public List<Item> GetNamesMatchingWith(Func<Item, bool> predicate)
    {
        return Find(predicate);
    }
}

public class Example
{
    public static void Main()
    {
        var root = new Model(0, "root");
        var one = new Model(1, "1");
        var two = new Model(2, "2");
        var tree = new Model(3, "3");

        root.Add(one);
        root.Add(two);
        root.Add(tree);

        var a = new Model(4, "a");
        var b = new Model(5, "b");

        two.Add(a);
        two.Add(b);

        var namesMatchingWith = root.GetNamesMatchingWith(x=> x.Parent!=null && x.Parent.Node == 2);
        Console.ReadKey();
    }
}

希望它能激励你......

C＃根据公共属性

3 个答案: