c# - Silverlight 中的异步套接字连接

Question

我有 TCP Socket 服务器，想为它制作异步 Silverlight 客户端，但我找不到任何有用的信息。确切地说，我需要三个步骤：连接、发送和接收。

不需要很详细，至少是如何构建它以连接到服务器的想法。

顺便说一句，我使用 Silverlight 5。

Answer 1

非常感谢 Karel Frajtak 提供有关 Silverlight 中套接字的视频链接！该视频教程中显示并解释了所有内容，因此我建议每个需要 Silverlight 中的套接字的人观看它！这是我需要的解决方案，并解释了做什么和我的评论：

我假设所有连接操作都将由单独的类SocketConnection处理：

public class MessageEventArgs : EventArgs
{
    public string Message { get; set; }
}
public class SocketConnection
{
    /// <summary>
    /// Event handler shot when message is received
    /// </summary>
    public event EventHandler<MessageEventArgs> MessageReceived;

    /// <summary>
    /// Socket used for connection to the server, sending and receiving data
    /// </summary>
    Socket socket;

    /// <summary>
    /// Default buffer size that should be used with the same value in both server and client
    /// </summary>
    int bufferSize = 128;

    /// <summary>
    /// Buffer used to store bytes received
    /// </summary>
    byte[] buffer;

    /// <summary>
    /// Bytes received in current receiving operation
    /// </summary>
    int bytesReceived;

    public SocketConnection(string host = "localhost", int port = 4502)
    {
        // Initializing buffer for receiving data
        buffer = new byte[bufferSize];
        // Initializing socket to connect to the server with default parameters
        // *** If you need IPv6, set the AddressFamily.InterNetworkV6 ***
        // *** Silverlight supports only Stream or Unknown socket types (Silverlight 5) ***
        // *** The only defined protocol supported by Silverlight is TCP.
        //     Others can be only Unknown or Unspecified (Silverlight 5)***
        socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

        // Socket args that are needed for connection
        SocketAsyncEventArgs args = new SocketAsyncEventArgs()
        {
            // Server IP and port
            RemoteEndPoint = new DnsEndPoint(host, port),
            // If policy server is hosted as TCP socket, this has to be set to SocketClientAccessPolicyProtocol.Tcp
            // If policy is stored in HTTP server, this has to be set SocketClientAccessPolicyProtocol.Http
            SocketClientAccessPolicyProtocol = SocketClientAccessPolicyProtocol.Tcp
        };
        // Set the event handler for completed connection (nomatter if it is successful or not)
        args.Completed += OnConnected;
        // Start connecting to the server asynchronously
        socket.ConnectAsync(args);
    }

    /// <summary>
    /// Even handler shot when socket connection is completed
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    void OnConnected(object sender, SocketAsyncEventArgs e)
    {
        // If the connection is not successful, set socket object to null
        if (e.SocketError != SocketError.Success)
        {
            if (e.SocketError == SocketError.AccessDenied)
            {
                // Policy server is not running or cannot be reached
                throw new SocketException((int)SocketError.AccessDenied);
            }
            socket = null;
        }
        // Begin receiving data otherwise
        else
        {
            BeginRead();
        }
    }

    /// <summary>
    /// Method for receiving data from the server
    /// </summary>
    private void BeginRead()
    {
        // Receive data only if socket is connected
        if (socket != null && socket.Connected)
        {
            SocketAsyncEventArgs args = new SocketAsyncEventArgs();
            // Store the received buffer in a class variable
            args.SetBuffer(buffer, bytesReceived, buffer.Length - bytesReceived);
            // Set the event handler for received data
            args.Completed += OnReceived;

            // Start receiving data asynchronously
            socket.ReceiveAsync(args);
        }
    }

    /// <summary>
    /// Event handler shot when data is received from the server
    /// </summary>
    void OnReceived(object sender, SocketAsyncEventArgs e)
    {
        // Make sure that receiving was successful
        if (e.SocketError == SocketError.Success)
        {
            // Increase the count of received bytes in the current receiving operation
            bytesReceived += e.BytesTransferred;
        }
        // If the receiving was unsuccessful, throw an exception
        else
        {
            throw new SocketException();
        }
        // Check if the buffer is already full
        if (bytesReceived == buffer.Length)
        {
            // If the buffer is full, decode the string received from bytes
            // *** This should be your object deserialization, if you use anything but string ***
            string text = Encoding.UTF8.GetString(buffer, 0, buffer.Length);

            // If the event was set from somewhere, shoot it
            // *** In most cases event is set from UI thread to handle the
            //     received string or object and show the result to user ***
            if (MessageReceived != null)
            {
                // Shoot the event, if it's set
                MessageReceived(this, new MessageEventArgs()
                {
                    Message = text
                });
            }

            // Set the bytes received count to 0, for other data receiving event to fill the buffer from begining
            bytesReceived = 0;
        }
        // Begin the data receiving again
        BeginRead();
    }

