Fatal编程技术网
  • .net/
  • 使用UDP输入的.NET并行处理

使用UDP输入的.NET并行处理

.net algorithm parallel-processing

使用UDP输入的.NET并行处理,.net,algorithm,parallel-processing,task-parallel-library,udpclient,.net,Algorithm,Parallel Processing,Task Parallel Library,Udpclient,我正在思考如何在我的应用程序中并行化我的数据处理。让我解释一下模型和数据流的结构： 型号： public CollectData(proc proc) { _proc = proc; PoolClass.lstDataType1 = new List<DataType1>(); } public void Init(List<DataType1> lstDT1, List<DataType2> lstDT2) { fore

我正在思考如何在我的应用程序中并行化我的数据处理。让我解释一下模型和数据流的结构：

型号：

 public CollectData(proc proc)
{
    _proc = proc;
    PoolClass.lstDataType1 = new List<DataType1>();

}

public void Init(List<DataType1> lstDT1, List<DataType2> lstDT2)
{
        foreach (DataType1 dt1Data in lstDT1)
        {
            DataType1 dt1 = new DataType1(dt1ID, lstDT2, IncRec);
            PoolClass.lstDataType1.Add(dt1);

        }


}

delegate void ProcCallback(int dtID);
private void ProcRec(int dtID)
{
    if (_proc != null)
    {
        _proc(dtID);
    }

}

public void Push(Message message)
{
     PoolClass.lstDataType1.Where(t => t.dtId == message.DT1ID).FirstOrDefault().lstDataType2.Where(d => d.Id == message.DT2ID).FirstOrDefault().Stack.Push(message);
}

 public class DataType1
        {
            public int dtId;
            public List<DataType2> lstDataType2;

            public DataType1(int tdt1ID, List<DataType2> lstDT2, incRec incRec)
            {
                foreach (DataType2 dt2 in list)
                {
                    DataType2 dt2 = new DataType2(DataLimitReached);
                    lstDataType2.Add(dt2);
                }
            }


  delegate void DataLimitReachedCallback();
  private void DataLimitReached()
    {
        _proc(dt1ID);

    }
}

public class DataType2
{   
  public DataType3 Stack;
  Stack = new DataType3(DataLimitReached);

   delegate void DataLimitReachedCallback();
        private void DataLimitReached()
        {
            if (_DataLimitReached != null)
            {
                _DataLimitReached();
            }

        }   
}

public class DataType3
{
     public delegate void DataLimitReached();
     public DataLimitReached _DataLimitReached;

     public DataType3[] arrData;

     public DataStack(DataLimitReached DataLimitReached)
     {
          _DataLimitReached = DataLimitReached;
     }

     public void Push(Message message)
    {
        //add message to arrData
        //check if data limit was reached, build average
        if (_DataLimitReached != null)
        {
            _DataLimitReached();
        }
    }


}

Server udpServer = new Server(port);
this.udpServer.OnMessage += new Server.DelegateMessageReceived(udpServer_OnMessage);

Module module = new Module();
module.Init();
module.OnProcData += new Module.RecHandler(module_OnProcData);

void udpServer_OnMessage(Message message)
{
    procMessage(message);

}

private void procMessage(Message message)
{
    module.setData(message);
    //I tried: this.actionBlock.Post(message);
}

 void module_OnProcData(Module m, ModuleEventArgs e)
{
  //log data result or put to listbox
}

public class PoolClass
{
      public static List<DataType1> lstDataType1;
}

public CollectData cData;

public void Init()
{
    cData = new CollectData(Proc);

    List<DataType2> lstDT2 = new List<DataType2>;

    cData.Init(lstDT2);

}

public void setData(Message message)
{
    cData.Push(message);
}       


delegate void ProcCallback(int dtID);
private void Proc(int dtID)
{
    DoCalculation(dtID);
    //I tried: this.actionBlock.Post(dtID);
}

private void RaiseProcEvent(ModuleEventArgs e)
{
    if (OnProcData != null)
    {
        OnProcData(this, e);
    }

}

public void DoCalculation(int DT1Id)
{
   //do calculation
   RaiseProcEvent(e);
}

public class Server

public delegate void DelegateMessageReceived(Message message);

Task.Run(async () =>
{
    using (var udpClient = new UdpClient())
    {
        udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
        udpClient.Client.Bind(localpt);

        while (true)
        {
            if (udpClient.Available > 0)
            {
                var receiveBytes = await udpClient.ReceiveAsync();
                if (receiveBytes.Buffer.Length <= 0)
                    return;
                Message message = JsonConvert.DeserializeObject<Message>(Encoding.ASCII.GetString(receiveBytes.Buffer));


                if (OnMessage != null)
                {
                   OnMessage(message);
                }
                //I tried:  this.actionBlock.Post(message);
            }
        }
    }
});

}
  • DataType1类型的列表
  • 每个DataType1都包含DataType2的列表
  • 每个DataType2包含一个DataType3类
  • 每个数据类型3都包含一个int的列表
数据流：

 public CollectData(proc proc)
{
    _proc = proc;
    PoolClass.lstDataType1 = new List<DataType1>();

}

public void Init(List<DataType1> lstDT1, List<DataType2> lstDT2)
{
        foreach (DataType1 dt1Data in lstDT1)
        {
            DataType1 dt1 = new DataType1(dt1ID, lstDT2, IncRec);
            PoolClass.lstDataType1.Add(dt1);

        }


}

delegate void ProcCallback(int dtID);
private void ProcRec(int dtID)
{
    if (_proc != null)
    {
        _proc(dtID);
    }

}

public void Push(Message message)
{
     PoolClass.lstDataType1.Where(t => t.dtId == message.DT1ID).FirstOrDefault().lstDataType2.Where(d => d.Id == message.DT2ID).FirstOrDefault().Stack.Push(message);
}

 public class DataType1
        {
            public int dtId;
            public List<DataType2> lstDataType2;

            public DataType1(int tdt1ID, List<DataType2> lstDT2, incRec incRec)
            {
                foreach (DataType2 dt2 in list)
                {
                    DataType2 dt2 = new DataType2(DataLimitReached);
                    lstDataType2.Add(dt2);
                }
            }


  delegate void DataLimitReachedCallback();
  private void DataLimitReached()
    {
        _proc(dt1ID);

    }
}

public class DataType2
{   
  public DataType3 Stack;
  Stack = new DataType3(DataLimitReached);

   delegate void DataLimitReachedCallback();
        private void DataLimitReached()
        {
            if (_DataLimitReached != null)
            {
                _DataLimitReached();
            }

        }   
}

public class DataType3
{
     public delegate void DataLimitReached();
     public DataLimitReached _DataLimitReached;

     public DataType3[] arrData;

     public DataStack(DataLimitReached DataLimitReached)
     {
          _DataLimitReached = DataLimitReached;
     }

     public void Push(Message message)
    {
        //add message to arrData
        //check if data limit was reached, build average
        if (_DataLimitReached != null)
        {
            _DataLimitReached();
        }
    }


}

Server udpServer = new Server(port);
this.udpServer.OnMessage += new Server.DelegateMessageReceived(udpServer_OnMessage);

Module module = new Module();
module.Init();
module.OnProcData += new Module.RecHandler(module_OnProcData);

void udpServer_OnMessage(Message message)
{
    procMessage(message);

}

private void procMessage(Message message)
{
    module.setData(message);
    //I tried: this.actionBlock.Post(message);
}

 void module_OnProcData(Module m, ModuleEventArgs e)
{
  //log data result or put to listbox
}

public class PoolClass
{
      public static List<DataType1> lstDataType1;
}

public CollectData cData;

public void Init()
{
    cData = new CollectData(Proc);

    List<DataType2> lstDT2 = new List<DataType2>;

    cData.Init(lstDT2);

}

public void setData(Message message)
{
    cData.Push(message);
}       


delegate void ProcCallback(int dtID);
private void Proc(int dtID)
{
    DoCalculation(dtID);
    //I tried: this.actionBlock.Post(dtID);
}

private void RaiseProcEvent(ModuleEventArgs e)
{
    if (OnProcData != null)
    {
        OnProcData(this, e);
    }

}

public void DoCalculation(int DT1Id)
{
   //do calculation
   RaiseProcEvent(e);
}

public class Server

public delegate void DelegateMessageReceived(Message message);

Task.Run(async () =>
{
    using (var udpClient = new UdpClient())
    {
        udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
        udpClient.Client.Bind(localpt);

        while (true)
        {
            if (udpClient.Available > 0)
            {
                var receiveBytes = await udpClient.ReceiveAsync();
                if (receiveBytes.Buffer.Length <= 0)
                    return;
                Message message = JsonConvert.DeserializeObject<Message>(Encoding.ASCII.GetString(receiveBytes.Buffer));


                if (OnMessage != null)
                {
                   OnMessage(message);
                }
                //I tried:  this.actionBlock.Post(message);
            }
        }
    }
});

}
  • 输入：UDP数据（使用异步udpclient实现）
  • 从UDP类向主类引发事件（带有消息） 信息：每条消息包含DataType1和DataType2等信息
  • 每条消息都被推送到DataType3的int值列表中
  • 如果int值列表达到指定的值量：
    • 引发事件以调用生成结果的算法
