Windows Phone 8.1不發送UDP廣播

Question

我正在嘗試使用Windows Phone 8.1發送UDP廣播。 因此，我創建了一個UDP服務器（控制台應用程序），該服務器在與WP8.1相同的Wifi網絡中的筆記本電腦上運行。

這是測試服務器：

static void Main(string[] args)
{
    var client = new UdpClient(12345);
    client.MulticastLoopback = false;

    var isRunning = true;

    var thread = new Thread(() =>
    {
        while (isRunning)
        {
            var endpoint = new IPEndPoint(IPAddress.Any, 0);
            var data = client.Receive(ref endpoint);

            Console.WriteLine("Received message from {0}:{1} with length={2}", endpoint.Address, endpoint.Port, data.Length);
            client.Send(data, data.Length, endpoint);
        }
    });

    thread.Start();

    Console.ReadLine();
    isRunning = false;
}

當我創建另一個控制台應用程序作為UDP廣播發送一些數據時，我將獲得與服務器響應相同的數據。 因此服務器工作正常。 對於Windows Phone 8.1，我必須使用DatagramSocket。 這是我的代碼：

var socket = new DatagramSocket();
socket.MessageReceived += HandleIncomingMessages;
using (var stream = await socket.GetOutputStreamAsync(new HostName("255.255.255.255"), "12345"))
{
    await stream.WriteAsync(data.AsBuffer());
    await stream.FlushAsync();
}

我還嘗試了一個額外的await _socket.ConnectAsync(new HostName("255.255.255.255"), "12345"); 創建socket對象之后。

不幸的是，我永遠不會得到答案。

Answer 1

這是我對支持廣播的UdpClient的實現。

public class UdpClient : IDisposable
{
    private readonly DatagramSocket _socket;
    private readonly BlockingCollection<Tuple<IpAddress, byte[]>> _incomingMessages;
    private readonly IpAddress _ipAddress;
    private readonly object _lock = new object();
    private bool _isBound;
    private bool _isBinding;

    public UdpClient(IpAddress ipAddress)
    {
        _ipAddress = ipAddress;
        _socket = new DatagramSocket();
        _socket.Control.DontFragment = true;
        _incomingMessages = new BlockingCollection<Tuple<IpAddress, byte[]>>();
        _socket.MessageReceived += HandleIncomingMessages;
    }

    public async Task SendAsync(byte[] data)
    {
        try
        {
            await Connect();

            using (var stream = await _socket.GetOutputStreamAsync(_ipAddress.Host, _ipAddress.ServiceName))
            {
                await stream.WriteAsync(data.AsBuffer(0, data.Length));
            }
        }
        catch (Exception e)
        {
            Debug.WriteLine(e);
        }
    }

    public bool TryGetIncomingMessage(out Tuple<IpAddress, byte[]> message)
    {
        return _incomingMessages.TryTake(out message, TimeSpan.FromMilliseconds(20));
    }

    public void Dispose()
    {
        _socket.Dispose();
    }

    private async Task Connect()
    {
        if (_isBound || _isBinding)
        {
            return;
        }

        lock (_lock)
        {
            if (_isBound || _isBinding)
            {
                return;
            }

            _isBinding = true;
        }

        var possibleConnectionProfiles = NetworkInformation.GetConnectionProfiles()
            .Where(p => p.IsWlanConnectionProfile && p.GetNetworkConnectivityLevel() != NetworkConnectivityLevel.None)
            .ToList();

        var connectionProfile = possibleConnectionProfiles.FirstOrDefault();

        if (connectionProfile != null)
        {
            await _socket.BindServiceNameAsync(_ipAddress.ServiceName, connectionProfile.NetworkAdapter);
        }

        _isBound = true;
        _isBinding = false;
    }

    private void HandleIncomingMessages(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs e)
    {
        var address = e.RemoteAddress.ToString();
        var port = int.Parse(e.RemotePort);

        using (var reader = e.GetDataReader())
        {
            var data = reader.DetachBuffer().ToArray();
            _incomingMessages.Add(Tuple.Create(new IpAddress(address, port), data));
        }
    }
}

public struct IpAddress
{
    public static readonly IpAddress Broadcast = new IpAddress("255.255.255.255");

    public readonly string Address;
    public readonly int Port;
    public readonly HostName Host;
    public readonly string ServiceName;

    public IpAddress(string address, int port)
    {
        Address = address;
        Port = port;
        Host = new HostName(address);
        ServiceName = port.ToString(CultureInfo.InvariantCulture);
    }

    public override string ToString()
    {
        return string.Format(CultureInfo.InvariantCulture, "{0}:{1}", Address, Port);
    }

    public bool Equals(IpAddress other)
    {
        return string.Equals(Address, other.Address) && Port == other.Port;
    }

    public override bool Equals(object obj)
    {
        if (ReferenceEquals(null, obj))
            return false;
        return obj is IpAddress && Equals((IpAddress)obj);
    }

    public override int GetHashCode()
    {
        unchecked
        {
            return ((Address != null ? Address.GetHashCode() : 0) * 397) ^ Port;
        }
    }
}

我讀過，將消息廣播到255.255.255.255不是一個好習慣。 相反，一個人應該發送給本地廣播地址一樣（即192.168.1。255）

為此，我編寫了以下IpAddressProvider：

public static class IpProvider
{
    private static readonly Lazy<string> _localAddress;
    private static readonly Lazy<string> _broadcastAddress;

    static IpProvider()
    {
        _localAddress = new Lazy<string>(GetLocalAddress);
        _broadcastAddress = new Lazy<string>(GetBroadcastAddress);
    }

    public static string LocalAddress { get { return _localAddress.Value; } }

    public static string BroadcastAddress { get { return _broadcastAddress.Value; } }

    private static string GetLocalAddress()
    {
        var hostnames = NetworkInformation.GetHostNames();
        foreach (var hn in hostnames)
        {
            //IanaInterfaceType == 71 => Wifi
            //IanaInterfaceType == 6 => Ethernet (Emulator)
            if (hn.IPInformation != null &&
                (hn.IPInformation.NetworkAdapter.IanaInterfaceType == 71
                 || hn.IPInformation.NetworkAdapter.IanaInterfaceType == 6))
            {
                return hn.DisplayName;
            }
        }

        return IpAddress.Broadcast.Address;
    }

    private static string GetBroadcastAddress()
    {
        var parts = _localAddress.Value.Split(new[] { '.' }).Take(3);
        return string.Join(".", parts) + ".255";
    }
}

現在，我將它們一起用於發送廣播消息：

var gatewayAddress = new IpAddress(IpProvider.BroadcastAddress);
var udpClient = new UdpClient(gatewayAddress);
await udpClient.SendAsync(data);

Tuple<IpAddress, byte[]> message;
while (udpClient.TryGetIncomingMessage(out message))
{
    if (message.Item1.Address == IpProvider.LocalAddress)
    {
        continue;
    }

    HandleIncomingPacket(message);
}