<Type Name="Socket" FullName="System.Net.Sockets.Socket" FullNameSP="System_Net_Sockets_Socket" Maintainer="ecma">
  <TypeSignature Language="ILASM" Value=".class public Socket extends System.Object implements System.IDisposable" />
  <TypeSignature Language="C#" Value="public class Socket : IDisposable" />
  <MemberOfLibrary>Networking</MemberOfLibrary>
  <AssemblyInfo>
    <AssemblyName>System</AssemblyName>
    <AssemblyPublicKey>[00 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00 ]</AssemblyPublicKey>
    <AssemblyVersion>1.0.x.x</AssemblyVersion>
    <AssemblyCulture>none</AssemblyCulture>
    <Attributes>
      <Attribute>
        <AttributeName>CLSCompliantAttribute(true)</AttributeName>
        <Excluded>0</Excluded>
      </Attribute>
    </Attributes>
  </AssemblyInfo>
  <ThreadingSafetyStatement>All public static members of this type are safe for multithreaded operations. No instance members are guaranteed to be thread safe.</ThreadingSafetyStatement>
  <Docs>
    <summary>
      <para> Creates a communication endpoint through which an application sends or receives data across a
      network.</para>
    </summary>
    <remarks>
      <para> This class enables a <see cref="T:System.Net.Sockets.Socket" /> instance to communicate with another socket
   across a network. The communication can
   be through connection-oriented and connectionless protocols using either data streams or datagrams
   (discrete message packets).</para>
      <para>Message-oriented protocols preserve message boundaries
   and require that for each <see cref="M:System.Net.Sockets.Socket.Send(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" /> method call there is one
   corresponding <see cref="M:System.Net.Sockets.Socket.Receive(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" /> method call. For stream-oriented protocols, data
   is transmitted without regards to message boundaries. In this case, for
   example, multiple <see cref="M:System.Net.Sockets.Socket.Receive(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" /> method calls may be necessary to
   retrieve all the data from one <see cref="M:System.Net.Sockets.Socket.Send(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" /> method call. The protocol is set in
   the <see langword="Socket" />
   
   class
   constructor. </para>
      <para>A <see cref="T:System.Net.Sockets.Socket" />
instance has a local and a remote endpoint associated with it. The local
endpoint contains the connection information for the current socket instance.
The remote endpoint contains the connection information for the socket that the current instance communicates with. The
endpoints are required to be an instance of a type derived from
the <see cref="T:System.Net.EndPoint" qualify="true" /> class. For the Transmission Control Protocol (TCP) and User Datagram Protocol (UDP) protocols, an endpoint
includes the address family, an Internet Protocol (IP) address, and a port number.
For connection-oriented protocols (for example, TCP), the remote endpoint
does not have to be specified when transferring data. For connectionless
protocols (for example, UDP), the remote endpoint is required to be specified.</para>
      <para>Methods are provided for both synchronous and asynchronous
   operations. A synchronous method can operate in blocking mode, in which it waits
   (blocks) until the operation is complete before returning, or in non-blocking
   mode, where it returns immediately, possibly before the operation has completed.
   The blocking mode is set through the <see cref="P:System.Net.Sockets.Socket.Blocking" /> property.</para>
      <para> An asynchronous method returns immediately and, by convention, relies on a delegate to
   complete the operation. Asynchronous methods have names which correspond to their
   synchronous counterparts prefixed with either 'Begin' or End'. For example, the
   synchronous <see cref="M:System.Net.Sockets.Socket.Accept" /> method has asynchronous counterpart methods
   named <see cref="M:System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object)" /> and <see cref="M:System.Net.Sockets.Socket.EndAccept(System.IAsyncResult)" />. The
   example for the <see cref="M:System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object)" /> method shows the basic
   steps for using an asynchronous operation. A complete working example follows this
   discussion.</para>
      <para>Connection-oriented protocols commonly use the client/server model. In this model, one of
   the sockets is set up as a server, and one or more sockets are set
   up as clients. A general procedure demonstrating the synchronous communication process for this model is as
   follows.</para>
      <para>On the server-side:</para>
      <list type="number">
        <item>
          <term>
      Create a socket to listen for incoming connection
      requests.</term>
        </item>
        <item>
          <term>
      Set the local endpoint using the <see cref="M:System.Net.Sockets.Socket.Bind(System.Net.EndPoint)" /> method.</term>
        </item>
        <item>
          <term>
      Put the socket in the
      listening state using the <see cref="M:System.Net.Sockets.Socket.Listen(System.Int32)" /> method.</term>
        </item>
        <item>
          <term>
      At this point incoming connection requests from a
      client are placed in a queue.</term>
        </item>
        <item>
          <term>
      Use the <see cref="M:System.Net.Sockets.Socket.Accept" /> method to create a server socket
      for a connection request issued by a client-side socket. This sets the remote
      endpoint.</term>
        </item>
        <item>
          <term>
      Use the <see cref="M:System.Net.Sockets.Socket.Send(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" /> and <see cref="M:System.Net.Sockets.Socket.Receive(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" /> methods to communicate with the
      client socket.</term>
        </item>
        <item>
          <term>
      When communication is finished, terminate the connection
      using the <see cref="M:System.Net.Sockets.Socket.Shutdown(System.Net.Sockets.SocketShutdown)" /> method.</term>
        </item>
        <item>
          <term>
      Release the resources allocated by the server socket using
      the <see cref="M:System.Net.Sockets.Socket.Close" /> method.</term>
        </item>
        <item>
          <term>
      Release the resources allocated by the listener socket using the <see cref="M:System.Net.Sockets.Socket.Close" /> method.</term>
        </item>
      </list>
      <para>On the client-side:</para>
      <list type="number">
        <item>
          <term>
      Create the client socket.</term>
        </item>
        <item>
          <term>
      Connect to the server socket using the <see cref="M:System.Net.Sockets.Socket.Connect(System.Net.EndPoint)" /> method.
      This sets both the local and remote endpoints for the client socket.</term>
        </item>
        <item>
          <term>
      Use the <see cref="M:System.Net.Sockets.Socket.Send(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" /> and <see cref="M:System.Net.Sockets.Socket.Receive(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" /> methods to communicate with the
      server socket.</term>
        </item>
        <item>
          <term>&gt;
      When communication is finished, terminate the connection
      using the <see cref="M:System.Net.Sockets.Socket.Shutdown(System.Net.Sockets.SocketShutdown)" /> method.</term>
        </item>
        <item>
          <term>
      Release
      
      the resources allocated by the client socket using
      the <see cref="M:System.Net.Sockets.Socket.Close" />
      
      method.</term>
        </item>
      </list>
      <para> The shutdown step in the previous procedure is
   not necessary but ensures that any pending data is not lost. If the
<see cref="M:System.Net.Sockets.Socket.Shutdown(System.Net.Sockets.SocketShutdown)" /> method is not called, the 
<see cref="M:System.Net.Sockets.Socket.Close" /> 
method shuts
down the connection either gracefully or by force. A graceful closure attempts
to transfer all pending data before the connection is terminated. Use
the <see cref="F:System.Net.Sockets.SocketOptionName.Linger" /> socket option to specify a graceful closure for a
socket. </para>
      <block subset="none" type="note">
        <para> This implementation is based on the UNIX sockets implementation
      in the Berkeley Software Distribution (BSD, release 4.3)
      from the University of California at Berkeley. </para>
      </block>
    </remarks>
    <example>
      <para>The following examples provide a client/server
      application that demonstrates the
      use of asynchronous communication between sockets. Run the client and server on
      different consoles.</para>
      <para> The following code is for the
      server application. Start this application before the client application.</para>
      <code lang="C#">using System;
using System.Threading;
using System.Text;
using System.Net;
using System.Net.Sockets;

public class Server 
{
  // used to pass state information to delegate
  internal class StateObject 
  {
    internal byte[] sBuffer;
    internal Socket sSocket;
    internal StateObject(int size, Socket sock) {
      sBuffer = new byte[size];
      sSocket = sock;
    }
  }
  static void Main() 
  {
    IPAddress ipAddress =
      Dns.Resolve( Dns.GetHostName() ).AddressList[0];

    IPEndPoint ipEndpoint =
      new IPEndPoint(ipAddress, 1800);

    Socket listenSocket =
      new Socket(AddressFamily.InterNetwork,
                 SocketType.Stream,
                 ProtocolType.Tcp);

    listenSocket.Bind(ipEndpoint);
    listenSocket.Listen(1);
    IAsyncResult asyncAccept = listenSocket.BeginAccept(
      new AsyncCallback(Server.acceptCallback),
      listenSocket );

    // could call listenSocket.EndAccept(asyncAccept) here
    // instead of in the callback method, but since 
    // EndAccept blocks, the behavior would be similar to 
    // calling the synchronous Accept method

    Console.Write("Connection in progress.");
    if( writeDot(asyncAccept) == true ) 
    {
      // allow time for callbacks to
      // finish before the program ends 
      Thread.Sleep(3000);
    }
  }

  public static void
    acceptCallback(IAsyncResult asyncAccept) {
      Socket listenSocket = (Socket)asyncAccept.AsyncState;
      Socket serverSocket =
        listenSocket.EndAccept(asyncAccept);

      // arriving here means the operation completed
      // (asyncAccept.IsCompleted = true) but not
      // necessarily successfully
      if( serverSocket.Connected == false )
      {
        Console.WriteLine( ".server is not connected." );
        return;
      }
      else Console.WriteLine( ".server is connected." );

      listenSocket.Close();

      StateObject stateObject =
        new StateObject(16, serverSocket);

      // this call passes the StateObject because it 
      // needs to pass the buffer as well as the socket
      IAsyncResult asyncReceive =
        serverSocket.BeginReceive(
          stateObject.sBuffer,
          0,
          stateObject.sBuffer.Length,
          SocketFlags.None,
          new AsyncCallback(receiveCallback),
          stateObject);

      Console.Write("Receiving data.");
      writeDot(asyncReceive);
  }

  public static void
    receiveCallback(IAsyncResult asyncReceive) {
      StateObject stateObject =
        (StateObject)asyncReceive.AsyncState;
      int bytesReceived =
        stateObject.sSocket.EndReceive(asyncReceive);

      Console.WriteLine(
        ".{0} bytes received: {1}",
        bytesReceived.ToString(),
        Encoding.ASCII.GetString(stateObject.sBuffer) );

      byte[] sendBuffer =
        Encoding.ASCII.GetBytes("Goodbye");
      IAsyncResult asyncSend =
        stateObject.sSocket.BeginSend(
          sendBuffer,
          0,
          sendBuffer.Length,
          SocketFlags.None,
          new AsyncCallback(sendCallback),
          stateObject.sSocket);

      Console.Write("Sending response.");
      writeDot(asyncSend);
  }

  public static void sendCallback(IAsyncResult asyncSend) {
    Socket serverSocket = (Socket)asyncSend.AsyncState;
    int bytesSent = serverSocket.EndSend(asyncSend);
    Console.WriteLine(
      ".{0} bytes sent.{1}{1}Shutting down.",
      bytesSent.ToString(),
      Environment.NewLine );

    serverSocket.Shutdown(SocketShutdown.Both);
    serverSocket.Close();
  }

  // times out after 20 seconds but operation continues
  internal static bool writeDot(IAsyncResult ar)
  {
    int i = 0;
    while( ar.IsCompleted == false ) 
    {
      if( i++ &gt; 40 ) 
      {
        Console.WriteLine("Timed out.");
        return false;
      }
      Console.Write(".");
      Thread.Sleep(500);
    }
    return true;
  }
}
   </code>
      <para>The following code is for the client application. When
      starting the application, supply the hostname of the console running the server
      application as an input parameter (for example, ProgramName <paramref name="hostname" />
      ). </para>
      <code lang="C#">using System;
using System.Threading;
using System.Text;
using System.Net;
using System.Net.Sockets;

public class Client {

  // used to pass state information to delegate
  class StateObject 
  {
    internal byte[] sBuffer;
    internal Socket sSocket;
    internal StateObject(int size, Socket sock) {
      sBuffer = new byte[size];
      sSocket = sock;
    }
  }

  static void Main(string[] argHostName) 
  {
    IPAddress ipAddress =
      Dns.Resolve( argHostName[0] ).AddressList[0];

    IPEndPoint ipEndpoint =
      new IPEndPoint(ipAddress, 1800);

    Socket clientSocket = new Socket(
      AddressFamily.InterNetwork,
      SocketType.Stream,
      ProtocolType.Tcp);

    IAsyncResult asyncConnect = clientSocket.BeginConnect(
      ipEndpoint,
      new AsyncCallback(connectCallback),
      clientSocket );

    Console.Write("Connection in progress.");
    if( writeDot(asyncConnect) == true ) 
    {
      // allow time for callbacks to
      // finish before the program ends
      Thread.Sleep(3000);
    }
  }

  public static void
    connectCallback(IAsyncResult asyncConnect) {
      Socket clientSocket =
        (Socket)asyncConnect.AsyncState;
      clientSocket.EndConnect(asyncConnect);
      // arriving here means the operation completed
      // (asyncConnect.IsCompleted = true) but not
      // necessarily successfully
      if( clientSocket.Connected == false )
      {
        Console.WriteLine( ".client is not connected." );
        return;
      }
      else Console.WriteLine( ".client is connected." );

      byte[] sendBuffer = Encoding.ASCII.GetBytes("Hello");
      IAsyncResult asyncSend = clientSocket.BeginSend(
        sendBuffer,
        0,
        sendBuffer.Length,
        SocketFlags.None,
        new AsyncCallback(sendCallback),
        clientSocket);

      Console.Write("Sending data.");
      writeDot(asyncSend);
  }

  public static void sendCallback(IAsyncResult asyncSend) 
  {
    Socket clientSocket = (Socket)asyncSend.AsyncState;
    int bytesSent = clientSocket.EndSend(asyncSend);
    Console.WriteLine(
      ".{0} bytes sent.",
      bytesSent.ToString() );

    StateObject stateObject =
      new StateObject(16, clientSocket);

    // this call passes the StateObject because it
    // needs to pass the buffer as well as the socket
    IAsyncResult asyncReceive =
      clientSocket.BeginReceive(
        stateObject.sBuffer,
        0,
        stateObject.sBuffer.Length,
        SocketFlags.None,
        new AsyncCallback(receiveCallback),
        stateObject);

    Console.Write("Receiving response.");
    writeDot(asyncReceive);
  }

  public static void
    receiveCallback(IAsyncResult asyncReceive) {
      StateObject stateObject =
       (StateObject)asyncReceive.AsyncState;

      int bytesReceived =
        stateObject.sSocket.EndReceive(asyncReceive);

      Console.WriteLine(
        ".{0} bytes received: {1}{2}{2}Shutting down.",
        bytesReceived.ToString(),
        Encoding.ASCII.GetString(stateObject.sBuffer),
        Environment.NewLine );

      stateObject.sSocket.Shutdown(SocketShutdown.Both);
      stateObject.sSocket.Close();
  }

  // times out after 2 seconds but operation continues
  internal static bool writeDot(IAsyncResult ar)
  {
    int i = 0;
    while( ar.IsCompleted == false ) 
    {
      if( i++ &gt; 20 ) 
      {
        Console.WriteLine("Timed out.");
        return false;
      }
      Console.Write(".");
      Thread.Sleep(100);
    }
    return true;
  }
}
   </code>
      <para>The output of the server application is</para>
      <c>
        <para>Connection in progress...........server is connected.</para>
        <para>Receiving data......5 bytes received: Hello</para>
        <para>Sending response....7 bytes sent.</para>
        <para>Shutting down.</para>
        <para>-----------------------------------------</para>
      </c>
      <para>The output of the client application is</para>
      <c>
        <para>Connection in progress......client is connected.</para>
        <para>Sending data......5 bytes sent.</para>
        <para>Receiving response......7 bytes received: Goodbye</para>
        <para>Shutting down.</para>
      </c>
    </example>
  </Docs>
  <Base>
    <BaseTypeName>System.Object</BaseTypeName>
  </Base>
  <Interfaces>
    <Interface>
      <InterfaceName>System.IDisposable</InterfaceName>
      <Excluded>0</Excluded>
    </Interface>
  </Interfaces>
  <Members>
    <Member MemberName="System.IDisposable.Dispose">
      <MemberSignature Language="ILASM" Value=".method private final hidebysig virtual void System.IDisposable.Dispose()" />
      <MemberSignature Language="C#" Value="void IDisposable.Dispose();" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Implemented to support the <see cref="T:System.IDisposable" /> interface. [Note: For more information, see <see cref="M:System.IDisposable.Dispose" />.]</summary>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Dispose">
      <MemberSignature Language="ILASM" Value=".method family hidebysig virtual void Dispose(bool disposing)" />
      <MemberSignature Language="C#" Value="protected virtual void Dispose(bool disposing);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="disposing" Type="System.Boolean" />
	</Parameters>
      <Docs>
        <summary>
          <para>Closes the current instance, releases the unmanaged resources allocated by the current
      instance, and optionally releases the
      managed resources.</para>
        </summary>
        <param name="disposing">A <see cref="T:System.Boolean" qualify="true" />. Specify <see langword="true" /> to release both managed and unmanaged resources; <see langword="false" /> to release only unmanaged resources.</param>
        <remarks>
          <para>
            <block subset="none" type="behaviors">
      
      This method
      closes the current <see cref="T:System.Net.Sockets.Socket" /> instance
      and releases all unmanaged resources allocated by the
      current instance. When <paramref name="disposing" /> is <see langword="true" />, this method also releases all resources held by any managed
      objects allocated by the current
      instance.
   </block>
          </para>
          <para>
            <block subset="none" type="default">
      
      This method
      closes the current <see cref="T:System.Net.Sockets.Socket" /> instance but does not release any managed
      resources.
   </block>
          </para>
          <para>
            <block subset="none" type="overrides">
      
      The <see cref="M:System.Net.Sockets.Socket.Dispose(System.Boolean)" /> method can be called
      multiple times by other objects. When overriding this method, do not reference
      objects that have been previously disposed in an earlier call.
   </block>
          </para>
          <para>
            <block subset="none" type="usage">
      
      Use this method to release
      resources allocated by
      the current
      instance.
   </block>
          </para>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Finalize">
      <MemberSignature Language="ILASM" Value=".method family hidebysig virtual void Finalize()" />
      <MemberSignature Language="C#" Value="~Socket();" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para>Closes the current instance and releases unmanaged resources allocated by the current
      instance.</para>
        </summary>
        <remarks>
          <block subset="none" type="note">
            <para> Application code does not call this method; it
         is automatically invoked during garbage collection unless finalization by the
         garbage collector has been disabled. For more information, see <see cref="M:System.GC.SuppressFinalize(System.Object)" qualify="true" />,
         and <see cref="M:System.Object.Finalize" qualify="true" />.</para>
            <para> This method calls <see cref="M:System.Net.Sockets.NetworkStream.Dispose(System.Boolean)" />(<see langword="false" />) to free unmanaged
      resources used by the current instance.</para>
            <para>This method overrides <see cref="M:System.Object.Finalize" qualify="true" />.</para>
          </block>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="GetHashCode">
      <MemberSignature Language="ILASM" Value=".method public hidebysig virtual int32 GetHashCode()" />
      <MemberSignature Language="C#" Value="public override int GetHashCode();" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para>Generates a hash code for the current instance.</para>
        </summary>
        <returns>
          <para>A <see cref="T:System.Int32" qualify="true" /> containing the hash code for the current instance.</para>
        </returns>
        <remarks>
          <para>
      The algorithm used to generate the hash code is unspecified.
   </para>
          <para>
            <block subset="none" type="note">
      
      This method overrides <see cref="M:System.Object.GetHashCode" qualify="true" />.
   </block>
          </para>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Bind">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance void Bind(class System.Net.EndPoint localEP)" />
      <MemberSignature Language="C#" Value="public void Bind(EndPoint localEP);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="localEP" Type="System.Net.EndPoint" />
	</Parameters>
      <Docs>
        <summary>
          <para>Associates the current instance with a local endpoint.</para>
        </summary>
        <param name="localEP">
          <para>The local <see cref="T:System.Net.EndPoint" qualify="true" /> to be associated with the socket.</para>
        </param>
        <exception cref="T:System.ArgumentNullException">
          <paramref name="localEP " />is <see langword="null" />.</exception>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred while accessing the socket. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <exception cref="T:System.Security.SecurityException"> A caller in the call stack does not have the required permission.</exception>
        <remarks>
          <para>This method sets the <see cref="P:System.Net.Sockets.Socket.LocalEndPoint" /> property of the current instance to