假设我有500个DataType1元素（每个结果引用DataType1的一个元素），处理完成需要将近40秒

我想知道我应该如何尝试（如果可能的话）将该数据流转换为并行数据流，例如，可以在3-5秒内完成？我尝试使用任务并行库，但没有任何收获

我将非常感谢任何关于这项任务的意见，我被卡住了

编辑：

 public CollectData(proc proc)
{
    _proc = proc;
    PoolClass.lstDataType1 = new List<DataType1>();

}

public void Init(List<DataType1> lstDT1, List<DataType2> lstDT2)
{
        foreach (DataType1 dt1Data in lstDT1)
        {
            DataType1 dt1 = new DataType1(dt1ID, lstDT2, IncRec);
            PoolClass.lstDataType1.Add(dt1);

        }


}

delegate void ProcCallback(int dtID);
private void ProcRec(int dtID)
{
    if (_proc != null)
    {
        _proc(dtID);
    }

}

public void Push(Message message)
{
     PoolClass.lstDataType1.Where(t => t.dtId == message.DT1ID).FirstOrDefault().lstDataType2.Where(d => d.Id == message.DT2ID).FirstOrDefault().Stack.Push(message);
}

 public class DataType1
        {
            public int dtId;
            public List<DataType2> lstDataType2;

            public DataType1(int tdt1ID, List<DataType2> lstDT2, incRec incRec)
            {
                foreach (DataType2 dt2 in list)
                {
                    DataType2 dt2 = new DataType2(DataLimitReached);
                    lstDataType2.Add(dt2);
                }
            }


  delegate void DataLimitReachedCallback();
  private void DataLimitReached()
    {
        _proc(dt1ID);

    }
}

public class DataType2
{   
  public DataType3 Stack;
  Stack = new DataType3(DataLimitReached);

   delegate void DataLimitReachedCallback();
        private void DataLimitReached()
        {
            if (_DataLimitReached != null)
            {
                _DataLimitReached();
            }

        }   
}

public class DataType3
{
     public delegate void DataLimitReached();
     public DataLimitReached _DataLimitReached;

     public DataType3[] arrData;

     public DataStack(DataLimitReached DataLimitReached)
     {
          _DataLimitReached = DataLimitReached;
     }

     public void Push(Message message)
    {
        //add message to arrData
        //check if data limit was reached, build average
        if (_DataLimitReached != null)
        {
            _DataLimitReached();
        }
    }


}

Server udpServer = new Server(port);
this.udpServer.OnMessage += new Server.DelegateMessageReceived(udpServer_OnMessage);

Module module = new Module();
module.Init();
module.OnProcData += new Module.RecHandler(module_OnProcData);

void udpServer_OnMessage(Message message)
{
    procMessage(message);

}

private void procMessage(Message message)
{
    module.setData(message);
    //I tried: this.actionBlock.Post(message);
}

 void module_OnProcData(Module m, ModuleEventArgs e)
{
  //log data result or put to listbox
}

public class PoolClass
{
      public static List<DataType1> lstDataType1;
}

public CollectData cData;

public void Init()
{
    cData = new CollectData(Proc);

    List<DataType2> lstDT2 = new List<DataType2>;

    cData.Init(lstDT2);

}

public void setData(Message message)
{
    cData.Push(message);
}       


delegate void ProcCallback(int dtID);
private void Proc(int dtID)
{
    DoCalculation(dtID);
    //I tried: this.actionBlock.Post(dtID);
}

private void RaiseProcEvent(ModuleEventArgs e)
{
    if (OnProcData != null)
    {
        OnProcData(this, e);
    }

}

public void DoCalculation(int DT1Id)
{
   //do calculation
   RaiseProcEvent(e);
}

public class Server

public delegate void DelegateMessageReceived(Message message);

Task.Run(async () =>
{
    using (var udpClient = new UdpClient())
    {
        udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
        udpClient.Client.Bind(localpt);

        while (true)
        {
            if (udpClient.Available > 0)
            {
                var receiveBytes = await udpClient.ReceiveAsync();
                if (receiveBytes.Buffer.Length <= 0)
                    return;
                Message message = JsonConvert.DeserializeObject<Message>(Encoding.ASCII.GetString(receiveBytes.Buffer));


                if (OnMessage != null)
                {
                   OnMessage(message);
                }
                //I tried:  this.actionBlock.Post(message);
            }
        }
    }
});

}
@斯维克：谢谢你的回复。我试着对我的结构进行更详细的阐述。 下面是一些源代码。如您所见，我使用了很多回调构造、不同的类、列表等等。首先回答问题2和3： 我目前使用的是双核处理器，我可能没有机会得到它 使用性能更好的任何东西。我希望在表现上有所提高的原因 是因为希望我的源代码可以针对它进行优化。 当我使用任务并行库时，我构建了一个特殊类型的actionblock 调用Post而不是我以前的代码，后者调用了执行相同代码的方法 和以前一样（只是希望在引擎盖下它与任务等并行完成）。 （您可以在下面我的源代码（“我尝试过”）中找到这些行） 一旦达到数据限制，就会引发一系列回调。每个数据类型1都已完成， 一旦他的一个DataType2元素有一个填充堆栈。然后，一个算法开始运行 比较不同的堆栈。 这是为每个DataType1元素完成的，因此我希望以某种方式并行完成

