public void Connect(IPEndPoint remoteEP)
{
Reset();
sock.BeginConnect(remoteEP, onConnect, null);
asyncEvent.WaitOne(MaxWaitTime, false);
Verify();
}
/// <summary>
/// Initates an asynchronous connection to the server whose network
/// endpoint is specified.
/// </summary>
/// <param name="endPoint">The network endpoint.</param>
/// <param name="callback">The delegate to call when the operation completes (or <c>null</c>).</param>
/// <param name="state">Application state.</param>
/// <returns>The async result used to track the operation.</returns>
public IAsyncResult BeginConnect(IPEndPoint endPoint, AsyncCallback callback, object state)
{
using (TimedLock.Lock(this))
{
sock = new EnhancedSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
return(sock.BeginConnect(endPoint, callback, state));
}
}
/// <summary>
/// Initiates a network connection to the message router at the
/// specified network endpoint and then initiates the transmission
/// of the message once the connection is established.
/// </summary>
/// <param name="ep">The remote router's endpoint.</param>
/// <param name="msg">The message to be sent (or <c>null</c>).</param>
public void Connect(IPEndPoint ep, Msg msg)
{
using (TimedLock.Lock(router.SyncRoot))
{
Assertion.Test(sock == null);
sock = new EnhancedSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
localEP = new ChannelEP(Transport.Tcp, router.NormalizeEP(router.TcpEP));
sock.NoDelay = !router.TcpDelay;
sock.SendBufferSize = router.TcpSockConfig.SendBufferSize;
sock.ReceiveBufferSize = router.TcpSockConfig.ReceiveBufferSize;
if (router.FragmentTcp)
{
sock.SendMax = 1;
sock.ReceiveMax = 1;
}
// Queue the channel initialization message and the message passed
Msg initMsg;
initMsg = new TcpInitMsg(router.RouterEP, new MsgRouterInfo(router), isUplink, router.TcpEP.Port);
initMsg._TTL = 1;
Serialize(initMsg);
Enqueue(initMsg);
try
{
SetLastAccess();
remoteEP = new ChannelEP(Transport.Tcp, router.NormalizeEP(ep));
if (msg != null)
{
msg._SetToChannel(remoteEP);
msg._SetFromChannel(localEP);
msg._Trace(router, 2, "TCP: Queue", null);
Serialize(msg);
Enqueue(msg);
}
router.Trace(2, "TCP: Outbound", "LocalEP=" + localEP.NetEP.ToString() + " remoteEP=" + remoteEP.NetEP.ToString(), null);
sock.BeginConnect(remoteEP.NetEP, new AsyncCallback(OnConnect), null);
}
catch (Exception e)
{
router.Trace(string.Format(null, "TCP: Connect Failed [{0}]", ep), e);
router.OnTcpClose(this);
Close();
}
}
}
/// <summary>
/// Initates an asynchronous connection to the server whose host and
/// port are specified by a URI.
/// </summary>
/// <param name="uri">The uri.</param>
/// <param name="callback">The delegate to call when the operation completes (or <c>null</c>).</param>
/// <param name="state">Application state.</param>
/// <returns>The async result used to track the operation.</returns>
public IAsyncResult BeginConnect(string uri, AsyncCallback callback, object state)
{
var u = new Uri(uri);
using (TimedLock.Lock(this))
{
if (sock != null)
{
throw new InvalidOperationException(AlreadyConnectedMsg);
}
sock = new EnhancedSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
return(sock.BeginConnect(u.Host, u.Port, callback, state));
}
}
public void EnhancedSocket_Async_ConnectToHost()
{
EnhancedSocket sock;
IAsyncResult ar;
IPAddress addr;
sock = new EnhancedSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
ar = sock.BeginConnect("www.google.com", 80, null, null);
sock.EndConnect(ar);
addr = ((IPEndPoint)sock.RemoteEndPoint).Address;
sock.Close();
sock = new EnhancedSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
ar = sock.BeginConnect(addr.ToString(), 80, null, null);
sock.EndConnect(ar);
sock.Close();
}
/// <summary>
/// Initiates an asynchronous operation to establish a connection with a remote endpoint.
/// </summary>
/// <param name="remoteBinding">Specifies the remote endpoint.</param>
/// <param name="packet">The packet to be transmitted for UDP sockets, ignored for TCP.</param>
/// <param name="callback">The delegate to be called when the operation completes (or <c>null</c>).</param>
/// <param name="state">Application specific state.</param>
/// <returns>
/// An <see cref="IAsyncResult" /> instance to be used to track the progress of the
/// operation and to eventually to be passed to the <see cref="EndConnect" /> method.
/// </returns>
/// <exception cref="InvalidOperationException">Thrown if the socket is already been connected.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="remoteBinding" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown for UDP sockets when <paramref name="packet" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown if <paramref name="packet" /> is empty.</exception>
/// <remarks>
/// <para>
/// Due to quirks in how UDP sockets work in Silverlight and Windows Phone, a packet must be
/// transmitted to remote endpoint as part of establishing a connection. Use the <paramref name="packet" />
/// parameter to pass the non-empty array of bytes to be transmitted. This parameter is ignored
/// for TCP connections.
/// </para>
/// <note>
/// All successful calls to <see cref="BeginConnect" /> should be eventually matched with a call to <see cref="EndConnect" />.
/// </note>
/// </remarks>
public IAsyncResult BeginConnect(NetworkBinding remoteBinding, byte[] packet, AsyncCallback callback, object state)
{
if (remoteBinding == null)
{
throw new ArgumentNullException("remoteBinding");
}
lock (syncLock)
{
this.remoteBinding = remoteBinding;
if (isTcp)
{
return(sock.BeginConnect(remoteBinding, callback, state));
}
else
{
if (isUdpConnected)
{
throw new InvalidOperationException("Socket is already connected.");
}
const string packetError = "[LiteSocket] requires a valid [packet] when connecting a UDP socket.";
if (packet == null)
{
throw new ArgumentNullException("packet", packetError);
}
if (packet.Length == 0)
{
throw new ArgumentNullException("packet", packetError);
}
udpConnectPacket = packet;
return(Dns.BeginGetHostAddresses(remoteBinding.HostOrAddress, callback, state));
}
}
}
