C# UdpClient.SendAsync方法代码示例

        /// <summary>
        /// 向客户端异步发送文件
        /// </summary>
        /// <param name="ip"></param>
        /// <param name="port"></param>
        /// <param name="filePath"></param>
        public async Task SendToClientFileAsync(string ip, int port, string filePath, Message msg)
        {
            // 新建 Udp 用于发送文件
            var sendClient = new UdpClient();

            try
            {
                FileInfo fileInfo = new FileInfo(filePath);
                msg.Type = MessageEnum.FILE;  // 设置发送文件标识
                msg.FileLength = fileInfo.Length;

                msg.FileName = Regex.Match(filePath, @"\\([^\\]+\.[^\\]+)").Groups[1].Value;  // 获取文件名

                byte[] datagram = Encoding.Unicode.GetBytes(JsonConvert.SerializeObject(msg));
                IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse(ip), port);

                /*
                 * 向‘原’远程客户端发送请求传送文件的请求,
                 * 接收‘新’远程客户端的响应,获取传送文件的端口
                 * 
                 * 注：原远程客户端用于发送消息，新远程客户端用于发送文件
                 */
                await sendClient.SendAsync(datagram, datagram.Length, endPoint);

                //IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
                UdpReceiveResult result = await sendClient.ReceiveAsync().ConfigureAwait(false);   // 阻塞直到接收到远程客户端的响应

                /*
                 * 开始发送文件
                 */
                byte[] buffer = new byte[MAXSIZE];
                using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 1, true))
                {
                    int percent = 0;
                    int count = 0;
                    while ((count = await fs.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false)) > 0)
                    {
                        //await Task.Delay(10);
                        await sendClient.SendAsync(buffer, count, result.RemoteEndPoint);

                        if (Client.SendFileProgressNotify != null)
                        {
                            Client.SendFileProgressNotify(String.Format("{0:F2}%", (percent += count) / msg.FileLength * 100));
                        }
                    }
                    sendClient.Close();
                }
            }
            catch (Exception e)
            {
                Log.Write(e.Message);
            }
        }

 public static async Task Start()
 {
     var client = new UdpClient(1812);
     var serializer = new RadiusPacketSerializer();
     while (true)
     {
         try
         {
             var result = await client.ReceiveAsync();
             var request = serializer.Read(result.Buffer);
             Console.WriteLine(request.Dump());
             if (request.Code == RadiusPacketCode.AccessRequest)
             {
                 var password = (RadiusBinaryAttribute)request.Attributes.FirstOrDefault(a => a.Type == RadiusAttributeType.UserPassword);
                 var code = ((password == null) || (string.Compare(RadiusPacketSerializer.DecodePassword(Secret, request.Authenticator, password.Value), Password, StringComparison.InvariantCulture) != 0))
                     ? RadiusPacketCode.AccessReject
                     : RadiusPacketCode.AccessAccept;
                 var response = new RadiusPacket
                 {
                     Code = code,
                     Identifier = request.Identifier,
                     Authenticator = request.Authenticator
                 };
                 var buffer = serializer.Write(response);
                 await client.SendAsync(buffer, buffer.Length, result.RemoteEndPoint);
             }
         }
         catch (Exception ex)
         {
             Console.WriteLine(ex);
         }
     }
 }

        public async Task<IEnumerable<Server>> GetServers(
            MasterServerRegion region = MasterServerRegion.All,
            params MasterServerFilter[] masterServerFilters)
        {
            var servers = new List<Server>();

            using (var client = new UdpClient(new IPEndPoint(IPAddress.Any, 0)))
            {
                client.Connect(_steamSteamIpAddress, _steamSteamPort);

                string thisServer = null;
                while (thisServer != FIRST_AND_LAST_SERVER)
                {
                    var requestPacket = CreateRequestPacket(thisServer ?? FIRST_AND_LAST_SERVER, region, masterServerFilters);
                    await client.SendAsync(requestPacket, requestPacket.Length);
                    var response = await client.ReceiveAsync();
                    var responseData = response.Buffer.ToList();
                    for (int i = HEADER_BYTES_LENGTH; i < responseData.Count; i++)
                    {
                        var ip = string.Join(".", responseData.GetRange(i, 4).ToArray());
                        int port = responseData[i + 4] << 8 | responseData[i + 5];
                        thisServer = string.Format("{0}:{1}", ip, port);
                        if (thisServer != FIRST_AND_LAST_SERVER)
                        {
                            servers.Add(new Server(new IPEndPoint(IPAddress.Parse(ip), port)));
                        }
                        i += 5;
                    }
                }
            }

            return servers;
        }

        private async Task SendWakeOnLan(string macAddress, IPEndPoint endPoint, CancellationToken cancellationToken)
        {
            const int payloadSize = 102;

            var macBytes = PhysicalAddress.Parse(macAddress).GetAddressBytes();
            _logger.Debug(String.Format("Sending magic packet to {0}", macAddress));

            // Construct magic packet
            var payload = new byte[payloadSize];
            Buffer.BlockCopy(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, 0, payload, 0, 6);

            for (var i = 1; i < 17; i++) 
            { 
                Buffer.BlockCopy(macBytes, 0, payload, 6 * i, 6);
            }

            // Send packet LAN
            using (var udp = new UdpClient())
            {
                udp.Connect(endPoint);

                cancellationToken.ThrowIfCancellationRequested();

                await udp.SendAsync(payload, payloadSize).ConfigureAwait(false);
            }
        }

        private async void FindServers(Action<ServerDiscoveryInfo> serverFound, Action<Exception> error, CancellationToken cancellationToken)
        {
            var serverIdsFound = new List<string>();

            // Create a udp client
            using (var client = new UdpClient(new IPEndPoint(IPAddress.Any, GetRandomUnusedPort())))
            {
                // Construct the message the server is expecting
                var bytes = Encoding.UTF8.GetBytes("who is EmbyServer?");

                // Send it - must be IPAddress.Broadcast, 7359
                var targetEndPoint = new IPEndPoint(IPAddress.Broadcast, 7359);

                try
                {
                    // Send the broadcast
                    await client.SendAsync(bytes, bytes.Length, targetEndPoint).ConfigureAwait(false);

                    while (!cancellationToken.IsCancellationRequested)
                    {
                        // Get a result back
                        var result = await client.ReceiveAsync().ConfigureAwait(false);

                        if (result.RemoteEndPoint.Port == targetEndPoint.Port)
                        {
                            // Convert bytes to text
                            var json = Encoding.UTF8.GetString(result.Buffer);

                            _logger.Debug("Received response from endpoint: " + result.RemoteEndPoint + ". Response: " + json);

                            if (!string.IsNullOrEmpty(json))
                            {
                                try
                                {
                                    var info = _jsonSerializer.DeserializeFromString<ServerDiscoveryInfo>(json);

                                    if (!serverIdsFound.Contains(info.Id))
                                    {
                                        serverIdsFound.Add(info.Id);
                                        info.EndpointAddress = result.RemoteEndPoint.Address.ToString();
                                        serverFound(info);
                                    }
                                }
                                catch (Exception ex)
                                {
                                    _logger.ErrorException("Error parsing server discovery info", ex);
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    error(ex);
                }
            }
        }

 public async Task<ServerRulesResult> GetServerRules()
 {
     using (var client = new UdpClient(new IPEndPoint(IPAddress.Any, 0)))
     {
         client.Connect(EndPoint);
         var requestPacket = new List<byte>();
         requestPacket.AddRange(new Byte[] {0xFF, 0xFF, 0xFF, 0xFF, 0x56});
         requestPacket.AddRange(BitConverter.GetBytes(-1));
         await client.SendAsync(requestPacket.ToArray(), requestPacket.ToArray().Length);
         UdpReceiveResult response = await client.ReceiveAsync();
         List<byte> responseData = response.Buffer.ToList();
         requestPacket.Clear();
         requestPacket.AddRange(new Byte[] {0xFF, 0xFF, 0xFF, 0xFF, 0x56});
         requestPacket.AddRange(responseData.GetRange(5, 4));
         await client.SendAsync(requestPacket.ToArray(), requestPacket.ToArray().Length);
         response = await client.ReceiveAsync();
         return ServerRulesResult.Parse(response.Buffer);
     }
 }

 protected async Task replyUdpAsync(String replyMessage, IPAddress ip, int port)
 {
     UdpClient udpClient = new UdpClient();
     udpClient.MulticastLoopback = true;
     udpClient.ExclusiveAddressUse = false;
     
     byte[] bytes = Encoding.ASCII.GetBytes(replyMessage);
     await udpClient.SendAsync(bytes, bytes.Length, new IPEndPoint(ip, port));
     udpClient.Close();
 }

        private async Task<ReceiveDataInfo> ReceiveDataAsync(ServerAddress address, byte[] data, CancellationToken ct, params char[] header)
        {
            var udpClient = new UdpClient();
            var ipAddr = IPAddress.Parse(address.Ip);
            try
            {
                udpClient.Connect(ipAddr, address.Port);

                var sendTime = DateTime.Now;
                await udpClient.SendAsync(data, data.Length);

                Packet packet = null;            
                return await Task.Run(async () =>
                {
                    while (true)
                    {
                        var clientResult = await udpClient.ReceiveAsync().WithCancellation(ct);
                        var remoteIp = clientResult.RemoteEndPoint.Address.ToString();
                        var remotePort = clientResult.RemoteEndPoint.Port;
                        var receiveDate = DateTime.Now;
                        var packetReader = new PacketReader(clientResult.Buffer);
                        var packetheader = packetReader.ReadLong();
                        if (packet == null)
                        {
                            packet = engineFactory.CreatePacket(packetheader);
                        }
                        packet.AddData(clientResult.Buffer);
                        if (packet.IsCompleted)
                        {
                            var messageReader = new PacketReader(packet.Payload);
                            var messageheader = messageReader.ReadByte();
                            var messageHeaderChar = Convert.ToChar(messageheader);
                            if (header.Contains(messageHeaderChar))
                            {
                                var result = new ReceiveDataInfo
                                {
                                    Ping = (int)(DateTime.Now - sendTime).TotalMilliseconds,
                                    Data = packet.Payload,
                                    MessageHeaderChar = messageHeaderChar,
                                };
                                return result;
                            }
                        }
                    }
                });
            }
            catch 
            {
                throw new OperationCanceledException();
            }
            finally
            {
                udpClient.Close();
            }
        }

        public async Task<List<IPEndPoint>> GetParsedServers(CancellationToken cancelToken, int limit = -1,
            IPEndPoint remote = null, int tried = -1) {
            var cur = -1;
            var servers = new List<IPEndPoint>();
            if (remote == null) {
                var hosts = await Dns.GetHostAddressesAsync("hl2master.steampowered.com").ConfigureAwait(false);
                if (tried == -1)
                    cur = new Random().Next(hosts.Length);
                else
                    cur = (tried + 1)%hosts.Length;
                var host = hosts[cur];
                const int port = 27011;

                remote = new IPEndPoint(host, port); //TODO: alternate ip and ports availability
            }
            var e = new IPEndPoint(IPAddress.Any, 0);
            var udpClient = new UdpClient(e) {
                Client = {ReceiveTimeout = Consts.DefaultReceiveTimeout, SendTimeout = Consts.DefaultSendTimeout }
            };

            var i = 0;
            const int maxIterations = 30;
            string lastSeed;
            var seed = "0.0.0.0:0";
            do {
                cancelToken.ThrowIfCancellationRequested();
                lastSeed = seed;
                var msg = BuildMessage(seed);

                if (await udpClient.SendAsync(msg, msg.Length, remote).ConfigureAwait(false) != msg.Length)
                    throw new Exception("Send failed.");
                byte[] response = null;
                var timedOut = false;
                try {
                    response =
                        (await
                                udpClient.ReceiveWithTimeoutAfter(Consts.DefaultReceiveTimeout, cancelToken).ConfigureAwait(false))
                            .Buffer;
                } catch (TimeoutException) {
                    timedOut = true;
                    if ((cur == -1) || (tried != -1) || (i != 0)) {
                        throw new TimeoutException(string.Format("Received timeout on try: {0} packet: {1}",
                            tried == -1 ? 1 : 2, i));
                    }
                }
                //only retries when remote was not passed in, on the first try, and when the first packet was never received
                if (timedOut)
                    return await GetParsedServers(cancelToken, limit, null, cur).ConfigureAwait(false);
                seed = ParseResponse(servers, response, limit);
                if (seed == null)
                    throw new Exception("Bad packet recieved.");
                i++;
            } while ((i < maxIterations) && !seed.Equals("0.0.0.0:0") && !seed.Equals(lastSeed));
            return servers;
        }

 private static async Task ConsumeOneAsync(UdpClient client, IPAddress ipAddress, int port)
 {
     client.Connect(ipAddress, port);
     var bytes = Encoding.UTF8.GetBytes(Constants.ClientToServer);
     var tasks = new[]
     {
         client.SendAsync(bytes, bytes.Length),
         ReceiveAndCheckAsync(client, Constants.ServerToClient)
     };
     await Task.WhenAll(tasks);
 }

 public async Task sendUnicastBytesAsync(byte[] bytes, int port)
 {
     try
     {
         if (bytes.Count() <= 0) return;
         UdpClient trasport = new UdpClient();
         trasport.Connect("127.0.0.1", port);
         await trasport.SendAsync(bytes, bytes.Length);
         trasport.Close();
     }
     catch { }
 }

        protected async Task broadcast(String message, int port)
        {
            UdpClient udpClient = new UdpClient();
            udpClient.EnableBroadcast = true;
            udpClient.MulticastLoopback = true;
            udpClient.ExclusiveAddressUse = false;

            IPEndPoint ip = new IPEndPoint(IPAddress.Broadcast, port);
            byte[] bytes = Encoding.ASCII.GetBytes(message);
            await udpClient.SendAsync(bytes, bytes.Length, ip);
            udpClient.Close();
        }

 public async Task sendBroadcastBytesAsync(byte[] bytes, int port)
 {
     try
     {
         if (bytes.Count() <= 0) return;
         UdpClient trasport = new UdpClient();
         trasport.Connect(IPAddress.Broadcast, port);
         await trasport.SendAsync(bytes, bytes.Length);
         trasport.Close();
     }
     catch { }
 }

    static async Task ServerAsync(CancellationToken ct)
    {
      throw new ApplicationException("died");

      var client = new UdpClient(5555);

      var request = new byte[0];

      while (!ct.IsCancellationRequested)
      {
        await client.SendAsync(request, request.Length);
        var response = await client.ReceiveAsync();
      }
    }

		/// <summary>
		/// Broadcasts the current game information so that other instances can find players.
		/// </summary>
		/// <param name="gameInstance">the game information</param>
		/// <returns><c>true</c>, if message was sent, <c>false</c> otherwise.</returns>
		public async Task<bool> BroadcastGameInstanceAsync(NetworkGameInstance gameInstance, CancellationToken ct = default(CancellationToken))
		{
			int bytesSent = 0;
			var json = gameInstance.ToJsonString ();
			using (var udpClient = new UdpClient ())
			{ 
				udpClient.EnableBroadcast = true;
				var recipient = new IPEndPoint (IPAddress.Broadcast, this.Port);
				var data = Encoding.UTF8.GetBytes (json);
				bytesSent = await udpClient.SendAsync (data, data.Length, recipient);
				udpClient.Close ();
			}

			return bytesSent == json.Length;
		}