在这里您可以找到一些代码片段。 p、 美国：我试图通过第二个应用程序模拟数据，因为我构建了一个包含近4000条消息的列表，这些消息通过foreach循环中的udp发送到我的应用程序。（在同一台机器上使用相同的端口）

模型类（每个类向其上级类转发回调）：

收集数据：

 public CollectData(proc proc)
{
    _proc = proc;
    PoolClass.lstDataType1 = new List<DataType1>();

}

public void Init(List<DataType1> lstDT1, List<DataType2> lstDT2)
{
        foreach (DataType1 dt1Data in lstDT1)
        {
            DataType1 dt1 = new DataType1(dt1ID, lstDT2, IncRec);
            PoolClass.lstDataType1.Add(dt1);

        }


}

delegate void ProcCallback(int dtID);
private void ProcRec(int dtID)
{
    if (_proc != null)
    {
        _proc(dtID);
    }

}

public void Push(Message message)
{
     PoolClass.lstDataType1.Where(t => t.dtId == message.DT1ID).FirstOrDefault().lstDataType2.Where(d => d.Id == message.DT2ID).FirstOrDefault().Stack.Push(message);
}

 public class DataType1
        {
            public int dtId;
            public List<DataType2> lstDataType2;

            public DataType1(int tdt1ID, List<DataType2> lstDT2, incRec incRec)
            {
                foreach (DataType2 dt2 in list)
                {
                    DataType2 dt2 = new DataType2(DataLimitReached);
                    lstDataType2.Add(dt2);
                }
            }


  delegate void DataLimitReachedCallback();
  private void DataLimitReached()
    {
        _proc(dt1ID);

    }
}

public class DataType2
{   
  public DataType3 Stack;
  Stack = new DataType3(DataLimitReached);

   delegate void DataLimitReachedCallback();
        private void DataLimitReached()
        {
            if (_DataLimitReached != null)
            {
                _DataLimitReached();
            }

        }   
}

public class DataType3
{
     public delegate void DataLimitReached();
     public DataLimitReached _DataLimitReached;

     public DataType3[] arrData;

     public DataStack(DataLimitReached DataLimitReached)
     {
          _DataLimitReached = DataLimitReached;
     }

     public void Push(Message message)
    {
        //add message to arrData
        //check if data limit was reached, build average
        if (_DataLimitReached != null)
        {
            _DataLimitReached();
        }
    }


}

Server udpServer = new Server(port);
this.udpServer.OnMessage += new Server.DelegateMessageReceived(udpServer_OnMessage);

Module module = new Module();
module.Init();
module.OnProcData += new Module.RecHandler(module_OnProcData);

void udpServer_OnMessage(Message message)
{
    procMessage(message);

}

private void procMessage(Message message)
{
    module.setData(message);
    //I tried: this.actionBlock.Post(message);
}

 void module_OnProcData(Module m, ModuleEventArgs e)
{
  //log data result or put to listbox
}

public class PoolClass
{
      public static List<DataType1> lstDataType1;
}

public CollectData cData;

public void Init()
{
    cData = new CollectData(Proc);

    List<DataType2> lstDT2 = new List<DataType2>;

    cData.Init(lstDT2);

}

public void setData(Message message)
{
    cData.Push(message);
}       


delegate void ProcCallback(int dtID);
private void Proc(int dtID)
{
    DoCalculation(dtID);
    //I tried: this.actionBlock.Post(dtID);
}

private void RaiseProcEvent(ModuleEventArgs e)
{
    if (OnProcData != null)
    {
        OnProcData(this, e);
    }

}

public void DoCalculation(int DT1Id)
{
   //do calculation
   RaiseProcEvent(e);
}

public class Server

public delegate void DelegateMessageReceived(Message message);

