Question

我有一个应用程序可以打开套接字并通过它发送信息。此功能封装在一个类中。

如果我使用Parallel.ForEach运行此功能，我认为并行工作可能很容易。这样，每个任务都会打开/关闭一个套接字并通过它发送（到同一个ip / port）。此解决方案不起作用。

第二种方式，我以异步方式实现套接字操作，其行为是服务器从第一个任务接收所有数据，然后从其他任务接收其余数据。从服务器端来看，没有并行行为。

我正在搜索和阅读有关此内容的信息，但我无法解决此问题。

有什么想法吗？您是否有使用并行库的套接字的完整示例？或者在多线程环境中使用套接字的任何完整示例？

补充资料：

我有一个返回文件列表的LINQ表达式。此列表按以下方式处理：

Parallel.ForEach(AllFiles, new ParallelOptions { MaxDegreeOfParallelism = _maxDegreeOfParallelism }, currentFile => 
{
    ProcessFiles(currentFile);
});

...

ProcessFiles sumarized：

void ProcessFile (string currentFile)
{
    MyTcpClient client = null;

    try
    {  
        var AllLinesInFiles = // LINQ Expression that returns a list of strings    
        int port = 23000;
        client = new MyTcpServer(ip, port);                

        foreach (string data in AllLinesInFiles)
        {
            if (data.Length > 0)
            {
                if (!client.IsOk)
                {
                    client.Connect(false);
                    if (!client.IsOk)
                        break;
                }
                client.SendMessage(tmpLine2);
        }                   
    }
}            
catch (Exception ex)
{
    ...
}
finally
{
    if ((client != null) && (client.IsOk))
        client.Close();                
}

}

MyTcpClient，同步版本是：

public class MyTcpClient : IDisposable 
{
    private static object objLock = new object();
    public int Port = ...
    public IPAddress IPAddress = ...              
    private string _Host;
    private TcpClient _client = null;        
    private Stream _stream = null;

    static MyTcpClient()
    {
    }

    public MyTcpClient(string PassedIPAddress, Int32 PassedPort)
    {
        try
        {                
            this.IPAddress = PassedIPAddress;
            this.Port = PassedPort;
        }
        catch (Exception ex)
        {
            ...
        }
    }

    public TcpClient TcpClient
    {
        get { return _client; }
        set { _client = value; }
    }

    public X509Certificate Certificate
    {
        get { return _certificate; }
        set { _certificate = value; }
    }

    public bool IsOk
    {
        get 
        {
            return ((_client != null) && (_client.Connected));           
        }
    }

    public void Connect(bool isSecure)
    {
        if (IsOk == false)
        {                
            _client = new TcpClient(this.IPAddress.ToString(), this.Port);                
            _stream = null;

            try
            {                                     
                NetworkStream networkStream = _client.GetStream();
                _stream = (NetworkStream)networkStream;

            }
            catch (AuthenticationException ex)
            {
                ...
            }
            catch (Exception ex)
            {
                ...                    
            }
            finally
            {

            }
        }
    }

    public void SendMessage(string message)
    {
        if (_client != null && IsOk)
        {
            byte[] dgram = EncodingHelper.GetEncoding().GetBytes(message);

            lock (MyTcpClient.objLock)                
            {
                _stream.Write(dgram, 0, dgram.Length);
            }
        }
    }

    public void SendMessage(byte[] dgram)
    {
        if (_client != null && IsOk)
        {
            lock (MyTcpClient.objLock)                
            {
                _stream.Write(dgram, 0, dgram.Length);
            }
        }
    }

    public void Close()
    {
        this.Dispose();
    }

    public void Dispose()
    {
        if (_stream != null)
        {
            _stream.Close();
        }
        if (_client != null)
        {
            _client.Close();
        }
    }
}

对于异步版本，我在这里使用了示例http://msdn.microsoft.com/en-us/library/bew39x2a.aspx 当我使用异步套接字客户端时，我更新了ProcessFile方法但是，这个想法是在这个方法中打开/关闭套接字。

使用parallels通过套接字发送数据

0 个答案: