public void Connect(IPAddress address) { this.ipAddress = address; try { NetworkComms.RemoveGlobalConnectionCloseHandler(HandleConnectionClosed); NetworkComms.Shutdown(); } catch { // Just here to avoid potential crash } if (!packetsAppended) { NetworkComms.AppendGlobalIncomingPacketHandler <Custom>("Custom", ReceiveCustomPacket); NetworkComms.AppendGlobalIncomingPacketHandler <int>(PacketName.ReLoginResult.ToString(), ReceiveLoginResult); NetworkComms.AppendGlobalIncomingPacketHandler <ModuleList>(PacketName.ReModuleList.ToString(), ModuleList); NetworkComms.AppendGlobalIncomingPacketHandler <AppFileData>(PacketName.ReAppFile.ToString(), AppFile); NetworkComms.AppendGlobalIncomingPacketHandler <GroupList>(PacketName.ReUserGroupList.ToString(), GroupListReceived); NetworkComms.AppendGlobalIncomingPacketHandler <int>(PacketName.ReSessionVerificationResult.ToString(), SessionVerificationResultReceived); NetworkComms.AppendGlobalIncomingPacketHandler <string>(PacketName.ReSessionId.ToString(), SessionIdReceived); NetworkComms.AppendGlobalIncomingPacketHandler <int>(PacketName.ReUnauthorized.ToString(), UnAuthorizedReceived); packetsAppended = true; } NetworkComms.AppendGlobalConnectionCloseHandler(HandleConnectionClosed); NetworkComms.DefaultSendReceiveOptions = new SendReceiveOptions(DPSManager.GetDataSerializer <NetworkCommsDotNet.DPSBase.ProtobufSerializer>(), NetworkComms.DefaultSendReceiveOptions.DataProcessors, NetworkComms.DefaultSendReceiveOptions.Options); if (Connectable(address.ToString())) { connectionInfo = new ConnectionInfo(address.ToString(), port); } }
public Server() { //Trigger the method PrintIncomingMessage when a packet of type 'Message' is received //We expect the incoming object to be a string which we state explicitly by using <string> NetworkComms.AppendGlobalIncomingPacketHandler <string>("Message", PrintIncomingMessage); //Start listening for incoming connections Connection.StartListening(ConnectionType.TCP, new System.Net.IPEndPoint(System.Net.IPAddress.Any, 50111)); //Print out the IPs and ports we are now listening on Console.WriteLine("Server listening for TCP connection on:"); foreach (System.Net.IPEndPoint localEndPoint in Connection.ExistingLocalListenEndPoints(ConnectionType.TCP)) { Console.WriteLine("{0}:{1}", localEndPoint.Address, localEndPoint.Port); } //Let the user close the server Console.WriteLine("\nPress any key to close server."); Console.ReadKey(true); //We have used NetworkComms so we should ensure that we correctly call shutdown NetworkComms.Shutdown(); }
public User() { //Request server IP and port number Console.WriteLine("Please enter the server IP and port in the format 192.168.0.1:10000 and press return:"); //string serverInfo = Console.ReadLine(); string serverInfo = "127.0.0.1:50111"; //Parse the necessary information out of the provided string string serverIP = serverInfo.Split(':').First(); int serverPort = int.Parse(serverInfo.Split(':').Last()); //Keep a loopcounter int loopCounter = 1; while (true) { //Write some information to the console window string messageToSend = "This is message #" + loopCounter; Console.WriteLine("Sending message to server saying '" + messageToSend + "'"); //Send the message in a single line NetworkComms.SendObject("Message", serverIP, serverPort, messageToSend); //Check if user wants to go around the loop Console.WriteLine("\nPress q to quit or any other key to send another message."); if (Console.ReadKey(true).Key == ConsoleKey.Q) { break; } else { loopCounter++; } } //We have used comms so we make sure to call shutdown NetworkComms.Shutdown(); }
public void Disconnect() { while (Peers.Count > 0) { Peers.First().DisconnectAny(); } while (Trackers.Count > 0) { Trackers.First().Disconnect(); } t.Stop(); PeerDiscovery.DisableDiscoverable(); Connection.StopListening(); NetworkComms.CloseAllConnections(); NetworkComms.Shutdown(); NetworkComms.Logger.Warn("===== Client stopped ====="); Started = false; }
static void Main(string[] args) { //Solicita IP y puerto del servidor Console.WriteLine("Por favor ingrese la direccion IP del servidor y puerto en el formato 192.168.0.1:10000 y presione enter:"); string serverInfo = Console.ReadLine(); //Parsea la información necesaria del string solicitado string serverIP = serverInfo.Split(':').First(); int serverPort = int.Parse(serverInfo.Split(':').Last()); //Keep a loopcounter int loopCounter = 1; while (true) { //Write some information to the console window string messageToSend = "This is message #" + loopCounter; Console.WriteLine("Sending message to server saying '" + messageToSend + "'"); //Send the message in a single line NetworkComms.SendObject("Message", serverIP, serverPort, messageToSend); //Check if user wants to go around the loop Console.WriteLine("\nPress q to quit or any other key to send another message."); if (Console.ReadKey(true).Key == ConsoleKey.Q) { break; } else { loopCounter++; } } //We have used comms so we make sure to call shutdown NetworkComms.Shutdown(); }
private void parsMessage(String msg) { if (msg.Contains(Macro.RESPONSE_EXPECTED_QUERY)) { _responseExpected = true; try { System.Console.WriteLine(msg.Substring(Macro.RESPONSE_EXPECTED_QUERY.Count())); } catch (ArgumentOutOfRangeException) { System.Console.WriteLine("Une erreur est survenue. Le message suivant provenant du serveur peut contenir des erreurs"); System.Console.WriteLine(msg); } } else if (msg.Contains(Macro.CLIENT_DISCONNECT_QUERY)) { NetworkComms.Shutdown(); _end = true; } else { System.Console.WriteLine(msg); } }
static void Main(string[] args) { NetworkComms.AppendGlobalIncomingPacketHandler <ServerRequest>("ServerRequest", IncomingServerRequest); NetworkComms.AppendGlobalIncomingPacketHandler <ClientRequest>("ClientRequest", IncomingClientRequest); NetworkComms.AppendGlobalConnectionCloseHandler(ClientDisconnected); NetworkComms.AppendGlobalConnectionEstablishHandler(ClientConnected); Connection.StartListening(ConnectionType.TCP, new System.Net.IPEndPoint(System.Net.IPAddress.Any, 0)); Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine("[+] Server listening for TCP conneciotn on:"); foreach (var endPoint in Connection.ExistingLocalListenEndPoints(ConnectionType.TCP)) { var localEndPoint = (IPEndPoint)endPoint; Console.WriteLine("[*] {0}:{1}", localEndPoint.Address, localEndPoint.Port); } Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine("\n[!] Press any key to close server."); Console.ForegroundColor = ConsoleColor.White; Console.ReadKey(true); NetworkComms.Shutdown(); System.Environment.Exit(0); }
public static void ConfigureSockets(Message messageToSend, string serverInfo) { //Request server IP and port number // Console.WriteLine("Please enter the server IP and port in the format 192.168.0.1:10000 and press return:"); //Parse the necessary information out of the provided string string serverIP = serverInfo.Split(':').First(); int serverPort = int.Parse(serverInfo.Split(':').Last()); //Write some information to the console window // NetworkComms.SendObject("Message", serverIP, serverPort, "OK"); // NetworkComms.SendObject("Message", serverIP, serverPort, SerializeObject<Message>(messageToSend)); var message = getSourceNodes(); NetworkComms.SendObject("Message", serverIP, serverPort, SerializeObject <List <SourceNode> >(message)); //We have used comms so we make sure to call shutdown NetworkComms.Shutdown(); }
/// <summary> /// 关闭程序时,调用释放所有的资源 /// Shutdown all connections, threads and execute OnCommsShutdown event. /// should be called on application close. /// </summary> public static void ShutDown() { NetworkComms.Shutdown(); }
/// <summary> /// Called before the assembly reloads -- responsible for shutting down network comms safely /// </summary> void OnBeforeAssemblyReload() { NetworkComms.Shutdown(); }
public void Disconnect() { NetworkComms.Shutdown(); }
private void MidiForwarderForm_FormClosed(object sender, FormClosedEventArgs e) { NetworkComms.Shutdown(); }
private void ClientForm_FormClosing(object sender, FormClosingEventArgs e) { NetworkComms.Shutdown(); GC.Collect(); GC.WaitForPendingFinalizers(); }
/// <summary> /// Correctly shutdown NetworkComms .Net when closing the WPF application /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e) { //Ensure we shutdown comms when we are finished NetworkComms.Shutdown(); }
/// <summary> /// Called when the window is closing. /// </summary> private void WindowRegister_Closing(object sender, System.ComponentModel.CancelEventArgs e) { NetworkComms.Shutdown(); this.Owner.Close(); }
// Code to execute when the application is closing (eg, user hit Back) // This code will not execute when the application is deactivated private void Application_Closing(object sender, ClosingEventArgs e) { //When the application closes it is necessary to shutdown any remaining NetworkComms activity NetworkComms.Shutdown(); }
/// <summary> /// callback for window closing /// </summary> private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e) { NetworkComms.Shutdown(); }
// Sent to all game objects before the application is quit private void OnApplicationQuit() { NetworkComms.Shutdown(); }
// This function is called when the MonoBehaviour will be destroyed private void OnDestroy() { NetworkComms.Shutdown(); }
static void Main(string[] args) { try { Console.SetBufferSize(120, 200); Console.SetWindowSize(120, 25); } catch (NotImplementedException) { } Thread.CurrentThread.Name = "MainThread"; Console.WriteLine("Initiating NetworkCommsDotNet examples.\n"); //Ask user if they want to enable comms logging SelectLogging(); #if DEBUG //Set debug timeouts SetDebugTimeouts(); #endif //All we do here is let the user choice a specific example Console.WriteLine("Please selected an example:\n"); //Print out the available examples int totalNumberOfExamples = 9; Console.WriteLine("1 - Basic - Message Send (Only 11 lines!)"); Console.WriteLine(); Console.WriteLine("2 - Intermediate - Message Send"); Console.WriteLine("3 - Intermediate - Peer Discovery"); Console.WriteLine(); Console.WriteLine("4 - Advanced - Object Send"); Console.WriteLine("5 - Advanced - Distributed File System"); Console.WriteLine("6 - Advanced - Remote Procedure Call"); Console.WriteLine("7 - Advanced - Unmanaged Connections"); Console.WriteLine("8 - Advanced - TCP (SSL) Connections"); Console.WriteLine(""); Console.WriteLine("9 - Debug - Speed Test"); //Get the user choice Console.WriteLine(""); int selectedExample; while (true) { bool parseSucces = int.TryParse(Console.ReadKey().KeyChar.ToString(), out selectedExample); if (parseSucces && selectedExample <= totalNumberOfExamples) { break; } Console.WriteLine("\nInvalid example choice. Please try again."); } //Clear all input so that each example can do it's own thing Console.Clear(); //Run the selected example try { #region Run Example switch (selectedExample) { case 1: BasicSend.RunExample(); break; case 2: IntermediateSend.RunExample(); break; case 3: PeerDiscoveryExample.RunExample(); break; case 4: AdvancedSend.RunExample(); break; case 5: DFSTest.RunExample(); break; case 6: RPCExample.RunExample(); break; case 7: UnmanagedConnectionExample.RunExample(); break; case 8: SSLExample.RunExample(); break; case 9: SpeedTest.RunExample(); break; default: Console.WriteLine("Selected an invalid example number. Please restart and try again."); break; } #endregion } catch (Exception ex) { //If an error was uncaught by the examples we can log the exception to a file here LogTools.LogException(ex, "ExampleError"); NetworkComms.Shutdown(); Console.WriteLine(ex.ToString()); } //When we are done we give the user a chance to see all output Console.WriteLine("\n\nExample has completed. Please press any key to close."); Console.ReadKey(true); }
/// <summary> /// Run example /// </summary> public static void RunExample() { SendReceiveOptions nullCompressionSRO = new SendReceiveOptions(DPSManager.GetDataSerializer <ProtobufSerializer>(), null, null); NetworkComms.DefaultSendReceiveOptions = nullCompressionSRO; //We need to define what happens when packets are received. //To do this we add an incoming packet handler for a 'Message' packet type. // //We will define what we want the handler to do inline by using a lambda expression //http://msdn.microsoft.com/en-us/library/bb397687.aspx. //We could also just point the AppendGlobalIncomingPacketHandler method //to a standard method (See AdvancedSend example) // //This handler will convert the incoming raw bytes into a string (this is what //the <string> bit means) and then write that string to the local console window. NetworkComms.AppendGlobalIncomingPacketHandler <PingRequestReturnDC>("Message", (packetHeader, connection, incomingString) => { Console.WriteLine("\n ... Incoming message from " + connection.ToString() + " saying '" + incomingString.ClientID + "'-'" + incomingString.PingID + "'."); }); //Start listening for incoming 'TCP' connections. //We want to select a random port on all available adaptors so provide //an IPEndPoint using IPAddress.Any and port 0. //See also UDPConnection.StartListening() Connection.StartListening(ConnectionType.TCP, new IPEndPoint(IPAddress.Any, 0)); //Print the IP addresses and ports we are listening on to make sure everything //worked as expected. Console.WriteLine("Listening for messages on:"); foreach (System.Net.IPEndPoint localEndPoint in Connection.ExistingLocalListenEndPoints(ConnectionType.TCP)) { Console.WriteLine("{0}:{1}", localEndPoint.Address, localEndPoint.Port); } //We loop here to allow any number of test messages to be sent and received while (true) { //Request a message to send somewhere Console.WriteLine("\nPlease enter your message and press enter (Type 'exit' to quit):"); string stringToSend = Console.ReadLine(); //If the user has typed exit then we leave our loop and end the example if (stringToSend == "exit") { break; } else { //Once we have a message we need to know where to send it //We have created a small wrapper class to help keep things clean here ConnectionInfo targetServerConnectionInfo; ExampleHelper.GetServerDetails(out targetServerConnectionInfo); PingRequestReturnDC test = new PingRequestReturnDC(0, 0); //There are loads of ways of sending data (see AdvancedSend example for more) //but the most simple, which we use here, just uses an IP address (string) and port (integer) //We pull these values out of the ConnectionInfo object we got above and voila! NetworkComms.SendObject("Message", ((System.Net.IPEndPoint)targetServerConnectionInfo.RemoteEndPoint).Address.ToString(), ((System.Net.IPEndPoint)targetServerConnectionInfo.RemoteEndPoint).Port, test); } } //We should always call shutdown on comms if we have used it NetworkComms.Shutdown(); }
static void Main(string[] args) { NetworkManager.Start(); Console.ReadKey(); NetworkComms.Shutdown(); }
public void TestMethodClientPeer() { NetworkComms.EnableLogging(); NetworkComms.Shutdown(); int theirPort = CommonHelpers.PeerPort + 2; string hash = "hash1"; VotingsUser.PeerDiscovery = true; Peer peer1 = null; TCPConnection our = null; List <Peer> allPeers = null; int reqHash = 0; int reqPeers = 0; int reqBlocks = 0; int respPeers = 0; int blocksEvent = 0; int trsEvent = 0; int blocksReqEvent = 0; int trsReqEvent = 0; //============ //прослушиваем 2 порта TCPConnection.StartListening(CommonHelpers.GetLocalEndPoint(CommonHelpers.PeerPort, true)); //мы TCPConnection.StartListening(CommonHelpers.GetLocalEndPoint(theirPort, true)); //они allPeers = new List <Peer>(); peer1 = new Peer(CommonHelpers.GetLocalEndPoint(theirPort, true), allPeers); allPeers.Add(peer1); //получаем подключение пира к нам NetworkComms.AppendGlobalConnectionEstablishHandler((c) => { our = c as TCPConnection; }); //определяем, что сообщения пришли NetworkComms.AppendGlobalIncomingPacketHandler <PeerHashMessage>(typeof(PeerHashMessage).Name, (p, c, i) => { reqHash++; }); NetworkComms.AppendGlobalIncomingPacketHandler <RequestPeersMessage>(typeof(RequestPeersMessage).Name, (p, c, i) => { reqPeers++; }); NetworkComms.AppendGlobalIncomingPacketHandler <RequestBlocksMessage>(typeof(RequestBlocksMessage).Name, (p, c, i) => { reqBlocks++; }); NetworkComms.AppendGlobalIncomingPacketHandler <PeersMessage>(typeof(PeersMessage).Name, (p, c, i) => { respPeers++; }); peer1.OnBlocksMessage += (s, e) => { blocksEvent++; }; peer1.OnTransactionsMessage += (s, e) => { trsEvent++; }; peer1.OnRequestBlocksMessage += (s, e) => { blocksReqEvent++; }; peer1.OnRequestTransactionsMessage += (s, e) => { trsReqEvent++; }; //============ //подключаемся к пиру peer1.Connect(); w(); Assert.IsTrue(peer1.Status == PeerStatus.NoHashRecieved); Assert.IsTrue(reqHash == 1); //отправляем хеш пиру our.SendObject <PeerHashMessage>(typeof(PeerHashMessage).Name, new PeerHashMessage(hash, false)); w(); Assert.IsTrue(peer1.Hash == hash); Assert.IsTrue(peer1.Status == PeerStatus.Connected); //отправляем сообщение нам peer1.SendMessage(new RequestBlocksMessage(new List <string>())); w(); Assert.IsTrue(reqBlocks == 1); //проверяем подключение peer1.CheckConnection(); w(); Assert.IsTrue(peer1.ErrorsCount == 0); //запрашиваем пиры у нас peer1.RequestPeers(10); w(); Assert.IsTrue(reqPeers == 1); //запрашиваем пиры у пира our.SendObject <RequestPeersMessage>(typeof(RequestPeersMessage).Name, new RequestPeersMessage(10)); w(); Assert.IsTrue(reqPeers == 2); Assert.IsTrue(respPeers == 1); //отправляем блоки пиру our.SendObject <BlocksMessage>(typeof(BlocksMessage).Name, new BlocksMessage()); w(); Assert.IsTrue(blocksEvent == 1); //отправляем транзакции пиру our.SendObject <TransactionsMessage>(typeof(TransactionsMessage).Name, new TransactionsMessage()); w(); Assert.IsTrue(trsEvent == 1); //запрашиваем транзакции у пира our.SendObject <RequestTransactionsMessage>(typeof(RequestTransactionsMessage).Name, new RequestTransactionsMessage()); w(); Assert.IsTrue(trsReqEvent == 1); //запрашиваем транзакции у пира our.SendObject <RequestBlocksMessage>(typeof(RequestBlocksMessage).Name, new RequestBlocksMessage()); w(); Assert.IsTrue(blocksReqEvent == 1); //отключаемся от пира peer1.DisconnectAny(); w(); Assert.IsTrue(allPeers.Count == 0); }
/// <summary> /// Updates the configuration of this instance depending on set fields /// </summary> public void RefreshNetworkCommsConfiguration() { #region First Initialisation //On first initialisation we need to configure NetworkComms.Net to handle our incoming packet types //We only need to add the packet handlers once. If we call NetworkComms.Shutdown() at some future point these are not removed. if (FirstInitialisation) { FirstInitialisation = false; //Configure NetworkComms.Net to handle any incoming packet of type 'ChatMessage' //e.g. If we receive a packet of type 'ChatMessage' execute the method 'HandleIncomingChatMessage' NetworkComms.AppendGlobalIncomingPacketHandler <ChatMessage>("ChatMessage", HandleIncomingChatMessage); //Configure NetworkComms.Net to perform some action when a connection is closed //e.g. When a connection is closed execute the method 'HandleConnectionClosed' NetworkComms.AppendGlobalConnectionCloseHandler(HandleConnectionClosed); } #endregion #region Set serializer //Set the default send recieve options to use the specified serializer. Keep the DataProcessors and Options from the previous defaults NetworkComms.DefaultSendReceiveOptions = new SendReceiveOptions(Serializer, NetworkComms.DefaultSendReceiveOptions.DataProcessors, NetworkComms.DefaultSendReceiveOptions.Options); #endregion #region Optional Encryption //Configure encryption if requested if (EncryptionEnabled && !NetworkComms.DefaultSendReceiveOptions.DataProcessors.Contains(DPSManager.GetDataProcessor <RijndaelPSKEncrypter>())) { //Encryption is currently implemented using a pre-shared key (PSK) system //NetworkComms.Net supports multiple data processors which can be used with any level of granularity //To enable encryption globally (i.e. for all connections) we first add the encryption password as an option RijndaelPSKEncrypter.AddPasswordToOptions(NetworkComms.DefaultSendReceiveOptions.Options, _encryptionKey); //Finally we add the RijndaelPSKEncrypter data processor to the sendReceiveOptions NetworkComms.DefaultSendReceiveOptions.DataProcessors.Add(DPSManager.GetDataProcessor <RijndaelPSKEncrypter>()); } else if (!EncryptionEnabled && NetworkComms.DefaultSendReceiveOptions.DataProcessors.Contains(DPSManager.GetDataProcessor <RijndaelPSKEncrypter>())) { //If encryption has been disabled but is currently enabled //To disable encryption we just remove the RijndaelPSKEncrypter data processor from the sendReceiveOptions NetworkComms.DefaultSendReceiveOptions.DataProcessors.Remove(DPSManager.GetDataProcessor <RijndaelPSKEncrypter>()); } #endregion #region Local Server Mode and Connection Type Changes if (LocalServerEnabled && ConnectionType == ConnectionType.TCP && !Connection.Listening(ConnectionType.TCP)) { //If we were previously listening for UDP we first shutdown NetworkComms.Net. if (Connection.Listening(ConnectionType.UDP)) { AppendLineToChatHistory("Connection mode has been changed. Any existing connections will be closed."); NetworkComms.Shutdown(); } else { AppendLineToChatHistory("Enabling local server mode. Any existing connections will be closed."); NetworkComms.Shutdown(); } //Start listening for new incoming TCP connections //We want to select a random port on all available adaptors so provide //an IPEndPoint using IPAddress.Any and port 0. Connection.StartListening(ConnectionType.TCP, new IPEndPoint(IPAddress.Any, 0)); //Write the IP addresses and ports that we are listening on to the chatBox AppendLineToChatHistory("Listening for incoming TCP connections on:"); foreach (IPEndPoint listenEndPoint in Connection.ExistingLocalListenEndPoints(ConnectionType.TCP)) { AppendLineToChatHistory(listenEndPoint.Address + ":" + listenEndPoint.Port); } //Add a blank line after the initialisation output AppendLineToChatHistory(System.Environment.NewLine); } else if (LocalServerEnabled && ConnectionType == ConnectionType.UDP && !Connection.Listening(ConnectionType.UDP)) { //If we were previously listening for TCP we first shutdown NetworkComms.Net. if (Connection.Listening(ConnectionType.TCP)) { AppendLineToChatHistory("Connection mode has been changed. Any existing connections will be closed."); NetworkComms.Shutdown(); } else { AppendLineToChatHistory("Enabling local server mode. Any existing connections will be closed."); NetworkComms.Shutdown(); } //Start listening for new incoming UDP connections //We want to select a random port on all available adaptors so provide //an IPEndPoint using IPAddress.Any and port 0. Connection.StartListening(ConnectionType.UDP, new IPEndPoint(IPAddress.Any, 0)); //Write the IP addresses and ports that we are listening on to the chatBox AppendLineToChatHistory("Listening for incoming UDP connections on:"); foreach (IPEndPoint listenEndPoint in Connection.ExistingLocalListenEndPoints(ConnectionType.UDP)) { AppendLineToChatHistory(listenEndPoint.Address + ":" + listenEndPoint.Port); } //Add a blank line after the initialisation output AppendLineToChatHistory(System.Environment.NewLine); } else if (!LocalServerEnabled && (Connection.Listening(ConnectionType.TCP) || Connection.Listening(ConnectionType.UDP))) { //If the local server mode has been disabled but we are still listening we need to stop accepting incoming connections NetworkComms.Shutdown(); AppendLineToChatHistory("Local server mode disabled. Any existing connections will be closed."); AppendLineToChatHistory(System.Environment.NewLine); } else if (!LocalServerEnabled && ((ConnectionType == ConnectionType.UDP && NetworkComms.GetExistingConnection(ConnectionType.TCP).Count > 0) || (ConnectionType == ConnectionType.TCP && NetworkComms.GetExistingConnection(ConnectionType.UDP).Count > 0))) { //If we are not running a local server but have changed the connection type after creating connections we need to close //existing connections. NetworkComms.Shutdown(); AppendLineToChatHistory("Connection mode has been changed. Existing connections will be closed."); AppendLineToChatHistory(System.Environment.NewLine); } #endregion }
/// <summary> /// Run the AdvancedSend example. /// </summary> public static void RunExample() { Console.WriteLine("Unmanaged Connection Example ...\n"); //***************************************************************// // Start of interesting stuff // //***************************************************************// Console.WriteLine("\nNOTE: From this point on make sure both clients are configured in the same way if you want the example to work."); Console.WriteLine("\nIMPORTANT!! - Many of the features offered by NetworkComms.Net rely on managed connections, " + "i.e. those which enable the custom ApplicationLayerProtocol. If you use unmanaged connections, i.e. where the custom " + "application protocol has been disabled, you must take into account TCP packet fragmentation and concatenation, " + "correctly handling it, for all circumstances."); //Choose between unmanaged TCP or UDP SelectConnectionType(); //Add a packet handler for dealing with incoming unmanaged data NetworkComms.AppendGlobalIncomingUnmanagedPacketHandler((header, connection, array) => { Console.WriteLine("\nReceived unmanaged byte[] from " + connection.ToString()); for (int i = 0; i < array.Length; i++) { Console.WriteLine(i.ToString() + " - " + array[i].ToString()); } }); //Create suitable send receive options for use with unmanaged connections SendReceiveOptions optionsToUse = new SendReceiveOptions <NullSerializer>(); //Get the local IPEndPoints we intend to listen on //The port provided is '0' meaning select a random port. List <IPEndPoint> localIPEndPoints = (from current in HostInfo.IP.FilteredLocalAddresses() select new IPEndPoint(current, 0)).ToList(); //Create suitable listeners depending on the desired connectionType List <ConnectionListenerBase> listeners; if (connectionTypeToUse == ConnectionType.TCP) { //For each localIPEndPoint get a TCP listener //We need to set the ApplicationLayerProtocolStatus to Disabled listeners = (from current in localIPEndPoints select(ConnectionListenerBase) new TCPConnectionListener(optionsToUse, ApplicationLayerProtocolStatus.Disabled)).ToList(); } else { //We need to set the ApplicationLayerProtocolStatus to Disabled listeners = (from current in localIPEndPoints select(ConnectionListenerBase) new UDPConnectionListener(optionsToUse, ApplicationLayerProtocolStatus.Disabled, UDPConnection.DefaultUDPOptions)).ToList(); } //Start listening Connection.StartListening(listeners, localIPEndPoints, true); //***************************************************************// // End of interesting stuff // //***************************************************************// Console.WriteLine("Listening for incoming byte[] on:"); List <EndPoint> localListeningEndPoints = Connection.ExistingLocalListenEndPoints(connectionTypeToUse); foreach (IPEndPoint localEndPoint in localListeningEndPoints) { Console.WriteLine("{0}:{1}", localEndPoint.Address, localEndPoint.Port); } Console.WriteLine("\nPress any key if you want to send data from this client. Press q to quit."); while (true) { //Wait for user to press something before sending anything from this end var keyContinue = Console.ReadKey(true); if (keyContinue.Key == ConsoleKey.Q) { break; } //Create the send object based on user input byteDataToSend = CreateSendArray(); //Get remote endpoint address //Expecting user to enter IP address as 192.168.0.1:4000 ConnectionInfo connectionInfo = ExampleHelper.GetServerDetails(ApplicationLayerProtocolStatus.Disabled); //***************************************************************// // Start of interesting stuff // //***************************************************************// Connection connectionToUse; //Create the connection if (connectionTypeToUse == ConnectionType.TCP) { connectionToUse = TCPConnection.GetConnection(connectionInfo, optionsToUse); } else { connectionToUse = UDPConnection.GetConnection(connectionInfo, UDPOptions.None, optionsToUse); } //Send the object connectionToUse.SendUnmanagedBytes(byteDataToSend); //***************************************************************// // End of interesting stuff // //***************************************************************// Console.WriteLine("\nSend complete. Press 'q' to quit or any other key to send something else."); } //***************************************************************// // Start of interesting stuff // //***************************************************************// //Make sure you call shutdown when finished to clean up. NetworkComms.Shutdown(); //***************************************************************// // End of interesting stuff // //***************************************************************// }
static void Main(string[] args) { NetworkComms.AppendGlobalIncomingPacketHandler <MessageObject>("Message", Connected); Connection.StartListening(ConnectionType.TCP, new System.Net.IPEndPoint(System.Net.IPAddress.Any, 0)); Console.WriteLine("Server listening for TCP connection on:"); foreach (System.Net.IPEndPoint localEndPoint in Connection.ExistingLocalListenEndPoints(ConnectionType.TCP)) { Console.WriteLine("{0}:{1}", localEndPoint.Address, localEndPoint.Port); } createDeck(); /* * int i = 0; * while (i < 52) * { * Console.WriteLine("[" + deck[i].rank + " of " + deck[i].sign + "]"); * i++; * } * i = 0; * Console.WriteLine("\n////////////////////////////////\n"); */ Shuffle(); /* * while (i < 52) * { * Console.WriteLine("[" + deck[i].rank + " of " + deck[i].sign + "]"); * i++; * } */ bool cond = true; while (end != true) { if (play == true) { play = false; MessageObject msg = new MessageObject("Bienvenue", "Bienvenue"); if (nturn >= 52) { msg.action = "End"; if (point1 > point2) { msg.action = "End"; msg.message = "Vous avez gagné !"; player1.SendObject("Message", msg); msg.action = "End"; msg.message = "Vous avez perdu..."; player2.SendObject("Message", msg); } else if (point2 > point1) { msg.action = "End"; msg.message = "Vous avez gagné !"; player2.SendObject("Message", msg); msg.action = "End"; msg.message = "Vous avez perdu..."; player1.SendObject("Message", msg); } else if (point1 == point2) { msg.action = "End"; msg.message = "Egalité !"; player1.SendObject("Message", msg); player2.SendObject("Message", msg); } end = true; } else { if (nplay == 1) { msg.action = "You"; if (nturn != 0) { msg.message = "L'adversaire a joué la carte : " + cardPlayed.card2 + "\nA vous de poser une carte..."; } else { msg.message = "A vous de poser une carte..."; } player1.SendObject("Message", msg); msg.action = "Other"; msg.message = "L'adversaire pose une carte..."; player2.SendObject("Message", msg); nturn++; } else { msg.action = "You"; msg.message = "L'adversaire a joué la carte : " + cardPlayed.card1 + "\nA vous de poser une carte..."; player2.SendObject("Message", msg); msg.action = "Other"; msg.message = "L'adversaire pose une carte..."; player1.SendObject("Message", msg); nturn++; while (wait != true) { i++; } if (firstPlay == true && secPlay == true) { check_better(); } } } } if (nbPlayers == 2) { if (cond == true) { cond = false; MessageObject msg = new MessageObject("Bienvenue", "Bienvenue"); player1.SendObject("Message", msg); player2.SendObject("Message", msg); msg.action = "Card"; int i = 0; while (i < 26) { msg.message = "[" + deck[i].rank + " of " + deck[i].sign + "]"; player1.SendObject("Message", msg); i++; } while (i < 52) { msg.message = "[" + deck[i].rank + " of " + deck[i].sign + "]"; player2.SendObject("Message", msg); i++; } //Console.WriteLine("test\n"); msg.action = "Message"; msg.message = "Le jeu peut commencer."; player1.SendObject("Message", msg); player2.SendObject("Message", msg); play = true; //end = true; } } } Console.WriteLine("\nPress any key to close server."); Console.ReadKey(true); NetworkComms.Shutdown(); }
private void ChatForm_Closing(object sender, EventArgs e) { // [ttaj] Turn off server/client once done. NetworkComms.Shutdown(); }
internal void Stop() { _Server.Shutdown("Server is shutting down..."); NetworkComms.Shutdown(); _WebServer.Stop(); }
void Application_Suspending(object sender, Windows.ApplicationModel.SuspendingEventArgs e) { NetworkComms.Shutdown(); }
/// <summary> /// Para a escuta do servidor /// </summary> public void Stop() { NetworkComms.Shutdown(); ServerLog.Write("!.....Server desativado manualmente.................."); }