Task.Run(async () =>
{
    using (var udpClient = new UdpClient())
    {
        udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
        udpClient.Client.Bind(localpt);

        while (true)
        {
            if (udpClient.Available > 0)
            {
                var receiveBytes = await udpClient.ReceiveAsync();
                if (receiveBytes.Buffer.Length <= 0)
                    return;
                Message message = JsonConvert.DeserializeObject<Message>(Encoding.ASCII.GetString(receiveBytes.Buffer));


                if (OnMessage != null)
                {
                   OnMessage(message);
                }
                //I tried:  this.actionBlock.Post(message);
            }
        }
    }
});

}
数据类型3:

 public CollectData(proc proc)
{
    _proc = proc;
    PoolClass.lstDataType1 = new List<DataType1>();

}

public void Init(List<DataType1> lstDT1, List<DataType2> lstDT2)
{
        foreach (DataType1 dt1Data in lstDT1)
        {
            DataType1 dt1 = new DataType1(dt1ID, lstDT2, IncRec);
            PoolClass.lstDataType1.Add(dt1);

        }


}

delegate void ProcCallback(int dtID);
private void ProcRec(int dtID)
{
    if (_proc != null)
    {
        _proc(dtID);
    }

}

public void Push(Message message)
{
     PoolClass.lstDataType1.Where(t => t.dtId == message.DT1ID).FirstOrDefault().lstDataType2.Where(d => d.Id == message.DT2ID).FirstOrDefault().Stack.Push(message);
}

 public class DataType1
        {
            public int dtId;
            public List<DataType2> lstDataType2;

            public DataType1(int tdt1ID, List<DataType2> lstDT2, incRec incRec)
            {
                foreach (DataType2 dt2 in list)
                {
                    DataType2 dt2 = new DataType2(DataLimitReached);
                    lstDataType2.Add(dt2);
                }
            }


  delegate void DataLimitReachedCallback();
  private void DataLimitReached()
    {
        _proc(dt1ID);

    }
}

public class DataType2
{   
  public DataType3 Stack;
  Stack = new DataType3(DataLimitReached);

   delegate void DataLimitReachedCallback();
        private void DataLimitReached()
        {
            if (_DataLimitReached != null)
            {
                _DataLimitReached();
            }

        }   
}

public class DataType3
{
     public delegate void DataLimitReached();
     public DataLimitReached _DataLimitReached;

     public DataType3[] arrData;

     public DataStack(DataLimitReached DataLimitReached)
     {
          _DataLimitReached = DataLimitReached;
     }

     public void Push(Message message)
    {
        //add message to arrData
        //check if data limit was reached, build average
        if (_DataLimitReached != null)
        {
            _DataLimitReached();
        }
    }


}

Server udpServer = new Server(port);
this.udpServer.OnMessage += new Server.DelegateMessageReceived(udpServer_OnMessage);

Module module = new Module();
module.Init();
module.OnProcData += new Module.RecHandler(module_OnProcData);

void udpServer_OnMessage(Message message)
{
    procMessage(message);

}

private void procMessage(Message message)
{
    module.setData(message);
    //I tried: this.actionBlock.Post(message);
}

 void module_OnProcData(Module m, ModuleEventArgs e)
{
  //log data result or put to listbox
}

public class PoolClass
{
      public static List<DataType1> lstDataType1;
}

public CollectData cData;

public void Init()
{
    cData = new CollectData(Proc);

    List<DataType2> lstDT2 = new List<DataType2>;

    cData.Init(lstDT2);

}

public void setData(Message message)
{
    cData.Push(message);
}       


delegate void ProcCallback(int dtID);
private void Proc(int dtID)
{
    DoCalculation(dtID);
    //I tried: this.actionBlock.Post(dtID);
}

private void RaiseProcEvent(ModuleEventArgs e)
{
    if (OnProcData != null)
    {
        OnProcData(this, e);
    }

}

public void DoCalculation(int DT1Id)
{
   //do calculation
   RaiseProcEvent(e);
}

public class Server

public delegate void DelegateMessageReceived(Message message);

Task.Run(async () =>
{
    using (var udpClient = new UdpClient())
    {
        udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
        udpClient.Client.Bind(localpt);

        while (true)
        {
            if (udpClient.Available > 0)
            {
                var receiveBytes = await udpClient.ReceiveAsync();
                if (receiveBytes.Buffer.Length <= 0)
                    return;
                Message message = JsonConvert.DeserializeObject<Message>(Encoding.ASCII.GetString(receiveBytes.Buffer));


                if (OnMessage != null)
                {
                   OnMessage(message);
                }
                //I tried:  this.actionBlock.Post(message);
            }
        }
    }
});

}
Main:

 public CollectData(proc proc)
{
    _proc = proc;
    PoolClass.lstDataType1 = new List<DataType1>();

}

public void Init(List<DataType1> lstDT1, List<DataType2> lstDT2)
{
        foreach (DataType1 dt1Data in lstDT1)
        {
            DataType1 dt1 = new DataType1(dt1ID, lstDT2, IncRec);
            PoolClass.lstDataType1.Add(dt1);

        }


}

