牛++的博客

  1 using System;
  2  using System.Net;
  3  using System.Net.Sockets;
  4 using System.ServiceProcess;
  5 using System.Threading;
  6 
  7 namespace TestUdpServer
  8 {
  9  // this class encapsulates a single packet that
 10  // is either sent or received by a UDP socket
 11  public class UDPPacketBuffer
 12     {
 13  // size of the buffer
 14  public const int BUFFER_SIZE = 4096;
 15 
 16  // the buffer itself
 17  public byte[] Data;
 18 
 19  // length of data to transmit
 20  public int DataLength;
 21 
 22  // the (IP)Endpoint of the remote host
 23  public EndPoint RemoteEndPoint;
 24 
 25  public UDPPacketBuffer()
 26         {
 27  this.Data = new byte[BUFFER_SIZE];
 28 
 29  // this will be filled in by the call to udpSocket.BeginReceiveFrom
 30             RemoteEndPoint = (EndPoint)new IPEndPoint(IPAddress.Any, 0);
 31         }
 32 
 33  public UDPPacketBuffer(byte[] data, EndPoint remoteEndPoint)
 34         {
 35  this.Data = data;
 36  this.DataLength = data.Length;
 37  this.RemoteEndPoint = remoteEndPoint;
 38         }
 39     }
 40 
 41  public abstract class UDPServer
 42     {
 43  // the port to listen on
 44  private int udpPort;
 45 
 46  // the UDP socket
 47  private Socket udpSocket;
 48 
 49  // the ReaderWriterLock is used solely for the purposes of shutdown (Stop()).
 50  // since there are potentially many "reader" threads in the internal .NET IOCP
 51  // thread pool, this is a cheaper synchronization primitive than using
 52  // a Mutex object.  This allows many UDP socket "reads" concurrently - when
 53  // Stop() is called, it attempts to obtain a writer lock which will then
 54  // wait until all outstanding operations are completed before shutting down.
 55  // this avoids the problem of closing the socket with outstanding operations
 56  // and trying to catch the inevitable ObjectDisposedException.
 57  private ReaderWriterLock rwLock = new ReaderWriterLock();
 58 
 59  // number of outstanding operations.  This is a reference count
 60  // which we use to ensure that the threads exit cleanly. Note that
 61  // we need this because the threads will potentially still need to process
 62  // data even after the socket is closed.
 63  private int rwOperationCount = 0;
 64 
 65  // the all important shutdownFlag.  This is synchronized through the ReaderWriterLock.
 66  private bool shutdownFlag = true;
 67 
 68  // these abstract methods must be implemented in a derived class to actually do
 69  // something with the packets that are sent and received.
 70  protected abstract void PacketReceived(UDPPacketBuffer buffer);
 71  protected abstract void PacketSent(UDPPacketBuffer buffer, int bytesSent);
 72 
 73  // ServiceName
 74         String ServiceName = "test";
 75 
 76  public UDPServer(int port)
 77         {
 78  this.udpPort = port;
 79         }
 80 
 81  public void Start()
 82         {
 83  if (shutdownFlag)
 84             {
 85  // create and bind the socket
 86                 IPEndPoint ipep = new IPEndPoint(IPAddress.Any, udpPort);
 87                 udpSocket = new Socket(
 88                     AddressFamily.InterNetwork,
 89                     SocketType.Dgram,
 90                     ProtocolType.Udp);
 91                 udpSocket.Bind(ipep);
 92  // we're not shutting down, we're starting up
 93                 shutdownFlag = false;
 94                 
 95  // kick off an async receive.  The Start() method will return, the
 96  // actual receives will occur asynchronously and will be caught in
 97  // AsyncEndRecieve().
 98  // I experimented with posting multiple AsyncBeginReceives() here in an attempt
 99  // to "queue up" reads, however I found that it negatively impacted performance.
100                 AsyncBeginReceive();
101             }
102         }
103 
104  protected void Stop()
105         {
106  if (!shutdownFlag)
107             {
108  // wait indefinitely for a writer lock.  Once this is called, the .NET runtime
109  // will deny any more reader locks, in effect blocking all other send/receive
110  // threads.  Once we have the lock, we set shutdownFlag to inform the other
111  // threads that the socket is closed.
112                 rwLock.AcquireWriterLock(-1);
113                 shutdownFlag = true;
114                 udpSocket.Close();
115                 rwLock.ReleaseWriterLock();
116 
117  // wait for any pending operations to complete on other
118  // threads before exiting.
119  while (rwOperationCount > 0)
120                     Thread.Sleep(1);
121             }
122         }
123 
124  public bool IsRunning
125         {
126  // self-explanitory
127  get { return !shutdownFlag; }
128         }
129 
130  private void AsyncBeginReceive()
131         {
132  // this method actually kicks off the async read on the socket.
133  // we aquire a reader lock here to ensure that no other thread
134  // is trying to set shutdownFlag and close the socket.
135             rwLock.AcquireReaderLock(-1);
136 
137  if (!shutdownFlag)
138             {
139  // increment the count of pending operations
140                 Interlocked.Increment(ref rwOperationCount);
141 
142  // allocate a packet buffer
143                 UDPPacketBuffer buf = new UDPPacketBuffer();
144 
145  try
146                 {
147  // kick off an async read
148                     udpSocket.BeginReceiveFrom(
149                         buf.Data,
150  0,
151                         UDPPacketBuffer.BUFFER_SIZE,
152                         SocketFlags.None,
153  ref buf.RemoteEndPoint,
154  new AsyncCallback(AsyncEndReceive),
155                         buf);
156                 }
157  catch (SocketException se)
158                 {
159  // something bad happened
160                     System.Diagnostics.EventLog.WriteEntry(ServiceName,
161  "A SocketException occurred in UDPServer.AsyncBeginReceive():\n\n" + se.Message,
162                         System.Diagnostics.EventLogEntryType.Error);
163 
164  // an error occurred, therefore the operation is void.  Decrement the reference count.
165                     Interlocked.Decrement(ref rwOperationCount);
166                 }
167             }
168 
169  // we're done with the socket for now, release the reader lock.
170             rwLock.ReleaseReaderLock();
171         }
172 
173  private void AsyncEndReceive(IAsyncResult iar)
174         {
175  // Asynchronous receive operations will complete here through the call
176  // to AsyncBeginReceive
177 
178  // aquire a reader lock
179             rwLock.AcquireReaderLock(-1);
180 
181  if (!shutdownFlag)
182             {
183  // start another receive - this keeps the server going!
184                 AsyncBeginReceive();
185 
186  // get the buffer that was created in AsyncBeginReceive
187  // this is the received data
188                 UDPPacketBuffer buffer = (UDPPacketBuffer)iar.AsyncState;
189 
190  try
191                 {
192  // get the length of data actually read from the socket, store it with the
193  // buffer
194                     buffer.DataLength = udpSocket.EndReceiveFrom(iar, ref buffer.RemoteEndPoint);
195 
196  // this operation is now complete, decrement the reference count
197                     Interlocked.Decrement(ref rwOperationCount);
198 
199  // we're done with the socket, release the reader lock
200                     rwLock.ReleaseReaderLock();
201 
202  // call the abstract method PacketReceived(), passing the buffer that
203  // has just been filled from the socket read.
204                     PacketReceived(buffer);
205                 }
206  catch (SocketException se)
207                 {
208  // something bad happened
209                     System.Diagnostics.EventLog.WriteEntry(ServiceName,
210  "A SocketException occurred in UDPServer.AsyncEndReceive():\n\n" + se.Message,
211                         System.Diagnostics.EventLogEntryType.Error);
212 
213  // an error occurred, therefore the operation is void.  Decrement the reference count.
214                     Interlocked.Decrement(ref rwOperationCount);
215 
216  // we're done with the socket for now, release the reader lock.
217                     rwLock.ReleaseReaderLock();
218                 }
219             }
220  else
221             {
222  // nothing bad happened, but we are done with the operation
223  // decrement the reference count and release the reader lock
224                 Interlocked.Decrement(ref rwOperationCount);
225                 rwLock.ReleaseReaderLock();
226             }
227         }
228 
229  public void AsyncBeginSend(UDPPacketBuffer buf)
230         {
231  // by now you should you get the idea - no further explanation necessary
232 
233             rwLock.AcquireReaderLock(-1);
234 
235  if (!shutdownFlag)
236             {
237  try
238                 {
239                     Interlocked.Increment(ref rwOperationCount);
240                     udpSocket.BeginSendTo(
241                         buf.Data,
242  0,
243                         buf.DataLength,
244                         SocketFlags.None,
245                         buf.RemoteEndPoint,
246  new AsyncCallback(AsyncEndSend),
247                         buf);
248                 }
249  catch (SocketException se)
250                 {
251                     System.Diagnostics.EventLog.WriteEntry(ServiceName,
252  "A SocketException occurred in UDPServer.AsyncBeginSend():\n\n" + se.Message,
253                         System.Diagnostics.EventLogEntryType.Error);
254                 }
255             }
256 
257             rwLock.ReleaseReaderLock();
258         }
259 
260  private void AsyncEndSend(IAsyncResult iar)
261         {
262  // by now you should you get the idea - no further explanation necessary
263 
264             rwLock.AcquireReaderLock(-1);
265 
266  if (!shutdownFlag)
267             {
268                 UDPPacketBuffer buffer = (UDPPacketBuffer)iar.AsyncState;
269 
270  try
271                 {
272  int bytesSent = udpSocket.EndSendTo(iar);
273 
274  // note that call to the abstract PacketSent() method - we are passing the number
275  // of bytes sent in a separate parameter, since we can't use buffer.DataLength which
276  // is the number of bytes to send (or bytes received depending upon whether this
277  // buffer was part of a send or a receive).
278                     PacketSent(buffer, bytesSent);
279                 }
280  catch (SocketException se)
281                 {
282                     System.Diagnostics.EventLog.WriteEntry(ServiceName,
283  "A SocketException occurred in UDPServer.AsyncEndSend():\n\n" + se.Message,
284                         System.Diagnostics.EventLogEntryType.Error);
285                 }
286             }
287 
288             Interlocked.Decrement(ref rwOperationCount);
289             rwLock.ReleaseReaderLock();
290         }
291 
292     }
293 }

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Text;
 4 using System.Runtime.InteropServices;
 5 
 6 namespace TestUdpServer
 7 {
 8  public class TUdpServer : UDPServer
 9     {
10 
11  public TUdpServer(int port)
12             : base(port)
13         {
14             Console.WriteLine("Server Start...@" + port.ToString());
15         }
16 
17  protected override void PacketReceived(UDPPacketBuffer buffer)
18         {
19             AsyncBeginSend(buffer);
20         }
21 
22  protected override void PacketSent(UDPPacketBuffer buffer, int bytesSent)
23         {
24 
25         }
26 
27     }
28 }
29