static void Main(string[] args) { string messageToSend = "This is a message To Send"; string messageFromServer = UDPConnection.GetConnection(new ConnectionInfo("127.0.0.1", 10000), UDPOptions.None).SendReceiveObject <string>("Message", "Message", 2000, messageToSend); Console.WriteLine("Server said '{0}'.", messageFromServer); Console.WriteLine("Press any key to exit."); Console.ReadKey(true); NetworkComms.Shutdown(); }
public static bool To(string ip, int timeout = 10000) { var conn = UDPConnection.GetConnection(new ConnectionInfo(ip, Port), UDPOptions.Handshake, true, false); try { conn.EstablishConnection(); } catch (Exception e) { return(false); } conn.CloseConnection(false); return(true); }
private UDPConnection CreateUDPConnection() { try { var connectionInfo = new ConnectionInfo(ConnectionType.UDP, ShortGuid.NewGuid(), new IPEndPoint(IPAddress.Any, 0), true); var connection = UDPConnection.GetConnection(connectionInfo, UDPOptions.None); return(connection); } catch (Exception ex) { Trace.TraceError("[ UDP ] CreateLocalUDPConnection, Error = {0}", ex.Message); } return(null); }
public Client() { // Set connection to server Console.WriteLine("Please enter the server IP:port"); var serverInfo = Console.ReadLine(); var serverIp = serverInfo.Split(':').First(); var serverPort = int.Parse(serverInfo.Split(':').Last()); var connInfo = new ConnectionInfo(serverIp, serverPort); ClientConnection = UDPConnection.GetConnection(connInfo, UDPOptions.None); // Handlers NetworkComms.AppendGlobalIncomingPacketHandler <string>("message", WriteMessage); NetworkComms.AppendGlobalIncomingPacketHandler <int>("clientId", SetId); // Send my name to server Console.WriteLine("Please enter your name:"); var name = Console.ReadLine(); ClientConnection.SendObject("Name", name); }
// generic method to send command object to ManageSystem private Task SendCommandToPeer(ConnectionInfo connectionInfo, object cmdObj) { return(Task.Run(() => { try { if (connectionInfo.ConnectionType == ConnectionType.TCP) { TCPConnection conn = TCPConnection.GetConnection(connectionInfo); conn.SendObject("Command", cmdObj); } else if (connectionInfo.ConnectionType == ConnectionType.UDP) { UDPConnection conn = UDPConnection.GetConnection(connectionInfo, UDPOptions.None); conn.SendObject("Command", cmdObj); } } catch (Exception ex) { logger.Info("SendCommandToPeer: Remote[" + connectionInfo.RemoteEndPoint.ToString() + "] Local[" + connectionInfo.LocalEndPoint.ToString() + "] TypeofcmdObj[" + cmdObj.GetType().ToString() + "] Error:" + ex.ToString()); } })); }
/// <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 // //***************************************************************// }
/// <summary> /// Send a message. /// </summary> public void SendMessage(string stringToSend) { //If we have tried to send a zero length string we just return if (stringToSend.Trim() == "") { return; } //We may or may not have entered some server connection information ConnectionInfo serverConnectionInfo = null; if (ServerIPAddress != "") { try { serverConnectionInfo = new ConnectionInfo(ServerIPAddress, ServerPort); } catch (Exception) { ShowMessage("Failed to parse the server IP and port. Please ensure it is correct and try again"); return; } } //We wrap everything we want to send in the ChatMessage class we created ChatMessage chatMessage = new ChatMessage(NetworkComms.NetworkIdentifier, LocalName, stringToSend, messageSendIndex++); //We add our own message to the message history in case it gets relayed back to us lock (lastPeerMessageDict) lastPeerMessageDict[NetworkComms.NetworkIdentifier] = chatMessage; //We write our own message to the chatBox AppendLineToChatHistory(chatMessage.SourceName + " - " + chatMessage.Message); //Clear the input box text ClearInputLine(); //If we provided server information we send to the server first if (serverConnectionInfo != null) { //We perform the send within a try catch to ensure the application continues to run if there is a problem. try { if (ConnectionType == ConnectionType.TCP) { TCPConnection.GetConnection(serverConnectionInfo).SendObject("ChatMessage", chatMessage); } else if (ConnectionType == ConnectionType.UDP) { UDPConnection.GetConnection(serverConnectionInfo, UDPOptions.None).SendObject("ChatMessage", chatMessage); } else { throw new Exception("An invalid connectionType is set."); } } catch (CommsException) { AppendLineToChatHistory("Error: A communication error occurred while trying to send message to " + serverConnectionInfo + ". Please check settings and try again."); } catch (Exception) { AppendLineToChatHistory("Error: A general error occurred while trying to send message to " + serverConnectionInfo + ". Please check settings and try again."); } } //If we have any other connections we now send the message to those as well //This ensures that if we are the server everyone who is connected to us gets our message //We want a list of all established connections not including the server if set List <ConnectionInfo> otherConnectionInfos; if (serverConnectionInfo != null) { otherConnectionInfos = (from current in NetworkComms.AllConnectionInfo() where current.RemoteEndPoint != serverConnectionInfo.RemoteEndPoint select current).ToList(); } else { otherConnectionInfos = NetworkComms.AllConnectionInfo(); } foreach (ConnectionInfo info in otherConnectionInfos) { //We perform the send within a try catch to ensure the application continues to run if there is a problem. try { if (ConnectionType == ConnectionType.TCP) { TCPConnection.GetConnection(info).SendObject("ChatMessage", chatMessage); } else if (ConnectionType == ConnectionType.UDP) { UDPConnection.GetConnection(info, UDPOptions.None).SendObject("ChatMessage", chatMessage); } else { throw new Exception("An invalid connectionType is set."); } } catch (CommsException) { AppendLineToChatHistory("Error: A communication error occurred while trying to send message to " + info + ". Please check settings and try again."); } catch (Exception) { AppendLineToChatHistory("Error: A general error occurred while trying to send message to " + info + ". Please check settings and try again."); } } return; }
/// <summary> /// Run the AdvancedSend example. /// </summary> public static void RunExample() { Console.WriteLine("AdvancedSend 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."); //Choose between TCP or UDP SelectConnectionType(); //Choose the serialiser and processors which network comms will use DataSerializer dataSerializer; SelectDataSerializer(out dataSerializer); List <DataProcessor> dataProcessors; Dictionary <string, string> dataProcessorOptions; //We cannot select data processors if the NullSerializer was selected if (dataSerializer.GetType() != typeof(NullSerializer)) { SelectDataProcessors(out dataProcessors, out dataProcessorOptions); } else { dataProcessors = new List <DataProcessor>(); dataProcessorOptions = new Dictionary <string, string>(); } NetworkComms.DefaultSendReceiveOptions = new SendReceiveOptions(dataSerializer, dataProcessors, dataProcessorOptions); //Add a packet handler for dealing with incoming connections. Function will be called when a packet is received with the specified type. We also here specify the type of object //we are expecting to receive. In this case we expect an int[] for packet type ArrayTestPacketInt NetworkComms.AppendGlobalIncomingPacketHandler <byte[]>("ArrayByte", (header, connection, array) => { Console.WriteLine("\nReceived byte array from " + connection.ToString()); for (int i = 0; i < array.Length; i++) { Console.WriteLine(i.ToString() + " - " + array[i].ToString()); } }); //As above but this time we expect a string[], and use a different packet type to distinguish the difference NetworkComms.AppendGlobalIncomingPacketHandler <string[]>("ArrayString", (header, connection, array) => { Console.WriteLine("\nReceived string array from " + connection); for (int i = 0; i < array.Length; i++) { Console.WriteLine(i.ToString() + " - " + array[i]); } }); //Our custom object packet handler will be different depending on which serializer we have chosen if (NetworkComms.DefaultSendReceiveOptions.DataSerializer.GetType() == typeof(ProtobufSerializer)) { NetworkComms.AppendGlobalIncomingPacketHandler <ProtobufCustomObject>("CustomObject", (header, connection, customObject) => { Console.WriteLine("\nReceived custom protobuf object from " + connection); Console.WriteLine(" ... intValue={0}, stringValue={1}", customObject.IntValue, customObject.StringValue); }); } else if (NetworkComms.DefaultSendReceiveOptions.DataSerializer.GetType() == typeof(BinaryFormaterSerializer)) { NetworkComms.AppendGlobalIncomingPacketHandler <BinaryFormatterCustomObject>("CustomObject", (header, connection, customObject) => { Console.WriteLine("\nReceived custom binary formatter object from " + connection); Console.WriteLine(" ... intValue={0}, stringValue={1}", customObject.IntValue, customObject.StringValue); }); } else { NetworkComms.AppendGlobalIncomingPacketHandler <JSONSerializerCustomObject>("CustomObject", (header, connection, customObject) => { Console.WriteLine("\nReceived custom JSON object from " + connection); Console.WriteLine(" ... intValue={0}, stringValue={1}", customObject.IntValue, customObject.StringValue); }); } //Start listening for incoming connections //We want to select a random port on all available adaptors so provide //an IPEndPoint using IPAddress.Any and port 0. //If we wanted to listen on a specific port we would use that instead of '0' Connection.StartListening(connectionTypeToUse, new IPEndPoint(IPAddress.Any, 0)); //***************************************************************// // End of interesting stuff // //***************************************************************// Console.WriteLine("Listening for incoming objects 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 something 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 CreateSendObject(); //Expecting user to enter IP address as 192.168.0.1:4000 ConnectionInfo connectionInfo = ExampleHelper.GetServerDetails(); //***************************************************************// // Start of interesting stuff // //***************************************************************// Connection connectionToUse; //Create the connection if (connectionTypeToUse == ConnectionType.TCP) { connectionToUse = TCPConnection.GetConnection(connectionInfo); } else { connectionToUse = UDPConnection.GetConnection(connectionInfo, UDPOptions.None); } //Send the object if (toSendType == typeof(Array)) { if (toSendObject.GetType().GetElementType() == typeof(byte)) { connectionToUse.SendObject("ArrayByte", toSendObject); } else { connectionToUse.SendObject("ArrayString", toSendObject); } } else { connectionToUse.SendObject("CustomObject", toSendObject); } //***************************************************************// // 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 // //***************************************************************// }
/// <summary> /// Hammers the server with connections. /// </summary> private static void ConnectionHammer(int index) { Random rand = new Random(index); for (int i = 0; i < connectionsPerHammer; i++) { bool tcpSelected = false; if (TCPServerEndPointsKeys.Count > 0 && UDPServerEndPointsKeys.Count > 0) { tcpSelected = (rand.NextDouble() > 0.5); } else if (TCPServerEndPointsKeys.Count > 0) { tcpSelected = true; } //options.Options.Add("ReceiveConfirmationRequired", ""); IPEndPoint selectedEndPoint; ConnectionInfo connInfo; if (tcpSelected) { selectedEndPoint = TCPServerEndPointsKeys[(int)(TCPServerEndPoints.Count * rand.NextDouble())]; connInfo = new ConnectionInfo(selectedEndPoint, TCPServerEndPoints[selectedEndPoint]); } else { selectedEndPoint = UDPServerEndPointsKeys[(int)(UDPServerEndPoints.Count * rand.NextDouble())]; connInfo = new ConnectionInfo(selectedEndPoint, UDPServerEndPoints[selectedEndPoint]); } try { Connection conn; if (tcpSelected) { conn = TCPConnection.GetConnection(connInfo, sendReceiveOptions); conn.SendObject(packetTypeStr, clientHammerData); if (closeConnectionAfterSend) { conn.CloseConnection(false); } } else { conn = UDPConnection.GetConnection(connInfo, UDPConnection.DefaultUDPOptions, sendReceiveOptions); conn.SendObject(packetTypeStr, clientHammerData); if (closeConnectionAfterSend) { conn.CloseConnection(false); } //SendReceiveOptions unmanagedOptions = new SendReceiveOptions<NullSerializer>(); //UDPConnection.SendObject("Unmanaged", clientHammerData, connInfo.RemoteEndPoint, unmanagedOptions, connInfo.ApplicationLayerProtocol); } } catch (CommsException ex) { Interlocked.Increment(ref exceptionCount); LogTools.AppendStringToLogFile("ClientExceptions", ex.ToString()); } } }
/// <summary> /// Run the example /// </summary> public void Run() { //Expecting user to enter ip address as 192.168.0.1:4000 ConnectionInfo connectionInfo = ExampleHelper.GetServerDetails(); SelectConnectionType(); try { //We would really like to create a local instance of MathClass, but the client does not have a //reference to MathClass (defined server side only): // //IMath remoteObject = new MathClass(); // //This example is all about RPC, so we create the instance remotely instead, as follows ... //We need to select our remote object using one of the available access methods string instanceId = ""; Connection connection = null; if (connectionTypeToUse == ConnectionType.TCP) { connection = TCPConnection.GetConnection(connectionInfo); } else { connection = UDPConnection.GetConnection(connectionInfo, UDPOptions.None); } //Get the remote object IMath remoteObject = SelectRemoteObject(connection, out instanceId); //Add a handler to the object's event to demonstrate remote triggering of events remoteObject.EchoEvent += (sender, args) => { Console.WriteLine("Echo event received saying {0}", args.EchoValue); }; Console.WriteLine("\nRemote object has been selected. RPC object instanceId: {0}", instanceId); while (true) { //We can now perform RPC operations on our remote object Console.WriteLine("\nPlease press 'y' key to perform some remote math. Any other key will quit the example."); string message = Console.ReadKey(true).KeyChar.ToString().ToLower(); //If the user has typed exit then we leave our loop and end the example if (message == "y") { //We pass our remoteObject to our local method DoMath to keep this area of code clean Console.WriteLine("Result: " + DoMath(remoteObject).ToString()); } else { break; } } } catch (Exception e) { Console.WriteLine(e.ToString()); } finally { NetworkComms.Shutdown(); } }