delegate void ProcCallback(int dtID);
private void ProcRec(int dtID)
{
    if (_proc != null)
    {
        _proc(dtID);
    }

}

public void Push(Message message)
{
     PoolClass.lstDataType1.Where(t => t.dtId == message.DT1ID).FirstOrDefault().lstDataType2.Where(d => d.Id == message.DT2ID).FirstOrDefault().Stack.Push(message);
}

 public class DataType1
        {
            public int dtId;
            public List<DataType2> lstDataType2;

            public DataType1(int tdt1ID, List<DataType2> lstDT2, incRec incRec)
            {
                foreach (DataType2 dt2 in list)
                {
                    DataType2 dt2 = new DataType2(DataLimitReached);
                    lstDataType2.Add(dt2);
                }
            }


  delegate void DataLimitReachedCallback();
  private void DataLimitReached()
    {
        _proc(dt1ID);

    }
}

public class DataType2
{   
  public DataType3 Stack;
  Stack = new DataType3(DataLimitReached);

   delegate void DataLimitReachedCallback();
        private void DataLimitReached()
        {
            if (_DataLimitReached != null)
            {
                _DataLimitReached();
            }

        }   
}

public class DataType3
{
     public delegate void DataLimitReached();
     public DataLimitReached _DataLimitReached;

     public DataType3[] arrData;

     public DataStack(DataLimitReached DataLimitReached)
     {
          _DataLimitReached = DataLimitReached;
     }

     public void Push(Message message)
    {
        //add message to arrData
        //check if data limit was reached, build average
        if (_DataLimitReached != null)
        {
            _DataLimitReached();
        }
    }


}

Server udpServer = new Server(port);
this.udpServer.OnMessage += new Server.DelegateMessageReceived(udpServer_OnMessage);

Module module = new Module();
module.Init();
module.OnProcData += new Module.RecHandler(module_OnProcData);

void udpServer_OnMessage(Message message)
{
    procMessage(message);

}

private void procMessage(Message message)
{
    module.setData(message);
    //I tried: this.actionBlock.Post(message);
}

 void module_OnProcData(Module m, ModuleEventArgs e)
{
  //log data result or put to listbox
}

public class PoolClass
{
      public static List<DataType1> lstDataType1;
}

public CollectData cData;

public void Init()
{
    cData = new CollectData(Proc);

    List<DataType2> lstDT2 = new List<DataType2>;

    cData.Init(lstDT2);

}

public void setData(Message message)
{
    cData.Push(message);
}       


delegate void ProcCallback(int dtID);
private void Proc(int dtID)
{
    DoCalculation(dtID);
    //I tried: this.actionBlock.Post(dtID);
}

private void RaiseProcEvent(ModuleEventArgs e)
{
    if (OnProcData != null)
    {
        OnProcData(this, e);
    }

}

public void DoCalculation(int DT1Id)
{
   //do calculation
   RaiseProcEvent(e);
}

public class Server

public delegate void DelegateMessageReceived(Message message);

Task.Run(async () =>
{
    using (var udpClient = new UdpClient())
    {
        udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
        udpClient.Client.Bind(localpt);

        while (true)
        {
            if (udpClient.Available > 0)
            {
                var receiveBytes = await udpClient.ReceiveAsync();
                if (receiveBytes.Buffer.Length <= 0)
                    return;
                Message message = JsonConvert.DeserializeObject<Message>(Encoding.ASCII.GetString(receiveBytes.Buffer));


                if (OnMessage != null)
                {
                   OnMessage(message);
                }
                //I tried:  this.actionBlock.Post(message);
            }
        }
    }
});

}

Server udpServer=新服务器（端口）；
this.udpServer.OnMessage+=新服务器.DelegateMessageReceived（udpServer_OnMessage）；
模块=新模块（）；
module.Init（）；
module.OnProcData+=新的module.RecHandler（module_OnProcData）；
无效udpServer_OnMessage（消息消息消息）
{
procMessage（消息）；
}
私有消息（消息消息消息）
{
模块设置数据（消息）；
//我试过：this.actionBlock.Post（message）；
}
无效模块（模块m，模块e）
{
//记录数据结果或放入列表框
}
公共类池类
{
公共静态列表lstDataType1；
}
模块：

 public CollectData(proc proc)
{
    _proc = proc;
    PoolClass.lstDataType1 = new List<DataType1>();

}

public void Init(List<DataType1> lstDT1, List<DataType2> lstDT2)
{
        foreach (DataType1 dt1Data in lstDT1)
        {
            DataType1 dt1 = new DataType1(dt1ID, lstDT2, IncRec);
            PoolClass.lstDataType1.Add(dt1);

        }


}

delegate void ProcCallback(int dtID);
private void ProcRec(int dtID)
{
    if (_proc != null)
    {
        _proc(dtID);
    }

}

public void Push(Message message)
{
     PoolClass.lstDataType1.Where(t => t.dtId == message.DT1ID).FirstOrDefault().lstDataType2.Where(d => d.Id == message.DT2ID).FirstOrDefault().Stack.Push(message);
}

 public class DataType1
        {
            public int dtId;
            public List<DataType2> lstDataType2;

            public DataType1(int tdt1ID, List<DataType2> lstDT2, incRec incRec)
            {
                foreach (DataType2 dt2 in list)
                {
                    DataType2 dt2 = new DataType2(DataLimitReached);
                    lstDataType2.Add(dt2);
                }
            }


  delegate void DataLimitReachedCallback();
  private void DataLimitReached()
    {
        _proc(dt1ID);

    }
}

public class DataType2
{   
  public DataType3 Stack;
  Stack = new DataType3(DataLimitReached);

   delegate void DataLimitReachedCallback();
        private void DataLimitReached()
        {
            if (_DataLimitReached != null)
            {
                _DataLimitReached();
            }

        }   
}

public class DataType3
{
     public delegate void DataLimitReached();
     public DataLimitReached _DataLimitReached;

     public DataType3[] arrData;

     public DataStack(DataLimitReached DataLimitReached)
     {
          _DataLimitReached = DataLimitReached;
     }

     public void Push(Message message)
    {
        //add message to arrData
        //check if data limit was reached, build average
        if (_DataLimitReached != null)
        {
            _DataLimitReached();
        }
    }


}

Server udpServer = new Server(port);
this.udpServer.OnMessage += new Server.DelegateMessageReceived(udpServer_OnMessage);

Module module = new Module();
module.Init();
module.OnProcData += new Module.RecHandler(module_OnProcData);

void udpServer_OnMessage(Message message)
{
    procMessage(message);

}

private void procMessage(Message message)
{
    module.setData(message);
    //I tried: this.actionBlock.Post(message);
}

 void module_OnProcData(Module m, ModuleEventArgs e)
{
  //log data result or put to listbox
}

public class PoolClass
{
      public static List<DataType1> lstDataType1;
}

public CollectData cData;

public void Init()
{
    cData = new CollectData(Proc);

    List<DataType2> lstDT2 = new List<DataType2>;

    cData.Init(lstDT2);

}

public void setData(Message message)
{
    cData.Push(message);
}       


delegate void ProcCallback(int dtID);
private void Proc(int dtID)
{
    DoCalculation(dtID);
    //I tried: this.actionBlock.Post(dtID);
}

private void RaiseProcEvent(ModuleEventArgs e)
{
    if (OnProcData != null)
    {
        OnProcData(this, e);
    }

}

public void DoCalculation(int DT1Id)
{
   //do calculation
   RaiseProcEvent(e);
}

public class Server

public delegate void DelegateMessageReceived(Message message);

Task.Run(async () =>
{
    using (var udpClient = new UdpClient())
    {
        udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
        udpClient.Client.Bind(localpt);

        while (true)
        {
            if (udpClient.Available > 0)
            {
                var receiveBytes = await udpClient.ReceiveAsync();
                if (receiveBytes.Buffer.Length <= 0)
                    return;
                Message message = JsonConvert.DeserializeObject<Message>(Encoding.ASCII.GetString(receiveBytes.Buffer));


                if (OnMessage != null)
                {
                   OnMessage(message);
                }
                //I tried:  this.actionBlock.Post(message);
            }
        }
    }
});

}

公共数据采集cData；
公共void Init（）
{
cData=新采集数据（Proc）；
列表lstDT2=新列表；
cData.Init（lstDT2）；
}
公共无效设置数据（消息）
{
cData.推送（信息）；
}       
委托无效回调（int-dtID）；
私有无效过程（int dtID）
{
数据计算（dtID）；
//我试过：this.actionBlock.Post（dtID）；
}
私有无效提升程序（模块EventArgs e）
{
如果（OnProcData！=null）
{
OnProcData（本，e）；
}
}
公共无效数据计算（int DT1Id）
{
//计算
提高程序（e）；
}
UDP:

 public CollectData(proc proc)
{
    _proc = proc;
    PoolClass.lstDataType1 = new List<DataType1>();

}

public void Init(List<DataType1> lstDT1, List<DataType2> lstDT2)
{
        foreach (DataType1 dt1Data in lstDT1)
        {
            DataType1 dt1 = new DataType1(dt1ID, lstDT2, IncRec);
            PoolClass.lstDataType1.Add(dt1);

        }


}

