Question

我已经设置了服务器和客户端，尝试从我的服务器向我的客户端发送字符串。看来，我的客户端没有收到消息，因为我是网络新手，我似乎无法找到错误。我的服务器：

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


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

    class Program
    {
        public static ManualResetEvent allDone = new ManualResetEvent(false);
        public static ManualResetEvent sendDone = new ManualResetEvent(false);

        public static void StartListening()
        {
            byte[] bytes = new byte[1024];
            IPHostEntry ipHostEntry = Dns.GetHostEntry(Dns.GetHostName());
            IPAddress ipAddress = ipHostEntry.AddressList[0];
            IPEndPoint localEndPointOut =
          new IPEndPoint(ipAddress, 22222);

            Console.WriteLine(ipAddress);

            Socket listenerOut = new Socket(ipAddress.AddressFamily,
           SocketType.Stream, ProtocolType.Tcp);
            StateObject state = new StateObject();
            Socket handler = state.workSocket;

            try
            {
                listenerOut.Bind(localEndPointOut);
                listenerOut.Listen(100);
                while (true)
                {
                    allDone.Reset();
                    listenerOut.BeginAccept(new AsyncCallback(outputCallback), listenerOut);
                    allDone.WaitOne();
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
            Console.WriteLine("\nPress enter to continue...");
            Console.Read();
        }

        public static void outputCallback(IAsyncResult ar)
        {
            allDone.Set();
            Socket listener = (Socket)ar.AsyncState;
            Socket handler = listener.EndAccept(ar);
            StateObject state = new StateObject();
            state.workSocket = handler;
            handler.BeginReceive(state.buffer, 0,
                StateObject.BufferSize, 0,
                new AsyncCallback(outputStream), state);
        }

        public static void outputStream(IAsyncResult ar)
        {
            String content = String.Empty;
            StateObject state = (StateObject)ar.AsyncState;
            Socket handler = state.workSocket;
            byte[] byteData = Encoding.ASCII.GetBytes("test");
            while (true)
            {
                try
                {
                    handler.Send(byteData, SocketFlags.None);
                }
                catch
                {
                    Console.WriteLine("Client forcebly closed.");
                }
            }
        }

        static void Main(string[] args)
        {
            StartListening();
            Console.ReadKey();
        }
    }
}

我的客户：

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace OutputClient
{
    public class StateObject
    {
        public Socket workSocket = null;
        public const int BufferSize = 256;
        public byte[] buffer = new byte[BufferSize];
        public StringBuilder sb = new StringBuilder();
    }

    class Program
    {
        private const int port = 22222;
        private static ManualResetEvent connectDone =
         new ManualResetEvent(false);
        private static ManualResetEvent receiveDone =
        new ManualResetEvent(false);

        private static String response = String.Empty;

        private static void StartClient()
        {
            IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
            IPAddress ipAddress = ipHostInfo.AddressList[0];
            IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);
            Socket client = new Socket(ipAddress.AddressFamily,
                   SocketType.Stream, ProtocolType.Tcp);
            client.BeginConnect(remoteEP,
                new AsyncCallback(ConnectCallback), client);
            connectDone.WaitOne();

            Receive(client);
            receiveDone.WaitOne();
            Console.WriteLine(response);
        }

        private static void ConnectCallback(IAsyncResult ar)
        {
            try
            {
                Socket client = (Socket)ar.AsyncState;
                client.EndConnect(ar);
                connectDone.Set();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }

        private static void Receive(Socket client)
        {
            try
            {
                StateObject state = new StateObject();
                state.workSocket = client;

                client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                    new AsyncCallback(ReceiveCallback), state);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }

        private static void ReceiveCallback(IAsyncResult ar)
        {
            try
            {
                StateObject state = (StateObject)ar.AsyncState;
                Socket client = state.workSocket;
                int bytesRead = client.EndReceive(ar);

                if (bytesRead > 0)
                {
                    state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
                    client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                        new AsyncCallback(ReceiveCallback), state);
                }
                else
                {
                    if (state.sb.Length > 1)
                    {
                        response = state.sb.ToString();
                    }
                    receiveDone.Set();
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }

        static void Main(string[] args)
        {
            StartClient();
            Console.ReadKey();
        }
    }
}

目前我在我的服务器上使用Socket.Send方法，我也尝试使用Socket.BeginSend，但结果相同。

我没有收到任何错误，似乎只有数据被发送。然而，服务器注册了客户端。

Answer 1

您的服务器调用BeginReceive并在其处理程序（outputCallback）中尝试发送数据。这意味着服务器在首先从客户端收到内容之前不会发送数据。

然而，客户端从不发送任何数据;只有当您关闭客户端时，您的服务器才会收到0字节的消息并开始发送数据（当然，客户端不再接收该数据）。

使用套接字从服务器向客户端发送信息

1 个答案: