项目需要，最近在着手开发的一个网站队列处理系统的一个网络模块

最新推荐文章于 2024-09-16 09:36:19 发布

pdckxd

最新推荐文章于 2024-09-16 09:36:19 发布

阅读量524

点赞数

分类专栏： C# 文章标签：网络 socket string asynchronous exception thread

本文链接：https://blog.csdn.net/pdckxd/article/details/6161417

版权

C# 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

其中使用到了Socket的非阻塞方法来接受数据，然后交由另一个线程进行命令的解释（只是将命令整条提取出来放入队列或者列表中），客户端测试程序有空再放出吧，测试的话用网络调试软件发ascii字符就可以

[6]abcd12

6为长度

abcd12为命令字符串（提取到队列或列表中的部分）

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Data;
using System.Collections.Generic;
using System.Text.RegularExpressions;
  
// State object for reading client data asynchronously
public class StateObject
{
    // Client  socket.
    public Socket workSocket = null;
    // Size of receive buffer.
    public const int BufferSize = 1024;
    // Receive buffer.
    public byte[] buffer = new byte[BufferSize];
    // Received data string.
    public StringBuilder sb = new StringBuilder();
    // Offset
    public int counter = 0;
    //
    public bool isDisconnected = false;
    //
    public Thread dataParseThread = null;
    //
    public ManualResetEvent readDone = new ManualResetEvent(false);
    //
    public ManualResetEvent ProcessDone = new ManualResetEvent(false);
}
  
public class AsynchronousSocketListener
{
    public static int Main(String[] args)
    {
        //StartListening();
  
        AsyncSocketServer asyncServer = new AsyncSocketServer();
        asyncServer.StartListening();
  
        return 0;
    }
}
  
public class AsyncSocketServer
{
    // Thread signal.
    private ManualResetEvent allDone = new ManualResetEvent(false);
  
    public AsyncSocketServer()
    {
    }
  
    public void StartListening()
    {
        // Data buffer for incoming data.
        byte[] bytes = new Byte[1024];
  
        // Establish the local endpoint for the socket.
        // The DNS name of the computer
        // running the listener is "host.contoso.com".
        IPHostEntry ipHostInfo = Dns.GetHostEntry("127.0.0.1");
        IPAddress ipAddress = ipHostInfo.AddressList[0];
        IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);
  
        // Create a TCP/IP socket.
        Socket listener = new Socket(AddressFamily.InterNetwork,
            SocketType.Stream, ProtocolType.Tcp);
  
        // Bind the socket to the local endpoint and listen for incoming connections.
        try
        {
            listener.Bind(localEndPoint);
            listener.Listen(10);
  
            while (true)
            {
                // Set the event to nonsignaled state.
                allDone.Reset();
  
                // Start an asynchronous socket to listen for connections.
                Console.WriteLine("Waiting for a connection...");
                listener.BeginAccept(
                    new AsyncCallback(AcceptCallback),
                    listener);
  
                // Wait until a connection is made before continuing.
                allDone.WaitOne();
            }
  
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
  
        Console.WriteLine("/nPress ENTER to continue...");
        Console.Read();
  
    }
  
    public void AcceptCallback(IAsyncResult ar)
    {
        // Signal the main thread to continue.
        allDone.Set();
  
        // Get the socket that handles the client request.
        Socket listener = (Socket)ar.AsyncState;
        Socket handler = listener.EndAccept(ar);
  
        // Create the state object.
        StateObject state = new StateObject();
        state.workSocket = handler;
  
        DataProcessor dateProcessor = new DataProcessor(state);
  
        Thread t = new Thread(dateProcessor.ParseRowData);
        state.dataParseThread = t;
        t.Start();
  
        IAsyncResult iar = handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
            new AsyncCallback(ReadCallback), state);
    }
  
    public void ReadCallback(IAsyncResult ar)
    {
        String content = String.Empty;
  
        // Retrieve the state object and the handler socket
        // from the asynchronous state object.
        StateObject state = (StateObject)ar.AsyncState;
        Socket handler = state.workSocket;
  
        try
        {
  
            // Read data from the client socket. 
            int bytesRead = handler.EndReceive(ar);
  
            if (bytesRead <= 0)
            {
                Console.WriteLine("Server can't handle because received data length is zero...");
                handler.Shutdown(SocketShutdown.Both);
                handler.Close();
                return;
            }
  
            state.readDone.Reset();
  
            string tmp = System.Text.Encoding.ASCII.GetString(state.buffer, 0, bytesRead);
            state.sb.Append(tmp);
  
            Console.WriteLine(state.sb.ToString());
  
            state.ProcessDone.Set();
            state.readDone.WaitOne();
  
            IAsyncResult iar = handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                new AsyncCallback(ReadCallback), state);
  
        }
        catch (Exception ex)
        {
            ;
        }
    }
  
    private void Send(Socket handler, String data)
    {
        // Convert the string data to byte data using ASCII encoding.
        byte[] byteData = Encoding.ASCII.GetBytes(data);
  
        // Begin sending the data to the remote device.
        handler.BeginSend(byteData, 0, byteData.Length, 0,
            new AsyncCallback(SendCallback), handler);
    }
  
    private void SendCallback(IAsyncResult ar)
    {
        try
        {
            // Retrieve the socket from the state object.
            Socket handler = (Socket)ar.AsyncState;
  
            // Complete sending the data to the remote device.
            int bytesSent = handler.EndSend(ar);
            Console.WriteLine("Sent {0} bytes to client.", bytesSent);
  
            handler.Shutdown(SocketShutdown.Both);
            handler.Close();
  
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
    }
}
  
public class DataProcessor
{
    private StateObject st = null;
    // hold command txt
    private static List<string> commandQueue = new List<string>();
  
    public DataProcessor(StateObject st)
    {
        this.st = st;
    }
    // 
    private Mutex addCommandMutex = new Mutex(false, "MUTEX_ADD_COMMAND");
  
    public void ParseRowData()
    {
        Regex regex = new Regex(@"/[([/d]+)/]");
  
        while (true)
        {
            st.ProcessDone.WaitOne();
            if (st.sb.Length > 0)
            {
                Console.WriteLine("Start to parse data...");
  
                string tmp = st.sb.ToString();
                Match match = regex.Match(tmp);
  
                if (match.Success == false)
                    Console.WriteLine("Not matched...");
  
                while (match.Success)
                {
                    string strLen = match.Groups[1].Value;
                    int len = int.Parse(strLen);
  
                    string strMatch = match.ToString();
                    if (tmp.Length - strMatch.Length - match.Index >= len)
                    {
                        string strToAdd = tmp.Substring(strMatch.Length + match.Index, len);
                        Console.WriteLine("Adding command: " + strToAdd);
                        AddToCommandQueue(strToAdd);
                        st.sb.Remove(0, match.Index + strMatch.Length + len);
                    }
                    else
                    {
                        Console.WriteLine("The string is not completed, waiting the reset data...");
                        break;
                    }
  
                    PrintCommandQueue();
  
                    tmp = st.sb.ToString();
                    match = regex.Match(tmp);
                }
  
                Console.WriteLine("End parsing data...");
            }
            else
            {
                Console.WriteLine("No data will be processed...");
            }
  
            st.readDone.Set();
            st.ProcessDone.Reset();
        }
    }
  
    private void AddToCommandQueue(string str)
    {
        addCommandMutex.WaitOne();
        commandQueue.Add(str);
        addCommandMutex.ReleaseMutex();
    }
  
    public static void PrintCommandQueue()
    {
        foreach(string item in commandQueue)
        {
            Console.WriteLine(item);
        }
    }
}