delegate void ProcCallback(int dtID);
private void ProcRec(int dtID)
{
    if (_proc != null)
    {
        _proc(dtID);
    }

}

public void Push(Message message)
{
     PoolClass.lstDataType1.Where(t => t.dtId == message.DT1ID).FirstOrDefault().lstDataType2.Where(d => d.Id == message.DT2ID).FirstOrDefault().Stack.Push(message);
}

 public class DataType1
        {
            public int dtId;
            public List<DataType2> lstDataType2;

            public DataType1(int tdt1ID, List<DataType2> lstDT2, incRec incRec)
            {
                foreach (DataType2 dt2 in list)
                {
                    DataType2 dt2 = new DataType2(DataLimitReached);
                    lstDataType2.Add(dt2);
                }
            }


  delegate void DataLimitReachedCallback();
  private void DataLimitReached()
    {
        _proc(dt1ID);

    }
}

public class DataType2
{   
  public DataType3 Stack;
  Stack = new DataType3(DataLimitReached);

   delegate void DataLimitReachedCallback();
        private void DataLimitReached()
        {
            if (_DataLimitReached != null)
            {
                _DataLimitReached();
            }

        }   
}

public class DataType3
{
     public delegate void DataLimitReached();
     public DataLimitReached _DataLimitReached;

     public DataType3[] arrData;

     public DataStack(DataLimitReached DataLimitReached)
     {
          _DataLimitReached = DataLimitReached;
     }

     public void Push(Message message)
    {
        //add message to arrData
        //check if data limit was reached, build average
        if (_DataLimitReached != null)
        {
            _DataLimitReached();
        }
    }


}

Server udpServer = new Server(port);
this.udpServer.OnMessage += new Server.DelegateMessageReceived(udpServer_OnMessage);

Module module = new Module();
module.Init();
module.OnProcData += new Module.RecHandler(module_OnProcData);

void udpServer_OnMessage(Message message)
{
    procMessage(message);

}

private void procMessage(Message message)
{
    module.setData(message);
    //I tried: this.actionBlock.Post(message);
}

 void module_OnProcData(Module m, ModuleEventArgs e)
{
  //log data result or put to listbox
}

public class PoolClass
{
      public static List<DataType1> lstDataType1;
}

public CollectData cData;

public void Init()
{
    cData = new CollectData(Proc);

    List<DataType2> lstDT2 = new List<DataType2>;

    cData.Init(lstDT2);

}

public void setData(Message message)
{
    cData.Push(message);
}       


delegate void ProcCallback(int dtID);
private void Proc(int dtID)
{
    DoCalculation(dtID);
    //I tried: this.actionBlock.Post(dtID);
}

private void RaiseProcEvent(ModuleEventArgs e)
{
    if (OnProcData != null)
    {
        OnProcData(this, e);
    }

}

public void DoCalculation(int DT1Id)
{
   //do calculation
   RaiseProcEvent(e);
}

public class Server

public delegate void DelegateMessageReceived(Message message);

Task.Run(async () =>
{
    using (var udpClient = new UdpClient())
    {
        udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
        udpClient.Client.Bind(localpt);

        while (true)
        {
            if (udpClient.Available > 0)
            {
                var receiveBytes = await udpClient.ReceiveAsync();
                if (receiveBytes.Buffer.Length <= 0)
                    return;
                Message message = JsonConvert.DeserializeObject<Message>(Encoding.ASCII.GetString(receiveBytes.Buffer));


                if (OnMessage != null)
                {
                   OnMessage(message);
                }
                //I tried:  this.actionBlock.Post(message);
            }
        }
    }
});

}

公共类服务器
接收到公共委托无效的DelegateMessage（消息消息）；
Task.Run（异步（）=>
{
使用（var udpClient=new udpClient（））
{
udpClient.Client.SetSocketOption（SocketOptionLevel.Socket，SocketOptionName.ReuseAddress，true）；
udpClient.Client.Bind（localpt）；
while（true）
{
如果（udpClient.Available>0）
{
var receiveBytes=await udpClient.ReceiveAsync（）；

如果（receiveBytes.Buffer.Length 1.从你的描述中，我不清楚到底发生了什么。你能提供一些代码来演示数据流是如何工作的吗？2.是什么让你认为你可以实现10倍的加速？你有一台拥有10个以上内核的机器吗？3.你能描述一下你到底尝试了什么吗？我试着回答你的问题e下面的答案，我无法将那么多信息添加到评论中，我希望这是正确的方式。（想知道否决票的情况）对您的问题的更新应该通过编辑问题而不是添加答案来完成。哦，我明白了，很抱歉，我不知道，下次会记住，谢谢。