<paramref name="localEP" />.</para>
          <block subset="none" type="note">
            <para>For connection-oriented protocols, this method is
      generally used only on the server-side and is required to be called before the first
      call to the <see cref="M:System.Net.Sockets.Socket.Listen(System.Int32)" /> method.
      On the client-side, binding is usually performed implicitly by the <see cref="M:System.Net.Sockets.Socket.Connect(System.Net.EndPoint)" /> method. </para>
            <para>For connectionless protocols, the <see cref="M:System.Net.Sockets.Socket.Connect(System.Net.EndPoint)" /><see cref="M:System.Net.Sockets.Socket.SendTo(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint)" />, and <see cref="M:System.Net.Sockets.Socket.BeginSendTo(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint,System.AsyncCallback,System.Object)" /> methods bind the current instance to
the local endpoint if the current instance has not previously been bound. </para>
          </block>
        </remarks>
        <permission cref="T:System.Net.SocketPermission">Requires permission to accept connections on the endpoint defined by <paramref name="localEP" />. See <see cref="F:System.Net.NetworkAccess.Accept" qualify="true" />.</permission>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Connect">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance void Connect(class System.Net.EndPoint remoteEP)" />
      <MemberSignature Language="C#" Value="public void Connect(EndPoint remoteEP);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="remoteEP" Type="System.Net.EndPoint" />
	</Parameters>
      <Docs>
        <summary>
          <para>Associates the current instance with a remote endpoint.</para>
        </summary>
        <param name="remoteEP">
          <para>The <see cref="T:System.Net.EndPoint" qualify="true" /> associated with the socket to connect to.</para>
        </param>
        <exception cref="T:System.ArgumentNullException">
          <paramref name="remoteEP " />is <see langword="null" />.</exception>
        <exception cref="T:System.InvalidOperationException">
          <para>An asynchronous call is pending and a blocking method has been called.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred while accessing the socket. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <exception cref="T:System.Security.SecurityException"> A caller in the call stack does not have the required permission.</exception>
        <remarks>
          <para>This method sets the <see cref="P:System.Net.Sockets.Socket.RemoteEndPoint" /> property of the current instance to
<paramref name="remoteEP" />.</para>
          <block subset="none" type="note">
            <para> For connection-oriented protocols, this method
      establishes a connection between the current instance and the
      socket associated with <paramref name="remoteEP" />. This method is used only on
      the client-side. The <see cref="M:System.Net.Sockets.Socket.Accept" /> method establishes the connection on the
      server-side. Once the connection has been made, data can
      be sent using the <see cref="M:System.Net.Sockets.Socket.Send(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" />
      method, and received using the <see cref="M:System.Net.Sockets.Socket.Receive(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" /> method. </para>
            <para> For connectionless protocols, the <see cref="M:System.Net.Sockets.Socket.Connect(System.Net.EndPoint)" />
method can be used from both
client and server-sides, allowing the use of the <see cref="M:System.Net.Sockets.Socket.Send(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" /> method instead of the <see cref="M:System.Net.Sockets.Socket.SendTo(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint)" />
method. The <see cref="P:System.Net.Sockets.Socket.RemoteEndPoint" /> property is set to
<paramref name="remoteEP" /> 
and
the <see cref="P:System.Net.Sockets.Socket.LocalEndPoint" /> property is set to a value determined
by the protocol; however, a connection is not established. Subsequent data is
required to be received on the endpoint set in
the <see cref="P:System.Net.Sockets.Socket.LocalEndPoint" /> property.</para>
          </block>
        </remarks>
        <permission cref="T:System.Net.SocketPermission">Requires permission to make a connection to the endpoint defined by <paramref name="remoteEP" />. See <see cref="F:System.Net.NetworkAccess.Connect" qualify="true" />.</permission>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Close">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance void Close()" />
      <MemberSignature Language="C#" Value="public void Close();" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para> Closes the current instance and releases all managed and unmanaged resources allocated by the current instance.
      </para>
        </summary>
        <remarks>
          <para> This method calls the
   <see cref="M:System.Net.Sockets.Socket.Dispose(System.Boolean)" />(<see cref="T:System.Boolean" />)
      method with the argument set to <see langword="true" />, which frees both managed
      and unmanaged resources used by the current instance. </para>
          <para>The socket attempts to perform a graceful closure when the <see cref="F:System.Net.Sockets.SocketOptionName.Linger" /> socket option is enabled
   and set to a non-zero linger time. In all other cases, closure is forced and any
   pending data is lost.</para>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Shutdown">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance void Shutdown(valuetype System.Net.Sockets.SocketShutdown how)" />
      <MemberSignature Language="C#" Value="public void Shutdown(SocketShutdown how);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="how" Type="System.Net.Sockets.SocketShutdown" />
	</Parameters>
      <Docs>
        <summary>
          <para> Terminates the ability to send or receive data on a connected socket.</para>
        </summary>
        <param name="how">One of the values defined in the <see cref="T:System.Net.Sockets.SocketShutdown" /> enumeration.</param>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred while accessing the socket. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>When <paramref name="how" /> is set to <see cref="F:System.Net.Sockets.SocketShutdown.Send" /> , the socket on the
   other end of the connection is notified that the current instance will not
   send any
   more data. If the <see cref="M:System.Net.Sockets.Socket.Send(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" /> method is
   subsequently called, a <see cref="T:System.Net.Sockets.SocketException" />
   
   exception is thrown.</para>
          <para>When <paramref name="how" /> is set to <see cref="F:System.Net.Sockets.SocketShutdown.Receive" />,
the
socket on the other end of the
connection is notified that the current instance will not receive any more
data. After all the data currently queued on the current instance is
received, any subsequent calls to the <see cref="M:System.Net.Sockets.Socket.Receive(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" /> method cause a <see cref="T:System.Net.Sockets.SocketException" /> exception to be thrown.</para>
          <para>Setting <paramref name="how" /> to <see cref="F:System.Net.Sockets.SocketShutdown.Both" /> terminates both sends and
receives as described above. Once this occurs, the socket cannot
be used.</para>
          <block subset="none" type="note">
            <para>To free resources allocated by the current instance, call the <see cref="M:System.Net.Sockets.Socket.Close" />
method.</para>
            <para>Expected common usage is for the <see cref="M:System.Net.Sockets.Socket.Shutdown(System.Net.Sockets.SocketShutdown)" />
method to be called before the <see cref="M:System.Net.Sockets.Socket.Close" /> method to
ensure that all pending data is sent or received.</para>
          </block>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Listen">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance void Listen(int32 backlog)" />
      <MemberSignature Language="C#" Value="public void Listen(int backlog);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="backlog" Type="System.Int32" />
	</Parameters>
      <Docs>
        <summary>
          <para>Places the current instance into the listening
      state where it waits for incoming connection requests.</para>
        </summary>
        <param name="backlog">A <see cref="T:System.Int32" qualify="true" /> containing the maximum length of the queue of pending connections.</param>
        <exception cref="T:System.Net.Sockets.SocketException">The <see cref="P:System.Net.Sockets.Socket.Connected" /> property of the current instance is true, or an error occurred while accessing the socket. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para> Once this method is called, incoming connection requests
      are placed in a queue. The maximum size of the queue is specified by the
      <paramref name="backlog" /> parameter. The size of the queue is limited to legal
      values by the underlying protocol. Illegal values of the <paramref name="backlog" />
      parameter are replaced with a legal value, which is implementation defined.</para>
          <para>If a connection request arrives and the queue is full, a <see cref="T:System.Net.Sockets.SocketException" /> is thrown on the client.</para>
          <para> A socket in the listening state has no
   remote endpoint associated with it. Attempting to access the <see cref="P:System.Net.Sockets.Socket.RemoteEndPoint" /> property throws a <see cref="T:System.Net.Sockets.SocketException" /> exception.</para>
          <para> This method is ignored if called more than once on the
   current instance.</para>
          <block subset="none" type="note">
            <para>This method is used
      only on the server-side of connection-oriented protocols. Call the <see cref="M:System.Net.Sockets.Socket.Bind(System.Net.EndPoint)" /> method before
      this method is called the first time. Call the <see cref="M:System.Net.Sockets.Socket.Listen(System.Int32)" /> method before the first call to the <see cref="M:System.Net.Sockets.Socket.Accept" />
      method.</para>
          </block>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Accept">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance class System.Net.Sockets.Socket Accept()" />
      <MemberSignature Language="C#" Value="public Socket Accept();" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Net.Sockets.Socket</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para>Creates and initializes a new <see cref="T:System.Net.Sockets.Socket" /> instance and connects it to an incoming connection
   request.</para>
        </summary>
        <returns>
          <para> A new connected <see cref="T:System.Net.Sockets.Socket" />
instance.</para>
        </returns>
        <exception cref="T:System.ArgumentException">An error occurred while creating the new <see cref="T:System.Net.Sockets.Socket" />.</exception>
        <exception cref="T:System.InvalidOperationException">
          <para>An asynchronous call is pending and a blocking method has been called.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>An error occurred while accessing the socket.</para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para> This method is used only on the server-side of connection-oriented protocols. It extracts the first
      connection request from the queue of pending requests, creates a new <see cref="T:System.Net.Sockets.Socket" />
      instance, and connects this instance to the socket associated with the request.</para>
          <para> The <see cref="P:System.Net.Sockets.Socket.Blocking" /> property
   of the socket determines the behavior of this method when there are no pending
   connection requests. When <see langword="false" />, this method returns
<see langword="null" />.
   When <see langword="true" />, this method blocks.</para>
          <para> The following properties of the new <see cref="T:System.Net.Sockets.Socket" /> instance returned by this method have values 
identical to the corresponding properties of the current instance:</para>
          <list type="bullet">
            <item>
              <term>
                <see cref="P:System.Net.Sockets.Socket.AddressFamily" />
              </term>
            </item>
            <item>
              <term>
                <see cref="P:System.Net.Sockets.Socket.Blocking" />
              </term>
            </item>
            <item>
              <term>
                <see cref="P:System.Net.Sockets.Socket.LocalEndPoint" />
              </term>
            </item>
            <item>
              <term>
                <see cref="P:System.Net.Sockets.Socket.ProtocolType" />
              </term>
            </item>
            <item>
              <term>
                <see cref="P:System.Net.Sockets.Socket.SocketType" />
              </term>
            </item>
          </list>
          <para> The <see cref="P:System.Net.Sockets.Socket.RemoteEndPoint" /> property of the new instance is set to the local endpoint of the first request in
the input queue. The <see cref="P:System.Net.Sockets.Socket.Connected" /> property is set to <see langword="true" />.</para>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Send">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 Send(class System.Byte[] buffer, int32 size, valuetype System.Net.Sockets.SocketFlags socketFlags)" />
      <MemberSignature Language="C#" Value="public int Send(byte[] buffer, int size, SocketFlags socketFlags);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="buffer" Type="System.Byte[]" />
		<Parameter Name="size" Type="System.Int32" />
		<Parameter Name="socketFlags" Type="System.Net.Sockets.SocketFlags" />
	</Parameters>
      <Docs>
        <summary>
          <para>Sends data to a connected socket.</para>
        </summary>
        <param name="buffer">A <see cref="T:System.Byte" qualify="true" /> array containing data to send to the socket.</param>
        <param name="size">A <see cref="T:System.Int32" qualify="true" /> containing the number of bytes to send.</param>
        <param name="socketFlags">A bitwise combination of any of the following values defined in the <see cref="T:System.Net.Sockets.SocketFlags" /> enumeration: <see cref="F:System.Net.Sockets.SocketFlags.None" />, <see cref="F:System.Net.Sockets.SocketFlags.DontRoute" />, or <see cref="F:System.Net.Sockets.SocketFlags.OutOfBand" />.</param>
        <returns>
          <para>A <see cref="T:System.Int32" qualify="true" />
containing the number of bytes sent.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <paramref name="buffer " />is <see langword="null" />.</exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="size" /> &lt; 0.</para>
          <para> -or-</para>
          <para>
            <paramref name="size" /> &gt; <paramref name="buffer" />.Length.</para>
        </exception>
        <exception cref="T:System.InvalidOperationException">
          <para>An asynchronous call is pending and a blocking method has been called.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>
            <paramref name="socketFlags" /> is not a valid combination of values. </para>
          <para>-or-</para>
          <para>An error occurred while accessing the socket.</para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>This method is equivalent to <see cref="M:System.Net.Sockets.Socket.Send(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" />(<paramref name="buffer" />, 0, <paramref name="size" />,
<paramref name="socketFlags" />).</para>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Send">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 Send(class System.Byte[] buffer, valuetype System.Net.Sockets.SocketFlags socketFlags)" />
      <MemberSignature Language="C#" Value="public int Send(byte[] buffer, SocketFlags socketFlags);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="buffer" Type="System.Byte[]" />
		<Parameter Name="socketFlags" Type="System.Net.Sockets.SocketFlags" />
	</Parameters>
      <Docs>
        <summary>
          <para>Sends data to a connected socket.</para>
        </summary>
        <param name="buffer">A <see cref="T:System.Byte" qualify="true" /> array containing data to send to the socket.</param>
        <param name="socketFlags">A bitwise combination of any of the following values defined in the <see cref="T:System.Net.Sockets.SocketFlags" /> enumeration: <see cref="F:System.Net.Sockets.SocketFlags.None" />, <see cref="F:System.Net.Sockets.SocketFlags.DontRoute" />, or <see cref="F:System.Net.Sockets.SocketFlags.OutOfBand" />.</param>
        <returns>
          <para>A <see cref="T:System.Int32" qualify="true" />
containing the number of bytes sent.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <paramref name="buffer " />is <see langword="null" />.</exception>
        <exception cref="T:System.InvalidOperationException">
          <para>An asynchronous call is pending and a blocking method has been called.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>
            <paramref name="socketFlags" /> is not a valid combination of values.</para>
          <para>-or-</para>
          <para>An error occurred while accessing the socket. </para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>This method is equivalent to <see cref="M:System.Net.Sockets.Socket.Send(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" />(<paramref name="buffer" />, 0, <paramref name="buffer" />.Length,
<paramref name="socketFlags" />).</para>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Send">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 Send(class System.Byte[] buffer)" />
      <MemberSignature Language="C#" Value="public int Send(byte[] buffer);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="buffer" Type="System.Byte[]" />
	</Parameters>
      <Docs>
        <summary>
          <para> Sends data to a
      connected socket.</para>
        </summary>
        <param name="buffer">A <see cref="T:System.Byte" qualify="true" /> array containing data to send to the socket.</param>
        <returns>
          <para>A <see cref="T:System.Int32" qualify="true" />
containing the number of bytes sent.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <paramref name="buffer " />is <see langword="null" />.</exception>
        <exception cref="T:System.InvalidOperationException">
          <para>An asynchronous call is pending and a blocking method has been called.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>An error occurred while accessing the socket.</para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>This method is equivalent to <see cref="M:System.Net.Sockets.Socket.Send(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" />(<paramref name="buffer" />, 0,
<paramref name="buffer" />.Length, <see cref="F:System.Net.Sockets.SocketFlags.None" qualify="true" />).</para>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Send">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 Send(class System.Byte[] buffer, int32 offset, int32 size, valuetype System.Net.Sockets.SocketFlags socketFlags)" />
      <MemberSignature Language="C#" Value="public int Send(byte[] buffer, int offset, int size, SocketFlags socketFlags);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="buffer" Type="System.Byte[]" />
		<Parameter Name="offset" Type="System.Int32" />
		<Parameter Name="size" Type="System.Int32" />
		<Parameter Name="socketFlags" Type="System.Net.Sockets.SocketFlags" />
	</Parameters>
      <Docs>
        <summary>
          <para>Sends data to a connected socket.</para>
        </summary>
        <param name="buffer">A <see cref="T:System.Byte" qualify="true" /> array containing data to send to the socket.</param>
        <param name="offset">A <see cref="T:System.Int32" qualify="true" /> that specifies the zero-based position in buffer that is the starting location of the data to send.</param>
        <param name="size">A <see cref="T:System.Int32" qualify="true" /> containing the number of bytes to send.</param>
        <param name="socketFlags">A bitwise combination of any of the following values defined in the <see cref="T:System.Net.Sockets.SocketFlags" /> enumeration: <see cref="F:System.Net.Sockets.SocketFlags.None" />, <see cref="F:System.Net.Sockets.SocketFlags.DontRoute" />, or <see cref="F:System.Net.Sockets.SocketFlags.OutOfBand" />.</param>
        <returns>
          <para>A <see cref="T:System.Int32" qualify="true" />
containing the number of bytes sent.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <paramref name="buffer " />is <see langword="null" />.</exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="offset" /> &lt; 0. </para>
          <para>-or- </para>
          <para>
            <paramref name="offset" /> &gt; <paramref name="buffer" />.Length. </para>
          <para> -or-</para>
          <para>
            <paramref name="size" /> &lt; 0.</para>
          <para>-or-</para>
          <para>
            <paramref name="size" /> &gt; <paramref name="buffer" />.Length - <paramref name="offset" />.</para>
        </exception>
        <exception cref="T:System.InvalidOperationException">
          <para>An asynchronous call is pending and a blocking method has been called.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>
            <paramref name="socketFlags" /> is not a valid combination of values.</para>
          <para>-or-</para>
          <para>An error occurred while accessing the socket. </para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>For connection-oriented protocols, the <see cref="P:System.Net.Sockets.Socket.LocalEndPoint" /> property of the current instance is
   required to be set before calling this
   method.</para>
          <para>For connectionless protocols, calling the <see cref="M:System.Net.Sockets.Socket.Connect(System.Net.EndPoint)" /> methods sets the <see cref="P:System.Net.Sockets.Socket.RemoteEndPoint" /> property and allows the <see cref="M:System.Net.Sockets.Socket.Send(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" />
method to be used instead of the <see cref="M:System.Net.Sockets.Socket.SendTo(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint)" />
method.</para>
          <para>When the <see cref="F:System.Net.Sockets.SocketFlags.DontRoute" /> flag
is specified as part of the <paramref name="socketFlags" /> parameter,
the sent data is not routed.</para>
          <para>When the <see cref="F:System.Net.Sockets.SocketFlags.OutOfBand" /> flag is specified as part of the
<paramref name="socketFlags" /> parameter, only out-of-band (OOB) data is sent.</para>
          <para>When the <see cref="P:System.Net.Sockets.Socket.Blocking" /> property of the current instance is
set to <see langword="true" /> and
buffer space is not available within the underlying protocol, this method
blocks. </para>
          <para>For message-oriented sockets, when the size of
<paramref name="buffer" /> is greater than the maximum message size of the underlying
   protocol, no data is sent and the <see cref="T:System.Net.Sockets.SocketException" /> exception is thrown.</para>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="SendTo">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 SendTo(class System.Byte[] buffer, int32 offset, int32 size, valuetype System.Net.Sockets.SocketFlags socketFlags, class System.Net.EndPoint remoteEP)" />
      <MemberSignature Language="C#" Value="public int SendTo(byte[] buffer, int offset, int size, SocketFlags socketFlags, EndPoint remoteEP);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="buffer" Type="System.Byte[]" />
		<Parameter Name="offset" Type="System.Int32" />
		<Parameter Name="size" Type="System.Int32" />
		<Parameter Name="socketFlags" Type="System.Net.Sockets.SocketFlags" />
		<Parameter Name="remoteEP" Type="System.Net.EndPoint" />
	</Parameters>
      <Docs>
        <summary>
          <para> Sends data to the socket associated with the specified
      endpoint.</para>
        </summary>
        <param name="buffer">A <see cref="T:System.Byte" qualify="true" /> array containing data to send to the socket.</param>
        <param name="offset">A <see cref="T:System.Int32" qualify="true" /> that specifies the zero-based position in buffer that is the starting location of the data to send.</param>
        <param name="size">A <see cref="T:System.Int32" qualify="true" /> containing the number of bytes to send.</param>
        <param name="socketFlags">A bitwise combination of any of the following values defined in the <see cref="T:System.Net.Sockets.SocketFlags" /> enumeration: <see cref="F:System.Net.Sockets.SocketFlags.None" />, <see cref="F:System.Net.Sockets.SocketFlags.DontRoute" />, or <see cref="F:System.Net.Sockets.SocketFlags.OutOfBand" />.</param>
        <param name="remoteEP">
          <para>The <see cref="T:System.Net.EndPoint" qualify="true" /> associated with the socket to receive the data.</para>
        </param>
        <returns>
          <para>A <see cref="T:System.Int32" qualify="true" />
