एएसआईएनसी सॉकेट समानांतर और टीपीएल

Question

का उपयोग करके बहुत गहन अनुप्रयोग में समवर्ती नहीं है। मैं सॉकेट का उपयोग करने वाला एक एप्लीकेशन लिख रहा हूं और यह बहुत गहन होगा तो मुझे वास्तव में हमारे बड़े सर्वर में हमारे प्रत्येक कोर का उपयोग करने की आवश्यकता है। मुझे प्रश्न (how to using ThreadPool to run socket thread parallel?) यहां स्टैक ओवरफ्लो में दिखाई देता है, केवल एक ही जवाब है जो इस MSDN Sample पर इंगित करता है।

लेकिन मैं इसे केवल इशारा करते हैं कि यह कैसे समवर्ती और नहीं समानांतर लगता है, यहाँ किसी को How cpu intensive is opening a socket और उसके दिखता पूछ बहुत गहन होना है, किसी को यहाँ बता इसकी न TPL TaskFactory.FromAsync vs Tasks with blocking methods मदद और किसी को पढ़ाने इसे यहाँ कैसे करना है जबकि TaskFactory.FromAsync (Is there a pattern for wrapping existing BeginXXX/EndXXX async methods into async tasks?)।

मैं सॉकेट ऑपरेशंस को समानांतर और निष्पादक कैसे रख सकता हूं और अगर सॉकेट डिस्कनेक्शन, आधा कनेक्टेड सॉकेट और संदेश सीमाएं जैसी समस्याएं सामान्य एसिंक तरीके से सिरदर्द हैं। अगर टीपीएल और टास्क एक साथ रखा जाता है तो इससे कैसे निपटें।

Answer 1

इस लिंक को TPL and Traditional .NET Asynchronous Programming के बारे में देखें, यह उत्तर नहीं देता लेकिन शायद आपकी मदद कर सकता है। वहाँ जानकारी के बारे में अतुल्यकालिक प्रोग्रामिंग मॉडल (एपीएम) और घटना-आधारित अतुल्यकालिक पैटर्न (EAP) है

Answer 2

कि देखें:

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Net; 
using System.Net.Sockets; 
using System.Text; 
using System.Threading; 
using System.Threading.Tasks; 

namespace skttool 
{ 
    public class StateObject 
    { 
     public Socket workSocket = null; 
     public const int BufferSize = 1024; 
     public byte[] buffer = new byte[BufferSize]; 
     public int bytesRead = 0; 
     public StringBuilder sb = new StringBuilder(); 
    } 

    public class tool 
    { 
     //------------------------------------------------- 
     private ManualResetEvent evtConnectionDone = new ManualResetEvent(false); 
     private Socket skttool = null; 
     private bool running = false; 
     private StateObject state = null; 
     //------------------------------------------------- 
     toolConfig _cfg; 
     public tool(toolConfig cfg) 
     { 
      _cfg = cfg; 
     } 
     //------------------------------------------------- 
     public void socketListeningSet() 
     { 
      IPEndPoint localEndPoint; 
      Socket skttool; 
      byte[] bytes = new Byte[1024]; 
      localEndPoint = new IPEndPoint(IPAddress.Any, _cfg.addressPort); 
      skttool = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); 
      skttool.Bind(localEndPoint); 
      skttool.Listen(_cfg.maxQtdSockets); 
     } 
     //------------------------------------------------- 
     public void start() 
     { 
      running = true; 
      Task T1 = Task.Factory.StartNew(socketListeningSet); 
      T1.ContinueWith(prev => 
      { 
       while (running) 
       { 
        evtConnectionDone.Reset(); 
        Task<Socket> accepetChunk = Task<Socket>.Factory.FromAsync(
                     skttool.BeginAccept, 
                     skttool.EndAccept, 
                     accept, 
                     skttool, 
                     TaskCreationOptions.AttachedToParent); 
        accepetChunk.ContinueWith(accept, TaskContinuationOptions.NotOnFaulted | TaskCreationOptions.AttachedToParent); 
        evtConnectionDone.WaitOne(); 
       } 
      }); 
     } 
     //------------------------------------------------- 
     void accept(Task<Socket> accepetChunk) 
     { 
      state = new StateObject(); 
      evtConnectionDone.Set(); 
      state.workSocket = accepetChunk.Result; 
      Task<int> readChunk = Task<int>.Factory.FromAsync(
                 state.workSocket.BeginReceive, 
                 state.workSocket.EndReceive, 
                 state.buffer, 
                 state.bytesRead, 
                 state.buffer.Length - state.bytesRead, 
                 null, 
                 TaskCreationOptions.AttachedToParent); 
      readChunk.ContinueWith(read, TaskContinuationOptions.NotOnFaulted | TaskCreationOptions.AttachedToParent); 
     } 
     //------------------------------------------------- 
     void read(Task<int> readChunk) 
     { 
      state.bytesRead += readChunk.Result; 
      if (readChunk.Result > 0 && state.bytesRead < state.buffer.Length) 
      { 
       read(); 
       return; 
      } 
      _data = doTask(_data); 
      Task<int> sendChunk = Task<int>.Factory.FromAsync(
                 state.workSocket.BeginSend, 
                 state.workSocket.EndSend, 
                 state.buffer, 
                 state.bytesRead, 
                 state.buffer.Length - state.bytesRead, 
                 null, 
                 TaskCreationOptions.AttachedToParent); 
      sendChunk.ContinueWith(send, TaskContinuationOptions.NotOnFaulted | TaskCreationOptions.AttachedToParent); 
     } 
     //------------------------------------------------- 
     void send(Task<int> readChunk) 
     { 
      state.workSocket.Shutdown(SocketShutdown.Both); 
      state.workSocket.Close(); 
     } 
     //------------------------------------------------- 
     byte[] doTask(byte[] data) 
     { 
      return Array.Reverse(data); 
     } 
     //------------------------------------------------- 
    } 
}