C# UdpClient.Receive方法代码示例

        protected void serverLoop()
        {
            Trace.WriteLine("Waiting for UDP messages.");
            listener = new UdpClient(UDP_PORT);
            IPEndPoint groupEP = new IPEndPoint(IPAddress.Any, UDP_PORT);
            byte[] receive_byte_array;

            bool running = true;
            while (running)
            {
                try
                {
                    receive_byte_array = listener.Receive(ref groupEP);
                    if (receive_byte_array.Length != 2)
                    {
                        Trace.WriteLine("Invalid UDP message received. Ignored message!");
                        continue;
                    }

                    Trace.WriteLine("Upp fan speed message received.");
                    int fan = receive_byte_array[0];
                    byte speed = receive_byte_array[1];
                    fanControlDataObject.setPinSpeed(fan, speed, true);
                }
                catch
                {
                    running = false;
                }
            }
        }

    static void Main(string[] args)
    {
      byte[] data = new byte[1024];
      IPEndPoint ipep = new IPEndPoint(IPAddress.Any, 19511);
      UdpClient newsock = new UdpClient(ipep);

      Console.WriteLine("Waiting for a client...");

      IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);

      data = newsock.Receive(ref sender);

      Console.WriteLine("Message received from {0}:", sender.ToString());
      Console.WriteLine(Encoding.ASCII.GetString(data, 0, data.Length));

      string welcome = "Welcome to my test server";
      data = Encoding.ASCII.GetBytes(welcome);
      newsock.Send(data, data.Length, sender);

      while (true)
      {
        data = newsock.Receive(ref sender);

        Console.WriteLine(Encoding.ASCII.GetString(data, 0, data.Length));
        newsock.Send(data, data.Length, sender);
      }
    }

        public ServerPlayers GetServerChallengeSync(GetServerInfoSettings settings)
        {
            var localEndpoint = new IPEndPoint(IPAddress.Any, 0);
            using (var client = new UdpClient(localEndpoint))
            {
                client.Client.ReceiveTimeout = settings.ReceiveTimeout;
                client.Client.SendTimeout = settings.SendTimeout;

                client.Connect(EndPoint);

                var requestPacket = new List<byte>();
                requestPacket.AddRange(new Byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0x55 });
                requestPacket.AddRange(BitConverter.GetBytes(-1));

                client.Send(requestPacket.ToArray(), requestPacket.ToArray().Length);
                byte[] responseData = client.Receive(ref localEndpoint);
                requestPacket.Clear();
                requestPacket.AddRange(new Byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0x55 });
                requestPacket.AddRange(responseData.Skip(5).Take(4));
                client.Send(requestPacket.ToArray(), requestPacket.ToArray().Length);
                responseData = client.Receive(ref localEndpoint);

                return ServerPlayers.Parse(responseData);
            }
        }

        public Reciver(string portString,HlavneOkno ho)
        {
            this.ho = ho;
            int port = 0;
            if (Int32.TryParse(portString, out port)==false)
            {
                return;
            }
            socket = new UdpClient(port);
            IPEndPoint server = new IPEndPoint(IPAddress.Any, port);

            System.Threading.ThreadPool.QueueUserWorkItem(delegate
            {
                try
                {
                    byte[] packet = socket.Receive(ref server);
                    ocakavany = Int32.Parse(Encoding.ASCII.GetString(packet).Substring(4, 4));
                    pocet++;
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
                sprava = new String[ocakavany];
                Thread.Sleep(20);
                while (nacitavaj)
                {
                    try
                    {
                        byte[] packet = socket.Receive(ref server);
                        String Sprava = Encoding.ASCII.GetString(packet).Substring(4,packet.Length-4);
                        Int32 poradie = Int32.Parse(Encoding.ASCII.GetString(packet).Substring(0,4));
                        sprava[poradie] = Sprava;
                        pocet++;
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                    }
                    Thread.Sleep(20);
                    if (pocet == ocakavany)
                    {
                        ho.pocuvatStop_Click();
                        break;
                    }
                }
            }, null);
        }

		/// <summary>
		/// Attempts to receive a packet.
		/// </summary>
		/// <param name="client">the UDP client to receive from</param>
		/// <returns>the length of the received packet or -1 if nothing was received</returns>
		/// 
		public int Receive(UdpClient client)
		{
			source = new IPEndPoint(IPAddress.Any, 0);

			idx    = 0;
			data   = null;
			id     = -1;
			length = 0;
			try
			{
				data    = client.Receive(ref source);
				length  = data.Length - 4;
				id      = GetInt16();
				int len = GetInt16();
				if ( len != length )
				{
					Debug.LogWarning("Packet length mismatch (" + length + " received, " + len + " announced)");
				}
				errorCounter = 0;
			}
			catch (SocketException e)
			{
				if (errorCounter == 0)
				{
					Debug.LogWarning("Exception while waiting for MoCap server response (Time: " + Time.timeSinceLevelLoad + "s): " + e.Message);
				}
				errorCounter++;
			}

			return (data == null) ? -1 : length;
		}

	public static NameServerProxy locateNS(string host, int port) {
		if(host!=null) {
			if(port==0)
				port=Config.NS_PORT;
			NameServerProxy proxy=new NameServerProxy(host, port);
			proxy.ping();
			return proxy;
		}
		if(port==0)
			port=Config.NS_BCPORT;
		
		IPEndPoint ipendpoint = new IPEndPoint(IPAddress.Broadcast, port);
		using(UdpClient udpclient=new UdpClient()) {
			udpclient.Client.ReceiveTimeout = 2000;
			udpclient.EnableBroadcast=true;
			byte[] buf=Encoding.ASCII.GetBytes("GET_NSURI");
			udpclient.Send(buf, buf.Length, ipendpoint);
			IPEndPoint source=null;
			try {
				buf=udpclient.Receive(ref source);
			} catch (SocketException) {
				// try localhost explicitly (if host wasn't localhost already)
				if(host==null || (!host.StartsWith("127.0") && host!="localhost"))
					return locateNS("localhost", Config.NS_PORT);
				else
					throw;
			}
			string location=Encoding.ASCII.GetString(buf);
			return new NameServerProxy(new PyroURI(location));
		}
	}

        /// <summary>
        /// Provides a one-time, preprocessing functionality for the cmdlet.
        /// </summary>
        protected override void BeginProcessing()
        {
            // Initialize parameters and base Incog cmdlet components
            this.InitializeComponent();

            // Invoke Interative Mode if selected
            if (this.Interactive) this.InteractiveMode();

            // Receiving messages endpoint
            IPEndPoint bobEndpoint = new IPEndPoint(this.LocalAddress, 53);

            // Sending messages endpoing
            IPEndPoint aliceEndpoint = new IPEndPoint(this.RemoteAddress, 0);

            // Open up the UDP port for packet capture
            UdpClient socket = new UdpClient(bobEndpoint);
            this.packetCapturing = true;

            do
            {
                byte[] payload = socket.Receive(ref aliceEndpoint);
                string text = System.Text.Encoding.ASCII.GetString(payload);
                this.ReceiveCovertMessage(text);
            }
            while (this.packetCapturing);

            socket.Close();
        }

        public static void Listen(IPEndPoint remoteIP)
        {
            var done = false;

            var listener = new UdpClient(remoteIP);
            listener.Connect(remoteIP);
            var groupEP = new IPEndPoint(IPAddress.Any, remoteIP.Port);
            try
            {
                while (!done)
                {
                    Console.WriteLine("Waiting for broadcast..");
                    byte[] bytes = listener.Receive(ref groupEP);
                    string json = EncodingUtility.Decode(bytes);
                    Console.WriteLine("Received broadcast from {0}:{1} :\n {2}\n", groupEP.Address,groupEP.Port, json);
                    var message = JsonHelper.JsonDeserialize<ExchangeAMd>(json);
                    //Do aaync
                    ProcessOrder(message);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
            finally
            {
                listener.Close();
            }
        }

        public void SendBytesNow_LoopBack_SequenceNumber16K()
        {
            int i;
            bool result = false;

            UDPSender us = new UDPSender("127.0.0.1", 7770);

            byte[] data = new byte[1024 * 16];

            for (i = 0; i < data.Length; i++)
            {
                data[i] = (byte)i;
            }

            UdpClient listener = new UdpClient(7770);
            IPEndPoint groupEP = new IPEndPoint(IPAddress.Any, 7770);

            //Blocking Call
            us.SendBytesNow(data, 1024 * 16);

            //BLOCKING CALL
            byte[] bytes = listener.Receive(ref groupEP);

            for (i = 0; i < data.Length; i++)
            {
                if (bytes[i] != (byte)i)
                {
                    Assert.True(false);
                }
            }

            Assert.True(true);

            listener.Close();
        }

        static void Main(string[] args)
        {
            System.Net.Sockets.UdpClient sock = new System.Net.Sockets.UdpClient();
            IPEndPoint iep = new IPEndPoint(IPAddress.Parse("129.241.187.44"), 20004);

            Console.WriteLine("Enter message");
            string userinput = Console.ReadLine();
            byte[] data = Encoding.ASCII.GetBytes(userinput);
            sock.Send(data, data.Length, iep);
            sock.Close();

            Console.WriteLine("Message sent.");



            System.Net.Sockets.UdpClient server = new System.Net.Sockets.UdpClient(20004);
            IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
            byte[] recvdata = new byte[1024];
            recvdata = server.Receive(ref sender);
            server.Close();
            string stringData = Encoding.ASCII.GetString(recvdata, 0, recvdata.Length);
            Console.WriteLine("Response from " + sender.Address + Environment.NewLine + "Message: " + stringData);
            Console.ReadLine();

        }

        private void listen()
        {
            UdpClient uc = new UdpClient(9527);
            while (true)
            {
                IPEndPoint ipep = new IPEndPoint(IPAddress.Any,0);
                byte[] bmsg = uc.Receive(ref ipep);
                string msg = Encoding.Default.GetString(bmsg);
                string[] s = msg.Split('|');
                if (s[0] == "PUBLIC")
                {
                   this.txtHistory.Text += s[2] +"："+ "\r\n";
                   this.txtHistory.Text += s[1] + "\r\n";

                }
                else if (s[0] == "INROOM")
                {
                    this.txtHistory.Text += s[1] + "登录了" + "\r\n";
                }
                else
                {
                    return;
                }

            }
        }

        static void Main(string[] args)
        {
            String s;
            byte[] data;
            IPEndPoint ipep = new IPEndPoint(IPAddress.Any, 1165);
            UdpClient client = new UdpClient(ipep);
            client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);

            String c;
            byte[] cdata;
            IPEndPoint cipep = new IPEndPoint(IPAddress.Any, 1166);
            UdpClient Cclient = new UdpClient(cipep);
            Cclient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
            while (true)
              {
              data = client.Receive(ref ipep);
              s = Encoding.ASCII.GetString(data);
              Console.WriteLine(s.Substring(35,75));//only what we need to see

              //don't need the console stuff right now...
              //cdata = Cclient.Receive(ref cipep);
              //c = Encoding.ASCII.GetString(cdata);
              //Console.ReadLine(); //this will pause the console
              //Console.WriteLine(c); //we dont want to do this quite yet
            }
        }

        public static void StartListener(int port)
        {
            UdpClient client = new UdpClient();

                        client.ExclusiveAddressUse = false;
            IPEndPoint localEp = new IPEndPoint(IPAddress.Any, port);

                        client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
                        client.ExclusiveAddressUse = false;

                        client.Client.Bind(localEp);

                        //IPAddress multicastaddress = IPAddress.Parse("239.0.0.222");
                        //client.JoinMulticastGroup(multicastaddress);

                        while (true)
                        {
                            Byte[] data = client.Receive(ref localEp);

                            string strData = Encoding.ASCII.GetString(data);

                eventH e = JsonConvert.DeserializeObject<eventH>(strData);
                e.handle();

                        }
        }

        public static void Receiver()
        {
            // Создаем UdpClient для чтения входящих данных
            UdpClient receivingUdpClient = new UdpClient(localPort);

            IPEndPoint RemoteIpEndPoint = null;

            try
            {
                Console.WriteLine(
                   "\n-----------*******Общий чат*******-----------");

                while (true)
                {
                    // Ожидание дейтаграммы
                    byte[] receiveBytes = receivingUdpClient.Receive(
                       ref RemoteIpEndPoint);

                    // Преобразуем и отображаем данные
                    Console.WriteLine(RemoteIpEndPoint.Address.ToString());
                    Console.WriteLine(RemoteIpEndPoint.Port.ToString());
                    string returnData = Encoding.UTF8.GetString(receiveBytes);
                    Console.WriteLine(" --> " + returnData.ToString());
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Возникло исключение: " + ex.ToString() + "\n  " + ex.Message);
            }
        }

        private void listen()
        {
            UdpClient uc = new UdpClient(9527);
            while (true)
            {
                IPEndPoint ipep = new IPEndPoint(IPAddress.Any, 0);
                byte[] bmsg = uc.Receive(ref ipep);
                string scontent = Encoding.Default.GetString(bmsg);
                string[] data = scontent.Split('|');
                if(data[0]=="INROOM")
                {
                    this.txt_person.Text += data[1] + "上线了\r\n";
                }
                if(data[0]=="PUBLIC")
                {
                    int l = data.Count();
                    if(l>3)
                    {
                        this.txtHistory.Text += data[2] + ":\r\n";
                        this.txtHistory.Text += data[2] + "\r\n";
                    }
                }

            }
        }