public void Constructor4() { Socket s; IPEndPoint localEP; IPEndPoint clientEP; clientEP = new IPEndPoint(IPAddress.Loopback, NetworkHelpers.FindFreePort()); using (MyUdpClient client = new MyUdpClient(clientEP)) { s = client.Client; Assert.IsNotNull(s, "#A:Client"); Assert.AreEqual(AddressFamily.InterNetwork, s.AddressFamily, "#A:Client:AddressFamily"); Assert.IsFalse(s.Connected, "#A:Client:Connected"); Assert.IsTrue(s.IsBound, "#A:Client:IsBound"); Assert.AreEqual(ProtocolType.Udp, s.ProtocolType, "#A:Client:ProtocolType"); Assert.AreEqual(SocketType.Dgram, s.SocketType, "#A:Client:SocketType"); Assert.IsFalse(client.Active, "#A:Active"); Assert.IsFalse(client.DontFragment, "#A:DontFragment"); Assert.IsFalse(client.EnableBroadcast, "#A:EnableBroadcast"); //Assert.IsFalse (client.ExclusiveAddressUse, "#A:ExclusiveAddressUse"); Assert.IsTrue(client.MulticastLoopback, "#A:MulticastLoopback"); //Assert.AreEqual (32, client.Ttl, "#A:Ttl"); localEP = s.LocalEndPoint as IPEndPoint; Assert.IsNotNull(localEP, "#A:Client:LocalEndpoint"); Assert.IsFalse(object.ReferenceEquals(clientEP, localEP), "#A:Client:LocalEndPoint/ReferenceEquality"); Assert.AreEqual(clientEP.Address, localEP.Address, "#A:Client:LocalEndPoint/Address"); Assert.AreEqual(clientEP.AddressFamily, localEP.AddressFamily, "#A:Client:LocalEndPoint/AddressFamily"); Assert.AreEqual(clientEP.Port, localEP.Port, "#A:Client:LocalEndPoint/Port"); } }
public void Constructor5_IPv6() { MyUdpClient client; Socket s; IPEndPoint localEP; client = new MyUdpClient(IPEndPoint.MaxPort, AddressFamily.InterNetworkV6); s = client.Client; Assert.IsNotNull(s, "#B:Client"); Assert.AreEqual(AddressFamily.InterNetworkV6, s.AddressFamily, "#B:Client:AddressFamily"); Assert.IsFalse(s.Connected, "#B:Client:Connected"); #if NET_2_0 Assert.IsTrue(s.IsBound, "#B:Client:IsBound"); #endif Assert.AreEqual(ProtocolType.Udp, s.ProtocolType, "#B:Client:ProtocolType"); Assert.AreEqual(SocketType.Dgram, s.SocketType, "#B:Client:SocketType"); Assert.IsFalse(client.Active, "#B:Active"); #if NET_2_0 //Assert.IsFalse (client.DontFragment, "#B:DontFragment"); Assert.IsFalse(client.EnableBroadcast, "#B:EnableBroadcast"); //Assert.IsFalse (client.ExclusiveAddressUse, "#B:ExclusiveAddressUse"); Assert.IsTrue(client.MulticastLoopback, "#B:MulticastLoopback"); //Assert.AreEqual (32, client.Ttl, "#B:Ttl"); #endif localEP = s.LocalEndPoint as IPEndPoint; Assert.IsNotNull(localEP, "#B:Client:LocalEndpoint"); Assert.AreEqual(IPAddress.IPv6Any, localEP.Address, "#B:Client:LocalEndPoint/Address"); Assert.AreEqual(AddressFamily.InterNetworkV6, localEP.AddressFamily, "#B:Client:LocalEndPoint/AddressFamily"); Assert.AreEqual(IPEndPoint.MaxPort, localEP.Port, "#B:Client:LocalEndPoint/Port"); }
[Test] // .ctor () public void Constructor1() { MyUdpClient client; Socket s; client = new MyUdpClient(); s = client.Client; Assert.IsNotNull(s, "Client"); Assert.AreEqual(AddressFamily.InterNetwork, s.AddressFamily, "Client:AddressFamily"); Assert.IsFalse(s.Connected, "Client:Connected"); #if NET_2_0 Assert.IsFalse(s.IsBound, "#A:Client:IsBound"); #endif Assert.IsNull(s.LocalEndPoint, "Client:LocalEndPoint"); Assert.AreEqual(ProtocolType.Udp, s.ProtocolType, "Client:ProtocolType"); Assert.IsNull(s.RemoteEndPoint, "Client:RemoteEndPoint"); Assert.AreEqual(SocketType.Dgram, s.SocketType, "Client:SocketType"); Assert.IsFalse(client.Active, "Active"); #if NET_2_0 Assert.IsFalse(client.DontFragment, "DontFragment"); Assert.IsFalse(client.EnableBroadcast, "EnableBroadcast"); //Assert.IsFalse (client.ExclusiveAddressUse, "ExclusiveAddressUse"); Assert.IsTrue(client.MulticastLoopback, "MulticastLoopback"); //Assert.AreEqual (32, client.Ttl, "Ttl"); #endif client.Close(); }
[Test] // .ctor () public void Constructor1 () { MyUdpClient client; Socket s; client = new MyUdpClient (); s = client.Client; Assert.IsNotNull (s, "Client"); Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "Client:AddressFamily"); Assert.IsFalse (s.Connected, "Client:Connected"); #if NET_2_0 Assert.IsFalse (s.IsBound, "#A:Client:IsBound"); #endif Assert.IsNull (s.LocalEndPoint, "Client:LocalEndPoint"); Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "Client:ProtocolType"); Assert.IsNull (s.RemoteEndPoint, "Client:RemoteEndPoint"); Assert.AreEqual (SocketType.Dgram, s.SocketType, "Client:SocketType"); Assert.IsFalse (client.Active, "Active"); #if NET_2_0 Assert.IsFalse (client.DontFragment, "DontFragment"); Assert.IsFalse (client.EnableBroadcast, "EnableBroadcast"); //Assert.IsFalse (client.ExclusiveAddressUse, "ExclusiveAddressUse"); Assert.IsTrue (client.MulticastLoopback, "MulticastLoopback"); //Assert.AreEqual (32, client.Ttl, "Ttl"); #endif client.Close (); }
public void Start(ServerDatas serverDatas, ServerDatas sdatas, Func <ClientGameMaster> createGameMaster, bool debug = false) { Client = new MyUdpClient(); this.debug = debug; Client.Start(serverDatas.address, serverDatas.port, GetReady, debug); _gameMaster = createGameMaster(); _gameMaster.Init(this); }
public void CloseClient() { if (this.client != null) { this.client.Close(this.client.IsConnected); this.client = null; } this.hasExit = true; }
[Test] // .ctor (String, Int32) public void Constructor6() { Socket s; IPEndPoint localEP; // Bug #5503 // UDP port 0 doesn't seem to be valid. using (MyUdpClient client = new MyUdpClient("127.0.0.1", 53)) { s = client.Client; Assert.IsNotNull(s, "#A:Client"); Assert.AreEqual(AddressFamily.InterNetwork, s.AddressFamily, "#A:Client:AddressFamily"); Assert.IsTrue(s.Connected, "#A:Client:Connected"); #if NET_2_0 Assert.IsTrue(s.IsBound, "#A:Client:IsBound"); #endif Assert.AreEqual(ProtocolType.Udp, s.ProtocolType, "#A:Client:ProtocolType"); Assert.AreEqual(SocketType.Dgram, s.SocketType, "#A:Client:SocketType"); Assert.IsTrue(client.Active, "#A:Active"); #if NET_2_0 Assert.IsFalse(client.DontFragment, "#A:DontFragment"); Assert.IsFalse(client.EnableBroadcast, "#A:EnableBroadcast"); //Assert.IsFalse (client.ExclusiveAddressUse, "#A:ExclusiveAddressUse"); //Assert.IsFalse (client.MulticastLoopback, "#A:MulticastLoopback"); //Assert.AreEqual (32, client.Ttl, "#A:Ttl"); #endif localEP = s.LocalEndPoint as IPEndPoint; Assert.IsNotNull(localEP, "#A:Client:LocalEndpoint"); Assert.AreEqual(IPAddress.Loopback, localEP.Address, "#A:Client:LocalEndPoint/Address"); Assert.AreEqual(AddressFamily.InterNetwork, localEP.AddressFamily, "#A:Client:LocalEndPoint/AddressFamily"); } using (MyUdpClient client = new MyUdpClient("127.0.0.1", IPEndPoint.MaxPort)) { s = client.Client; Assert.IsNotNull(s, "#B:Client"); Assert.AreEqual(AddressFamily.InterNetwork, s.AddressFamily, "#B:Client:AddressFamily"); Assert.IsTrue(s.Connected, "#B:Client:Connected"); #if NET_2_0 Assert.IsTrue(s.IsBound, "#B:Client:IsBound"); #endif Assert.AreEqual(ProtocolType.Udp, s.ProtocolType, "#B:Client:ProtocolType"); Assert.AreEqual(SocketType.Dgram, s.SocketType, "#B:Client:SocketType"); Assert.IsTrue(client.Active, "#B:Active"); #if NET_2_0 Assert.IsFalse(client.DontFragment, "#B:DontFragment"); Assert.IsFalse(client.EnableBroadcast, "#B:EnableBroadcast"); //Assert.IsFalse (client.ExclusiveAddressUse, "#B:ExclusiveAddressUse"); //Assert.IsFalse (client.MulticastLoopback, "#B:MulticastLoopback"); //Assert.AreEqual (32, client.Ttl, "#B:Ttl"); #endif localEP = s.LocalEndPoint as IPEndPoint; Assert.IsNotNull(localEP, "#B:Client:LocalEndpoint"); Assert.AreEqual(IPAddress.Loopback, localEP.Address, "#B:Client:LocalEndPoint/Address"); Assert.AreEqual(AddressFamily.InterNetwork, localEP.AddressFamily, "#B:Client:LocalEndPoint/AddressFamily"); } }
public static void smethod_0() { myUdpClient_0 = new MyUdpClient("192.168.5.126", 0x8f0, 0xe10); myUdpClient_0.LoginOKEvent += new MyUdpClient.LoginOKDelegate(Class1.smethod_2); myUdpClient_0.ReceiveMsgEvent += new MyUdpClient.ReceiveMsgDelegate(Class1.smethod_3); myUdpClient_0.StopEvent += new MyUdpClient.StopDelegate(Class1.smethod_4); myUdpClient_0.Connect("myname2", "1234", "0"); Console.ReadLine(); myUdpClient_0.Close(true); }
[Test] // .ctor (AddressFamily) public void Constructor2() { MyUdpClient client; Socket s; client = new MyUdpClient(AddressFamily.InterNetwork); s = client.Client; Assert.IsNotNull(s, "#A:Client"); Assert.AreEqual(AddressFamily.InterNetwork, s.AddressFamily, "#A:Client:AddressFamily"); Assert.IsFalse(s.Connected, "#A:Client:Connected"); #if NET_2_0 Assert.IsFalse(s.IsBound, "#A:Client:IsBound"); #endif Assert.IsNull(s.LocalEndPoint, "#A:Client:LocalEndPoint"); Assert.AreEqual(ProtocolType.Udp, s.ProtocolType, "#A:Client:ProtocolType"); Assert.IsNull(s.RemoteEndPoint, "#A:Client:RemoteEndPoint"); Assert.AreEqual(SocketType.Dgram, s.SocketType, "#A:Client:SocketType"); Assert.IsFalse(client.Active, "#A:Active"); #if NET_2_0 //Assert.IsFalse (client.DontFragment, "#A:DontFragment"); Assert.IsFalse(client.EnableBroadcast, "#A:EnableBroadcast"); //Assert.IsFalse (client.ExclusiveAddressUse, "#A:ExclusiveAddressUse"); Assert.IsTrue(client.MulticastLoopback, "#A:MulticastLoopback"); //Assert.AreEqual (32, client.Ttl, "#A:Ttl"); #endif #if NET_2_0 if (!Socket.OSSupportsIPv6) #else if (!Socket.SupportsIPv6) #endif { Assert.Ignore("IPv6 not enabled."); } client = new MyUdpClient(AddressFamily.InterNetworkV6); s = client.Client; Assert.IsNotNull(s, "#B:Client"); Assert.AreEqual(AddressFamily.InterNetworkV6, s.AddressFamily, "#B:Client:AddressFamily"); Assert.IsFalse(s.Connected, "#B:Client:Connected"); #if NET_2_0 Assert.IsFalse(s.IsBound, "#A:Client:IsBound"); #endif Assert.IsNull(s.LocalEndPoint, "#B:Client:LocalEndPoint"); Assert.AreEqual(ProtocolType.Udp, s.ProtocolType, "#B:Client:ProtocolType"); Assert.IsNull(s.RemoteEndPoint, "#B:Client:RemoteEndPoint"); Assert.AreEqual(SocketType.Dgram, s.SocketType, "#B:Client:SocketType"); Assert.IsFalse(client.Active, "#B:Active"); #if NET_2_0 //Assert.IsFalse (client.DontFragment, "#B:DontFragment"); Assert.IsFalse(client.EnableBroadcast, "#B:EnableBroadcast"); //Assert.IsFalse (client.ExclusiveAddressUse, "#B:ExclusiveAddressUse"); Assert.IsTrue(client.MulticastLoopback, "#B:MulticastLoopback"); //Assert.AreEqual (32, client.Ttl, "#B:Ttl"); #endif client.Close(); }
[Test] // .ctor (AddressFamily) public void Constructor2 () { MyUdpClient client; Socket s; client = new MyUdpClient (AddressFamily.InterNetwork); s = client.Client; Assert.IsNotNull (s, "#A:Client"); Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "#A:Client:AddressFamily"); Assert.IsFalse (s.Connected, "#A:Client:Connected"); #if NET_2_0 Assert.IsFalse (s.IsBound, "#A:Client:IsBound"); #endif Assert.IsNull (s.LocalEndPoint, "#A:Client:LocalEndPoint"); Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#A:Client:ProtocolType"); Assert.IsNull (s.RemoteEndPoint, "#A:Client:RemoteEndPoint"); Assert.AreEqual (SocketType.Dgram, s.SocketType, "#A:Client:SocketType"); Assert.IsFalse (client.Active, "#A:Active"); #if NET_2_0 //Assert.IsFalse (client.DontFragment, "#A:DontFragment"); Assert.IsFalse (client.EnableBroadcast, "#A:EnableBroadcast"); //Assert.IsFalse (client.ExclusiveAddressUse, "#A:ExclusiveAddressUse"); Assert.IsTrue (client.MulticastLoopback, "#A:MulticastLoopback"); //Assert.AreEqual (32, client.Ttl, "#A:Ttl"); #endif #if NET_2_0 if (!Socket.OSSupportsIPv6) #else if (!Socket.SupportsIPv6) #endif Assert.Ignore ("IPv6 not enabled."); client = new MyUdpClient (AddressFamily.InterNetworkV6); s = client.Client; Assert.IsNotNull (s, "#B:Client"); Assert.AreEqual (AddressFamily.InterNetworkV6, s.AddressFamily, "#B:Client:AddressFamily"); Assert.IsFalse (s.Connected, "#B:Client:Connected"); #if NET_2_0 Assert.IsFalse (s.IsBound, "#A:Client:IsBound"); #endif Assert.IsNull (s.LocalEndPoint, "#B:Client:LocalEndPoint"); Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#B:Client:ProtocolType"); Assert.IsNull (s.RemoteEndPoint, "#B:Client:RemoteEndPoint"); Assert.AreEqual (SocketType.Dgram, s.SocketType, "#B:Client:SocketType"); Assert.IsFalse (client.Active, "#B:Active"); #if NET_2_0 //Assert.IsFalse (client.DontFragment, "#B:DontFragment"); Assert.IsFalse (client.EnableBroadcast, "#B:EnableBroadcast"); //Assert.IsFalse (client.ExclusiveAddressUse, "#B:ExclusiveAddressUse"); Assert.IsTrue (client.MulticastLoopback, "#B:MulticastLoopback"); //Assert.AreEqual (32, client.Ttl, "#B:Ttl"); #endif client.Close (); }
public MyDataComunication OpenCommunication(string ipAddress, Action <object> callbackDataForImageProcessing) { ImageServer = new MyTcpServer(NetworkConstants.LocalLisenerConnection, 27001); ImageClient = new MyTcpClient(ipAddress, 27001); VoiceClient = new MyUdpClient(ipAddress, 27000); VoiceServer = new MyUdpServer(NetworkConstants.LocalLisenerConnection, 27000); ReciveImageAndProcess(callbackDataForImageProcessing); GrabImageAndSend(); RecordSoundAndSend(); ReceiveAndPlaySound(); return(this); }
public void Constructor5() { Socket s; IPEndPoint localEP; using (MyUdpClient client = new MyUdpClient(IPEndPoint.MinPort, AddressFamily.InterNetwork)) { s = client.Client; Assert.IsNotNull(s, "#A:Client"); Assert.AreEqual(AddressFamily.InterNetwork, s.AddressFamily, "#A:Client:AddressFamily"); Assert.IsFalse(s.Connected, "#A:Client:Connected"); Assert.IsTrue(s.IsBound, "#A:Client:IsBound"); Assert.AreEqual(ProtocolType.Udp, s.ProtocolType, "#A:Client:ProtocolType"); Assert.AreEqual(SocketType.Dgram, s.SocketType, "#A:Client:SocketType"); Assert.IsFalse(client.Active, "#A:Active"); //Assert.IsFalse (client.DontFragment, "#A:DontFragment"); Assert.IsFalse(client.EnableBroadcast, "#A:EnableBroadcast"); //Assert.IsFalse (client.ExclusiveAddressUse, "#A:ExclusiveAddressUse"); Assert.IsTrue(client.MulticastLoopback, "#A:MulticastLoopback"); //Assert.AreEqual (32, client.Ttl, "#A:Ttl"); localEP = s.LocalEndPoint as IPEndPoint; Assert.IsNotNull(localEP, "#A:Client:LocalEndpoint"); Assert.AreEqual(IPAddress.Any, localEP.Address, "#A:Client:LocalEndPoint/Address"); Assert.AreEqual(AddressFamily.InterNetwork, localEP.AddressFamily, "#A:Client:LocalEndPoint/AddressFamily"); } if (!Socket.OSSupportsIPv6) { Assert.Ignore("IPv6 not enabled."); } using (MyUdpClient client = new MyUdpClient(IPEndPoint.MaxPort, AddressFamily.InterNetworkV6)) { s = client.Client; Assert.IsNotNull(s, "#B:Client"); Assert.AreEqual(AddressFamily.InterNetworkV6, s.AddressFamily, "#B:Client:AddressFamily"); Assert.IsFalse(s.Connected, "#B:Client:Connected"); Assert.IsTrue(s.IsBound, "#B:Client:IsBound"); Assert.AreEqual(ProtocolType.Udp, s.ProtocolType, "#B:Client:ProtocolType"); Assert.AreEqual(SocketType.Dgram, s.SocketType, "#B:Client:SocketType"); Assert.IsFalse(client.Active, "#B:Active"); //Assert.IsFalse (client.DontFragment, "#B:DontFragment"); Assert.IsFalse(client.EnableBroadcast, "#B:EnableBroadcast"); //Assert.IsFalse (client.ExclusiveAddressUse, "#B:ExclusiveAddressUse"); Assert.IsTrue(client.MulticastLoopback, "#B:MulticastLoopback"); //Assert.AreEqual (32, client.Ttl, "#B:Ttl"); localEP = s.LocalEndPoint as IPEndPoint; Assert.IsNotNull(localEP, "#B:Client:LocalEndpoint"); Assert.AreEqual(IPAddress.IPv6Any, localEP.Address, "#B:Client:LocalEndPoint/Address"); Assert.AreEqual(AddressFamily.InterNetworkV6, localEP.AddressFamily, "#B:Client:LocalEndPoint/AddressFamily"); Assert.AreEqual(IPEndPoint.MaxPort, localEP.Port, "#B:Client:LocalEndPoint/Port"); } }
internal void ConnectServer() { try { if (((this.client == null) || !this.client.ServerPoint.Address.ToString().Equals(Config.serverIP)) || (this.client.ServerPoint.Port != int.Parse(Config.serverPort))) { this.client = new MyUdpClient(Config.serverIP, int.Parse(Config.serverPort), int.Parse(Config.clientPort)); this.client.MaxConnWaitTime = int.Parse(Config.maxConnWaitTime); this.client.LoginOKEvent += Login; this.client.ReceiveMsgEvent += getMess; this.client.StopEvent += stopMess; this.client.ReConnectEvent += ReConnectServer; } if (!this.client.IsConnected) { this.client.Connect(this.userName, this.userID + "." + MD5_Crypt.GetHashString32(this.userID + "saxiTAO"), Config.maxMessID); } } catch (Exception exception) { this.log.ErrorFormat("登录公告服务器异常:{0}", exception.ToString()); } }
/// <summary> /// Creates a "channel" to the given address. /// This won't send any message unlike TCP. /// </summary> /// <param name="broadcast">Sets this channel to be able to broadcast.</param> /// <param name="handlers">The handlers to be added to the channel's pipeline.</param> /// <returns>The created channel or null, if the channel could not be created.</returns> public MyUdpClient CreateUdp(bool broadcast, IDictionary <string, IChannelHandler> handlers) { _readWriteLockUdp.EnterReadLock(); try { if (_shutdownUdp) { return(null); } // try to aquire resources for the channel if (_semaphoreUdp == null || !_semaphoreUdp.TryAcquire()) { const string errorMsg = "Tried to acquire more resources (UDP) than announced."; Logger.Error(errorMsg); throw new SystemException(errorMsg); } // create and bind var pipeline = new Pipeline(handlers); var filteredPipeline = _channelClientConfiguration.PipelineFilter.Filter(pipeline, false, true); var udpClient = new MyUdpClient(_externalBindings.WildcardSocket(), filteredPipeline); _recipients.Add(udpClient); SetupCloseListener(udpClient, _semaphoreUdp); if (broadcast) { udpClient.Socket.EnableBroadcast = true; } return(udpClient); } finally { _readWriteLockUdp.ExitReadLock(); } }
private void Start() { _udpClient = new MyUdpClient(); _udpClient.OnReceived.Subscribe(x => Debug.Log(x.Length)); _udpClient.AddTo(this); }
/// <summary> /// Sends a message via UDP. /// </summary> /// <param name="handler">The handler to deal with the response message.</param> /// <param name="tcsResponse">The TCS for the response message. (FutureResponse equivalent.)</param> /// <param name="message">The message to send.</param> /// <param name="channelCreator">The channel creator for the UDP channel.</param> /// <param name="idleUdpSeconds">The idle time of a message until fail.</param> /// <param name="broadcast">True, if the message is to be sent via layer 2 broadcast.</param> /// <returns>The response message or null, if it is fire-and-forget or a failure occurred.</returns> public async Task SendUdpAsync(IInboundHandler handler, TaskCompletionSource <Message.Message> tcsResponse, Message.Message message, ChannelCreator channelCreator, int idleUdpSeconds, bool broadcast) { // no need to continue if already finished if (tcsResponse.Task.IsCompleted) { return; } RemovePeerIfFailed(tcsResponse, message); bool isFireAndForget = handler == null; // relay options if (message.Sender.IsRelayed) { message.SetPeerSocketAddresses(message.Sender.PeerSocketAddresses); IList <PeerSocketAddress> relayAddresses = new List <PeerSocketAddress>(message.Recipient.PeerSocketAddresses); Logger.Debug("Send neighbor request to random relay peer {0}.", relayAddresses); if (relayAddresses.Count > 0) { var relayAddress = relayAddresses[_random.NextInt(relayAddresses.Count)]; message.SetRecipientRelay(message.Recipient .ChangePeerSocketAddress(relayAddress) .ChangeIsRelayed(true)); } else { const string msg = "Peer is relayed, but no relay is given."; Logger.Error(msg); tcsResponse.SetException(new TaskFailedException(msg)); return; } } // check for invalid UDP connection to unreachable peers if (message.Recipient.IsRelayed && message.Command != Rpc.Rpc.Commands.Neighbor.GetNr() && message.Command != Rpc.Rpc.Commands.Ping.GetNr()) { string msg = String.Format( "Tried to send a UDP message to unreachable peers. Only TCP messages can be sent to unreachable peers: {0}.", message); Logger.Warn(msg); tcsResponse.SetException(new TaskFailedException(msg)); return; } // pipeline handler setup TimeoutFactory timeoutFactory = CreateTimeoutHandler(tcsResponse, idleUdpSeconds, isFireAndForget); var handlers = new Dictionary <string, IChannelHandler>(); if (!isFireAndForget) { handlers.Add("timeout0", timeoutFactory.CreateIdleStateHandlerTomP2P()); handlers.Add("timeout1", timeoutFactory.CreateTimeHandler()); } handlers.Add("decoder", new TomP2PSinglePacketUdp(ChannelClientConfiguration.SignatureFactory)); handlers.Add("encoder", new TomP2POutbound(false, ChannelClientConfiguration.SignatureFactory)); if (!isFireAndForget) { handlers.Add("handler", handler); } // create UDP channel MyUdpClient udpClient = null; try { udpClient = channelCreator.CreateUdp(broadcast, handlers); } catch (Exception ex) { string msg = "Channel creation failed. " + ex; Logger.Debug(msg); tcsResponse.SetException(ex); // may have been closed by the other side // or it may have been canceled from this side } // "afterConnect" // check if channel could be created (due to shutdown) if (udpClient == null) { const string msg = "Could not create a UDP socket. (Due to shutdown.)"; Logger.Warn(msg); tcsResponse.SetException(new TaskFailedException(msg)); return; } Logger.Debug("About to connect to {0} with channel {1}, ff = {2}.", message.Recipient, udpClient, isFireAndForget); // send request message // processes client-side outbound pipeline // (await for possible exception re-throw, does not block) await udpClient.SendMessageAsync(message); // if not fire-and-forget, receive response if (isFireAndForget) { Logger.Debug("Fire and forget message {0} sent. Close channel {1} now.", message, udpClient); tcsResponse.SetResult(null); // set FF result } else { // receive response message // processes client-side inbound pipeline await udpClient.ReceiveMessageAsync(); } udpClient.Close(); }
[Test] // .ctor (IPEndPoint) public void Constructor4 () { MyUdpClient client; Socket s; IPEndPoint localEP; IPEndPoint clientEP; clientEP = new IPEndPoint (IPAddress.Loopback, 8001); client = new MyUdpClient (clientEP); s = client.Client; Assert.IsNotNull (s, "#A:Client"); Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "#A:Client:AddressFamily"); Assert.IsFalse (s.Connected, "#A:Client:Connected"); #if NET_2_0 Assert.IsTrue (s.IsBound, "#A:Client:IsBound"); #endif Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#A:Client:ProtocolType"); Assert.AreEqual (SocketType.Dgram, s.SocketType, "#A:Client:SocketType"); Assert.IsFalse (client.Active, "#A:Active"); #if NET_2_0 Assert.IsFalse (client.DontFragment, "#A:DontFragment"); Assert.IsFalse (client.EnableBroadcast, "#A:EnableBroadcast"); //Assert.IsFalse (client.ExclusiveAddressUse, "#A:ExclusiveAddressUse"); Assert.IsTrue (client.MulticastLoopback, "#A:MulticastLoopback"); //Assert.AreEqual (32, client.Ttl, "#A:Ttl"); #endif localEP = s.LocalEndPoint as IPEndPoint; Assert.IsNotNull (localEP, "#A:Client:LocalEndpoint"); Assert.IsFalse (object.ReferenceEquals (clientEP, localEP), "#A:Client:LocalEndPoint/ReferenceEquality"); Assert.AreEqual (clientEP.Address, localEP.Address, "#A:Client:LocalEndPoint/Address"); Assert.AreEqual (clientEP.AddressFamily, localEP.AddressFamily, "#A:Client:LocalEndPoint/AddressFamily"); Assert.AreEqual (clientEP.Port, localEP.Port, "#A:Client:LocalEndPoint/Port"); }
[Test] // .ctor (Int32, AddressFamily) public void Constructor5 () { Socket s; IPEndPoint localEP; using (MyUdpClient client = new MyUdpClient (IPEndPoint.MinPort, AddressFamily.InterNetwork)) { s = client.Client; Assert.IsNotNull (s, "#A:Client"); Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "#A:Client:AddressFamily"); Assert.IsFalse (s.Connected, "#A:Client:Connected"); #if NET_2_0 Assert.IsTrue (s.IsBound, "#A:Client:IsBound"); #endif Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#A:Client:ProtocolType"); Assert.AreEqual (SocketType.Dgram, s.SocketType, "#A:Client:SocketType"); Assert.IsFalse (client.Active, "#A:Active"); #if NET_2_0 //Assert.IsFalse (client.DontFragment, "#A:DontFragment"); Assert.IsFalse (client.EnableBroadcast, "#A:EnableBroadcast"); //Assert.IsFalse (client.ExclusiveAddressUse, "#A:ExclusiveAddressUse"); Assert.IsTrue (client.MulticastLoopback, "#A:MulticastLoopback"); //Assert.AreEqual (32, client.Ttl, "#A:Ttl"); #endif localEP = s.LocalEndPoint as IPEndPoint; Assert.IsNotNull (localEP, "#A:Client:LocalEndpoint"); Assert.AreEqual (IPAddress.Any, localEP.Address, "#A:Client:LocalEndPoint/Address"); Assert.AreEqual (AddressFamily.InterNetwork, localEP.AddressFamily, "#A:Client:LocalEndPoint/AddressFamily"); } using (MyUdpClient client = new MyUdpClient (IPEndPoint.MaxPort, AddressFamily.InterNetworkV6)) { s = client.Client; Assert.IsNotNull (s, "#B:Client"); Assert.AreEqual (AddressFamily.InterNetworkV6, s.AddressFamily, "#B:Client:AddressFamily"); Assert.IsFalse (s.Connected, "#B:Client:Connected"); #if NET_2_0 Assert.IsTrue (s.IsBound, "#B:Client:IsBound"); #endif Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#B:Client:ProtocolType"); Assert.AreEqual (SocketType.Dgram, s.SocketType, "#B:Client:SocketType"); Assert.IsFalse (client.Active, "#B:Active"); #if NET_2_0 //Assert.IsFalse (client.DontFragment, "#B:DontFragment"); Assert.IsFalse (client.EnableBroadcast, "#B:EnableBroadcast"); //Assert.IsFalse (client.ExclusiveAddressUse, "#B:ExclusiveAddressUse"); Assert.IsTrue (client.MulticastLoopback, "#B:MulticastLoopback"); //Assert.AreEqual (32, client.Ttl, "#B:Ttl"); #endif localEP = s.LocalEndPoint as IPEndPoint; Assert.IsNotNull (localEP, "#B:Client:LocalEndpoint"); Assert.AreEqual (IPAddress.IPv6Any, localEP.Address, "#B:Client:LocalEndPoint/Address"); Assert.AreEqual (AddressFamily.InterNetworkV6, localEP.AddressFamily, "#B:Client:LocalEndPoint/AddressFamily"); Assert.AreEqual (IPEndPoint.MaxPort, localEP.Port, "#B:Client:LocalEndPoint/Port"); } }
[Test] // .ctor (String, Int32) public void Constructor6 () { Socket s; IPEndPoint localEP; // Bug #5503 // UDP port 0 doesn't seem to be valid. using (MyUdpClient client = new MyUdpClient ("127.0.0.1", 53)) { s = client.Client; Assert.IsNotNull (s, "#A:Client"); Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "#A:Client:AddressFamily"); Assert.IsTrue (s.Connected, "#A:Client:Connected"); #if NET_2_0 Assert.IsTrue (s.IsBound, "#A:Client:IsBound"); #endif Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#A:Client:ProtocolType"); Assert.AreEqual (SocketType.Dgram, s.SocketType, "#A:Client:SocketType"); Assert.IsTrue (client.Active, "#A:Active"); #if NET_2_0 Assert.IsFalse (client.DontFragment, "#A:DontFragment"); Assert.IsFalse (client.EnableBroadcast, "#A:EnableBroadcast"); //Assert.IsFalse (client.ExclusiveAddressUse, "#A:ExclusiveAddressUse"); //Assert.IsFalse (client.MulticastLoopback, "#A:MulticastLoopback"); //Assert.AreEqual (32, client.Ttl, "#A:Ttl"); #endif localEP = s.LocalEndPoint as IPEndPoint; Assert.IsNotNull (localEP, "#A:Client:LocalEndpoint"); Assert.AreEqual (IPAddress.Loopback, localEP.Address, "#A:Client:LocalEndPoint/Address"); Assert.AreEqual (AddressFamily.InterNetwork, localEP.AddressFamily, "#A:Client:LocalEndPoint/AddressFamily"); } using (MyUdpClient client = new MyUdpClient ("127.0.0.1", IPEndPoint.MaxPort)) { s = client.Client; Assert.IsNotNull (s, "#B:Client"); Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "#B:Client:AddressFamily"); Assert.IsTrue (s.Connected, "#B:Client:Connected"); #if NET_2_0 Assert.IsTrue (s.IsBound, "#B:Client:IsBound"); #endif Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#B:Client:ProtocolType"); Assert.AreEqual (SocketType.Dgram, s.SocketType, "#B:Client:SocketType"); Assert.IsTrue (client.Active, "#B:Active"); #if NET_2_0 Assert.IsFalse (client.DontFragment, "#B:DontFragment"); Assert.IsFalse (client.EnableBroadcast, "#B:EnableBroadcast"); //Assert.IsFalse (client.ExclusiveAddressUse, "#B:ExclusiveAddressUse"); //Assert.IsFalse (client.MulticastLoopback, "#B:MulticastLoopback"); //Assert.AreEqual (32, client.Ttl, "#B:Ttl"); #endif localEP = s.LocalEndPoint as IPEndPoint; Assert.IsNotNull (localEP, "#B:Client:LocalEndpoint"); Assert.AreEqual (IPAddress.Loopback, localEP.Address, "#B:Client:LocalEndPoint/Address"); Assert.AreEqual (AddressFamily.InterNetwork, localEP.AddressFamily, "#B:Client:LocalEndPoint/AddressFamily"); } }