title: C# .NET 4.0/4.5 UDP send issue
body: <p>I am working on writing a network library in C# and originally had used the .NET 3.5 Framework.  I recently decided to switch to .NET 4.5 but started running into an issue with sending UDP packets.  What I'm running into is if UDP packets are sent too fast, the <code>Socket.SendToAsync</code> method completes with a <code>SocketError</code> of <code>AddressFamilyNotSupported</code> and the packets are never sent.  </p>
  
  <p>If I switch the project to .NET 3.5, I never run into the issue no matter how hard I try to repeat it.  This also can be reproduced in .NET 4.0.</p>
  
  <p>Here is a <a href="http://dl.dropbox.com/u/11540065/UdpTest.zip" rel="nofollow">link</a> to the project I put together to reproduce the issue.  If you spam the "ClientSnd" or "ServerSnd" buttons you'll see the error occur.  Switch the project to .NET 3.5 and spam all you want... no issues at all.</p>
  
  <p>I haven't been able to find much useful information searching on this issue.  Any ideas?</p>
  
  <p><strong>EDIT (added code from the sample project demoing the issue):</strong></p>
  
  <p>Here's where the binds are happening for both the client and server:</p>
  
  <pre><code>            byte[] clientBuffer = new byte[32768];
              byte[] serverBuffer = new byte[32768];
  
              IPEndPoint clientLocalEndPoint = GetLocalIPEndPoint(0, AddressFamily.InterNetwork);
              IPEndPoint serverLocalEndPoint = GetLocalIPEndPoint(6337, AddressFamily.InterNetwork);
  
              m_ClientSocket.ExclusiveAddressUse = true;
              m_ServerSocket.ExclusiveAddressUse = true;
              m_ClientSocket.Bind(clientLocalEndPoint);
              m_ServerSocket.Bind(serverLocalEndPoint);
  
              m_ClientSendArgs.RemoteEndPoint = GetRemoteIPEndPoint("127.0.0.1", 6337, AddressFamily.InterNetwork);
              m_ClientRecvArgs.RemoteEndPoint = m_ClientSocket.LocalEndPoint;
  
              m_ServerSendArgs.RemoteEndPoint = GetRemoteIPEndPoint("127.0.0.1", ((IPEndPoint)m_ClientSocket.LocalEndPoint).Port, AddressFamily.InterNetwork);
              m_ServerRecvArgs.RemoteEndPoint = m_ServerSocket.LocalEndPoint;
  
              m_ClientSendArgs.Completed += new EventHandler&lt;SocketAsyncEventArgs&gt;(OnClientCompletion);
              m_ClientRecvArgs.Completed += new EventHandler&lt;SocketAsyncEventArgs&gt;(OnClientCompletion);
              m_ServerSendArgs.Completed += new EventHandler&lt;SocketAsyncEventArgs&gt;(OnServerCompletion);
              m_ServerRecvArgs.Completed += new EventHandler&lt;SocketAsyncEventArgs&gt;(OnServerCompletion);
  
              m_ClientRecvArgs.SetBuffer(clientBuffer, 0, clientBuffer.Length);
              m_ServerRecvArgs.SetBuffer(serverBuffer, 0, serverBuffer.Length);
  
              ClientReceive();
              ServerReceive();
  </code></pre>
  
  <p>The <code>GetRemoteIPEndPoint</code> and <code>GetLocalIPEndPoint</code> methods:</p>
  
  <pre><code>    private static IPEndPoint GetRemoteIPEndPoint(string address, int port, AddressFamily addressFamily)
      {
          IPAddress[] ipAddresses = null;
  
          ipAddresses = Dns.GetHostAddresses(address);
  
          List&lt;IPEndPoint&gt; ipEndPointList = new List&lt;IPEndPoint&gt;();
  
          for (int i = 0; i &lt; ipAddresses.Length; i++)
          {
              IPAddress ipAddress = ipAddresses[i];
  
              if (ipAddress.AddressFamily == addressFamily)
              {
                  IPEndPoint ipEndPoint = new IPEndPoint(ipAddress, port);
  
                  ipEndPointList.Add(ipEndPoint);
              }
          }
  
          return ipEndPointList.ToArray()[0];
      }
  
      private static IPEndPoint GetLocalIPEndPoint(int port, AddressFamily addressFamily)
      {
          IPEndPoint localEndPoint = null;
  
          switch (addressFamily)
          {
              case AddressFamily.InterNetwork:
                  {
                      localEndPoint = new IPEndPoint(IPAddress.Any, port);
  
                      break;
                  }
              case AddressFamily.InterNetworkV6:
                  {
                      localEndPoint = new IPEndPoint(IPAddress.IPv6Any, port);
  
                      break;
                  }
          }
  
          return localEndPoint;
      }
  </code></pre>
  
  <p><strong>Since this happens regardless of who sends the data (client or server), I'll focus on the client being the sender:</strong></p>
  
  <p>Clicking the <code>ClientSnd</code> button:</p>
  
  <pre><code>    private void Button_ClientSnd_Click(object sender, RoutedEventArgs e)
      {
          lock (SyncRoot)
          {
              byte[] buffer = Encoding.ASCII.GetBytes("Hello there.  Just testing.  Nothing to see here.  Move along.");
  
              m_ClientSendQueue.Enqueue(buffer);
  
              if (!m_ClientTransmitting)
              {
                  m_ClientTransmitting = true;
  
                  ClientSendBuffer();
              }
          }
      }
  </code></pre>
  
  <p>Sending methods for the client:</p>
  
  <pre><code>    private void ClientSendBuffer()
      {
          lock (SyncRoot)
          {
              if (m_ClientSendQueue.Count &gt; 0)
              {
                  byte[] buffer = m_ClientSendQueue.Dequeue();
  
                  m_ClientSendArgs.SetBuffer(buffer, 0, buffer.Length);
  
                  ClientSend();
              }
              else
              {
                  m_ClientTransmitting = false;
              }
          }
      }
  
      private void ClientSend()
      {
          if (!m_ClientSocket.SendToAsync(m_ClientSendArgs))
          {
              OnClientCompletion(this, m_ClientSendArgs);
          }
      }
  </code></pre>
  
  <p>Completion callback for the client:</p>
  
  <pre><code>    private void OnClientCompletion(object sender, SocketAsyncEventArgs e)
      {
          SocketError socketError = e.SocketError;
  
          if (socketError != SocketError.Success)
          {
              ClientConsoleWrite("SocketError: {0}\r\n", socketError);
          }
  
          switch (e.LastOperation)
          {
              case SocketAsyncOperation.SendTo:
                  {
                      if (socketError == SocketError.Success)
                      {
                          ClientConsoleWrite("Client message sent!\r\n");
                      }
  
                      ClientSendBuffer();
  
                      break;
                  }
              case SocketAsyncOperation.ReceiveFrom:
                  {
                      int bytesTransferred = e.BytesTransferred;
  
                      byte[] buffer = new byte[bytesTransferred];
  
                      Buffer.BlockCopy(e.Buffer, e.Offset, buffer, 0, bytesTransferred);
  
                      string message = Encoding.ASCII.GetString(buffer);
  
                      ClientConsoleWrite("Message received: {0}\r\n", message);
  
                      ClientReceive();
  
                      break;
                  }
          }
      }
  </code></pre>