containing the number of bytes sent.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="buffer or remoteEP " />is <see langword="null" />.</para>
        </exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="offset" /> &lt; 0. </para>
          <para>-or- </para>
          <para>
            <paramref name="offset" /> &gt; <paramref name="buffer" />.Length. </para>
          <para> -or-</para>
          <para>
            <paramref name="size" /> &lt; 0.</para>
          <para>-or-</para>
          <para>
            <paramref name="size" /> &gt; <paramref name="buffer" />.Length - <paramref name="offset" />.</para>
        </exception>
        <exception cref="T:System.InvalidOperationException">
          <para>An asynchronous call is pending and a blocking method has been called.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>
            <paramref name="socketFlags" /> is not a valid combination of values.</para>
          <para>-or-</para>
          <para>An error occurred while accessing the socket. </para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.Security.SecurityException"> A caller in the call stack does not have the required permissions.</exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>For connection-oriented protocols and connected sockets using connectionless
      protocols, <paramref name="remoteEP" /> overrides the endpoint specified in the <see cref="P:System.Net.Sockets.Socket.RemoteEndPoint" /> property.</para>
          <para>For unconnected sockets using connectionless protocols, this method sets
      the <see cref="P:System.Net.Sockets.Socket.LocalEndPoint" />
      property of the current instance to a value determined by the protocol.
      Subsequent data is required to be received on <see langword="LocalEndPoint" />.</para>
          <para>When the <see cref="F:System.Net.Sockets.SocketFlags.DontRoute" /> flag
   is specified as part of the <paramref name="socketFlags" /> parameter,
   the sent data is not routed.</para>
          <para>When the <see cref="F:System.Net.Sockets.SocketFlags.OutOfBand" /> flag is specified as part of the
<paramref name="socketFlags" /> parameter, only out-of-band (OOB) data is sent.</para>
          <para>When the <see cref="P:System.Net.Sockets.Socket.Blocking" /> property of the current instance is
set to <see langword="true" /> and
buffer space is not available within the underlying protocol, this method
blocks. </para>
          <para>For message-oriented sockets, when the size of <paramref name="buffer" /> is greater than
the maximum message size of the underlying protocol, no data is sent and the
<see cref="T:System.Net.Sockets.SocketException" /> exception is thrown.</para>
          <para>For connection-oriented sockets, the <paramref name="remoteEP" /> property is
ignored.</para>
        </remarks>
        <permission cref="T:System.Net.SocketPermission">Requires permission to make a connection to the endpoint defined by <paramref name="remoteEP" />. See <see cref="F:System.Net.NetworkAccess.Connect" qualify="true" />.</permission>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="SendTo">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 SendTo(class System.Byte[] buffer, int32 size, valuetype System.Net.Sockets.SocketFlags socketFlags, class System.Net.EndPoint remoteEP)" />
      <MemberSignature Language="C#" Value="public int SendTo(byte[] buffer, int size, SocketFlags socketFlags, EndPoint remoteEP);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="buffer" Type="System.Byte[]" />
		<Parameter Name="size" Type="System.Int32" />
		<Parameter Name="socketFlags" Type="System.Net.Sockets.SocketFlags" />
		<Parameter Name="remoteEP" Type="System.Net.EndPoint" />
	</Parameters>
      <Docs>
        <summary>
          <para> Sends data to the socket associated with the specified
      endpoint.</para>
        </summary>
        <param name="buffer">A <see cref="T:System.Byte" qualify="true" /> array containing data to send to the socket.</param>
        <param name="size">A <see cref="T:System.Int32" qualify="true" /> containing the number of bytes to send.</param>
        <param name="socketFlags">A bitwise combination of any of the following values defined in the <see cref="T:System.Net.Sockets.SocketFlags" /> enumeration: <see cref="F:System.Net.Sockets.SocketFlags.None" />, <see cref="F:System.Net.Sockets.SocketFlags.DontRoute" />, or <see cref="F:System.Net.Sockets.SocketFlags.OutOfBand" />.</param>
        <param name="remoteEP">
          <para>The <see cref="T:System.Net.EndPoint" qualify="true" /> associated with the socket to receive the data.</para>
        </param>
        <returns>
          <para>A <see cref="T:System.Int32" qualify="true" />
containing the number of bytes sent.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="buffer or remoteEP " />is <see langword="null" />.</para>
        </exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="size" /> &lt; 0.</para>
          <para> -or-</para>
          <para>
            <paramref name="size" /> &gt; <paramref name="buffer" />.Length.</para>
        </exception>
        <exception cref="T:System.InvalidOperationException">
          <para>An asynchronous call is pending and a blocking method has been called.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>
            <paramref name="socketFlags" /> is not a valid combination of values.</para>
          <para>-or-</para>
          <para>An error occurred while accessing the socket. </para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.Security.SecurityException">A caller in the call stack does not have the required permissions.</exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>This method is equivalent to <see cref="M:System.Net.Sockets.Socket.SendTo(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint)" />(<paramref name="buffer" />, 0, <paramref name="size" />,
<paramref name="socketFlags" />, <paramref name="remoteEP" />).</para>
        </remarks>
        <permission cref="T:System.Net.SocketPermission">Requires permission to make a connection to the endpoint defined by <paramref name="remoteEP" />. See <see cref="F:System.Net.NetworkAccess.Connect" qualify="true" />.</permission>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="SendTo">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 SendTo(class System.Byte[] buffer, valuetype System.Net.Sockets.SocketFlags socketFlags, class System.Net.EndPoint remoteEP)" />
      <MemberSignature Language="C#" Value="public int SendTo(byte[] buffer, SocketFlags socketFlags, EndPoint remoteEP);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="buffer" Type="System.Byte[]" />
		<Parameter Name="socketFlags" Type="System.Net.Sockets.SocketFlags" />
		<Parameter Name="remoteEP" Type="System.Net.EndPoint" />
	</Parameters>
      <Docs>
        <summary>
          <para> Sends data to the socket associated with the specified
      endpoint.</para>
        </summary>
        <param name="buffer">A <see cref="T:System.Byte" qualify="true" /> array containing data to send to the socket.</param>
        <param name="socketFlags">A bitwise combination of any of the following values defined in the <see cref="T:System.Net.Sockets.SocketFlags" /> enumeration: <see cref="F:System.Net.Sockets.SocketFlags.None" />, <see cref="F:System.Net.Sockets.SocketFlags.DontRoute" />, or <see cref="F:System.Net.Sockets.SocketFlags.OutOfBand" />.</param>
        <param name="remoteEP">
          <para>The <see cref="T:System.Net.EndPoint" qualify="true" /> associated with the socket to receive the data.</para>
        </param>
        <returns>
          <para>A <see cref="T:System.Int32" qualify="true" />
containing the number of bytes sent.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="buffer or remoteEP " />is <see langword="null" />.</para>
        </exception>
        <exception cref="T:System.InvalidOperationException">
          <para>An asynchronous call is pending and a blocking method has been called.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>
            <paramref name="socketFlags" /> is not a valid combination of values.</para>
          <para>-or-</para>
          <para>An error occurred while accessing the socket. </para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.Security.SecurityException">A caller in the call stack does not have the required permissions.</exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>This method is equivalent to <see cref="M:System.Net.Sockets.Socket.SendTo(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint)" />(<paramref name="buffer" />, 0, <paramref name="buffer" />.Length,
<paramref name="socketFlags" />, <paramref name="remoteEP" />).</para>
        </remarks>
        <permission cref="T:System.Net.SocketPermission">Requires permission to make a connection to the endpoint defined by <paramref name="remoteEP" />. See <see cref="F:System.Net.NetworkAccess.Connect" qualify="true" />.</permission>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="SendTo">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 SendTo(class System.Byte[] buffer, class System.Net.EndPoint remoteEP)" />
      <MemberSignature Language="C#" Value="public int SendTo(byte[] buffer, EndPoint remoteEP);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="buffer" Type="System.Byte[]" />
		<Parameter Name="remoteEP" Type="System.Net.EndPoint" />
	</Parameters>
      <Docs>
        <summary>
          <para> Sends data to the socket associated with the specified
      endpoint.</para>
        </summary>
        <param name="buffer">A <see cref="T:System.Byte" qualify="true" /> array containing data to send to the socket.</param>
        <param name="remoteEP">
          <para>The <see cref="T:System.Net.EndPoint" qualify="true" /> associated with the socket to receive the data.</para>
        </param>
        <returns>
          <para>A <see cref="T:System.Int32" qualify="true" />
containing the number of bytes sent.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="buffer or remoteEP " />is <see langword="null" />.</para>
        </exception>
        <exception cref="T:System.InvalidOperationException">
          <para>An asynchronous call is pending and a blocking method has been called.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred while accessing the socket. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.Security.SecurityException">A caller in the call stack does not have the required permissions.</exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>This method is equivalent to <see cref="M:System.Net.Sockets.Socket.SendTo(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint)" />(<paramref name="buffer" />,
   0, <paramref name="buffer" />.Length, <see cref="F:System.Net.Sockets.SocketFlags.None" qualify="true" />,<paramref name=" remoteEP" />).</para>
        </remarks>
        <permission cref="T:System.Net.SocketPermission">Requires permission to make a connection to the endpoint defined by <paramref name="remoteEP" />. See <see cref="F:System.Net.NetworkAccess.Connect" qualify="true" />.</permission>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Receive">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 Receive(class System.Byte[] buffer, int32 size, valuetype System.Net.Sockets.SocketFlags socketFlags)" />
      <MemberSignature Language="C#" Value="public int Receive(byte[] buffer, int size, SocketFlags socketFlags);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="buffer" Type="System.Byte[]" />
		<Parameter Name="size" Type="System.Int32" />
		<Parameter Name="socketFlags" Type="System.Net.Sockets.SocketFlags" />
	</Parameters>
      <Docs>
        <summary>
          <para> Receives data from a socket.</para>
        </summary>
        <param name="buffer">A <see cref="T:System.Byte" qualify="true" /> array to store data received from the socket.</param>
        <param name="size">A <see cref="T:System.Int32" qualify="true" /> containing the number of bytes to receive.</param>
        <param name="socketFlags">A bitwise combination of any of the following values defined in the <see cref="T:System.Net.Sockets.SocketFlags" /> enumeration: <see cref="F:System.Net.Sockets.SocketFlags.None" />, <see cref="F:System.Net.Sockets.SocketFlags.OutOfBand" />, or <see cref="F:System.Net.Sockets.SocketFlags.Peek" />.</param>
        <returns>
          <para>A <see cref="T:System.Int32" qualify="true" /> containing the number of bytes received.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <paramref name="buffer " />is <see langword="null" />.</exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="size" /> &lt; 0.</para>
          <para> -or-</para>
          <para>
            <paramref name="size" /> &gt; <paramref name="buffer" />.Length.</para>
        </exception>
        <exception cref="T:System.InvalidOperationException">
          <para>An asynchronous call is pending and a blocking method has been called.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>
            <paramref name="socketFlags" /> is not a valid combination of values.</para>
          <para> -or- </para>
          <para> An error occurred while accessing the socket. </para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.Security.SecurityException">A caller in the call stack does not have the required permissions.</exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para> This method is equivalent to <see cref="M:System.Net.Sockets.Socket.Receive(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" />(<paramref name="buffer" />, 0, <paramref name="size" />,
<paramref name="socketFlags" />).</para>
        </remarks>
        <permission cref="T:System.Net.SocketPermission">Requires permission to accept connections. See <see cref="F:System.Net.NetworkAccess.Accept" qualify="true" />.</permission>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Receive">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 Receive(class System.Byte[] buffer, valuetype System.Net.Sockets.SocketFlags socketFlags)" />
      <MemberSignature Language="C#" Value="public int Receive(byte[] buffer, SocketFlags socketFlags);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="buffer" Type="System.Byte[]" />
		<Parameter Name="socketFlags" Type="System.Net.Sockets.SocketFlags" />
	</Parameters>
      <Docs>
        <summary>
          <para> Receives data from a
      socket.</para>
        </summary>
        <param name="buffer">A <see cref="T:System.Byte" qualify="true" /> array to store data received from the socket.</param>
        <param name="socketFlags">A bitwise combination of any of the following values defined in the <see cref="T:System.Net.Sockets.SocketFlags" /> enumeration: <see cref="F:System.Net.Sockets.SocketFlags.None" />, <see cref="F:System.Net.Sockets.SocketFlags.OutOfBand" />, or <see cref="F:System.Net.Sockets.SocketFlags.Peek" />.</param>
        <returns>
          <para>A <see cref="T:System.Int32" qualify="true" /> containing the number of bytes received.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <paramref name="buffer " />is <see langword="null" />.</exception>
        <exception cref="T:System.InvalidOperationException">
          <para>An asynchronous call is pending and a blocking method has been called.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>
            <paramref name="socketFlags" /> is not a valid combination of values.</para>
        </exception>
        <exception cref="T:System.Security.SecurityException"> A caller in the call stack does not have the required permissions.</exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>This method is equivalent to <see cref="M:System.Net.Sockets.Socket.Receive(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" />(<paramref name="buffer" />, 0, <paramref name="buffer" />.Length,
<paramref name="socketFlags" />).</para>
        </remarks>
        <permission cref="T:System.Net.SocketPermission">Requires permission to accept connections. <block subset="none" type="note">See <see cref="F:System.Net.NetworkAccess.Accept" qualify="true" />.</block></permission>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Receive">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 Receive(class System.Byte[] buffer)" />
      <MemberSignature Language="C#" Value="public int Receive(byte[] buffer);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="buffer" Type="System.Byte[]" />
	</Parameters>
      <Docs>
        <summary>
          <para> Receives data from a socket.</para>
        </summary>
        <param name="buffer">A <see cref="T:System.Byte" qualify="true" /> array to store data received from the socket.</param>
        <returns>
          <para>A <see cref="T:System.Int32" qualify="true" />
containing the number of bytes received.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <paramref name="buffer " />is <see langword="null" />.</exception>
        <exception cref="T:System.InvalidOperationException">
          <para>An asynchronous call is pending and a blocking method has been called.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>An error occurred while accessing the socket.</para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.Security.SecurityException"> A caller in the call stack does not have the required permissions.</exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>This method is equivalent to <see cref="M:System.Net.Sockets.Socket.Receive(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" />(<paramref name="buffer" />, 0, <paramref name="buffer" />.Length,
<see cref="F:System.Net.Sockets.SocketFlags.None" qualify="true" />).</para>
        </remarks>
        <permission cref="T:System.Net.SocketPermission">Requires permission to accept connections. See <see cref="F:System.Net.NetworkAccess.Accept" qualify="true" />.</permission>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Receive">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 Receive(class System.Byte[] buffer, int32 offset, int32 size, valuetype System.Net.Sockets.SocketFlags socketFlags)" />
      <MemberSignature Language="C#" Value="public int Receive(byte[] buffer, int offset, int size, SocketFlags socketFlags);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="buffer" Type="System.Byte[]" />
		<Parameter Name="offset" Type="System.Int32" />
		<Parameter Name="size" Type="System.Int32" />
		<Parameter Name="socketFlags" Type="System.Net.Sockets.SocketFlags" />
	</Parameters>
      <Docs>
        <summary>
          <para> Receives data from a socket.</para>
        </summary>
        <param name="buffer">A <see cref="T:System.Byte" qualify="true" /> array to store data received from the socket.</param>
        <param name="offset">A <see cref="T:System.Int32" qualify="true" /> containing the zero-based position in <paramref name="buffer " />to begin storing the received data.</param>
        <param name="size">A <see cref="T:System.Int32" qualify="true" /> containing the number of bytes to receive.</param>
        <param name="socketFlags">A bitwise combination of any of the following values defined in the <see cref="T:System.Net.Sockets.SocketFlags" /> enumeration: <see cref="F:System.Net.Sockets.SocketFlags.None" />, <see cref="F:System.Net.Sockets.SocketFlags.OutOfBand" />, or <see cref="F:System.Net.Sockets.SocketFlags.Peek" />.</param>
        <returns>
          <para>A <see cref="T:System.Int32" qualify="true" />
containing the number of bytes received.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <paramref name="buffer " />is <see langword="null" />.</exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="offset" /> &lt; 0.</para>
          <para>-or-</para>
          <para>
            <paramref name="offset" /> &gt; <paramref name="buffer" />.Length. </para>
          <para>-or-</para>
          <para>
            <paramref name="size" /> &lt; 0.</para>
          <para>-or-</para>
          <para>
            <paramref name="size" /> &gt; <paramref name="buffer" />.Length - <paramref name="offset" />.</para>
        </exception>
        <exception cref="T:System.InvalidOperationException">
          <para>An asynchronous call is pending and a blocking method has been called.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>
            <paramref name="socketFlags" /> is not a valid combination of values.</para>
          <para>-or-</para>
          <para>The <see cref="P:System.Net.Sockets.Socket.LocalEndPoint" /> property was not set.</para>
          <para>-or-</para>
          <para>An error occurred while accessing the socket.</para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.Security.SecurityException">A caller in the call stack does not have the required permissions.</exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>The <see cref="P:System.Net.Sockets.Socket.LocalEndPoint" /> property is required to be set before 
   this method
   is called.</para>
          <para>The <see cref="P:System.Net.Sockets.Socket.Blocking" /> property of the socket determines
the behavior of this method when no incoming data is available. When
<see langword="false" />, the <see cref="T:System.Net.Sockets.SocketException" /> exception is thrown. When 
<see langword="true" />, this method blocks and 
waits for data
to arrive.</para>
          <para> For <see cref="F:System.Net.Sockets.SocketType.Stream" qualify="true" /> socket types, if the remote socket
was shut down gracefully, and all data was received, this method immediately returns zero,
regardless of the blocking state.</para>
          <para>For message-oriented sockets, if the message is larger than the size of
<paramref name="buffer" />, the buffer is filled with the first part of the message, and the 
<see cref="T:System.Net.Sockets.SocketException" /> exception is thrown. For unreliable 
   protocols, the excess data is lost; for reliable protocols, the data is retained
   by the service provider.</para>
          <para>When the <see cref="F:System.Net.Sockets.SocketFlags.OutOfBand" /> flag is
specified as part of the <paramref name="socketFlags" /> parameter and the socket is configured for in-line reception of
out-of-band (OOB) data (using the <see cref="F:System.Net.Sockets.SocketOptionName.OutOfBandInline" /> socket option) and OOB data is available,
only OOB data is returned.</para>
          <para>When the <see cref="F:System.Net.Sockets.SocketFlags.Peek" /> flag is specified as part of the
<paramref name="socketFlags" /> parameter, available data is copied into 
<paramref name="buffer" /> but is not removed from the system
buffer.</para>
        </remarks>
        <permission cref="T:System.Net.SocketPermission">
          <para>Requires permission to accept a connection on the endpoint defined by the <see cref="P:System.Net.Sockets.Socket.LocalEndPoint" /> property of the current instance. See <see cref="F:System.Net.NetworkAccess.Accept" qualify="true" />.</para>
        </permission>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="ReceiveFrom">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 ReceiveFrom(class System.Byte[] buffer, int32 offset, int32 size, valuetype System.Net.Sockets.SocketFlags socketFlags, class System.Net.EndPoint&amp; remoteEP)" />
      <MemberSignature Language="C#" Value="public int ReceiveFrom(byte[] buffer, int offset, int size, SocketFlags socketFlags, ref EndPoint remoteEP);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="buffer" Type="System.Byte[]" />
		<Parameter Name="offset" Type="System.Int32" />
		<Parameter Name="size" Type="System.Int32" />
		<Parameter Name="socketFlags" Type="System.Net.Sockets.SocketFlags" />
		<Parameter Name="remoteEP" Type="System.Net.EndPoint&amp;" RefType="ref" />
	</Parameters>
      <Docs>
        <summary>
          <para> Receives data from a socket and,
      for connectionless protocols, stores the endpoint associated with the socket that sent
      the data.</para>
        </summary>
        <param name="buffer">A <see cref="T:System.Byte" qualify="true" /> array to store data received from the socket.</param>
        <param name="offset">A <see cref="T:System.Int32" qualify="true" /> containing the zero-based position in <paramref name="buffer " />to begin storing the received data.</param>
        <param name="size">A <see cref="T:System.Int32" qualify="true" /> containing the number of bytes to receive.</param>
        <param name="socketFlags">A bitwise combination of any of the following values defined in the <see cref="T:System.Net.Sockets.SocketFlags" /> enumeration: <see cref="F:System.Net.Sockets.SocketFlags.None" />, <see cref="F:System.Net.Sockets.SocketFlags.OutOfBand" />, or <see cref="F:System.Net.Sockets.SocketFlags.Peek" />.</param>
        <param name="remoteEP">A reference to the <see cref="T:System.Net.EndPoint" qualify="true" /> associated with the socket that sent the data.</param>
        <returns>
          <para>A <see cref="T:System.Int32" qualify="true" />
containing the number of bytes received.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="buffer" /> or <paramref name="remoteEP" /> is <see langword="null" />.</para>
        </exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="offset" /> &lt; 0.</para>
          <para>-or-</para>
          <para>
            <paramref name="offset" /> &gt; <paramref name="buffer" />.Length. </para>
          <para>-or-</para>
          <para>
            <paramref name="size" /> &lt; 0.</para>
          <para>-or-</para>
          <para>
            <paramref name="size" /> &gt; <paramref name="buffer" />.Length - <paramref name="offset" />.</para>
        </exception>
        <exception cref="T:System.InvalidOperationException">
          <para>An asynchronous call is pending and a blocking method has been called.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>
            <paramref name="socketFlags" /> is not a valid combination of values.</para>
          <para>-or-</para>
          <para>The <see cref="P:System.Net.Sockets.Socket.LocalEndPoint" /> property was not set.</para>
          <para>-or-</para>
          <para>An error occurred while accessing the socket.</para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.Security.SecurityException">A caller in the call stack does not have the required permissions.</exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>For connectionless protocols, when this method successfully completes, <paramref name="remoteEP" /> contains the
   endpoint associated with the socket that sent the data.</para>
          <para>For connection-oriented protocols, <paramref name="remoteEP" /> is left unchanged.</para>
          <para>The <see cref="P:System.Net.Sockets.Socket.LocalEndPoint" /> property is required to be set before
this method is called or a <see cref="T:System.Net.Sockets.SocketException" />
is thrown.</para>
          <para>The <see cref="P:System.Net.Sockets.Socket.Blocking" /> property of the socket determines
the behavior of this method when no incoming data is available. When
<see langword="false" />, the <see cref="T:System.Net.Sockets.SocketException" /> exception is thrown. When 
<see langword="true" />, this method blocks and 
waits for data to arrive.</para>
          <para>For <see cref="F:System.Net.Sockets.SocketType.Stream" qualify="true" /> socket types, if the
remote socket was shut down gracefully, and all data was received, this method
immediately returns zero, regardless of the blocking state.</para>
          <para>For message-oriented sockets, if the message is larger than the size of
<paramref name="buffer" />, the buffer is filled with the first part of the message, and the 
<see cref="T:System.Net.Sockets.SocketException" /> 
exception is thrown. For unreliable protocols, the excess data is lost; for
reliable protocols, the data is retained by the service provider.</para>
          <para>When the <see cref="F:System.Net.Sockets.SocketFlags.OutOfBand" /> flag is specified as part of the<paramref name="socketFlags " />parameter and the socket is configured for
in-line reception of out-of-band (OOB) data (using the <see cref="F:System.Net.Sockets.SocketOptionName.OutOfBandInline" /> socket option) and OOB
data is available, only OOB data is returned.</para>
          <para>When the <see cref="F:System.Net.Sockets.SocketFlags.Peek" /> flag is specified as part of the
<paramref name="socketFlags" /> parameter, available data is copied into 
<paramref name="buffer" /> 
but is not removed from the system
buffer.</para>
        </remarks>
        <permission cref="T:System.Net.SocketPermission">
          <para>Requires permission to accept a connection on the endpoint defined by the <see cref="P:System.Net.Sockets.Socket.LocalEndPoint" /> property of the current instance. See <see cref="F:System.Net.NetworkAccess.Accept" qualify="true" />.</para>
          <para>Requires permission to make a connection to the endpoint defined by <paramref name="remoteEP" />. See <see cref="F:System.Net.NetworkAccess.Connect" qualify="true" />.</para>
        </permission>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="ReceiveFrom">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 ReceiveFrom(class System.Byte[] buffer, int32 size, valuetype System.Net.Sockets.SocketFlags socketFlags, class System.Net.EndPoint&amp; remoteEP)" />
      <MemberSignature Language="C#" Value="public int ReceiveFrom(byte[] buffer, int size, SocketFlags socketFlags, ref EndPoint remoteEP);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="buffer" Type="System.Byte[]" />
		<Parameter Name="size" Type="System.Int32" />
		<Parameter Name="socketFlags" Type="System.Net.Sockets.SocketFlags" />
		<Parameter Name="remoteEP" Type="System.Net.EndPoint&amp;" RefType="ref" />
	</Parameters>
      <Docs>
        <summary>
          <para> Receives data from a socket and, for connectionless protocols, stores the
      endpoint associated with the socket that sent the data.</para>
        </summary>
        <param name="buffer">A <see cref="T:System.Byte" qualify="true" /> array to store data received from the socket.</param>
        <param name="size">A <see cref="T:System.Int32" qualify="true" /> containing the number of bytes to receive.</param>
        <param name="socketFlags">A bitwise combination of any of the following values defined in the <see cref="T:System.Net.Sockets.SocketFlags" /> enumeration: <see cref="F:System.Net.Sockets.SocketFlags.None" />, <see cref="F:System.Net.Sockets.SocketFlags.OutOfBand" />, or <see cref="F:System.Net.Sockets.SocketFlags.Peek" />.</param>
        <param name="remoteEP">A reference to the <see cref="T:System.Net.EndPoint" qualify="true" /> associated with the socket that sent the data.</param>
        <returns>
          <para>A <see cref="T:System.Int32" qualify="true" />
containing the number of bytes received.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="buffer" /> or <paramref name="remoteEP" /> is <see langword="null" />.</para>
        </exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="size" /> &lt; 0.</para>
          <para> -or-</para>
          <para>
            <paramref name="size" /> &gt; <paramref name="buffer" />.Length.</para>
        </exception>
        <exception cref="T:System.InvalidOperationException">
          <para>An asynchronous call is pending and a blocking method has been called.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>
            <paramref name="socketFlags" /> is not a valid combination of values.</para>
          <para>-or-</para>
          <para>An error occurred while accessing the socket.</para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.Security.SecurityException">A caller in the call stack does not have the required permissions.</exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>This method is equivalent to <see cref="M:System.Net.Sockets.Socket.ReceiveFrom(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint@)" />(<paramref name="buffer" />, 0, <paramref name="size" /> , <paramref name="socketFlags" />, <paramref name="remoteEP" /> ).</para>
        </remarks>
        <permission cref="T:System.Net.SocketPermission">Requires permission to accept connections from the endpoint defined by <paramref name="remoteEP" />. See <see cref="F:System.Net.NetworkAccess.Accept" qualify="true" />.</permission>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="ReceiveFrom">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 ReceiveFrom(class System.Byte[] buffer, valuetype System.Net.Sockets.SocketFlags socketFlags, class System.Net.EndPoint&amp; remoteEP)" />
      <MemberSignature Language="C#" Value="public int ReceiveFrom(byte[] buffer, SocketFlags socketFlags, ref EndPoint remoteEP);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="buffer" Type="System.Byte[]" />
		<Parameter Name="socketFlags" Type="System.Net.Sockets.SocketFlags" />
		<Parameter Name="remoteEP" Type="System.Net.EndPoint&amp;" RefType="ref" />
	</Parameters>
      <Docs>
        <summary>
          <para> Receives data from a socket and, for connectionless protocols, stores the
      endpoint associated with the socket that sent the data.</para>
        </summary>
        <param name="buffer">A <see cref="T:System.Byte" qualify="true" /> array to store data received from the socket.</param>
        <param name="socketFlags">A bitwise combination of any of the following values defined in the <see cref="T:System.Net.Sockets.SocketFlags" /> enumeration: <see cref="F:System.Net.Sockets.SocketFlags.None" />, <see cref="F:System.Net.Sockets.SocketFlags.OutOfBand" />, or <see cref="F:System.Net.Sockets.SocketFlags.Peek" />.</param>
        <param name="remoteEP">A reference to the <see cref="T:System.Net.EndPoint" qualify="true" /> associated with the socket that sent the data.</param>
        <returns>
          <para>A <see cref="T:System.Int32" qualify="true" />
containing the number of bytes received.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="buffer" /> or <paramref name="remoteEP" /> is <see langword="null" />.</para>
        </exception>
        <exception cref="T:System.InvalidOperationException">
          <para>An asynchronous call is pending and a blocking method has been called.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>
            <paramref name="socketFlags" /> specified an invalid value.</para>
          <para>-or-</para>
          <para>An error occurred while accessing the socket. </para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.Security.SecurityException">A caller in the call stack does not have the required permissions.</exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>This method is equivalent to <see cref="M:System.Net.Sockets.Socket.ReceiveFrom(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint@)" />(<paramref name="buffer" />, 0, <paramref name="buffer" />.Length, <paramref name="socketFlags" />, <paramref name="remoteEP" />).</para>
        </remarks>
        <permission cref="T:System.Net.SocketPermission">Requires permission to accept connections from the endpoint defined by <paramref name="remoteEP" />. See <see cref="F:System.Net.NetworkAccess.Accept" qualify="true" />.</permission>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="ReceiveFrom">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 ReceiveFrom(class System.Byte[] buffer, class System.Net.EndPoint&amp; remoteEP)" />
      <MemberSignature Language="C#" Value="public int ReceiveFrom(byte[] buffer, ref EndPoint remoteEP);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="buffer" Type="System.Byte[]" />
		<Parameter Name="remoteEP" Type="System.Net.EndPoint&amp;" RefType="ref" />
	</Parameters>
      <Docs>
        <summary>
          <para> Receives data from a socket and, for connectionless protocols, stores the
      endpoint associated with the socket that sent the data.</para>
        </summary>
        <param name="buffer">A <see cref="T:System.Byte" qualify="true" /> array to store data received from the socket.</param>
        <param name="remoteEP">A reference to the <see cref="T:System.Net.EndPoint" qualify="true" /> associated with the socket that sent the data.</param>
        <returns>
          <para>A <see cref="T:System.Int32" qualify="true" />
containing the number of bytes received.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="buffer" /> or <paramref name="remoteEP" /> is <see langword="null" />.</para>
        </exception>
        <exception cref="T:System.InvalidOperationException">
          <para>An asynchronous call is pending and a blocking method has been called.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred while accessing the socket. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>This method is equivalent to <see cref="M:System.Net.Sockets.Socket.ReceiveFrom(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint@)" />(<paramref name="buffer" />, 0, <paramref name="buffer" />.Length,
<see cref="F:System.Net.Sockets.SocketFlags.None" qualify="true" />, <paramref name="remoteEP" />).</para>
        </remarks>
        <permission cref="T:System.Net.SocketPermission">Requires permission to accept connections from the endpoint defined by <paramref name="remoteEP" />. See <see cref="F:System.Net.NetworkAccess.Accept" qualify="true" />.</permission>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="IOControl">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 IOControl(int32 ioControlCode, class System.Byte[] optionInValue, class System.Byte[] optionOutValue)" />
      <MemberSignature Language="C#" Value="public int IOControl(int ioControlCode, byte[] optionInValue, byte[] optionOutValue);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="ioControlCode" Type="System.Int32" />
		<Parameter Name="optionInValue" Type="System.Byte[]" />
		<Parameter Name="optionOutValue" Type="System.Byte[]" />
	</Parameters>
      <Docs>
        <summary>
          <para> Provides low-level access to the socket, the
      transport protocol, or the communications subsystem.</para>
        </summary>
        <param name="ioControlCode">A <see cref="T:System.Int32" qualify="true" /> containing the control code of the operation to perform.</param>
        <param name=" optionInValue">A <see cref="T:System.Byte" qualify="true" /> array containing the input data required by the operation.</param>
        <param name=" optionOutValue">A <see cref="T:System.Byte" qualify="true" /> array containing the output data supplied by the operation.</param>
        <returns>
          <para> A <see cref="T:System.Int32" qualify="true" /> containing the length of the
<paramref name="optionOutValue" /> array after the method returns.</para>
        </returns>
        <exception cref="T:System.InvalidOperationException">
          <para>An attempt was made to change the blocking mode.</para>
          <block subset="none" type="note">
            <para>Use the <see cref="P:System.Net.Sockets.Socket.Blocking" /> property to change the blocking mode.</para>
          </block>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred while accessing the socket. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>If an attempt is made to change the blocking mode of the current instance, an
      exception is thrown. Use the <see cref="P:System.Net.Sockets.Socket.Blocking" /> property to change the
      blocking mode.</para>
          <para>
      The control codes and their requirements
      are implementation defined. Do not use
      this method if platform
      independence is a requirement.
      
      </para>
          <para>
            <block subset="none" type="note">
      
      Input data is not required for all control codes. Output data is not supplied
      by all control codes and, if not supplied, the return value is 0.
      
      </block>
          </para>
        </remarks>
        <permission cref="T:System.Security.Permissions.SecurityPermission">Requires permission to access unmanaged code. See <see cref="F:System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode" qualify="true" />.</permission>
        <example>
          <para>The following example gets the number of bytes of available
      data to be read and writes the result to the console on a Windows system.
      The remote endpoint (remoteEndpoint) to connect to may need to be changed to a value that is valid on the current system.</para>
          <code lang="C#">using System;
using System.Net;
using System.Net.Sockets;

class App {

  static void Main() {

    IPAddress remoteAddress =
    Dns.Resolve(Dns.GetHostName()).AddressList[0];

    IPEndPoint remoteEndpoint =
      new IPEndPoint(remoteAddress, 80);

    Socket someSocket =
      new Socket(AddressFamily.InterNetwork,
                 SocketType.Stream,
                 ProtocolType.Tcp);

    someSocket.Connect(remoteEndpoint);

    int fionRead = 0x4004667F;
    byte[]inValue = {0x00, 0x00, 0x00, 0x00};
    byte[]outValue = {0x00, 0x00, 0x00, 0x00};

    someSocket.IOControl(fionRead, inValue, outValue);

    uint bytesAvail = BitConverter.ToUInt32(outValue, 0);
      
    Console.WriteLine(
      "There are {0} bytes available to be read.",
      bytesAvail.ToString() );
  }
}
      </code>
          <para>The output is</para>
          <c>
            <para>There are 0 bytes available to be read.</para>
          </c>
        </example>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="SetSocketOption">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance void SetSocketOption(valuetype System.Net.Sockets.SocketOptionLevel optionLevel, valuetype System.Net.Sockets.SocketOptionName optionName, int32 optionValue)" />
      <MemberSignature Language="C#" Value="public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, int optionValue);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="optionLevel" Type="System.Net.Sockets.SocketOptionLevel" />
		<Parameter Name="optionName" Type="System.Net.Sockets.SocketOptionName" />
		<Parameter Name="optionValue" Type="System.Int32" />
	</Parameters>
      <Docs>
        <summary>
          <para> Sets socket options with values of type <see cref="T:System.Int32" qualify="true" /> and <see cref="T:System.Boolean" qualify="true" />.</para>
        </summary>
        <param name="optionLevel">One of the values defined in the <see cref="T:System.Net.Sockets.SocketOptionLevel" /> enumeration. </param>
        <param name="optionName">One of the values defined in the <see cref="T:System.Net.Sockets.SocketOptionName" /> enumeration.</param>
        <param name="optionValue">
          <para>A <see cref="T:System.Int32" qualify="true" /> containing the value of the option.</para>
        </param>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred while accessing the socket. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.Security.SecurityException">A caller in the call stack does not have the required permissions.</exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>Socket options determine the behavior of the current
      instance. Multiple options can be set on the current instance by calling
      this method multiple times.</para>
          <para> For a socket option with a <see cref="T:System.Boolean" />
data type, specify a non-zero
<paramref name="optionValue" /> to enable the option, and an <paramref name="optionValue" /> equal to zero
to disable the option.</para>
          <para>Socket options are grouped by level of protocol support.
   The following tables list the members of
   the <see cref="T:System.Net.Sockets.SocketOptionName" /> enumeration
   supported by each member of the <see cref="T:System.Net.Sockets.SocketOptionLevel" /> enumeration.
   Only members that have associated values of the <see cref="T:System.Int32" qualify="true" /> and <see cref="T:System.Boolean" qualify="true" />
   data types are listed.</para>
The following table lists the
members of the <see cref="T:System.Net.Sockets.SocketOptionName" /> enumeration supported by
the <see langword="Socket" /> member of the <see cref="T:System.Net.Sockets.SocketOptionLevel" /> enumeration.
Options that do not require permission to access unmanaged code are noted.
<list type="table">
            <listheader>
              <term>SocketOptionName</term>
              <description>Description</description>
            </listheader>
            <item>
              <term> Broadcast</term>
              <description>A
      <see cref="T:System.Boolean" /> where <see langword="true" /> indicates broadcast messages are allowed to be sent to the socket. </description>
            </item>
            <item>
              <term> Debug</term>
              <description>A <see cref="T:System.Boolean" />
   where <see langword="true" /> indicates to record debugging information.</description>
            </item>
            <item>
              <term> DontLinger</term>
              <description>A <see cref="T:System.Boolean" />
where <see langword="true" /> indicates to close the socket without
lingering. This option does not require permission to access unmanaged code.</description>
            </item>
            <item>
              <term> DontRoute</term>
              <description>A <see cref="T:System.Boolean" />
where <see langword="true" /> indicates not to route data.</description>
            </item>
            <item>
              <term> Error</term>
              <description>A
   <see cref="T:System.Int32" /> that
      contains the error code associated with the last socket error. The error
      code is cleared by this option. This option is read-only.</description>
            </item>
            <item>
              <term> KeepAlive</term>
              <description>A <see cref="T:System.Boolean" />
where <see langword="true" /> (the default) indicates to enable
keep-alives, which allows a connection to remain open after a request has completed. This option does not require permission to access unmanaged code.</description>
            </item>
            <item>
              <term> OutOfBandInline</term>
              <description>A <see cref="T:System.Boolean" />
where <see langword="true" /> indicates to receive out-of-band data in the normal data stream.</description>
            </item>
            <item>
              <term> ReceiveBuffer</term>
              <description>A <see cref="T:System.Int32" /> that specifies the
   total per-socket buffer space reserved for receives.
   This option does not require permission to access unmanaged code.</description>
            </item>
            <item>
              <term> ReceiveTimeout</term>
              <description>A
   <see cref="T:System.Int32" /> that
      specifies the maximum time, in milliseconds, the <see cref="M:System.Net.Sockets.Socket.Receive(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" /> and <see cref="M:System.Net.Sockets.Socket.ReceiveFrom(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint@)" /> methods will block when attempting to
      receive data. If data is not received within this
      time, a <see cref="T:System.Net.Sockets.SocketException" /> exception
      is thrown. This option does not require permission to access unmanaged code.</description>
            </item>
            <item>
              <term> ReuseAddress</term>
              <description>A <see cref="T:System.Boolean" />
where <see langword="true" /> allows the socket to be bound to an address that is already in use.</description>
            </item>
            <item>
              <term> SendBuffer</term>
              <description>A <see cref="T:System.Int32" /> that specifies the
   total per-socket buffer space reserved for sends. This option does not require permission to access unmanaged code.</description>
            </item>
            <item>
              <term> SendTimeout</term>
              <description>A
   <see cref="T:System.Int32" /> that
      specifies the maximum time, in milliseconds, the <see cref="M:System.Net.Sockets.Socket.Send(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" /> and <see cref="M:System.Net.Sockets.Socket.SendTo(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint)" /> methods will block when attempting to
      send data. If data is not sent within this time, a <see cref="T:System.Net.Sockets.SocketException" /> exception
      is thrown. This option does not require permission to access unmanaged code.</description>
            </item>
            <item>
              <term> Type</term>
              <description>
                <para>One of the values defined in the <see cref="T:System.Net.Sockets.SocketType" /> enumeration. This option is
      read-only.</para>
              </description>
            </item>
          </list><para>The following table lists the members of the <see cref="T:System.Net.Sockets.SocketOptionName" />
enumeration supported by the <see langword="IP" /> member of the <see cref="T:System.Net.Sockets.SocketOptionLevel" />
enumeration. These options require permission to access unmanaged
code.</para><para>
            <list type="table">
              <listheader>
                <term>SocketOptionName</term>
                <description>Description</description>
              </listheader>
              <item>
                <term> HeaderIncluded</term>
                <description>A
      <see cref="T:System.Boolean" /> where <see langword="true" /> indicates
         the application is providing the IP header for outgoing
         datagrams. </description>
              </item>
              <item>
                <term> IPOptions</term>
                <description>A <see cref="T:System.Byte" /> array
      that specifies IP options to be inserted into outgoing
      datagrams.</description>
              </item>
              <item>
                <term> IpTimeToLive</term>
                <description>A <see cref="T:System.Int32" /> that specifies the
   time-to-live for datagrams. The time-to-live designates the number of
   networks on which the datagram is allowed to travel
   before being discarded by a
   router.</description>
              </item>
              <item>
                <term> MulticastInterface</term>
                <description>A
   <see cref="T:System.Byte" qualify="true" />
   array that specifies the interface for outgoing multicast
   packets.</description>
              </item>
              <item>
                <term> MulticastLoopback</term>
                <description>A
   <see cref="T:System.Boolean" /> where <see langword="true" /> enables multicast
      loopback. </description>
              </item>
              <item>
                <term> MulticastTimeToLive</term>
                <description>A <see cref="T:System.Int32" /> that specifies the
   time-to-live for multicast datagrams. </description>
              </item>
              <item>
                <term> TypeOfService</term>
                <description>A <see cref="T:System.Int32" /> that specifies the
   type of service field in the IP header. </description>
              </item>
              <item>
                <term> UseLoopback</term>
                <description>A
   <see cref="T:System.Boolean" /> where <see langword="true" /> indicates to send a copy of the
      data back to the
      sender. </description>
              </item>
            </list>
          </para><para>The following table lists the members of the <see cref="T:System.Net.Sockets.SocketOptionName" />
enumeration supported by the <see langword="Tcp" /> member of the <see cref="T:System.Net.Sockets.SocketOptionLevel" /> enumeration.
These options do not require permission to access unmanaged code.</para><para>
            <list type="table">
              <listheader>
                <term>SocketOptionName</term>
                <description>Description</description>
              </listheader>
              <item>
                <term> BsdUrgent</term>
                <description>A
      <see cref="T:System.Boolean" /> where <see langword="true" /> indicates to use urgent data
         as defined by IETF RFC 1222. Once enabled, this option cannot be disabled.</description>
              </item>
              <item>
                <term> Expedited</term>
                <description>A
      <see cref="T:System.Boolean" /> where <see langword="true" /> indicates to use expedited data as defined by IETF RFC
         1222. Once enabled, this option cannot be disabled.</description>
              </item>
              <item>
                <term> NoDelay</term>
                <description>A
      <see cref="T:System.Boolean" /> where <see langword="true" /> indicates to disable the Nagle algorithm for send
         coalescing.</description>
              </item>
            </list>
          </para><para>The following table lists the members of the <see cref="T:System.Net.Sockets.SocketOptionName" />
enumeration supported by the <see langword="Udp" /> member of the <see cref="T:System.Net.Sockets.SocketOptionLevel" /> enumeration.
These options do not require permission to access unmanaged code.</para><para>
            <list type="table">
              <listheader>
                <term>SocketOptionName</term>
                <description>Description</description>
              </listheader>
              <item>
                <term> ChecksumCoverage</term>
                <description>A
      <see cref="T:System.Boolean" /> that specifies UDP checksum coverage.</description>
              </item>
              <item>
                <term> NoChecksum</term>
                <description>A
      <see cref="T:System.Boolean" /> where <see langword="true" /> indicates to send UDP datagrams with the checksum set to zero.</description>
              </item>
            </list>
          </para><block subset="none" type="note">
            <para>For the
   <see langword="AddMembership" />, <see langword="DropMembership" />, and
   <see langword="Linger" /> members of the <see cref="T:System.Net.Sockets.SocketOptionName" /> enumeration, see
      the <see cref="M:System.Net.Sockets.Socket.SetSocketOption(System.Net.Sockets.SocketOptionLevel,System.Net.Sockets.SocketOptionName,System.Int32)" />(<see cref="T:System.Net.Sockets.SocketOptionLevel" />, <see cref="T:System.Net.Sockets.SocketOptionName" />, <see cref="T:System.Object" />) version of this method.</para>
          </block></remarks>
        <permission cref="T:System.Security.Permissions.SecurityPermission">Some options require permission to access unmanaged code. All the options that do not require permission are noted in the tables in the Description section. All options not so noted require this permission. See <see cref="F:System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode" qualify="true" />.</permission>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="SetSocketOption">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance void SetSocketOption(valuetype System.Net.Sockets.SocketOptionLevel optionLevel, valuetype System.Net.Sockets.SocketOptionName optionName, class System.Byte[] optionValue)" />
      <MemberSignature Language="C#" Value="public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, byte[] optionValue);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="optionLevel" Type="System.Net.Sockets.SocketOptionLevel" />
		<Parameter Name="optionName" Type="System.Net.Sockets.SocketOptionName" />
		<Parameter Name="optionValue" Type="System.Byte[]" />
	</Parameters>
      <Docs>
        <summary>
          <para>Sets socket options with values of type <see langword="Byte[]" />.</para>
        </summary>
        <param name="optionLevel">One of the values defined in the <see cref="T:System.Net.Sockets.SocketOptionLevel" /> enumeration. </param>
        <param name="optionName">One of the values defined in the <see cref="T:System.Net.Sockets.SocketOptionName" /> enumeration.</param>
        <param name="optionValue">A <see cref="T:System.Byte" qualify="true" /> array containing the value of the option.</param>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred while accessing the socket. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.Security.SecurityException">A caller in the call stack does not have the required permissions.</exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>Socket options determine the behavior of the current
      instance. Multiple options can be set on the current instance by calling this method
      multiple times.</para>
          <para>
            <block subset="none" type="note">For socket options
      with values of type <see cref="T:System.Int32" /> or <see cref="T:System.Boolean" />,
      see the <see cref="M:System.Net.Sockets.Socket.SetSocketOption(System.Net.Sockets.SocketOptionLevel,System.Net.Sockets.SocketOptionName,System.Int32)" />(<see cref="T:System.Net.Sockets.SocketOptionLevel" />, <see cref="T:System.Net.Sockets.SocketOptionName" /> , <see cref="T:System.Int32" />) version of this method.</block>
          </para>
          <para>
            <block subset="none" type="note">For the <see cref="F:System.Net.Sockets.SocketOptionName.AddMembership" />, <see cref="F:System.Net.Sockets.SocketOptionName.DropMembership" />, or <see cref="F:System.Net.Sockets.SocketOptionName.Linger" /> socket options, see the
<see cref="M:System.Net.Sockets.Socket.SetSocketOption(System.Net.Sockets.SocketOptionLevel,System.Net.Sockets.SocketOptionName,System.Int32)" />(<see cref="T:System.Net.Sockets.SocketOptionLevel" />, <see cref="T:System.Net.Sockets.SocketOptionName" />, <see cref="T:System.Object" />) version of this 
   method.</block>
          </para>
        </remarks>
        <permission cref="T:System.Security.Permissions.SecurityPermission"> Requires permission to access unmanaged code. See <see cref="F:System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode" qualify="true" />.</permission>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="SetSocketOption">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance void SetSocketOption(valuetype System.Net.Sockets.SocketOptionLevel optionLevel, valuetype System.Net.Sockets.SocketOptionName optionName, object optionValue)" />
      <MemberSignature Language="C#" Value="public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, object optionValue);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="optionLevel" Type="System.Net.Sockets.SocketOptionLevel" />
		<Parameter Name="optionName" Type="System.Net.Sockets.SocketOptionName" />
		<Parameter Name="optionValue" Type="System.Object" />
	</Parameters>
      <Docs>
        <summary>
          <para> Sets the <see cref="F:System.Net.Sockets.SocketOptionName.AddMembership" />, <see cref="F:System.Net.Sockets.SocketOptionName.DropMembership" />, or
<see cref="F:System.Net.Sockets.SocketOptionName.Linger" /> socket options.</para>
        </summary>
        <param name="optionLevel">Either the <see langword="Socket" /> or <see langword="IP" /> member of the <see cref="T:System.Net.Sockets.SocketOptionLevel" /> enumeration.</param>
        <param name="optionName">Either the <see langword="Linger" />, <see langword="AddMembership" />, or <see langword="DropMembership" /> member of the <see cref="T:System.Net.Sockets.SocketOptionName" /> enumeration.</param>
        <param name="optionValue">An instance of the <see cref="T:System.Net.Sockets.LingerOption" /> or <see cref="T:System.Net.Sockets.MulticastOption" /> class.</param>
        <exception cref="T:System.ArgumentException">
          <paramref name="optionLevel" />, <paramref name="optionName" />, or <paramref name="optionValue" /> specified an invalid value.</exception>
        <exception cref="T:System.ArgumentNullException">
          <paramref name="optionValue" /> is <see langword="null" />.</exception>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred while accessing the socket. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.Security.SecurityException">A caller in the call stack does not have the required permissions.</exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>Socket options determine the behavior of the current
      instance. Multiple options can be set on the current instance by calling this method multiple times.</para>
          <para>The following table summarizes the valid combinations of input parameters.</para>
          <list type="table">
            <listheader>
              <term>optionLevel/optionName</term>
              <description>optionValue</description>
            </listheader>
            <item>
              <term>
                <see langword="Socket" />/<see langword="Linger" /></term>
              <description>An instance of the <see cref="T:System.Net.Sockets.LingerOption" qualify="true" /> class.</description>
            </item>
            <item>
              <term>
                <para>
                  <see langword="IP" />/<see langword="AddMembership" /></para>
                <para>- or -</para>
                <para>
                  <see langword="IP" />/<see langword="DropMembership" /></para>
              </term>
              <description>An instance of the <see cref="T:System.Net.Sockets.MulticastOption" qualify="true" /> class.</description>
            </item>
          </list>
          <para> When setting the <see cref="F:System.Net.Sockets.SocketOptionName.Linger" /> option, a <see cref="T:System.ArgumentException" qualify="true" />
exception is thrown if the <see cref="P:System.Net.Sockets.LingerOption.LingerTime" /> property of
the <see cref="T:System.Net.Sockets.LingerOption" /> instance is less than zero or greater
than <see cref="F:System.UInt16.MaxValue" />
. </para>
          <block subset="none" type="note">
            <para> For more information on the <see cref="F:System.Net.Sockets.SocketOptionName.Linger" /> option,
   see the <see cref="T:System.Net.Sockets.LingerOption" /> class and the <see cref="M:System.Net.Sockets.Socket.Shutdown(System.Net.Sockets.SocketShutdown)" />
   method. </para>
            <para> For more information on the <see cref="F:System.Net.Sockets.SocketOptionName.AddMembership" /> and <see cref="F:System.Net.Sockets.SocketOptionName.DropMembership" /> options, see the <see cref="T:System.Net.Sockets.MulticastOption" /> class. </para>
            <para>For socket options
   with values of type <see cref="T:System.Int32" /> or <see cref="T:System.Boolean" />, see the <see cref="M:System.Net.Sockets.Socket.SetSocketOption(System.Net.Sockets.SocketOptionLevel,System.Net.Sockets.SocketOptionName,System.Int32)" />(<see cref="T:System.Net.Sockets.SocketOptionLevel" />, <see cref="T:System.Net.Sockets.SocketOptionName" />, <see cref="T:System.Int32" />) version
   of this method.</para>
          </block>
        </remarks>
        <permission cref="T:System.Security.Permissions.SecurityPermission">The <see cref="F:System.Net.Sockets.SocketOptionName.AddMembership" /> and <see cref="F:System.Net.Sockets.SocketOptionName.DropMembership" /> options require permission to access unmanaged code. See <see cref="F:System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode" qualify="true" />.</permission>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="GetSocketOption">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance object GetSocketOption(valuetype System.Net.Sockets.SocketOptionLevel optionLevel, valuetype System.Net.Sockets.SocketOptionName optionName)" />
      <MemberSignature Language="C#" Value="public object GetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Object</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="optionLevel" Type="System.Net.Sockets.SocketOptionLevel" />
		<Parameter Name="optionName" Type="System.Net.Sockets.SocketOptionName" />
	</Parameters>
      <Docs>
        <summary>
          <para>Retrieves an object containing the value of the specified socket option.</para>
        </summary>
        <param name="optionLevel">One of the values defined in the <see cref="T:System.Net.Sockets.SocketOptionLevel" /> enumeration. </param>
        <param name="optionName">One of the values defined in the <see cref="T:System.Net.Sockets.SocketOptionName" /> enumeration.</param>
        <returns>
          <para> The following table describes the values returned 
      by this method.</para>
          <list type="table">
            <listheader>
              <term>optionName</term>
              <description>Return value</description>
            </listheader>
            <item>
              <term>
                <see langword="Linger" />
              </term>
              <description> An instance of the <see cref="T:System.Net.Sockets.LingerOption" qualify="true" />
   class.</description>
            </item>
            <item>
              <term>
                <para>
                  <see langword="AddMembership" />
                </para>
                <para> -or-</para>
                <para>
                  <see langword="DropMembership" />
                </para>
              </term>
              <description> An instance of
   the <see cref="T:System.Net.Sockets.MulticastOption" qualify="true" />
   class.</description>
            </item>
            <item>
              <term> All other values defined in the <see cref="T:System.Net.Sockets.SocketOptionName" /> enumeration.</term>
              <description>A <see cref="T:System.Int32" qualify="true" /> containing the value
of the option.</description>
            </item>
          </list>
        </returns>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred while accessing the socket. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>Socket options determine the behavior of the
      current instance. </para>
          <para>
            <paramref name="optionLevel" /> and <paramref name="optionName" /> are not
   independent. See the <see cref="M:System.Net.Sockets.Socket.SetSocketOption(System.Net.Sockets.SocketOptionLevel,System.Net.Sockets.SocketOptionName,System.Int32)" />(<see langword="SocketOptionLevel" />,
<see langword="SocketOptionName" />, <see langword="Int32" />) method for a listing of the values of the <see cref="T:System.Net.Sockets.SocketOptionName" /> enumeration grouped
   by <see cref="T:System.Net.Sockets.SocketOptionLevel" />. </para>
        </remarks>
        <example>
          <para>The following example gets the state of the linger option and the size of the receive buffer, changes the values of both, then gets the new values.</para>
          <code lang="C#">using System;
using System.Net.Sockets;

class OptionTest{

  public static void Main() {

    // Get the current option values.
    Socket someSocket =
      new Socket(AddressFamily.InterNetwork,
                 SocketType.Stream,
                 ProtocolType.Tcp);

    LingerOption lingerOp =
      (LingerOption)someSocket.GetSocketOption(
                    SocketOptionLevel.Socket,
                    SocketOptionName.Linger);

    int receiveBuffer =
      (int)someSocket.GetSocketOption(
           SocketOptionLevel.Socket,
           SocketOptionName.ReceiveBuffer);

    Console.WriteLine(
      "Linger option is {0} and set to {1} seconds.",
      lingerOp.Enabled.ToString(),
      lingerOp.LingerTime.ToString() );

    Console.WriteLine(
      "Size of the receive buffer is {0} bytes.",
      receiveBuffer.ToString() );

    // Change the options.
    lingerOp = new LingerOption(true, 10);
    someSocket.SetSocketOption(
      SocketOptionLevel.Socket,
      SocketOptionName.Linger,
      lingerOp);

    someSocket.SetSocketOption(
      SocketOptionLevel.Socket,
      SocketOptionName.ReceiveBuffer,
      2048);

    Console.WriteLine(
      "The SetSocketOption method has been called.");
 
    // Get the new option values.
    lingerOp =
      (LingerOption)someSocket.GetSocketOption(
                    SocketOptionLevel.Socket,
                    SocketOptionName.Linger);

    receiveBuffer =
      (int)someSocket.GetSocketOption(
           SocketOptionLevel.Socket,
           SocketOptionName.ReceiveBuffer);

    Console.WriteLine(
      "Linger option is now {0} and set to {1} seconds.",
      lingerOp.Enabled.ToString(),
      lingerOp.LingerTime.ToString());

    Console.WriteLine(
      "Size of the receive buffer is now {0} bytes.",
      receiveBuffer.ToString());
  }
}
   </code>
          <para>The output is</para>
          <c>
            <para> Linger option is False and set to 0 seconds.</para>
            <para> Size of the receive buffer is 8192 bytes.</para>
            <para>The SetSocketOption method has been called.</para>
            <para> Linger option is now True and set to 10 seconds.</para>
            <para> Size of the receive buffer is now 2048 bytes.</para>
          </c>
        </example>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="GetSocketOption">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance void GetSocketOption(valuetype System.Net.Sockets.SocketOptionLevel optionLevel, valuetype System.Net.Sockets.SocketOptionName optionName, class System.Byte[] optionValue)" />
      <MemberSignature Language="C#" Value="public void GetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, byte[] optionValue);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="optionLevel" Type="System.Net.Sockets.SocketOptionLevel" />
		<Parameter Name="optionName" Type="System.Net.Sockets.SocketOptionName" />
		<Parameter Name="optionValue" Type="System.Byte[]" />
	</Parameters>
      <Docs>
        <summary>
          <para>Retrieves the value of the specified socket option.</para>
        </summary>
        <param name="optionLevel">One of the values defined in the <see cref="T:System.Net.Sockets.SocketOptionLevel" /> enumeration. </param>
        <param name="optionName">One of the values defined in the <see cref="T:System.Net.Sockets.SocketOptionName" /> enumeration.</param>
        <param name=" optionValue">A <see cref="T:System.Byte" qualify="true" /> array that receives the value of the specified socket option.</param>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>
            <paramref name="optionValue" /> is too small to store the value of the specified socket option.</para>
          <para>-or-</para>
          <para>An error occurred while accessing the socket.</para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>Socket
      options determine the behavior of the current instance.</para>
          <para>Upon successful completion, the array specified by the <paramref name="optionValue" /> parameter contains the value of the
   specified socket option.</para>
          <para>When the length of the <paramref name="optionValue" /> array is smaller than the number of bytes required
to store the value of the specified socket option, a <see cref="T:System.Net.Sockets.SocketException" /> exception is thrown.</para>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="GetSocketOption">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance class System.Byte[] GetSocketOption(valuetype System.Net.Sockets.SocketOptionLevel optionLevel, valuetype System.Net.Sockets.SocketOptionName optionName, int32 optionLength)" />
      <MemberSignature Language="C#" Value="public byte[] GetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, int optionLength);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Byte[]</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="optionLevel" Type="System.Net.Sockets.SocketOptionLevel" />
		<Parameter Name="optionName" Type="System.Net.Sockets.SocketOptionName" />
		<Parameter Name="optionLength" Type="System.Int32" />
	</Parameters>
      <Docs>
        <summary>
          <para> Retrieves the value of the
      specified socket option.</para>
        </summary>
        <param name="optionLevel">One of the values defined in the <see cref="T:System.Net.Sockets.SocketOptionLevel" /> enumeration. </param>
        <param name="optionName">One of the values defined in the <see cref="T:System.Net.Sockets.SocketOptionName" /> enumeration.</param>
        <param name=" optionLength">A <see cref="T:System.Int32" qualify="true" /> containing the maximum length, in bytes, of the value of the specified socket option.</param>
        <returns>
          <para> A <see cref="T:System.Byte" qualify="true" /> array containing the value of the specified socket option.</para>
        </returns>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>
            <paramref name="optionLength" /> is smaller than the number of bytes required to store the value of the specified socket option.</para>
          <para>-or-</para>
          <para>An error occurred while accessing the socket.</para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para> Socket options
      determine the behavior of the current instance.</para>
          <para>The <paramref name="optionLength" /> parameter
   is used to allocate an array to store the value of the specified option. When this value is smaller than the number of bytes required to store
   the value of the specified option, a <see cref="T:System.Net.Sockets.SocketException" /> exception is thrown. When this value is
   greater than or equal to the number of bytes required to store the value of the
   specified option, the array returned by this
   method is allocated to be exactly the required length.</para>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Poll">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance bool Poll(int32 microSeconds, valuetype System.Net.Sockets.SelectMode mode)" />
      <MemberSignature Language="C#" Value="public bool Poll(int microSeconds, SelectMode mode);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="microSeconds" Type="System.Int32" />
		<Parameter Name="mode" Type="System.Net.Sockets.SelectMode" />
	</Parameters>
      <Docs>
        <summary>
          <para>Determines the read, write, or error status of the current instance.</para>
        </summary>
        <param name="microSeconds">A <see cref="T:System.Int32" qualify="true" /> containing the time to wait for a response, in microseconds. Set the <paramref name="microSeconds" /> parameter to a negative value to wait indefinitely for a response.</param>
        <param name=" mode">One of the values defined in the <see cref="T:System.Net.Sockets.SelectMode" /> enumeration.</param>
        <returns>
          <para>A <see cref="T:System.Boolean" qualify="true" /> where <see langword="true" /> indicates the current instance
   satisfies at least one of the conditions in the following table
   corresponding to the specified <see cref="T:System.Net.Sockets.SelectMode" />
   value; otherwise, <see langword="false" />. <see langword="false" /> is returned if the status of the current instance cannot be determined within the time specified by <paramref name="microSeconds" /> . </para>
          <list type="table">
            <listheader>
              <term>SelectMode value</term>
              <description> Condition</description>
            </listheader>
            <item>
              <term> SelectRead</term>
              <description>
                <para> Data is available for reading (includes
            out-of-band data if the <see cref="F:System.Net.Sockets.SocketOptionName.OutOfBandInline" /> value defined in
            the <see cref="T:System.Net.Sockets.SocketOptionName" />
            enumeration
            is set).</para>
                <para>-or-</para>
                <para>The socket is in the listening state with a
            pending connection, and
            the <see cref="M:System.Net.Sockets.Socket.Accept" /> method has been called and is guaranteed to succeed without
            blocking.</para>
                <para>-or-</para>
                <para> The connection has been closed, reset,
            or terminated.</para>
              </description>
            </item>
            <item>
              <term> SelectWrite</term>
              <description>
                <para>Data can be sent.</para>
                <para>-or-</para>
                <para> A non-blocking <see cref="M:System.Net.Sockets.Socket.Connect(System.Net.EndPoint)" /> method is being processed and the connection has
            succeeded.</para>
              </description>
            </item>
            <item>
              <term> SelectError</term>
              <description>
                <para>The <see cref="F:System.Net.Sockets.SocketOptionName.OutOfBandInline" /> value defined in
            the <see cref="T:System.Net.Sockets.SocketOptionName" /> enumeration is not set
            and out-of-band data is available.</para>
                <para>-or-</para>
                <para> A non-blocking <see cref="M:System.Net.Sockets.Socket.Connect(System.Net.EndPoint)" />
      method is being processed and the connection has
      failed.</para>
              </description>
            </item>
          </list>
        </returns>
        <exception cref="T:System.NotSupportedException">
          <paramref name="mode " />is not one of the values defined in the <see cref="T:System.Net.Sockets.SelectMode" /> enumeration.</exception>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>An error occurred while accessing the socket. </para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Select">
      <MemberSignature Language="ILASM" Value=".method public hidebysig static void Select(class System.Collections.IList checkRead, class System.Collections.IList checkWrite, class System.Collections.IList checkError, int32 microSeconds)" />
      <MemberSignature Language="C#" Value="public static void Select(IList checkRead, IList checkWrite, IList checkError, int microSeconds);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="checkRead" Type="System.Collections.IList" />
		<Parameter Name="checkWrite" Type="System.Collections.IList" />
		<Parameter Name="checkError" Type="System.Collections.IList" />
		<Parameter Name="microSeconds" Type="System.Int32" />
	</Parameters>
      <Docs>
        <summary>
          <para>Determines the read, write, or error status of a set
      of <see cref="T:System.Net.Sockets.Socket" /> instances.</para>
        </summary>
        <param name="checkRead">A <see cref="T:System.Collections.IList" /> object containing the <see cref="T:System.Net.Sockets.Socket" /> instances to check for read status.</param>
        <param name="checkWrite">A <see cref="T:System.Collections.IList" /> object containing the <see cref="T:System.Net.Sockets.Socket" /> instances to check for write status.</param>
        <param name="checkError">A <see cref="T:System.Collections.IList" /> object containing the <see cref="T:System.Net.Sockets.Socket" /> instances to check for error status.</param>
        <param name="microSeconds">A <see cref="T:System.Int32" qualify="true" /> that specifies the time to wait for a response, in microseconds. Specify a negative value to wait indefinitely for the status to be determined.</param>
        <exception cref="T:System.ArgumentNullException">All of the following parameters are <see langword="null" /> or empty: <paramref name="checkRead" />, <paramref name="checkWrite" />, and <paramref name="checkError" />.</exception>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred while accessing one of the sockets. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <remarks>
          <para>Upon successful completion, this method removes all
   <see cref="T:System.Net.Sockets.Socket" /> instances from
      the specified list that do not
      satisfy one of the conditions associated
      with that list. The following table describes the conditions for each list.</para>
          <list type="table">
            <listheader>
              <term>List</term>
              <description>Condition to remain in list</description>
            </listheader>
            <item>
              <term>
                <paramref name="checkRead" />
              </term>
              <description>
                <para>Data is available for reading (includes
            out-of-band data if the <see cref="F:System.Net.Sockets.SocketOptionName.OutOfBandInline" />
            value defined in the <see cref="T:System.Net.Sockets.SocketOptionName" /> enumeration is set).</para>
                <para>-or-</para>
                <para>The socket is in the listening state with a pending connection, and the <see cref="M:System.Net.Sockets.Socket.Accept" /> method has been called
         and is guaranteed to succeed without blocking.</para>
                <para>-or-</para>
                <para>The connection has been closed, reset, or terminated.</para>
              </description>
            </item>
            <item>
              <term>
                <paramref name="checkWrite" />
              </term>
              <description>
                <para>Data can be sent.</para>
                <para>-or-</para>
                <para>A non-blocking <see cref="M:System.Net.Sockets.Socket.Connect(System.Net.EndPoint)" /> method is being processed and the
      connection has succeeded.</para>
              </description>
            </item>
            <item>
              <term>
                <paramref name="checkError" />
              </term>
              <description>
                <para>The <see cref="F:System.Net.Sockets.SocketOptionName.OutOfBandInline" />
value defined in the <see cref="T:System.Net.Sockets.SocketOptionName" /> enumeration is not set and
out-of-band data is available.</para>
                <para>-or-</para>
                <para>A non-blocking <see cref="M:System.Net.Sockets.Socket.Connect(System.Net.EndPoint)" /> method is being processed and the
connection has failed.</para>
              </description>
            </item>
          </list>
          <para>
            <block subset="none" type="note">To determine the status of a specific
<see cref="T:System.Net.Sockets.Socket" /> instance, check whether the instance 
   remains in the list after the method returns.</block>
          </para>
          <para> When the method cannot determine the status of all the
<see cref="T:System.Net.Sockets.Socket" /> instances within the time specified in the 
<paramref name="microseconds" /> parameter, the 
   method removes all the <see cref="T:System.Net.Sockets.Socket" />
   instances from all the lists and returns.</para>
          <para> At least one of <paramref name="checkRead" />, <paramref name="checkWrite" />, or
<paramref name="checkError" />, is required to contain at least one <see cref="T:System.Net.Sockets.Socket" /> instance. The 
other parameters can be empty or <see langword="null" />.</para>
        </remarks>
        <example>
          <para>The following example determines the status of the socket instance named
      socket3 and writes the result to the console.</para>
          <code lang="C#">using System;
using System.Collections;
using System.Net.Sockets;

class SelectTest {

  public static void Main() {

    Socket socket1 =
      new Socket(AddressFamily.InterNetwork,
                 SocketType.Stream,
                 ProtocolType.Tcp);
    Socket socket2 =
      new Socket(AddressFamily.InterNetwork,
                 SocketType.Stream,
                 ProtocolType.Tcp);
    Socket socket3 =
      new Socket(AddressFamily.InterNetwork,
                 SocketType.Stream,
                 ProtocolType.Tcp);

    ArrayList readList = new ArrayList();
    ArrayList writeList = new ArrayList();
    ArrayList errorList = new ArrayList();

    readList.Add(socket1);
    readList.Add(socket2);
    readList.Add(socket3);
    errorList.Add(socket1);
    errorList.Add(socket3);

    // readList.Contains(Socket3) returns true
    // if Socket3 is in ReadList.
    Console.WriteLine(
      "socket3 is placed in readList and errorList.");
    Console.WriteLine(
      "socket3 is {0}in readList.",
      readList.Contains(socket3) ? "" : "not " );
    Console.WriteLine(
      "socket3 is {0}in writeList.",
      writeList.Contains(socket3) ? "" : "not " );
    Console.WriteLine(
      "socket3 is {0}in errorList.",
      errorList.Contains(socket3) ? "" : "not " );

    Socket.Select(readList, writeList, errorList, 10);
    Console.WriteLine("The Select method has been called.");
    Console.WriteLine(
      "socket3 is {0}in readList.",
      readList.Contains(socket3) ? "" : "not " );
    Console.WriteLine(
      "socket3 is {0}in writeList.",
      writeList.Contains(socket3) ? "" : "not " );
    Console.WriteLine(
      "socket3 is {0}in errorList.",
      errorList.Contains(socket3) ? "" : "not " );
  }
}
   </code>
          <para>The output is</para>
          <c>
            <para>socket3 is placed in readList and errorList.</para>
            <para>socket3 is in readList.</para>
            <para>socket3 is not in writeList.</para>
            <para>socket3 is in errorList.</para>
            <para>The Select method has been called.</para>
            <para>socket3 is not in readList.</para>
            <para>socket3 is not in writeList.</para>
            <para>socket3 is not in errorList.</para>
          </c>
        </example>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="BeginConnect">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance class System.IAsyncResult BeginConnect(class System.Net.EndPoint remoteEP, class System.AsyncCallback callback, object state)" />
      <MemberSignature Language="C#" Value="public IAsyncResult BeginConnect(EndPoint remoteEP, AsyncCallback callback, object state);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.IAsyncResult</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="remoteEP" Type="System.Net.EndPoint" />
		<Parameter Name="callback" Type="System.AsyncCallback" />
		<Parameter Name="state" Type="System.Object" />
	</Parameters>
      <Docs>
        <summary>
          <para> Begins an asynchronous operation to associate the current instance with a remote endpoint.</para>
        </summary>
        <param name="remoteEP">
          <para>The <see cref="T:System.Net.EndPoint" qualify="true" /> associated with the socket to connect to.</para>
        </param>
        <param name="callback">A <see cref="T:System.AsyncCallback" /> delegate, or <see langword="null" />.</param>
        <param name=" state">An application-defined object, or <see langword="null" />.</param>
        <returns>
          <para>A <see cref="T:System.IAsyncResult" /> instance that contains information about the asynchronous operation.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="remoteEP " />is <see langword="null" />.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred while starting the operation. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <exception cref="T:System.Security.SecurityException">A caller higher in the call stack does not have permission for the requested operation.</exception>
        <remarks>
          <para> To release
      resources allocated by the <see cref="M:System.Net.Sockets.Socket.BeginConnect(System.Net.EndPoint,System.AsyncCallback,System.Object)" /> method, call
      the <see cref="M:System.Net.Sockets.Socket.EndConnect(System.IAsyncResult)" /> method, and specify the
      <see cref="T:System.IAsyncResult" /> object returned by this
      
      method.</para>
          <para>
            <block subset="none" type="note">The <see cref="M:System.Net.Sockets.Socket.EndConnect(System.IAsyncResult)" /> method should be
   called exactly once for each call to the <see cref="M:System.Net.Sockets.Socket.BeginConnect(System.Net.EndPoint,System.AsyncCallback,System.Object)" />
   method.</block>
          </para>
          <para>If the <paramref name="callback" /> parameter is not
<see langword="null" />, the method referenced by <paramref name="callback" /> is invoked 
when the asynchronous operation completes. The <see cref="T:System.IAsyncResult" /> object returned by this method is
passed as the argument to the method referenced by <paramref name="callback" />. The method
referenced by <paramref name="callback" /> can retrieve the results of the operation by calling
the <see cref="M:System.Net.Sockets.Socket.EndConnect(System.IAsyncResult)" />
method.</para>
          <para> The <paramref name="state" /> parameter
can be any object that the caller wishes to have available for the duration of
the asynchronous operation. This object is available via the
<see cref="P:System.IAsyncResult.AsyncState" /> 
property of the object returned by this
method.</para>
          <para>To determine the connection status, check the <see cref="P:System.Net.Sockets.Socket.Connected" /> property, or use either the <see cref="M:System.Net.Sockets.Socket.Poll(System.Int32,System.Net.Sockets.SelectMode)" />
or <see cref="M:System.Net.Sockets.Socket.Select(System.Collections.IList,System.Collections.IList,System.Collections.IList,System.Int32)" /> method.</para>
          <block subset="none" type="note">
            <para>For more information, see <see cref="M:System.Net.Sockets.Socket.Connect(System.Net.EndPoint)" />, the
   synchronous version of this method.</para>
          </block>
        </remarks>
        <permission cref="T:System.Net.SocketPermission">Requires permission to make a connection to the endpoint defined by <paramref name="remoteEP" />. <block subset="none" type="note">See <see cref="F:System.Net.NetworkAccess.Connect" qualify="true" />.</block></permission>
        <example>
          <para> For an outline of an asynchronous
      operation, see the <see cref="M:System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object)" /> method.
      For the complete example, which uses the <see cref="M:System.Net.Sockets.Socket.BeginConnect(System.Net.EndPoint,System.AsyncCallback,System.Object)" /> method, see the
      <see cref="T:System.Net.Sockets.Socket" /> class overview.</para>
        </example>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="EndConnect">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance void EndConnect(class System.IAsyncResult asyncResult)" />
      <MemberSignature Language="C#" Value="public void EndConnect(IAsyncResult asyncResult);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="asyncResult" Type="System.IAsyncResult" />
	</Parameters>
      <Docs>
        <summary>
          <para> Ends an asynchronous call
      to associate the current instance with a remote endpoint.</para>
        </summary>
        <param name="asyncResult">A <see cref="T:System.IAsyncResult" /> object that holds the state information for the asynchronous operation.</param>
        <exception cref="T:System.ArgumentNullException">
          <paramref name="asyncResult " />is <see langword="null" />.</exception>
        <exception cref="T:System.ArgumentException">
          <paramref name="asyncResult " /> was not returned by the current instance from a call to the <see cref="M:System.Net.Sockets.Socket.BeginConnect(System.Net.EndPoint,System.AsyncCallback,System.Object)" /> method.</exception>
        <exception cref="T:System.InvalidOperationException">
          <see cref="M:System.Net.Sockets.Socket.EndConnect(System.IAsyncResult)" /> was previously called for this operation.</exception>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred during the operation. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para> This method blocks if the asynchronous operation has not completed.</para>
          <para>The <see cref="M:System.Net.Sockets.Socket.EndConnect(System.IAsyncResult)" />
method completes an asynchronous request that was started with a call to the
<see cref="M:System.Net.Sockets.Socket.BeginConnect(System.Net.EndPoint,System.AsyncCallback,System.Object)" /> method. The object specified for the 
<paramref name="asyncResult" /> parameter is required to be the same object as was returned 
by the <see cref="M:System.Net.Sockets.Socket.BeginConnect(System.Net.EndPoint,System.AsyncCallback,System.Object)" />
method call that began the
request.</para>
          <para>If the <see cref="M:System.Net.Sockets.Socket.EndConnect(System.IAsyncResult)" />
method is invoked via the <see cref="T:System.AsyncCallback" /> delegate specified to the <see cref="M:System.Net.Sockets.Socket.BeginConnect(System.Net.EndPoint,System.AsyncCallback,System.Object)" /> method, the
<paramref name="asyncResult" /> parameter is the <see cref="T:System.IAsyncResult" /> 
argument passed to the
delegate's method.</para>
        </remarks>
        <example>
          <para>For an outline of an asynchronous operation, see
      the <see cref="M:System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object)" /> method.
      For the complete example, which uses the <see cref="M:System.Net.Sockets.Socket.EndConnect(System.IAsyncResult)" /> method, see the <see cref="T:System.Net.Sockets.Socket" /> class overview.</para>
        </example>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="BeginSend">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance class System.IAsyncResult BeginSend(class System.Byte[] buffer, int32 offset, int32 size, valuetype System.Net.Sockets.SocketFlags socketFlags, class System.AsyncCallback callback, object state)" />
      <MemberSignature Language="C#" Value="public IAsyncResult BeginSend(byte[] buffer, int offset, int size, SocketFlags socketFlags, AsyncCallback callback, object state);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.IAsyncResult</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="buffer" Type="System.Byte[]" />
		<Parameter Name="offset" Type="System.Int32" />
		<Parameter Name="size" Type="System.Int32" />
		<Parameter Name="socketFlags" Type="System.Net.Sockets.SocketFlags" />
		<Parameter Name="callback" Type="System.AsyncCallback" />
		<Parameter Name="state" Type="System.Object" />
	</Parameters>
      <Docs>
        <summary>
          <para>Begins an asynchronous operation to send data to a connected socket.</para>
        </summary>
        <param name="buffer">A <see cref="T:System.Byte" qualify="true" /> array storing data to send to the socket.</param>
        <param name=" offset">A <see cref="T:System.Int32" qualify="true" /> containing the zero-based position in <paramref name="buffer" /> containing the starting location of the data to send.</param>
        <param name=" size">A <see cref="T:System.Int32" qualify="true" /> containing the number of bytes to send.</param>
        <param name=" socketFlags">A bitwise combination of any of the following values defined in the <see cref="T:System.Net.Sockets.SocketFlags" /> enumeration: <see cref="F:System.Net.Sockets.SocketFlags.None" />, <see cref="F:System.Net.Sockets.SocketFlags.DontRoute" />, or <see cref="F:System.Net.Sockets.SocketFlags.OutOfBand" /> .</param>
        <param name="callback">A <see cref="T:System.AsyncCallback" /> delegate, or <see langword="null" />.</param>
        <param name=" state">An application-defined object, or <see langword="null" />.</param>
        <returns>
          <para>A <see cref="T:System.IAsyncResult" /> instance that contains information about the asynchronous operation.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <paramref name="buffer " />is <see langword="null" />.</exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="offset" /> &lt; 0. </para>
          <para>-or- </para>
          <para>
            <paramref name="offset" /> &gt; <paramref name="buffer" />.Length. </para>
          <para> -or-</para>
          <para>
            <paramref name="size" /> &lt; 0.</para>
          <para>-or-</para>
          <para>
            <paramref name="size" /> &gt; <paramref name="buffer" />.Length - <paramref name="offset" />.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>
            <paramref name="socketFlags" /> is not a valid combination of values.</para>
          <para>-or-</para>
          <para>An error occurred while accessing the socket. </para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>To retrieve the results of the operation and release
      resources allocated by the <see cref="M:System.Net.Sockets.Socket.BeginSend(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.AsyncCallback,System.Object)" /> method, call
      the <see cref="M:System.Net.Sockets.Socket.EndSend(System.IAsyncResult)" /> method, and specify the
   <see cref="T:System.IAsyncResult" /> object returned by
      this
      
      method.</para>
          <para>
            <block subset="none" type="note">The <see cref="M:System.Net.Sockets.Socket.EndSend(System.IAsyncResult)" /> method should be
   called exactly once for each call to the <see cref="M:System.Net.Sockets.Socket.BeginSend(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.AsyncCallback,System.Object)" />
   method.</block>
          </para>
          <para>If the <paramref name="callback" /> parameter is not
<see langword="null" />, the method referenced by <paramref name="callback" /> is invoked 
when the asynchronous operation completes. The <see cref="T:System.IAsyncResult" /> object returned by this method is
passed as the argument to the method referenced by <paramref name="callback" />. The method
referenced by <paramref name="callback" /> can retrieve the results of the operation by calling
the <see cref="M:System.Net.Sockets.Socket.EndSend(System.IAsyncResult)" />
method.</para>
          <para> The <paramref name="state" /> parameter
can be any object that the caller wishes to have available for the duration of
the asynchronous operation. This object is available via the
<see cref="P:System.IAsyncResult.AsyncState" /> 
property of the object returned by this
method.</para>
          <block subset="none" type="note">
            <para>For more information, see <see cref="M:System.Net.Sockets.Socket.Send(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" />, the
   synchronous version of this method.</para>
          </block>
        </remarks>
        <example>
          <para>For an outline of an asynchronous operation, see
      the <see cref="M:System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object)" /> method.
      For the complete example, which uses the <see cref="M:System.Net.Sockets.Socket.BeginSend(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.AsyncCallback,System.Object)" /> method, see the <see cref="T:System.Net.Sockets.Socket" /> class overview.</para>
        </example>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="EndSend">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 EndSend(class System.IAsyncResult asyncResult)" />
      <MemberSignature Language="C#" Value="public int EndSend(IAsyncResult asyncResult);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="asyncResult" Type="System.IAsyncResult" />
	</Parameters>
      <Docs>
        <summary>
          <para>Ends an asynchronous call to send data
      to a connected socket.</para>
        </summary>
        <param name="asyncResult">
          <para>A <see cref="T:System.IAsyncResult" /> object that holds the state information for the asynchronous operation.</para>
        </param>
        <returns>
          <para>A <see cref="T:System.Int32" qualify="true" /> containing the number of bytes sent. </para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <paramref name="asyncResult " />is <see langword="null" />.</exception>
        <exception cref="T:System.ArgumentException">
          <paramref name="asyncResult " /> was not returned by the current instance from a call to the <see cref="M:System.Net.Sockets.Socket.BeginSend(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.AsyncCallback,System.Object)" /> method.</exception>
        <exception cref="T:System.InvalidOperationException">
          <see cref="M:System.Net.Sockets.Socket.EndSend(System.IAsyncResult)" /> was previously called for this operation.</exception>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred during the operation. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para> This method blocks if the asynchronous operation has not completed.</para>
          <para>The <see cref="M:System.Net.Sockets.Socket.EndSend(System.IAsyncResult)" />
method completes an asynchronous request that was started with a call to the
<see cref="M:System.Net.Sockets.Socket.BeginSend(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.AsyncCallback,System.Object)" /> method. The object specified for the 
<paramref name="asyncResult" /> parameter is required to be the same object as was returned 
by the <see cref="M:System.Net.Sockets.Socket.BeginSend(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.AsyncCallback,System.Object)" />
method call that began the
request.</para>
          <para>If the <see cref="M:System.Net.Sockets.Socket.EndSend(System.IAsyncResult)" />
method is invoked via the <see cref="T:System.AsyncCallback" /> delegate specified to the <see cref="M:System.Net.Sockets.Socket.BeginSend(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.AsyncCallback,System.Object)" /> method, the
<paramref name="asyncResult" /> parameter is the <see cref="T:System.IAsyncResult" /> 
argument passed to the
delegate's method.</para>
        </remarks>
        <example>
          <para>For an outline of an asynchronous operation, see
      the <see cref="M:System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object)" /> method.
      For the complete example, which uses the <see cref="M:System.Net.Sockets.Socket.EndSend(System.IAsyncResult)" /> method, see the <see cref="T:System.Net.Sockets.Socket" /> class overview.</para>
        </example>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="BeginSendTo">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance class System.IAsyncResult BeginSendTo(class System.Byte[] buffer, int32 offset, int32 size, valuetype System.Net.Sockets.SocketFlags socketFlags, class System.Net.EndPoint remoteEP, class System.AsyncCallback callback, object state)" />
      <MemberSignature Language="C#" Value="public IAsyncResult BeginSendTo(byte[] buffer, int offset, int size, SocketFlags socketFlags, EndPoint remoteEP, AsyncCallback callback, object state);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.IAsyncResult</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="buffer" Type="System.Byte[]" />
		<Parameter Name="offset" Type="System.Int32" />
		<Parameter Name="size" Type="System.Int32" />
		<Parameter Name="socketFlags" Type="System.Net.Sockets.SocketFlags" />
		<Parameter Name="remoteEP" Type="System.Net.EndPoint" />
		<Parameter Name="callback" Type="System.AsyncCallback" />
		<Parameter Name="state" Type="System.Object" />
	</Parameters>
      <Docs>
        <summary>
          <para> Begins an asynchronous operation to send data to the socket associated with the specified endpoint.</para>
        </summary>
        <param name="buffer">A <see cref="T:System.Byte" qualify="true" /> array storing data to send to the socket.</param>
        <param name="offset">A <see cref="T:System.Int32" qualify="true" /> containing the zero-based position in <paramref name="buffer" /> to begin sending data.</param>
        <param name="size">A <see cref="T:System.Int32" qualify="true" /> containing the number of bytes to send.</param>
        <param name="socketFlags">A bitwise combination of any of the following values defined in the <see cref="T:System.Net.Sockets.SocketFlags" /> enumeration: <see cref="F:System.Net.Sockets.SocketFlags.None" />, <see cref="F:System.Net.Sockets.SocketFlags.DontRoute" />, or <see cref="F:System.Net.Sockets.SocketFlags.OutOfBand" /> .</param>
        <param name=" remoteEP">
          <para>The <see cref="T:System.Net.EndPoint" qualify="true" /> associated with the socket to receive the data.</para>
        </param>
        <param name="callback">A <see cref="T:System.AsyncCallback" /> delegate, or <see langword="null" />.</param>
        <param name=" state">An application-defined object, or <see langword="null" />.</param>
        <returns>
          <para>A <see cref="T:System.IAsyncResult" /> instance that contains information about the asynchronous operation.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="buffer " />is <see langword="null" />.</para>
          <para>-or-</para>
          <para>
            <paramref name="remoteEP " />is <see langword="null" />.</para>
        </exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="offset" /> &lt; 0. </para>
          <para>-or-</para>
          <para>
            <paramref name="offset" /> &gt; <paramref name="buffer" />.Length. </para>
          <para> -or-</para>
          <para>
            <paramref name="size" /> &lt; 0.</para>
          <para>-or-</para>
          <para>
            <paramref name="size" /> &gt; <paramref name="buffer" />.Length - <paramref name="offset" />.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>
            <paramref name="socketFlags" /> is not a valid combination of values.</para>
          <para>-or-</para>
          <para>An error occurred while accessing the socket. </para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <exception cref="T:System.Security.SecurityException">A caller in the call stack does not have the required permissions.</exception>
        <remarks>
          <para>To retrieve the results of the operation and release
      resources allocated by the <see cref="M:System.Net.Sockets.Socket.BeginSendTo(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint,System.AsyncCallback,System.Object)" /> method, call
      the <see cref="M:System.Net.Sockets.Socket.EndSendTo(System.IAsyncResult)" /> method, and specify the
   <see cref="T:System.IAsyncResult" /> object returned by this
      
      method.</para>
          <para>
            <block subset="none" type="note">The <see cref="M:System.Net.Sockets.Socket.EndSendTo(System.IAsyncResult)" /> method should be
   called exactly once for each call to the <see cref="M:System.Net.Sockets.Socket.BeginSendTo(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint,System.AsyncCallback,System.Object)" />
   method.</block>
          </para>
          <para>If the <paramref name="callback" /> parameter is not
<see langword="null" />, the method referenced by <paramref name="callback" /> is invoked 
when the asynchronous operation completes. The <see cref="T:System.IAsyncResult" /> object returned by this method is
passed as the argument to the method referenced by <paramref name="callback" />. The method
referenced by <paramref name="callback" /> can retrieve the results of the operation by calling
the <see cref="M:System.Net.Sockets.Socket.EndSendTo(System.IAsyncResult)" />
method.</para>
          <para> The <paramref name="state" /> parameter
can be any object that the caller wishes to have available for the duration of
the asynchronous operation. This object is available via the
<see cref="P:System.IAsyncResult.AsyncState" /> 
property of the object returned by this
method.</para>
          <block subset="none" type="note">
            <para>For more information, see <see cref="M:System.Net.Sockets.Socket.SendTo(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint)" />, the
   synchronous version of this method.</para>
          </block>
        </remarks>
        <permission cref="T:System.Net.SocketPermission">
          <para>Requires permission to make a connection to the endpoint defined by <paramref name="remoteEP" />. See <see cref="F:System.Net.NetworkAccess.Connect" qualify="true" />.</para>
        </permission>
        <example>
          <para>For an outline of an asynchronous operation, see
      the <see cref="M:System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object)" /> method.
      For
      the complete example, see the <see cref="T:System.Net.Sockets.Socket" /> class overview.</para>
        </example>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="EndSendTo">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 EndSendTo(class System.IAsyncResult asyncResult)" />
      <MemberSignature Language="C#" Value="public int EndSendTo(IAsyncResult asyncResult);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="asyncResult" Type="System.IAsyncResult" />
	</Parameters>
      <Docs>
        <summary>
          <para>Ends an asynchronous call to send data to a socket associated
      with a specified endpoint.</para>
        </summary>
        <param name="asyncResult">
          <para>A <see cref="T:System.IAsyncResult" /> object that holds the state information for the asynchronous operation.</para>
        </param>
        <returns>
          <para>A <see cref="T:System.Int32" qualify="true" /> containing the number of bytes sent. </para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <paramref name="asyncResult " />is <see langword="null" />.</exception>
        <exception cref="T:System.ArgumentException">
          <paramref name="asyncResult " /> was not returned by the current instance from a call to the <see cref="M:System.Net.Sockets.Socket.SendTo(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint)" /> method.</exception>
        <exception cref="T:System.InvalidOperationException">
          <see cref="M:System.Net.Sockets.Socket.EndSendTo(System.IAsyncResult)" /> was previously called for this operation.</exception>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred during the operation. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para> This method blocks if the asynchronous operation has not completed.</para>
          <para>The <see cref="M:System.Net.Sockets.Socket.EndSendTo(System.IAsyncResult)" />
method completes an asynchronous request that was started with a call to the
<see cref="M:System.Net.Sockets.Socket.BeginSendTo(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint,System.AsyncCallback,System.Object)" /> method. The object specified for the 
<paramref name="asyncResult" /> parameter is required to be the same object as was returned 
by the <see cref="M:System.Net.Sockets.Socket.BeginSendTo(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint,System.AsyncCallback,System.Object)" />
method call that began the
request.</para>
          <para>If the <see cref="M:System.Net.Sockets.Socket.EndSendTo(System.IAsyncResult)" />
method is invoked via the <see cref="T:System.AsyncCallback" /> delegate specified to the <see cref="M:System.Net.Sockets.Socket.BeginSendTo(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint,System.AsyncCallback,System.Object)" /> method, the
<paramref name="asyncResult" /> parameter is the <see cref="T:System.IAsyncResult" /> 
argument passed to the
delegate's method.</para>
        </remarks>
        <example>
          <para>For an outline of an asynchronous operation, see
      the <see cref="M:System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object)" /> method.
      For
      the complete example, see the <see cref="T:System.Net.Sockets.Socket" /> class overview.</para>
        </example>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="BeginReceive">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance class System.IAsyncResult BeginReceive(class System.Byte[] buffer, int32 offset, int32 size, valuetype System.Net.Sockets.SocketFlags socketFlags, class System.AsyncCallback callback, object state)" />
      <MemberSignature Language="C#" Value="public IAsyncResult BeginReceive(byte[] buffer, int offset, int size, SocketFlags socketFlags, AsyncCallback callback, object state);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.IAsyncResult</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="buffer" Type="System.Byte[]" />
		<Parameter Name="offset" Type="System.Int32" />
		<Parameter Name="size" Type="System.Int32" />
		<Parameter Name="socketFlags" Type="System.Net.Sockets.SocketFlags" />
		<Parameter Name="callback" Type="System.AsyncCallback" />
		<Parameter Name="state" Type="System.Object" />
	</Parameters>
      <Docs>
        <summary>
          <para> Begins an asynchronous operation to receive data from a socket.</para>
        </summary>
        <param name="buffer">A <see cref="T:System.Byte" qualify="true" /> array to store data received from the socket.</param>
        <param name=" offset">A <see cref="T:System.Int32" qualify="true" /> containing the zero-based position in <paramref name="buffer " />to begin storing the received data.</param>
        <param name=" size">A <see cref="T:System.Int32" qualify="true" /> containing the number of bytes to receive.</param>
        <param name=" socketFlags">A bitwise combination of any of the following values defined in the <see cref="T:System.Net.Sockets.SocketFlags" /> enumeration: <see cref="F:System.Net.Sockets.SocketFlags.None" />, <see cref="F:System.Net.Sockets.SocketFlags.OutOfBand" />, or <see cref="F:System.Net.Sockets.SocketFlags.Peek" />.</param>
        <param name="callback">A <see cref="T:System.AsyncCallback" /> delegate, or <see langword="null" />.</param>
        <param name=" state">An application-defined object, or <see langword="null" />.</param>
        <returns>
          <para>A <see cref="T:System.IAsyncResult" /> instance that contains information about the asynchronous operation.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <paramref name="buffer " />is <see langword="null" />.</exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="offset" /> &lt; 0. </para>
          <para>-or-</para>
          <para>
            <paramref name="offset" /> &gt; <paramref name="buffer" />.Length. </para>
          <para> -or-</para>
          <para>
            <paramref name="size" /> &lt; 0.</para>
          <para>-or-</para>
          <para>
            <paramref name="size" /> &gt; <paramref name="buffer" />.Length - <paramref name="offset" />.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>
            <paramref name="socketFlags" /> is not a valid combination of values.</para>
          <para>-or-</para>
          <para>An error occurred while accessing the socket. </para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>To retrieve the results of the operation and release
      resources allocated by the <see cref="M:System.Net.Sockets.Socket.BeginReceive(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.AsyncCallback,System.Object)" /> method, call
      the <see cref="M:System.Net.Sockets.Socket.EndReceive(System.IAsyncResult)" /> method, and specify the
   <see cref="T:System.IAsyncResult" /> object returned by this
      
      method.</para>
          <para>
            <block subset="none" type="note">The <see cref="M:System.Net.Sockets.Socket.EndReceive(System.IAsyncResult)" /> method should be
   called exactly once for each call to the <see cref="M:System.Net.Sockets.Socket.BeginReceive(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.AsyncCallback,System.Object)" />
   method.</block>
          </para>
          <para>If the <paramref name="callback" /> parameter is not
<see langword="null" />, the method referenced by <paramref name="callback" /> is invoked 
when the asynchronous operation completes. The <see cref="T:System.IAsyncResult" /> object returned by this method is
passed as the argument to the method referenced by <paramref name="callback" />. The method
referenced by <paramref name="callback" /> can retrieve the results of the operation by calling
the <see cref="M:System.Net.Sockets.Socket.EndReceive(System.IAsyncResult)" />
method.</para>
          <para> The <paramref name="state" /> parameter
can be any object that the caller wishes to have available for the duration of
the asynchronous operation. This object is available via the
<see cref="P:System.IAsyncResult.AsyncState" /> 
property of the object returned by this
method.</para>
          <block subset="none" type="note">
            <para>For more information, see <see cref="M:System.Net.Sockets.Socket.Receive(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" />, the
   synchronous version of this method.</para>
          </block>
        </remarks>
        <example>
          <para>For an outline of an asynchronous operation, see
      the <see cref="M:System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object)" /> method.
      For the complete example, which uses the <see cref="M:System.Net.Sockets.Socket.BeginReceive(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.AsyncCallback,System.Object)" /> method, see the <see cref="T:System.Net.Sockets.Socket" /> class overview.</para>
        </example>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="EndReceive">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 EndReceive(class System.IAsyncResult asyncResult)" />
      <MemberSignature Language="C#" Value="public int EndReceive(IAsyncResult asyncResult);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="asyncResult" Type="System.IAsyncResult" />
	</Parameters>
      <Docs>
        <summary>
          <para> Ends an asynchronous call to receive
      data from a
      socket.</para>
        </summary>
        <param name="asyncResult">
          <para>A <see cref="T:System.IAsyncResult" /> object that holds the state information for the asynchronous operation.</para>
        </param>
        <returns>
          <para> A <see cref="T:System.Int32" qualify="true" /> containing the number of bytes received.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <paramref name="asyncResult " />is <see langword="null" />.</exception>
        <exception cref="T:System.ArgumentException">
          <paramref name="asyncResult " /> was not returned by the current instance from a call to the <see cref="M:System.Net.Sockets.Socket.BeginReceive(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.AsyncCallback,System.Object)" /> method.</exception>
        <exception cref="T:System.InvalidOperationException">
          <see cref="M:System.Net.Sockets.Socket.EndReceive(System.IAsyncResult)" /> was previously called for this operation.</exception>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred during the operation. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para> This method blocks if the asynchronous operation has not completed.</para>
          <para>The <see cref="M:System.Net.Sockets.Socket.EndReceive(System.IAsyncResult)" />
method completes an asynchronous request that was started with a call to the
<see cref="M:System.Net.Sockets.Socket.BeginReceive(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.AsyncCallback,System.Object)" /> method. The object specified for the 
<paramref name="asyncResult" /> parameter is required to be the same object as was returned 
by the <see cref="M:System.Net.Sockets.Socket.BeginReceive(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.AsyncCallback,System.Object)" />
method call that began the
request.</para>
          <para>If the <see cref="M:System.Net.Sockets.Socket.EndReceive(System.IAsyncResult)" />
method is invoked via the <see cref="T:System.AsyncCallback" /> delegate specified to the <see cref="M:System.Net.Sockets.Socket.BeginReceive(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.AsyncCallback,System.Object)" /> method, the
<paramref name="asyncResult" /> parameter is the <see cref="T:System.IAsyncResult" /> 
argument passed to the
delegate's method.</para>
        </remarks>
        <example>
          <para>For an outline of an asynchronous operation, see
      the <see cref="M:System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object)" /> method.
      For the complete example, which uses the <see cref="M:System.Net.Sockets.Socket.EndReceive(System.IAsyncResult)" /> method, see the <see cref="T:System.Net.Sockets.Socket" /> class overview.</para>
        </example>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="BeginReceiveFrom">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance class System.IAsyncResult BeginReceiveFrom(class System.Byte[] buffer, int32 offset, int32 size, valuetype System.Net.Sockets.SocketFlags socketFlags, class System.Net.EndPoint&amp; remoteEP, class System.AsyncCallback callback, object state)" />
      <MemberSignature Language="C#" Value="public IAsyncResult BeginReceiveFrom(byte[] buffer, int offset, int size, SocketFlags socketFlags, ref EndPoint remoteEP, AsyncCallback callback, object state);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.IAsyncResult</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="buffer" Type="System.Byte[]" />
		<Parameter Name="offset" Type="System.Int32" />
		<Parameter Name="size" Type="System.Int32" />
		<Parameter Name="socketFlags" Type="System.Net.Sockets.SocketFlags" />
		<Parameter Name="remoteEP" Type="System.Net.EndPoint&amp;" RefType="ref" />
		<Parameter Name="callback" Type="System.AsyncCallback" />
		<Parameter Name="state" Type="System.Object" />
	</Parameters>
      <Docs>
        <summary>
          <para> Begins an asynchronous operation to receive data from a socket and,
      for connectionless protocols, store the endpoint associated with the socket that
      sent the data.</para>
        </summary>
        <param name="buffer">A <see cref="T:System.Byte" qualify="true" /> array to store data received from the socket.</param>
        <param name=" offset">A <see cref="T:System.Int32" qualify="true" /> containing the zero-based position in <paramref name="buffer " />to begin storing the received data.</param>
        <param name=" size">A <see cref="T:System.Int32" qualify="true" /> containing the number of bytes to receive.</param>
        <param name=" socketFlags">A bitwise combination of any of the following values defined in the <see cref="T:System.Net.Sockets.SocketFlags" /> enumeration: <see cref="F:System.Net.Sockets.SocketFlags.None" />, <see cref="F:System.Net.Sockets.SocketFlags.OutOfBand" />, or <see cref="F:System.Net.Sockets.SocketFlags.Peek" /> .</param>
        <param name=" remoteEP">
          <para>An instance of a class derived from the <see cref="T:System.Net.EndPoint" qualify="true" /> class, which contains the endpoint associated with the socket that sent the data.</para>
        </param>
        <param name="callback">A <see cref="T:System.AsyncCallback" /> delegate, or <see langword="null" />.</param>
        <param name=" state">An application-defined object, or <see langword="null" />.</param>
        <returns>
          <para>A <see cref="T:System.IAsyncResult" /> instance that contains information about the asynchronous operation.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="buffer " />is <see langword="null" />.</para>
          <para>-or-</para>
          <para>
            <paramref name="remoteEP " />is <see langword="null" />.</para>
        </exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="offset" /> &lt; 0. </para>
          <para>-or-</para>
          <para>
            <paramref name="offset" /> &gt; <paramref name="buffer" />.Length. </para>
          <para> -or-</para>
          <para>
            <paramref name="size" /> &lt; 0.</para>
          <para>-or-</para>
          <para>
            <paramref name="size" /> &gt; <paramref name="buffer" />.Length - <paramref name="offset" />.</para>
        </exception>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>
            <paramref name="socketFlags" /> is not a valid combination of values.</para>
          <para>-or-</para>
          <para>An error occurred while accessing the socket. </para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <exception cref="T:System.Security.SecurityException">A caller in the call stack does not have the required permissions.</exception>
        <remarks>
          <para>To retrieve the results of the operation and release
      resources allocated by the <see cref="M:System.Net.Sockets.Socket.BeginReceiveFrom(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint@,System.AsyncCallback,System.Object)" /> method, call
      the <see cref="M:System.Net.Sockets.Socket.EndReceiveFrom(System.IAsyncResult,System.Net.EndPoint@)" /> method, and specify the
   <see cref="T:System.IAsyncResult" /> object returned by this
      
      method.</para>
          <para>
            <block subset="none" type="note">The <see cref="M:System.Net.Sockets.Socket.EndReceiveFrom(System.IAsyncResult,System.Net.EndPoint@)" /> method should be
   called exactly once for each call to the <see cref="M:System.Net.Sockets.Socket.BeginReceiveFrom(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint@,System.AsyncCallback,System.Object)" />
   method.</block>
          </para>
          <para>If the <paramref name="callback" /> parameter is not
<see langword="null" />, the method referenced by <paramref name="callback" /> is invoked 
when the asynchronous operation completes. The <see cref="T:System.IAsyncResult" /> object returned by this method is
passed as the argument to the method referenced by <paramref name="callback" />. The method
referenced by <paramref name="callback" /> can retrieve the results of the operation by calling
the <see cref="M:System.Net.Sockets.Socket.EndReceiveFrom(System.IAsyncResult,System.Net.EndPoint@)" />
method.</para>
          <para> The <paramref name="state" /> parameter
can be any object that the caller wishes to have available for the duration of
the asynchronous operation. This object is available via the
<see cref="P:System.IAsyncResult.AsyncState" /> 
property of the object returned by this
method.</para>
          <block subset="none" type="note">
            <para>For more information, see <see cref="M:System.Net.Sockets.Socket.ReceiveFrom(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint@)" />, the
   synchronous version of this method.</para>
          </block>
        </remarks>
        <permission cref="T:System.Net.SocketPermission">
          <para>Requires permission to accept a connection on the endpoint defined by the <see cref="P:System.Net.Sockets.Socket.LocalEndPoint" /> property of the current instance. See <see cref="F:System.Net.NetworkAccess.Accept" qualify="true" />.</para>
          <para>Requires permission to make a connection to the endpoint defined by <paramref name="remoteEP" />. See <see cref="F:System.Net.NetworkAccess.Connect" qualify="true" />.</para>
        </permission>
        <example>
          <para>For an outline of an asynchronous operation, see
      the <see cref="M:System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object)" /> method.
      For the complete example, see <see cref="T:System.Net.Sockets.Socket" />.</para>
        </example>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="EndReceiveFrom">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance int32 EndReceiveFrom(class System.IAsyncResult asyncResult, class System.Net.EndPoint&amp; endPoint)" />
      <MemberSignature Language="C#" Value="public int EndReceiveFrom(IAsyncResult asyncResult, ref EndPoint endPoint);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="asyncResult" Type="System.IAsyncResult" />
		<Parameter Name="endPoint" Type="System.Net.EndPoint&amp;" RefType="ref" />
	</Parameters>
      <Docs>
        <summary>
          <para>Ends an asynchronous call to receive
      data from a socket and store the endpoint associated with the socket that
      sent the data.</para>
        </summary>
        <param name="asyncResult">
          <para>A <see cref="T:System.IAsyncResult" /> object that holds the state information for the asynchronous operation.</para>
        </param>
        <param name=" endPoint">A reference to the <see cref="T:System.Net.EndPoint" qualify="true" /> associated with the socket that sent the data. </param>
        <returns>
          <para>A <see cref="T:System.Int32" qualify="true" /> containing the number of bytes received.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <paramref name="asyncResult " />is <see langword="null" />.</exception>
        <exception cref="T:System.ArgumentException">
          <paramref name="asyncResult " /> was not returned by the current instance from a call to the <see cref="M:System.Net.Sockets.Socket.BeginReceiveFrom(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint@,System.AsyncCallback,System.Object)" /> method.</exception>
        <exception cref="T:System.InvalidOperationException">
          <see cref="M:System.Net.Sockets.Socket.EndReceiveFrom(System.IAsyncResult,System.Net.EndPoint@)" /> was previously called for this operation.</exception>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred during the operation. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para> This method blocks if the asynchronous operation has not completed.</para>
          <para>The <see cref="M:System.Net.Sockets.Socket.EndReceiveFrom(System.IAsyncResult,System.Net.EndPoint@)" />
method completes an asynchronous request that was started with a call to the
<see cref="M:System.Net.Sockets.Socket.BeginReceiveFrom(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint@,System.AsyncCallback,System.Object)" /> method. The object specified for the 
<paramref name="asyncResult" /> parameter is required to be the same object as was returned 
by the <see cref="M:System.Net.Sockets.Socket.BeginReceiveFrom(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint@,System.AsyncCallback,System.Object)" />
method call that began the
request.</para>
          <para>If the <see cref="M:System.Net.Sockets.Socket.EndReceiveFrom(System.IAsyncResult,System.Net.EndPoint@)" />
method is invoked via the <see cref="T:System.AsyncCallback" /> delegate specified to the <see cref="M:System.Net.Sockets.Socket.BeginReceiveFrom(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint@,System.AsyncCallback,System.Object)" /> method, the
<paramref name="asyncResult" /> parameter is the <see cref="T:System.IAsyncResult" /> 
argument passed to the
delegate's method.</para>
        </remarks>
        <example>
          <para>For an outline of an asynchronous operation, see
      the <see cref="M:System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object)" /> method.
      For
      the complete example, see the <see cref="T:System.Net.Sockets.Socket" /> class overview.</para>
        </example>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="BeginAccept">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance class System.IAsyncResult BeginAccept(class System.AsyncCallback callback, object state)" />
      <MemberSignature Language="C#" Value="public IAsyncResult BeginAccept(AsyncCallback callback, object state);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.IAsyncResult</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="callback" Type="System.AsyncCallback" />
		<Parameter Name="state" Type="System.Object" />
	</Parameters>
      <Docs>
        <summary>
          <para>Begins an asynchronous operation to accept an incoming connection request.</para>
        </summary>
        <param name="callback">A <see cref="T:System.AsyncCallback" /> delegate, or <see langword="null" />.</param>
        <param name=" state">An application-defined object, or <see langword="null" />.</param>
        <returns>
          <para>A <see cref="T:System.IAsyncResult" /> instance that contains information about the asynchronous operation.</para>
        </returns>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred while starting the operation. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>To retrieve the results of the operation and release
      resources allocated by the <see cref="M:System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object)" /> method, call
      the <see cref="M:System.Net.Sockets.Socket.EndAccept(System.IAsyncResult)" /> method, and specify the
   <see cref="T:System.IAsyncResult" /> object returned by this
      method.</para>
          <para>
            <block subset="none" type="note">The <see cref="M:System.Net.Sockets.Socket.EndAccept(System.IAsyncResult)" /> method should be
   called exactly once for each call to the <see cref="M:System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object)" />
   method.</block>
          </para>
          <para>If the <paramref name="callback" /> parameter is not
<see langword="null" />, the method referenced by <paramref name="callback" /> is invoked 
when the asynchronous operation completes. The <see cref="T:System.IAsyncResult" /> object returned by this method is
passed as the argument to the method referenced by <paramref name="callback" />. The method
referenced by <paramref name="callback" /> can retrieve the results of the operation by calling
the <see cref="M:System.Net.Sockets.Socket.EndAccept(System.IAsyncResult)" />
method.</para>
          <para> The <paramref name="state" /> parameter
can be any object that the caller wishes to have available for the duration of
the asynchronous operation. This object is available via the
<see cref="P:System.IAsyncResult.AsyncState" /> 
property of the object returned by this
method.</para>
          <para>To determine the connection status, check the <see cref="P:System.Net.Sockets.Socket.Connected" /> property, or use either the <see cref="M:System.Net.Sockets.Socket.Poll(System.Int32,System.Net.Sockets.SelectMode)" />
or <see cref="M:System.Net.Sockets.Socket.Select(System.Collections.IList,System.Collections.IList,System.Collections.IList,System.Int32)" />
method.</para>
          <block subset="none" type="note">
            <para>For more information, see <see cref="M:System.Net.Sockets.Socket.Accept" />, the
   synchronous version of this method.</para>
          </block>
        </remarks>
        <example>
          <para> The following excerpt from the <see cref="T:System.Net.Sockets.Socket" /> class overview
   example outlines an asynchronous accept operation. </para>
          <code lang="C#">public class Server
{
  static void Main()
  {
    .
    .
    .
    listenSocket.BeginAccept(
      new AsyncCallback(Server.acceptCallback),
      listenSocket);
    .
    .
    .
    // EndAccept can be called here
    .
    .
    .
  }

  public static void
    acceptCallback(IAsyncResult asyncAccept)
  {
    Socket listenSocket =
      (Socket)asyncAccept.AsyncState;

    Socket serverSocket =
      listenSocket.EndAccept(asyncAccept);

    serverSocket.BeginReceive(...);
    .
    .
    .
  }
}
</code>
        </example>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="EndAccept">
      <MemberSignature Language="ILASM" Value=".method public hidebysig instance class System.Net.Sockets.Socket EndAccept(class System.IAsyncResult asyncResult)" />
      <MemberSignature Language="C#" Value="public Socket EndAccept(IAsyncResult asyncResult);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Net.Sockets.Socket</ReturnType>
      </ReturnValue>
      <Parameters>
		<Parameter Name="asyncResult" Type="System.IAsyncResult" />
	</Parameters>
      <Docs>
        <summary>
          <para> Ends an asynchronous call to accept
      an incoming connection
      request.</para>
        </summary>
        <param name="asyncResult">A <see cref="T:System.IAsyncResult" /> object that holds the state information for the asynchronous operation.</param>
        <returns>
          <para> A new connected <see cref="T:System.Net.Sockets.Socket" />
instance.</para>
        </returns>
        <exception cref="T:System.ArgumentNullException">
          <paramref name="asyncResult " />is <see langword="null" />.</exception>
        <exception cref="T:System.ArgumentException">
          <paramref name="asyncResult " /> was not returned by the current instance from a call to the <see cref="M:System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object)" /> method.</exception>
        <exception cref="T:System.InvalidOperationException">
          <see cref="M:System.Net.Sockets.Socket.EndAccept(System.IAsyncResult)" /> was previously called for this operation.</exception>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred during the operation. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para> This method blocks if the asynchronous operation has not completed.</para>
          <para>The <see cref="M:System.Net.Sockets.Socket.EndAccept(System.IAsyncResult)" />
method completes an asynchronous request that was started with a call to the
<see cref="M:System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object)" /> method. The object specified for the 
<paramref name="asyncResult" /> parameter is required to be the same object as was returned 
by the <see cref="M:System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object)" />
method call that began the
request.</para>
          <para>If the <see cref="M:System.Net.Sockets.Socket.EndAccept(System.IAsyncResult)" />
method is invoked via the <see cref="T:System.AsyncCallback" /> delegate specified to the <see cref="M:System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object)" /> method, the
<paramref name="asyncResult" /> parameter is the <see cref="T:System.IAsyncResult" /> 
argument passed to the
delegate's method.</para>
        </remarks>
        <example>
          <para>For an outline of an asynchronous operation, see
      the <see cref="M:System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object)" /> method.
      For the complete example, which uses the <see cref="M:System.Net.Sockets.Socket.EndAccept(System.IAsyncResult)" /> method, see the <see cref="T:System.Net.Sockets.Socket" /> class overview.</para>
        </example>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="ILASM" Value="public rtspecialname specialname instance void .ctor(valuetype System.Net.Sockets.AddressFamily addressFamily, valuetype System.Net.Sockets.SocketType socketType, valuetype System.Net.Sockets.ProtocolType protocolType)" />
      <MemberSignature Language="C#" Value="public Socket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType);" />
      <MemberType>Constructor</MemberType>
      <ReturnValue />
      <Parameters>
		<Parameter Name="addressFamily" Type="System.Net.Sockets.AddressFamily" />
		<Parameter Name="socketType" Type="System.Net.Sockets.SocketType" />
		<Parameter Name="protocolType" Type="System.Net.Sockets.ProtocolType" />
	</Parameters>
      <Docs>
        <summary>
          <para> Constructs and initializes a new instance of the <see cref="T:System.Net.Sockets.Socket" /> class.
   </para>
        </summary>
        <param name="addressFamily">One of the values defined in the <see cref="T:System.Net.Sockets.AddressFamily" /> enumeration. </param>
        <param name="socketType">One of the values defined in the <see cref="T:System.Net.Sockets.SocketType" /> enumeration. </param>
        <param name="protocolType">One of the values defined in the <see cref="T:System.Net.Sockets.ProtocolType" /> enumeration. </param>
        <exception cref="T:System.Net.Sockets.SocketException">
          <para>The combination of <paramref name="addressFamily" />, <paramref name="socketType" />, and <paramref name="protocolType" /> is invalid.</para>
          <para>-or-</para>
          <para>An error occurred while creating the socket. </para>
          <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para>
        </exception>
        <remarks>
          <para> The <paramref name="addressFamily " />parameter
   specifies the addressing scheme used by the current instance, the <paramref name="socketType    " />parameter specifies the socket type of the current instance, and the
<paramref name="protocolType" /> parameter 
   specifies the protocol
   used by the current instance. The three parameters are not independent. Some
   address families restrict which protocols are used, and often the socket type is
   determined by the protocol. When the specified
   values are not a valid combination, a <see cref="T:System.Net.Sockets.SocketException" /> exception
   is thrown.</para>
          <para>Using the <see langword="Unknown" /> member of either the
<see cref="T:System.Net.Sockets.AddressFamily" /> or <see cref="T:System.Net.Sockets.ProtocolType" /> enumeration, results 
in a <see cref="T:System.Net.Sockets.SocketException" />
exception being thrown.</para>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Connected">
      <MemberSignature Language="ILASM" Value=".property bool Connected { public hidebysig specialname instance bool get_Connected() }" />
      <MemberSignature Language="C#" Value="public bool Connected { get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para> Gets a <see cref="T:System.Boolean" /> value indicating whether the current instance is connected.
   </para>
        </summary>
        <value>
          <para>
            <see langword="true" /> indicates that 
   the current instance was connected at
   the time of the
   last I/O operation;
<see langword="false" /> indicates that the 
   current instance is not connected.</para>
        </value>
        <remarks>
          <para> This property is read-only.
      </para>
          <para>When this property returns <see langword="true" />, the current instance was
   connected at the time of the last I/O operation; it might not still be connected.
   When this property returns <see langword="false" />, the current instance was
   never connected or is not currently connected.</para>
          <para>The current instance is considered connected when
   the <see cref="P:System.Net.Sockets.Socket.RemoteEndPoint" />
   property contains a valid endpoint.</para>
          <para>
            <block subset="none" type="note">The <see cref="M:System.Net.Sockets.Socket.Accept" /> and <see cref="M:System.Net.Sockets.Socket.Connect(System.Net.EndPoint)" /> methods,
and their asynchronous counterparts set this
property.</block>
          </para>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="AddressFamily">
      <MemberSignature Language="ILASM" Value=".property valuetype System.Net.Sockets.AddressFamily AddressFamily { public hidebysig specialname instance valuetype System.Net.Sockets.AddressFamily get_AddressFamily() }" />
      <MemberSignature Language="C#" Value="public AddressFamily AddressFamily { get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Net.Sockets.AddressFamily</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para> Gets the address family of the current instance.
      </para>
        </summary>
        <value>
          <para>One of the values defined in
      the <see cref="T:System.Net.Sockets.AddressFamily" /> enumeration.</para>
        </value>
        <remarks>
          <para>This property is read-only.</para>
          <para>This property is set by the constructor for the current instance. The value of this property specifies the addressing scheme used by the current instance to resolve an address.</para>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="SocketType">
      <MemberSignature Language="ILASM" Value=".property valuetype System.Net.Sockets.SocketType SocketType { public hidebysig specialname instance valuetype System.Net.Sockets.SocketType get_SocketType() }" />
      <MemberSignature Language="C#" Value="public SocketType SocketType { get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Net.Sockets.SocketType</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para> Gets the socket type of the current instance.
      </para>
        </summary>
        <value>
          <para>One of the values defined in
      the <see cref="T:System.Net.Sockets.SocketType" /> enumeration.</para>
        </value>
        <remarks>
          <para>This property is read-only.</para>
          <para>This property is set by the constructor for the current instance.</para>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="ProtocolType">
      <MemberSignature Language="ILASM" Value=".property valuetype System.Net.Sockets.ProtocolType ProtocolType { public hidebysig specialname instance valuetype System.Net.Sockets.ProtocolType get_ProtocolType() }" />
      <MemberSignature Language="C#" Value="public ProtocolType ProtocolType { get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Net.Sockets.ProtocolType</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para> Gets the protocol type of the current instance.
      </para>
        </summary>
        <value>
          <para>One of the values defined in
      the <see cref="T:System.Net.Sockets.ProtocolType" /> enumeration. </para>
        </value>
        <remarks>
          <para>This property is read-only.</para>
          <para>This property is set by the constructor for the current instance. The value of
      this property specifies the protocol used by the current instance.</para>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Available">
      <MemberSignature Language="ILASM" Value=".property int32 Available { public hidebysig specialname instance int32 get_Available() }" />
      <MemberSignature Language="C#" Value="public int Available { get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para> Gets the amount
      of data available to be read in a single <see cref="M:System.Net.Sockets.Socket.Receive(System.Byte[],System.Int32,System.Net.Sockets.SocketFlags)" /> or <see cref="M:System.Net.Sockets.Socket.ReceiveFrom(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint@)" />
      call.
      </para>
        </summary>
        <value>
          <para> A <see cref="T:System.Int32" qualify="true" /> containing the number of bytes of data that are
   available to be read.</para>
        </value>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred while accessing the socket. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para>This property is read-only.</para>
          <para>When the current instance is stream-oriented (for example, the <see cref="F:System.Net.Sockets.SocketType.Stream" /> socket type), the available data
   is generally the total amount of data queued on the current instance.</para>
          <para>When the current instance is message-oriented (for example, the <see cref="F:System.Net.Sockets.SocketType.Dgram" /> socket type), the available data
is the first message in the input queue.</para>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="LocalEndPoint">
      <MemberSignature Language="ILASM" Value=".property class System.Net.EndPoint LocalEndPoint { public hidebysig specialname instance class System.Net.EndPoint get_LocalEndPoint() }" />
      <MemberSignature Language="C#" Value="public EndPoint LocalEndPoint { get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Net.EndPoint</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para> Gets the local endpoint associated with the current instance.
      </para>
        </summary>
        <value>
          <para> The local <see cref="T:System.Net.EndPoint" qualify="true" />
associated with the current
instance.</para>
        </value>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred while accessing the socket. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para> This property is read-only. </para>
          <para>This property contains the network connection information for the
      current instance. </para>
          <para>
            <block subset="none" type="note">The <see cref="M:System.Net.Sockets.Socket.Bind(System.Net.EndPoint)" /> and
<see cref="M:System.Net.Sockets.Socket.Accept" /> methods, 
   and their
   asynchronous counterparts set this property. If not previously set,
   the <see cref="M:System.Net.Sockets.Socket.Connect(System.Net.EndPoint)" /> and <see cref="M:System.Net.Sockets.Socket.SendTo(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.Net.EndPoint)" /> methods, and their asynchronous counterparts set this property.
</block>
          </para>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="RemoteEndPoint">
      <MemberSignature Language="ILASM" Value=".property class System.Net.EndPoint RemoteEndPoint { public hidebysig specialname instance class System.Net.EndPoint get_RemoteEndPoint() }" />
      <MemberSignature Language="C#" Value="public EndPoint RemoteEndPoint { get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Net.EndPoint</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para> Gets the remote endpoint associated with the current instance.
      </para>
        </summary>
        <value>
          <para> The remote <see cref="T:System.Net.EndPoint" qualify="true" />
associated with the current instance.</para>
        </value>
        <exception cref="T:System.Net.Sockets.SocketException">An error occurred while accessing the socket. <para>
            <block subset="none" type="note">For additional information on causes of the <see langword=" SocketException" />, see the <see cref="T:System.Net.Sockets.SocketException" qualify="true" /> class.</block>
          </para></exception>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para> This property
      is read-only.</para>
          <para> This property contains the network
      connection information associated with the socket communicating with the current
      instance.</para>
          <para> There is no remote endpoint
      associated with a socket in the listening state. An attempt to access the
   <see cref="P:System.Net.Sockets.Socket.RemoteEndPoint" /> 
   property causes a <see cref="T:System.Net.Sockets.SocketException" /> exception to be
   thrown.</para>
          <para>
            <block subset="none" type="note">The <see cref="M:System.Net.Sockets.Socket.Accept" /> and <see cref="M:System.Net.Sockets.Socket.Connect(System.Net.EndPoint)" /> methods, and their asynchronous 
counterparts set this property. </block>
          </para>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
    <Member MemberName="Handle">
      <MemberSignature Language="ILASM" Value=".property valuetype System.IntPtr Handle { public hidebysig specialname instance valuetype System.IntPtr get_Handle() }" />
      <MemberSignature Language="C#" Value="public IntPtr Handle { get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.IntPtr</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para> Gets the operating system handle for the current instance.
      </para>
        </summary>
        <value>
          <para>A <see cref="T:System.IntPtr" qualify="true" /> containing the operating system handle for the current instance.</para>
        </value>
        <remarks>
          <para>This property is read-only.</para>
        </remarks>
        <permission cref="T:System.Security.Permissions.SecurityPermission"> Requires permission to access unmanaged code. See <see cref="F:System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode" qualify="true" />.</permission>
      </Docs>
      <Excluded>1</Excluded>
      <ExcludedLibrary>RuntimeInfrastructure</ExcludedLibrary>
    </Member>
    <Member MemberName="Blocking">
      <MemberSignature Language="ILASM" Value=".property bool Blocking { public hidebysig specialname instance bool get_Blocking() public hidebysig specialname instance void set_Blocking(bool value) }" />
      <MemberSignature Language="C#" Value="public bool Blocking { get; set; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para> Gets or sets a <see cref="T:System.Boolean" qualify="true" /> value that indicates whether the socket is in blocking mode.
   </para>
        </summary>
        <value>
          <para>
            <see langword="true" /> indicates that
   the current instance is in blocking mode;
<see langword="false" /> indicates that the current instance is in 
   non-blocking mode. </para>
        </value>
        <exception cref="T:System.ObjectDisposedException">The current instance has been disposed.</exception>
        <remarks>
          <para> Blocking is when a method waits to complete an operation before returning. Sockets are created in blocking mode
      by default. </para>
          <para> Except for when the current instance has been disposed, no notification is given when an attempt to change
      the value of this property fails.</para>
        </remarks>
      </Docs>
      <Excluded>0</Excluded>
    </Member>
  <Member MemberName="SupportsIPv4">
      <MemberSignature Language="C#" Value="public static bool SupportsIPv4 { get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>To be added.</summary>
        <value>To be added.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
  <Member MemberName="SupportsIPv6">
      <MemberSignature Language="C#" Value="public static bool SupportsIPv6 { get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>To be added.</summary>
        <value>To be added.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
  </Members>
  <TypeExcluded>0</TypeExcluded>
</Type>
