C# 如何使用StreamSocket广播消息

我按照教程创建了WindowsPhone设备，并通过流套接字进行连接

互相发送信息效果很好。 但我不知道如何广播信息。有人能告诉我怎么做吗

    private StreamSocket _socket = new StreamSocket();
    private StreamSocketListener _listener = new StreamSocketListener();
    private List<StreamSocket> _connections = new List<StreamSocket>();
    private bool _connecting = false;

    protected override void OnNavigatedTo(NavigationEventArgs e)
    {
        //myConnectionTargetText.Text = "192.168.1.3";
        myConnectionTargetText.Text = "localhost"; // a TextBox
    }

    async private void WaitForData(StreamSocket socket)
    {
        var dr = new DataReader(socket.InputStream);
        //dr.InputStreamOptions = InputStreamOptions.Partial;
        var stringHeader = await dr.LoadAsync(4);

        if (stringHeader == 0)
        {
            LogMessage(string.Format("Disconnected (from {0})", socket.Information.RemoteHostName.DisplayName));
            return;
        }

        int strLength = dr.ReadInt32();

        uint numStrBytes = await dr.LoadAsync((uint)strLength);
        string msg = dr.ReadString(numStrBytes);

        LogMessage(string.Format("Received (from {0}): {1}", socket.Information.RemoteHostName.DisplayName, msg));

        WaitForData(socket);
    }

    async private void Connect(object sender, RoutedEventArgs e)
    {
        try
        {
            _connecting = true;
            await _socket.ConnectAsync(new HostName(myConnectionTargetText.Text), "3011");
            _connecting = false;

            LogMessage(string.Format("Connected to {0}", _socket.Information.RemoteHostName.DisplayName));

            WaitForData(_socket);
        }
        catch (Exception ex)
        {
            _connecting = false;
        }
    }

    async private void Listen(object sender, RoutedEventArgs e)
    {
        _listener.ConnectionReceived += listenerConnectionReceived;
        await _listener.BindServiceNameAsync("3011");

        LogMessage(string.Format("listening on {0}...", _listener.Information.LocalPort));
    }

    void listenerConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
    {
        _connections.Add(args.Socket);

        LogMessage(string.Format("Incoming connection from {0}", args.Socket.Information.RemoteHostName.DisplayName));

        WaitForData(args.Socket);
    }

    private void LogMessage(string message)
    {
        Dispatcher.BeginInvoke(() =>
            {
                myText.Text += message + Environment.NewLine;
            });
    }

    async private void SendMessage(StreamSocket socket, string message)
    {
        var writer = new DataWriter(socket.OutputStream);
        var len = writer.MeasureString(message); // Gets the UTF-8 string length.
        writer.WriteInt32((int)len);
        writer.WriteString(message);
        var ret = await writer.StoreAsync();
        writer.DetachStream();

        LogMessage(string.Format("Sent (to {0}) {1}", socket.Information.RemoteHostName.DisplayName, message)); // richTextBox
    }

private StreamSocket _socket=new StreamSocket（）；
私有StreamSocketListener _listener=new StreamSocketListener（）；
私有列表_connections=new List（）；
私有布尔_连接=假；
受保护的覆盖无效OnNavigatedTo（NavigationEventArgs e）
{
//myConnectionTargetText.Text=“192.168.1.3”；
myConnectionTargetText.Text=“localhost”//文本框
}
异步私有void WaitForData（StreamSocket套接字）
{
var dr=新的数据读取器（socket.InputStream）；
//dr.InputStreamOptions=InputStreamOptions.Partial；
var stringHeader=wait dr.LoadAsync（4）；
如果（stringHeader==0）
{
LogMessage（string.Format（“Disconnected（from{0}）”，socket.Information.RemoteHostName.DisplayName）；
返回；
}
int strLength=dr.ReadInt32（）；
uint numStrBytes=等待dr.LoadAsync（（uint）strLength）；
string msg=dr.ReadString（numStrBytes）；
LogMessage（string.Format（“接收（从{0}）：{1}”，socket.Information.RemoteHostName.DisplayName，msg））；
WaitForData（插座）；
}
异步专用void Connect（对象发送方，RoutedEventArgs e）
{
尝试
{
_连接=真；
wait_socket.ConnectAsync（新主机名（myConnectionTargetText.Text），“3011”）；
_连接=错误；
LogMessage（string.Format（“连接到{0}”，_socket.Information.RemoteHostName.DisplayName））；
WaitForData（_插座）；
}
捕获（例外情况除外）
{
_连接=错误；
}
}
异步私有void侦听（对象发送方，RoutedEventArgs e）
{
_listener.ConnectionReceived+=listenerConnectionReceived；
wait_listener.BindServiceNameAsync（“3011”）；
LogMessage（string.Format（“侦听{0}…”，_listener.Information.LocalPort））；
}
接收无效ListenerConnection（StreamSocketListener发送方，StreamSocketListenerConnectionReceivedEventArgs参数）
{
_添加（args.Socket）；
LogMessage（string.Format（“来自{0}的传入连接”，args.Socket.Information.RemoteHostName.DisplayName））；
WaitForData（参数套接字）；
}
私有无效日志消息（字符串消息）
{
Dispatcher.BeginInvoke（（）=>
{
myText.Text+=message+Environment.NewLine；
});
}
异步私有void发送消息（StreamSocket套接字、字符串消息）
{
var writer=新的数据编写器（socket.OutputStream）；
var len=writer.MeasureString（message）；//获取UTF-8字符串长度。
writer.WriteInt32（（int）len）；
writer.WriteString（消息）；
var ret=await writer.StoreAsync（）；
writer.DetachStream（）；
LogMessage（string.Format（“发送（到{0}）{1}”，socket.Information.RemoteHostName.DisplayName，message））；//richTextBox
}

不可能通过流套接字进行多播，因为流套接字是端点到端点的连接

您有两个选择：

让所有客户端连接到一个中央服务器，该服务器适当地发送消息。服务器将有一个所有客户端的列表，因此它可以通过复制消息来模拟多播

切换到UDP而不是TCP（即，

DatagramSocket

）并使用多播

请注意，切换到UDP会带来一系列问题：您会失去可靠性（数据包可能会丢失）、排序（数据包可能会无序到达）以及存在最大数据报大小（您必须自己拆分消息）。由于这个原因，大多数应用程序通过使用中央服务器来伪造多播