Question

想象一下执行图，其中每个进程可能有0到多个必需的进程要执行，相反必须执行才能执行0..many连续进程。

该算法在C＃中会是什么样的？

这是我到目前为止所做的：

while(Steps.Any(s => !s.Complete))
    Parallel.ForEach(Steps.Where(s => !s.Started), step =>
    {
        if(step.Parents.All(p=>p.Complete))
            step.Execute();
    });

我甚至不确定这是否有效。

想知道我是否走上了正确的道路或者是什么。

任何人都知道有关执行图表的任何好文献。

Answer 1

好，所以我首先从树的表示开始。在此，每个节点将包含一个任务（您的过程）。

    public sealed class Node
    {
        public string Name { get; }
        public Action Action { get; }
        public LinkedList<Node> Descendants { get; }

        public Node(string name, Action action)
        {
            Name = name;
            Action = action;
            Descendants = new LinkedList<Node>();
        }

        public void AddDescendant(Node node) => Descendants.AddLast(node);
    }

一旦有了这个，就可以创建一个简单的树：

    public Node CreateTree()
    {
        Node root = new Node("root", () => Console.WriteLine("1"));

        Node gen1_1 = new Node("gen1_1", () => Console.WriteLine("2"));
        Node gen1_2 = new Node("gen1_2", () => Console.WriteLine("3"));

        Node gen2_1 = new Node("gen2_1", () => Console.WriteLine("4"));
        Node gen2_2 = new Node("gen2_2", () => Console.WriteLine("5"));
        Node gen2_3 = new Node("gen2_3", () => Console.WriteLine("6"));
        Node gen2_4 = new Node("gen2_4", () => Console.WriteLine("7"));


        root.AddDescendant(gen1_1);
        root.AddDescendant(gen1_2);

        gen1_1.AddDescendant(gen2_1);
        gen1_1.AddDescendant(gen2_2);
        gen1_2.AddDescendant(gen2_3);
        gen1_2.AddDescendant(gen2_4);

        return root;
    }

这是有史以来最简单的功能，它可以从动作中创建任务并以异步方式运行它们：

    public async Task ExecuteAll(Node root)
    {
        await Task.Run(root.Action);
        await Task.WhenAll(root.Descendants.Select(ExecuteAll));
    }

这是测试：

    [Test]
    public async Task Test()
    {
        var root = CreateTree();
        Console.WriteLine("start");
        await ExecuteAll(root);
        Console.WriteLine("finish");
    }

C＃并行执行执行图

1 个答案: