1 using System;
2 using System.Collections.Generic;
3 using System.Text;
4 using System.Net.Sockets;
5 using System.Net;
6 using System.Threading;
7 using System.Runtime.InteropServices;
8
9 namespace ConsoleApplication2
10 {
11 class Program
12 {
13 static Socket m_sListen;
14
15 static void Main(string[] args)
16 {
17 new Thread(new ThreadStart(ListenThreadMothed)).Start();
18
19 Console.WriteLine("请按回车键结束!");
20 Console.ReadKey();
21 }
22
23 private static void ListenThreadMothed()
24 {
25 IPAddress ip = IPAddress.Parse("222.222.222.187");
26 IPEndPoint ipe = new IPEndPoint(ip, 60000);
27
28 m_sListen = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
29 m_sListen.Bind(ipe);
30
31 IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
32 EndPoint remote = (EndPoint)sender;
33
34 for (int i = 0; i < 5; i++)
35 {
36 PostRecv(remote);
37 }
38 }
39
40 private static void PostRecv(EndPoint endPoint)
41 {
42 byte[] buffer = new byte[516];
43 m_sListen.BeginReceiveFrom(buffer,
44 0,
45 buffer.Length,
46 SocketFlags.None,
47 ref endPoint,
48 EndRecv,
49 new AsyncState(buffer, 0, buffer.Length, endPoint));
50 }
51
52 private static void PostSend(byte[] buffer, int offset, int size, EndPoint endPoint)
53 {
54 m_sListen.BeginSendTo(buffer,
55 offset,
56 size,
57 SocketFlags.None,
58 endPoint,
59 EndSend,
60 new AsyncState(buffer, offset, size, endPoint));
61 }
62
63 private static void EndRecv(IAsyncResult asyncResult)
64 {
65 AsyncState state = (AsyncState)asyncResult.AsyncState;
66 int readBytes = m_sListen.EndReceiveFrom(asyncResult, ref state.EndPoint);
67
68 PostRecv(state.EndPoint);
69
70 //echo
71 //Console.WriteLine(Encoding.Default.GetString(state.buffer));
72 PostSend(state.Buffer, state.Offset, state.Size, state.EndPoint);
73 }
74
75 private static void EndSend(IAsyncResult asyncResult)
76 {
77 AsyncState state = (AsyncState)asyncResult.AsyncState;
78 byte[] buffer = state.Buffer;
79 int sendBytes = m_sListen.EndSendTo(asyncResult);
80 int remainBytes = state.Size - sendBytes;
81 if (remainBytes <= 0)
82 return;
83 PostSend(buffer, buffer.Length - remainBytes, remainBytes, state.EndPoint);
84 }
85
86 [Serializable, StructLayout(LayoutKind.Sequential)]
87 internal struct AsyncState
88 {
89 private readonly byte[] buffer;
90 private readonly int offset;
91 private readonly int size;
92
93 public AsyncState(byte[] buffer, EndPoint endPoint)
94 {
95 if (endPoint == null)
96 {
97 throw new ArgumentNullException("endPoint");
98 }
99 this.buffer = buffer;
100 this.offset = 0;
101 this.size = buffer.Length;
102 this.EndPoint = endPoint;
103 }
104
105 public AsyncState(byte[] buffer, int offset, int size, EndPoint endPoint)
106 {
107 if (buffer == null)
108 {
109 throw new ArgumentNullException("array");
110 }
111 if (offset < 0)
112 {
113 throw new ArgumentOutOfRangeException("offset", "ArgumentOutOfRange_NeedNonNegNum");
114 }
115 if (size < 0)
116 {
117 throw new ArgumentOutOfRangeException("count", "ArgumentOutOfRange_NeedNonNegNum");
118 }
119 if ((buffer.Length - offset) < size)
120 {
121 throw new ArgumentException("Argument_InvalidOffLen");
122 }
123 if (endPoint == null)
124 {
125 throw new ArgumentNullException("endPoint");
126 }
127 this.buffer = buffer;
128 this.offset = offset;
129 this.size = size;
130 this.EndPoint = endPoint;
131 }
132
133 public byte[] Buffer
134 {
135 get { return buffer; }
136 }
137
138 public int Offset
139 {
140 get { return offset; }
141 }
142
143 public int Size
144 {
145 get { return size; }
146 }
147
148 public EndPoint EndPoint;
149 }
150 }
151 }
