Параллельный процессный контрольный фреймворк на C#, построенный на основе модели CSP,主要用于工控逻辑、运动控制开发。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Go;

namespace WorkerFlow
{
    class Program
    {
        static shared_strand strand;

        static void Log(string msg)
        {
            Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss.fff")} {msg}");
        }

        static async Task Worker(string name, int time = 1000)
        {
            await generator.sleep(time);
            Log(name);
        }

        //1 A, B, C последовательно
        //A->B->C
        static async Task Worker1()
        {
            await Worker("A");
            await Worker("B");
            await Worker("C");
        }
}
```        //2 A, B, C параллельно, и все зависят от одного и того же потока (скрытый параметр, все задачи, зависящие от одного и того же потока, являются потокобезопасными)
        //A
        //B
        //C
        static async Task Worker2()
        {
            generator.children children = new generator.children();
            children.go(() => Worker("A"));
            children.go(() => Worker("B"));
            children.go(() => Worker("C"));
            await children.wait_all();
        }        //3 После выполнения A, B и C выполняются параллельно
        //  -->B
        //  |
        //A->
        //  |
        //  -->C
        static async Task Worker3()
        {
            await Worker("A");
            generator.children children = new generator.children();
            children.go(() => Worker("B"));
            children.go(() => Worker("C"));
            await children.wait_all();
        }
}
```        //4 B и C должны быть выполнены параллельно, после чего выполняется A
        //B--
        //  |
        //  -->A
        //  |
        //C--
        static async Task Worker4()
        {
            generator.children children = new generator.children();
            children.go(() => Worker("B"));
            children.go(() => Worker("C"));
            await children.wait_all();
            await Worker("A");
        }        //5 B или C выполнены, затем выполняется A
        //B--
        //  |
        //  >-->A
        //  |
        //C--
        static async Task Worker5()
        {
            generator.children children = new generator.children();
            var B = children.tgo(() => Worker("B", 1000));
            var C = children.tgo(() => Worker("C", 2000));
            var task = await children.wait_any();
            if (task == B)
            {
                Log("B выполнено");
            }
            else
            {
                Log("C выполнено");
            }
            await Worker("A");
        }

        //6 Ожидание конкретной задачи
        static async Task Worker6()
        {
            generator.children children = new generator.children();
            var A = children.tgo(() => Worker("A"));
            var B = children.tgo(() => Worker("B"));
            await children.wait(A);
        }        //7 Ожидание конкретной задачи с таймаутом, затем остановка всех задач
        static async Task Worker7()
        {
            generator.children children = new generator.children();
            var A = children.tgo(() => Worker("A", 1000));
            var B = children.tgo(() => Worker("B", 2000));
            if (await children.timed_wait(1500, A))
            {
                Log("успешно");
            }
            else
            {
                Log("таймаут");
            }
            await children.stop();
        }        //8 Ожидание группы задач с таймаутом, затем остановка всех задач
        static async Task Worker8()
        {
            generator.children children = new generator.children();
            children.go(() => Worker("A", 1000));
            children.go(() => Worker("B", 2000));
            var tasks = await children.timed_wait_all(1500);
            await children.stop();
            Log($"успешно завершено {tasks.Count} задач");
        }        //9 Ожидание завершения группы задач, затем остановка всех задач и обработка ошибок на месте
        static async Task Worker9()
        {
            generator.children children = new generator.children();
            children.go(() => Worker("A", 1000));
            children.go(async delegate ()
            {
                try
                {
                    await Worker("B", 2000);
                }
                catch (generator.stop_exception)
                {
                    Log("B был остановлен");
                    await generator.sleep(500);
                    throw;
                }
                catch (System.Exception)
                {
                }
            });
            var task = await children.timed_wait_all(1500);
            await children.stop();
            Log($"Успешно завершено {task.Count} задач");
        }        //10 Вложенные задачи
        static async Task Worker10()
        {
            generator.children children = new generator.children();
            children.go(async delegate ()
            {
                generator.children children1 = new generator.children();
                children1.go(() => Worker("A"));
                children1.go(() => Worker("B"));
                await children1.wait_all();
            });
            children.go(async delegate ()
            {
                generator.children children1 = new generator.children();
                children1.go(() => Worker("C"));
                children1.go(() => Worker("D"));
                await children1.wait_all();
            });
            await children.wait_all();
        }        //11 Вложенные задачи с прерыванием
         static async Task Worker11()
         {
             generator.children children = new generator.children();
             children.go(() => Worker("A", 1000));
             children.go(async delegate ()
             {
                 try
                 {
                     generator.children children1 = new generator.children();
                     children1.go(async delegate ()
                     {
                         try
                         {
                             await Worker("B", 2000);
                         }
                         catch (generator.stop_exception)
                         {
                             Log("B прерван 1");
                             await generator.sleep(500);
                             throw;
                         }
                         catch (System.Exception)
                         {
                         }
                     });
                     await children1.wait_all();
                 }
                 catch (generator.stop_exception)
                 {
                     Log("B прерван 2");
                     throw;
                 }
                 catch (System.Exception)
                 {
                 }
             });
             await generator.sleep(1500);
             await children.stop();
         }        //12 Параллельное выполнение и ожидание группы ресурсоемких алгоритмов
         static async Task Worker12()
         {
             wait_group wg = new wait_group();
             for (int i = 0; i < 2; i++)
             {
                 wg.add();
                 int idx = i;
                 var _ = Task.Run(delegate ()
                 {
                     try
                     {
                         Log($"Выполняется алгоритм {idx}");
                     }
                     finally
                     {
                         wg.done();
                     }
                 });
             }
             await wg.wait();
             Log("Алгоритмы выполнены");
         }```markdown
         //13 Последовательное выполнение затратных алгоритмов, затратные алгоритмы должны выполняться в пуле потоков, иначе планирование, зависящее от одного и того же strand, не будет своевременным
         static async Task Worker13()
         {
             for (int i = 0; i < 2; i++)
             {
                 await generator.send_task(() => Log($"Выполнение алгоритма {i}"));
             }
         }```markdown
        static async Task MainWorker()
        {
            await Worker1();
            await Worker2();
            await Worker3();
            await Worker4();
            await Worker5();
            await Worker6();
            await Worker7();
            await Worker8();
            await Worker9();
            await Worker10();
            await Worker11();
            await Worker12();
            await Worker13();
        }

        static void Main(string[] args)
        {
            work_service work = new work_service();
            work_strand strand = new work_strand(work);
            generator.go(strand, MainWorker);
            work.run();
            Console.ReadKey();
        }
    }