C#如何让不同速度的进程一起工作

问题描述 投票:0回答:3

在下面的测试场景中,我想通过使用多个计时器来触发某些任务。某些事件可以触发另一个事件。

一个事件必须完成该过程,然后才能开始新的过程。当另一个事件正在处理时,被触发的事件应排队并在没有任何处理时开始。计时器不需要准确。

一旦一行执行了代码,这仅需几秒钟,该行就无法在几分钟内接受任何新订单。这就是使用计时器的目的。

下面的代码问题是,在真正的App中事情变得混乱起来。 Line2开始处理,而Line尚未完成。如何使订单正确排队并处理?

在真实的应用程序中,MyTask将开始来回运行第一行代码,过一会儿将执行MyTask代码的最后一行。

我是初学者,请耐心等待。

public partial class Form1 : Form
    {
        readonly System.Windows.Forms.Timer myTimer1 = new System.Windows.Forms.Timer();
        readonly System.Windows.Forms.Timer myTimer2 = new System.Windows.Forms.Timer();

        int leadTime1 = 100;
        int leadTime2 = 100;

        public Form1()
        {
            InitializeComponent();
            TaskStarter();

        }

        private void TaskStarter()
        {
            myTimer1.Tick += new EventHandler(myEventTimer1);
            myTimer2.Tick += new EventHandler(myEventTimer2);

            myTimer1.Interval = leadTime1;
            myTimer2.Interval = leadTime2;

            myTimer1.Start();
        }

        private void myEventTimer1(object source, EventArgs e)
        {
            myTimer1.Stop();
            Console.WriteLine("Line1 Processing ");
            MyTask();
            Console.Write(" Line1 Completed");
            leadTime1.Interval = 5000; // this leadtime is variable and will show how long the line cant be used again, after the code is executed
            myTimer2.Start();
            myTimer1.Enabled = true;
        }

        private void myEventTimer2(object source, EventArgs e)
        {
            myTimer2.Stop();
            Console.WriteLine("Line2 Processing ");
            MyTask();
            Console.Write(" Line2 Completed");
            leadTime2.Interval = 5000; // this leadtime is variable
            myTimer2.Enabled = true;
        }

        private void MyTask()
        {
            Random rnd = new Random();
            int timeExecuteCode = rnd.Next(1000, 5000); // This leadtime does reflect the execution of the real code
            Thread.Sleep(timeExecuteCode );
        }
    }

更新多亏了输入,我得以对问题进行排序,这使我删除了所有引起异步任务处理的计时器。在完成所有订单之前,我不仅将行锁定到while loop。所有操作都在单个Thread中完成。我认为对于大多数Pro,我的代码看起来非常丑陋。用我4周的C#经验可以理解这个解决方案:)

我使用的2个列表和属性

    public class Orders
    {
        public string OrderID { get ; set ; }
        public Orders(string orderID) { OrderID = orderID; }
    }

    public class LineData
    {
        string lineID;
        public string LineID { get { return lineID; } set { lineID = value; } }
        private string orderId;
        public string OrderID { get { return orderId; } set { orderId = value; } }
        public string ID { get { return lineID + OrderID; } private set {; } } 
        public double TaskTime { get; set; }
    }

使用每个生产线和零件的交货时间创建生产线数据添加一些样品订单while循环直到所有订单完成

    public class Production
    {
        readonly static List<LineData> listLineData = new List<LineData>();
        readonly static List<Orders> listOrders = new List<Orders>();

        static void Main()
        {
            // List Line Processing Master Data 
            listLineData.Add(new LineData { LineID = "Line1", OrderID = "SubPart1", TaskTime = 3 });
            listLineData.Add(new LineData { LineID = "Line1", OrderID = "SubPart2", TaskTime = 3 });
            listLineData.Add(new LineData { LineID = "Line2", OrderID = "Part1", TaskTime = 1 });
            listLineData.Add(new LineData { LineID = "Line3", OrderID = "Part1", TaskTime = 1 });
            listLineData.Add(new LineData { LineID = "Line3", OrderID = "Part2", TaskTime = 2 });

            // Create Order Book 
            listOrders.Add(new Orders("SubPart1"));
            listOrders.Add(new Orders("SubPart2"));
            listOrders.Add(new Orders("Part1"));
            listOrders.Add(new Orders("Part2"));
            listOrders.Add(new Orders("SubPart1"));
            listOrders.Add(new Orders("SubPart2"));
            listOrders.Add(new Orders("Part1"));
            listOrders.Add(new Orders("Part2"));
            listOrders.Add(new Orders("SubPart1"));
            listOrders.Add(new Orders("SubPart2"));
            listOrders.Add(new Orders("Part1"));
            listOrders.Add(new Orders("Part2"));

            while (listOrders.Count > 0)
            {
                CheckProductionLines();
                Thread.Sleep(100)
            }
        }

listOrder提取订单,并将其分配给正确的行。使用DateTime.Now并添加taskTime来确定线路是否忙将订单发送到void InitializeProduction(int indexOrder, string line)处理订单。稍后,我将为Line1-Linex创建一个函数,因为它是重复的。

        static DateTime timeLine1Busy = new DateTime();
        static DateTime timeLine2Busy = new DateTime();
        static DateTime timeLine3Busy = new DateTime();

        static void CheckProductionLines()
        {            
            // Line 1
            int indexOrderLine1 = listOrders.FindIndex(x => x.OrderID == "SubPart1" || x.OrderID == "SubPart2");
            if (indexOrderLine1 >= 0 && timeLine1Busy < DateTime.Now)
            {
                string id = "Line1" + listOrders[indexOrderLine1].OrderID.ToString();// Construct LineID (Line + Part) for Task
                int indexTasktime = listLineData.FindIndex(x => x.ID == id);    // Get Index LineData where the tasktime is stored
                double taskTime = (listLineData[indexTasktime].TaskTime);       // Get the Task Time for the current order (min.)
                InitializeProduction(indexOrderLine1, "Line1");                 // Push the start button to run the task
                timeLine1Busy = DateTime.Now.AddSeconds(taskTime);              // Set the Line to busy 
            }

            // Line2
            int indexOrderLine2 = listOrders.FindIndex(x => x.OrderID == "Part1"); // Pick order Line2
            if (indexOrderLine2 >= 0 && timeLine2Busy < DateTime.Now)
            {
                string id = "Line2" + listOrders[indexOrderLine2].OrderID.ToString();  // Line2 + Order is unique ID in listLineData List
                int indexTasktime = listLineData.FindIndex(x => x.ID == id);// Get Index LineData where the tasktime is stored
                double taskTime = (listLineData[indexTasktime].TaskTime);      // Get the Task Time for the current order (min.)
                InitializeProduction(indexOrderLine2, "Line2");             // Push the start button to run the task
                timeLine2Busy = DateTime.Now.AddSeconds(taskTime);              // Set the Line to busy 
            }

            // Line 3
            int indexOrderLine3 = listOrders.FindIndex(x => x.OrderID == "Part1" || x.OrderID == "Part2"); // Pick order
            if (indexOrderLine3 >= 0 && timeLine3Busy < DateTime.Now)
            {
                string id = "Line3" + listOrders[indexOrderLine3].OrderID.ToString();  // Line3 + Order is unique ID in listLineData List
                int indexTasktime = listLineData.FindIndex(x => x.ID == id);// Get Index LineData where the tasktime is stored
                double taskTime = (listLineData[indexTasktime].TaskTime);      // Get the Task Time for the current order (min.)
                InitializeProduction(indexOrderLine3, "Line3");             // Push the start button to run the task
                timeLine3Busy = DateTime.Now.AddSeconds(taskTime);              // Set the Line to busy 
            }
        }

这里我InitializeProduction生产从listOrders中删除订单实际上,这里将处理许多任务

        static void InitializeProduction(int indexOrder, string line)
        {
            Thread.Sleep(1000);                                             //simulates the inizialsation code
            Debug.WriteLine($"{line} {listOrders[indexOrder].OrderID} Completed "); 
            listOrders.RemoveAt(indexOrder);                                //Remove Order from List
        }

    }

我相信您会看到很多改进的空间。如果简单的事情可以甚至必须应用,我正在听:)

c# winforms timer
3个回答
1
投票

在评论后添加内容

您的问题为生产者-消费者模式大喊大叫。这种鲜为人知的模式使生产者生产出消费者消费的东西。

生产者生产商品的速度可能不同于消费者消费的速度。有时生产者生产速度更快,有时生产者生产速度较慢。

在您的情况下,生产者产生“执行任务的请求”。消费者将一次执行一项任务。

为此,我使用Nuget包:Microsoft.Tpl.Dataflow。它可以做很多事情,但是对于您而言,用法很简单。

通常,您必须考虑很多多线程问题,例如发送和接收缓冲区中的关键部分。 TPL将为您处理这些问题。

如果生产者启动,它将产生执行某项操作,等待并等待Action<Task>的请求。生产者将这些请求放在BufferBlock<Action<Task>>中。它会尽快产生。

首先是一个工厂,它将创建具有随机执行时间的Action<Task>。请注意,每个创建的动作尚未执行,因此任务未运行!

class ActionFactory
{
    private readonly Random rnd = new Random();

    public Action<Task> Create()
    {
        TimeSpan timeExecuteCode = TimeSpan.FromMilliseconds(rnd.Next(1000, 5000));
        return _ => Task.Delay(timeExecuteCode);
        // if you want, you can use Thread.Sleep
    }
}

生产者非常简单:

class Producer
{
    private readonly BufferBlock<Action<Task>> buffer = new BufferBlock<Action<Task>>();

    public TaskFactory TaskFactory {get; set;}

    public ISourceBlock<Action<Task> ProducedActions => buffer;

    public async Task ProduceAsync()
    {
        // Create several tasks and put them on the buffer
        for (int i=0; i<10; ++i)
        {
            Action<Task> createdAction = this.TaskFactory.Create();
            await this.buffer.SendAsync(createdAction);
        }

        // notice listeners to my output that I won't produce anything anymore
        this.buffer.Complete();
    }

[如果需要,您可以对此进行优化:在SendAsync时,您可以创建下一个动作。然后等待SendAsync任务,然后再发送下一个操作。为了简单起见,我没有这样做。

使用者需要一个输入,该输入接受Action<Task>对象。它将读取此输入,执行操作并等待操作完成,然后再从缓冲区中获取下一个输入。

class Consumer
{
    public ISourceBlock<Action<Task>> ActionsToConsume {get; set;}

    public async Task ConsumeAsync()
    {
         // wait until the producer has produced something,
         // or says that nothing will be produced anymore
         while (await this.ActionsToConsume.OutputAvailableAsync())
         {
              // the Producer has produced something; fetch it
              Action<Task> actionToExecute = this.ActionsToConsume.ReceiveAsync();

              // execute the action, and await the eturned Task
              await actionToExecute();

              // wait until Producer produces a new action.
         }

         // if here: producer notifies completion: nothing is expected anymore
    }

全部放在一起:

TaskFactory factory = new TaskFactory();
Producer producer = new Producer
{
    TaskFactory = factory;
}
Consumer consumer = new Consumer
{
    Buffer = producer.ProducedActions;
}

// Start Producing and Consuming and wait until everything is ready
var taskProduce = producer.ProduceAsync();
var taskConsume = consumer.ConsumeAsync();

// now producer is happily producing actions and sending them to the consumer.
// the consumer is waiting for actions to consume
// await until both tasks are finished:
await Task.WhenAll(new Task[] {taskProduce, taskConsume});

添加注释:用更少的代码完成

上面似乎有很多工作。我创建了单独的类,因此您可以看到谁负责什么。如果需要,您可以使用一个缓冲区和两个方法来完成全部操作:一个产生的方法和一个消耗的方法:

private readonly BufferBlock<Action<Task>> buffer = new BufferBlock<Action<Task>>();

public async Task ProduceTasksAsync()
{
    // Create several tasks and put them on the buffer
    for (int i=0; i<10; ++i)
    {
        Action<Task> createdAction = ...
        await this.buffer.SendAsync(createdAction);
    }

    // producer will not produce anything anymore:
    buffer.Complete();
}

async Task ConsumeAsync()
{
    while (await this.ActionsToConsume.OutputAvailableAsync())
    {
        // the Producer has produced something; fetch it, execute it
        Action<Task> actionToExecute = this.ActionsToConsume.ReceiveAsync();
        await actionToExecute();
    }
}

用法:

async Task ProduceAndConsumeAsync()
{
    var taskProduce = producer.ProduceAsync();
    var taskConsume = consumer.ConsumeAsync();
    await Task.WhenAll(new Task[] {taskProduce, taskConsume});

}

1
投票

您的问题是两个计时器都在同一个UI事件循环上运行。这意味着timer1在执行该事件时,该线程上没有其他事件被执行。解决方案是使用thaasyncawait模式在您的情况下在后台运行代码,您可以执行以下操作:

private async void myEventTimer1(object source, EventArgs e)
{
    myTimer1.Stop();
    Console.WriteLine("Line1 Processing ");
    await MyTask();
    Console.Write(" Line1 Completed");
    myTimer1.Interval = 5000; // this leadtime is variable
    myTimer2.Start();
    myTimer1.Enabled = true;
}

private async void myEventTimer2(object source, EventArgs e)
{
    myTimer2.Stop();
    Console.WriteLine("Line2 Processing ");
    await MyTask();
    Console.Write(" Line2 Completed");
    myTimer2.Interval = 5000; // this leadtime is variable
    myTimer2.Enabled = true;
}

private async Task MyTask()
{
    Random rnd = new Random();
    int tleadtime = rnd.Next(1000, 5000);
    await Task.Delay(tleadtime);
}

[这会在后台运行MyTask(实际上只是Delay部分,但是在完成后会在前景中继续。


1
投票

现在要弄清楚,从技术上讲,这并不是您所提问题的答案,但我相信它会产生您要求的基本行为(在注释中,并且我相信会帮助人们。

我们以控制台应用程序编写的三个类,OrderLineFactory为例。

Order很简单,它具有两个属性,一个标识名称和一个以秒为单位的交货时间。

public class Order
{
    public string OrderName { get; set; }
    public int LeadTimeSeconds { get; set; }

    public Order(string orderName, int leadTimeSeconds)
    {
        OrderName = orderName;
        LeadTimeSeconds = leadTimeSeconds;
    }
}

Line继承自BackgroundWorker MSDN - BackgroundWorker。我将在这里不做详细介绍,因为有很多关于该主题的文章,但是您可以委派给异步调用的DoWork事件。由于它们公开了CancelAsync()方法,因此您可以连续(或长时间)执行某些操作而不会阻止行为。 Line也参考了您的Queue<Order>Queue<T>是一个不错的集合,因为它使您可以轻松地Dequeue()行中的下一项。在构造函数中,Line调用RunWorkerAsync(),调用DoWork事件,然后调用处理程序Line_ProcessOrder

public class Line: BackgroundWorker
{
    public string LineName { get; set; }
    public Queue<Order> OrderQueue { get; set; }

    public Line (string lineName, Queue<Order> orderQueue)
    {
        LineName = lineName;
        OrderQueue = orderQueue;
        DoWork += Line_ProcessOrder;
        RunWorkerAsync();
    }

    private void Line_ProcessOrder(object sender, DoWorkEventArgs e)
    {
        Order targetOrder;
        BackgroundWorker worker = sender as BackgroundWorker;

        while (true)
        {
            if (worker.CancellationPending == true)
            {
                e.Cancel = true;
                break;
            }
            else
            {
                if (OrderQueue.Count > 0)
                {
                    targetOrder = OrderQueue.Dequeue();
                    Console.WriteLine($"{LineName} is processing {targetOrder.OrderName}");
                    Thread.Sleep(targetOrder.LeadTimeSeconds * 1000);
                    Console.WriteLine($"{LineName} finished {targetOrder.OrderName}");
                }
            }
        }
    }
}

最后,Factory将所有内容组合在一起。我们可以有任意数量的Lines,共享一个Queue<Order>,该C0是从您可能拥有的任何IEnumerable<Queue>创建的。请注意,Lines立即开始​​工作。例如,您可能希望添加Start()Stop()方法。

public class Factory
{
    static void Main(string[] args)
    {
        List<Order> Orders = new List<Order>()
        {
            new Order("Order1",10),
            new Order("Order2",8),
            new Order("Order3",5),
            new Order("Order4",15)
        };

        Queue<Order> OrderQueue = new Queue<Order>(Orders);

        Line Line1 = new Line("Line1", OrderQueue);
        Line Line2 = new Line("Line2", OrderQueue);

        while (true) { }
    }
}

这可能不完全是您所需要的,但是我希望它可以使您摆脱使用计时器的方法进行异步编程。

© www.soinside.com 2019 - 2024. All rights reserved.