    /// <summary>
    /// Sample method to send data to the server
    /// </summary>
    /// <param name="text">Text you would like the server to receive</param>
    public void SendText(string text)
    {
        // Check if the socket is connected to the server
        if (socket != null && socket.Connected)
        {
            // Encode the string to be sent to bytes
            // *** This is where your object serialization should be done ***
            byte[] buffer = Encoding.UTF8.GetBytes(text);
            // Check if the buffer is not empty
            if (buffer.Length != 0)
            {
                SocketAsyncEventArgs args = new SocketAsyncEventArgs();
                // Set the buffer to be sent
                args.SetBuffer(buffer, 0, buffer.Length);

                // Start sending buffer to the server asynchronously
                socket.SendAsync(args);
            }
        }
    }
}

要使 Silverlight 中的套接字连接成功，必须有

• 跨域策略套接字服务器，托管在端口 943

或者

• 托管在HTTP 服务器（端口 80）上的跨域策略文件。

如果您选择使用socket server，这里有一个工作示例源代码：

样本取自这里，上面写着

策略服务器 <...> 必须在端口 943 上运行

并没有说明在 HTTP 服务器上托管它的可能性，只是因为文章太旧了。

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;

namespace PolicyServer
{
    // Encapsulate and manage state for a single connection from a client
    class PolicyConnection
    {
        private Socket _connection;
        private byte[] _buffer; // buffer to receive the request from the client       
        private int _received;
        private byte[] _policy; // the policy to return to the client

        // the request that we're expecting from the client
        private static string _policyRequestString = "<policy-file-request/>";

        public PolicyConnection(Socket client, byte[] policy)
        {
            _connection = client;
            _policy = policy;

            _buffer = new byte[_policyRequestString.Length];
            _received = 0;

            try
            {
                // receive the request from the client
                _connection.BeginReceive(_buffer, 0, _policyRequestString.Length, SocketFlags.None,
                    new AsyncCallback(OnReceive), null);
            }
            catch (SocketException)
            {
                _connection.Close();
            }
        }

        // Called when we receive data from the client
        private void OnReceive(IAsyncResult res)
        {
            try
            {
                _received += _connection.EndReceive(res);

                // if we haven't gotten enough for a full request yet, receive again
                if (_received < _policyRequestString.Length)
                {
                    _connection.BeginReceive(_buffer, _received, _policyRequestString.Length - _received,
                        SocketFlags.None, new AsyncCallback(OnReceive), null);
                    return;
                }

                // make sure the request is valid
                string request = System.Text.Encoding.UTF8.GetString(_buffer, 0, _received);
                if (StringComparer.InvariantCultureIgnoreCase.Compare(request, _policyRequestString) != 0)
                {
                    _connection.Close();
                    return;
                }

                // send the policy
                Console.Write("Sending policy...\n");
                _connection.BeginSend(_policy, 0, _policy.Length, SocketFlags.None,
                    new AsyncCallback(OnSend), null);
            }
            catch (SocketException)
            {
                _connection.Close();
            }
        }

        // called after sending the policy to the client; close the connection.
        public void OnSend(IAsyncResult res)
        {
            try
            {
                _connection.EndSend(res);
            }
            finally
            {
                _connection.Close();
            }
        }
    }

    // Listens for connections on port 943 and dispatches requests to a PolicyConnection
    class PolicyServer
    {
        private Socket _listener;
        private byte[] _policy;

        // pass in the path of an XML file containing the socket policy
        public PolicyServer(string policyFilePath)
        {

            // Load the policy file
            FileStream policyStream = new FileStream(policyFilePath, FileMode.Open);

            _policy = new byte[policyStream.Length];
            policyStream.Read(_policy, 0, _policy.Length);
            policyStream.Close();


            // Create the Listening Socket
            _listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream,
                ProtocolType.Tcp);

            _listener.SetSocketOption(SocketOptionLevel.Tcp, (SocketOptionName)
                SocketOptionName.NoDelay, 0);

            _listener.Bind(new IPEndPoint(IPAddress.Any, 943));
            _listener.Listen(10);

            _listener.BeginAccept(new AsyncCallback(OnConnection), null);
        }

        // Called when we receive a connection from a client
        public void OnConnection(IAsyncResult res)
        {
            Socket client = null;

            try
            {
                client = _listener.EndAccept(res);
            }
            catch (SocketException)
            {
                return;
            }

            // handle this policy request with a PolicyConnection
            PolicyConnection pc = new PolicyConnection(client, _policy);

            // look for more connections
            _listener.BeginAccept(new AsyncCallback(OnConnection), null);
        }

        public void Close()
        {
            _listener.Close();
        }
    }

    public class Program
    {
        static void Main()
        {
            Console.Write("Starting...\n");
            PolicyServer ps =
                new PolicyServer(@".\clientaccesspolicy.xml");
            System.Threading.Thread.Sleep(System.Threading.Timeout.Infinite);
        }
    }
}

就是这样。首先运行跨域策略服务器， 然后再运行您的客户端，以确保连接成功。

如果您需要异步 WPF 套接字服务器示例，请询问并给我问题的链接！我用 async-await 关键字构建了一个，尽可能简单。

祝一切顺利！

Answer 2

Mike Taulty 制作了一个介绍 Silverlight 4 网络的视频，这里讨论了套接字。