Question

所以我有一台服务器在一个while循环中射出了下面的任务，它作为我的客户端监听器。这个问题似乎想要通过客户端尽可能快地循环，这很棒！但是，在上一个任务完成之前，它会以太快的速度关闭任务（对于同一个客户端）。

我不希望它等待任务完成！我希望它能够拍摄更多任务，但只是不为已有任务的特定客户创建任务。

最好的方法是什么...我看到很多人使用WhenAll或者其他东西，但我并不关心所有的任务。

//the below is in a while loop which goes through the clients that are connected.
  if (stream.DataAvailable)
                    {
// the below task is the one that is firing before the pervious fired one completes.
                         Task DataInterpetTask = Task.Factory.StartNew(() =>
                        {
                            int totalBuffer, totalRecieved = 0;
                            byte[] totalBufferByte = new byte[4];
                            byte[] buffer = new byte[0];
                            byte[] tbuffer;
                            int rLength, prevLength;
                            stream.Read(totalBufferByte, 0, 4);
                            totalBuffer = BitConverter.ToInt32(totalBufferByte, 0);
                            Console.WriteLine("got stuff: " + totalBuffer);
                            byte[] buf = new byte[c.getClientSocket().ReceiveBufferSize];
                            while (totalBuffer > totalRecieved)
                            {

                                rLength = stream.Read(buf, 0, buf.Length);
                                totalRecieved = rLength + totalRecieved;
                                if (rLength < buf.Length)
                                {
                                    byte[] temp = new byte[rLength];
                                    Array.Copy(buf, temp, rLength);
                                    buf = temp;
                                }
                                prevLength = buffer.Length;
                                tbuffer = buffer;
                                buffer = new byte[buffer.Length + rLength];
                                Array.Copy(tbuffer, buffer, tbuffer.Length);
                                buf.CopyTo(buffer, prevLength);
                            }

                            String msg = Encoding.ASCII.GetString(buffer);
                            if (msg.Contains("PNG") || msg.Contains("RBG") || msg.Contains("HDR"))
                            {
                                Console.WriteLine("Receiving Picture");
                                RowContainer tempContainer;
                                if ((tempContainer = MainWindow.mainWindow.RowExists(c)) != null)
                                {
                                    tempContainer.Image = buffer;
                                    Console.WriteLine("Updating row: " + tempContainer.rowNumber);
                                    MainWindow.mainWindowDispacter.BeginInvoke(new Action(() =>
                                        MainWindow.mainWindow.UpdateRowContainer(tempContainer, 0)));
                                }
                                else
                                {
                                    Console.WriteLine("Adding row for Picture");
                                    MainWindow.mainWindowDispacter.BeginInvoke(new Action(() =>
                                       MainWindow.mainWindow.CreateClientRowContainer(c, buffer)));
                                }
                                return;
                            }


                            String switchString = msg.Substring(0, 4);
                            if (msg.Length > 4)
                                msg = msg.Substring(4);
                            MainWindow.mainWindowDispacter.BeginInvoke(new Action(() =>
                            {
                                if (MainWindow.debugWindow != null)
                                    MainWindow.debugWindow.LogTextBox.AppendText("Received message " + msg + " from client: " + c.getClientIp() + " as a " + switchString + " type" + Environment.NewLine);

                            }));
                            RowContainer tContain = MainWindow.mainWindow.RowExists(c);
                            if(tContain == null)
                                return;
                            switch (switchString)
                            {
                                case "pong":
                                    c.RespondedPong();
                                    break;
                                case "stat":
                                    tContain.SetState(msg);
                                    MainWindow.mainWindow.UpdateRowContainer(tContain, 1);
                                    break;
                                case "osif":
                                    tContain.Os = msg;
                                    MainWindow.mainWindowDispacter.BeginInvoke(new Action(() =>
                                       MainWindow.mainWindow.UpdateRowContainer(tContain, 2)));
                                    break;
                                case "idle":
                                    tContain.idle = msg;
                                    MainWindow.mainWindowDispacter.BeginInvoke(new Action(() =>
                                       MainWindow.mainWindow.UpdateRowContainer(tContain, 3)));
                                    break;
                            }
                        });
                    }

Answer 1

如果您不希望为给定客户端启动新操作，直到上一个客户端完成，那么只需跟踪它即可。将客户端对象移动到某个“进行中”列表，以便它甚至不在您在循环中处理的客户端列表中，或者向客户端对象类添加一个标志，指示操作“正在进行中” ，这样你的循环可以忽略客户端，直到当前操作完成（例如if (c.OperationInProgress) continue;）。

也就是说，您似乎正在使用轮询（即检查DataAvailable）来管理您的I / O.这是一种非常低效的方法，最重要的是当前问题的根本原因。如果您使用了更好的异步模型，那么您的代码将更高效和您甚至不会遇到此问题，因为异步API将提供您需要的所有状态管理以避免给定客户的重叠操作。

不幸的是，您的代码示例非常稀疏，缺少提供有关如何更改实现以使用异步模型的特定建议所需的所有详细信息（以及有哪些小代码），包括许多在a good code example中找不到的额外代码。所以希望上述内容足以让您找到正确的解决方案。

任务管理和使用？

1 个答案: