/// <summary> /// Constructor for client support /// </summary> /// <param name="sizeOfRawBuffer"> The size of the raw buffer </param> /// <param name="userArg"> A Reference to the Users arguments </param> /// <param name="messageHandler"> Reference to the user defined message handler method </param> /// <param name="closeHandler"> Reference to the user defined close handler method </param> /// <param name="errorHandler"> Reference to the user defined error handler method </param> public SocketClient(int sizeOfRawBuffer, object userArg, MessageHandler messageHandler, CloseHandler closeHandler, ErrorHandler errorHandler, ConnectHandler connectHandler) { // Create the raw buffer this.SizeOfRawBuffer = sizeOfRawBuffer; this.RawBuffer = new Byte[this.SizeOfRawBuffer]; // Save the user argument this.userArg = userArg; // Set the handler methods this.messageHandler = messageHandler; this.closeHandler = closeHandler; this.errorHandler = errorHandler; this.connectHandler = connectHandler; // Set the async socket method handlers this.callbackReadMethod = new AsyncCallback(ReceiveComplete); this.callbackWriteMethod = new AsyncCallback(SendComplete); this.callbackWriteHeadMethod = new AsyncCallback(SendHead); this.m_Connected = true; // Init the dispose flag this.disposed = false; }
/// <summary> /// </summary> /// <param name="repository"> /// Used to provide all queues that this broker is for. There is a built in class, /// <see cref="MemoryQueueRepository" />, which you can use. /// </param> public StompBroker(IQueueRepository repository) { if (repository == null) { throw new ArgumentNullException("repository"); } _queues = repository; _tcpListener = new StompTcpListener { MessageReceived = OnMessageReceived, MessageSent = OnMessageDelivered }; _tcpListener.ClientConnected += OnClientConnected; _tcpListener.ClientDisconnected += OnClientDisconnected; ServerName = "Griffin.Queue/1.0"; var connectHandler = new ConnectHandler(new NoAuthenticationService(), ServerName); _frameHandlers.Add("ACK", new AckHandler()); _frameHandlers.Add("ABORT", new AbortHandler()); _frameHandlers.Add("BEGIN", new BeginHandler()); _frameHandlers.Add("COMMIT", new CommitHandler()); _frameHandlers.Add("CONNECT", connectHandler); _frameHandlers.Add("DISCONNECT", new MessageHandlers.DisconnectHandler()); _frameHandlers.Add("NACK", new NackHandler(_queues)); _frameHandlers.Add("SEND", new SendHandler(_queues)); _frameHandlers.Add("SUBSCRIBE", new SubscribeHandler(_queues)); _frameHandlers.Add("STOMP", connectHandler); }
public Handler( InitializeHandler initialize, TerminateHandler terminate, LoginHandler login, ConnectHandler connect, LatencyHandler latency, DisconnectHandler disconnect, RoomHandler room, RoomsPageHandler roomsPage, RoomOperationHandler roomOperation, DataHandler data, ForeignDataHandler foreignData, LogHandler log) { Initialize = initialize; Terminate = terminate; Login = login; Connect = connect; Latency = latency; Disconnect = disconnect; Room = room; RoomsPage = roomsPage; RoomOperation = roomOperation; Data = data; ForeignData = foreignData; Log = log; }
/// <summary> /// /// </summary> internal ClientSocketManager(Connecter connecter, ConnectHandler connectHandler, ReceiveQueue receiveBuffer) { if (connecter == null) { throw new Exception("ClientSocketHandler.ClientSocketManager(...) - listener == null error!"); } if (connectHandler == null) { throw new Exception("ClientSocketHandler.ClientSocketManager(...) - serviceHandle == null error!"); } if (receiveBuffer == null) { throw new Exception("ClientSocketHandler.ClientSocketManager(...) - receiveBuffer == null error!"); } m_Connecter = connecter; m_ConnectHandle = connectHandler; m_ReceiveBuffer = receiveBuffer; { // 清空数据 m_ReceiveBuffer.Clear(); } // 初始化数据 表示还没调用过Free(...)函数 m_LockFree.SetValid(); }
public void using_authentication() { var authService = Substitute.For <IAuthenticationService>(); authService.IsActivated.Returns(true); authService.Login("hello", "world").Returns(new LoginResponse() { IsSuccessful = true, Token = "mamma" }); var frame = new BasicFrame("STOMP"); var client = Substitute.For <IStompClient>(); frame.Headers["accept-version"] = "2.0"; frame.Headers["login"] = "******"; frame.Headers["passcode"] = "world"; client.SessionKey.Returns(Guid.NewGuid().ToString()); var sut = new ConnectHandler(authService, "Kickass"); var actual = sut.Process(client, frame); actual.Should().NotBeNull(); actual.Headers["version"].Should().Be("2.0"); actual.Headers["server"].Should().Be("Kickass"); actual.Headers["session"].Should().NotBeNull(); client.ReceivedWithAnyArgs().SetAsAuthenticated("mamma"); }
public static ConnectHandler Get(string connectStr) { ConnectHandler ret = null; connectors.TryGetValue(connectStr, out ret); return(ret); }
protected override void ProcessAccept(UDPPacket packet) { IPEndPoint remote = (IPEndPoint)packet.AsyncEventArgs.RemoteEndPoint; //Task.Run(() => //{ if (packet.BytesRecieved.Length < 6) { return; } BasePacket basePacket = new BasePacket(packet.BytesRecieved); try { //BytesRecieved[7] is nnpacket.PacketType. switch (basePacket.PacketType) { case NatPacketType.PreInit: //NatNegHandler.PreInitResponse(this, packet, nnpacket); break; case NatPacketType.Init: InitHandler.InitResponse(this, packet); break; case NatPacketType.AddressCheck: AddressHandler.AddressCheckResponse(this, packet); break; case NatPacketType.NatifyRequest: NatifyHandler.NatifyResponse(this, packet); break; case NatPacketType.ConnectAck: ConnectHandler.ConnectResponse(this, packet); break; case NatPacketType.Report: ReportHandler.ReportResponse(this, packet); break; default: LogWriter.Log.Write(LogLevel.Error, "{0,-8} [Recv] unknow data", ServerName); break; } } catch (Exception e) { LogWriter.Log.WriteException(e); } finally { if (Replied == true) { Release(packet.AsyncEventArgs); } } }
protected void OnConnectEvent(EventArgs e) { ConnectHandler ev = ConnectEvent; //This may not be the exact right syntax. _syncSource.BeginInvoke(ev, this, e); }
public bool AddConnectHandler(ConnectHandler handler) { if (this.m_connectHandlers.Contains(handler)) { return(false); } this.m_connectHandlers.Add(handler); return(true); }
protected virtual SocketClient AcceptedSocketClient( SocketServer socketServer, Socket clientSocket, string ipAddress, int port, int sizeOfRawBuffer, object userArg, MessageHandler messageHandler, CloseHandler closeHandler, ErrorHandler errorHandler, ConnectHandler connectHandler) { return new SocketClient( socketServer, clientSocket, ipAddress, port, sizeOfRawBuffer, userArg, messageHandler, closeHandler, errorHandler, connectHandler); }
public void version_is_required_according_to_the_specification() { var authService = Substitute.For <IAuthenticationService>(); var frame = new BasicFrame("STOMP"); var client = Substitute.For <IStompClient>(); var sut = new ConnectHandler(authService, "Kickass"); var actual = sut.Process(client, frame); actual.Should().NotBeNull(); actual.Headers["version"].Should().Be("2.0"); actual.Headers["message"].Should().Be("Missing the 'accept-version' header."); }
public void only_accepting_20_clients() { var authService = Substitute.For <IAuthenticationService>(); var frame = new BasicFrame("STOMP"); var client = Substitute.For <IStompClient>(); frame.Headers["accept-version"] = "1.1"; var sut = new ConnectHandler(authService, "Kickass"); var actual = sut.Process(client, frame); actual.Should().NotBeNull(); actual.Headers["version"].Should().Be("2.0"); actual.Headers["message"].Should().Be("Only accepting stomp 2.0 clients."); }
private void OnConnect(Target trg) { ConnectHandler handler = Connected; m_curTarget = trg; m_curTarget.IsConnected = true; if (handler != null) { m_cctx.Send(delegate { handler(this, trg); }, null); } }
private void OnDisconnected() { ConnectHandler handler = Disconnected; m_curTarget.IsConnected = false; lock (m_syncSocket) { m_ConnectionInProgress = false; } if (handler != null) { m_cctx.Send(delegate { handler(this, m_curTarget); }, null); } }
public void using_authentication_but_no_password_was_supplied() { var authService = Substitute.For <IAuthenticationService>(); authService.IsActivated.Returns(true); var frame = new BasicFrame("STOMP"); var client = Substitute.For <IStompClient>(); frame.Headers["accept-version"] = "2.0"; frame.Headers["login"] = "******"; client.SessionKey.Returns(Guid.NewGuid().ToString()); var sut = new ConnectHandler(authService, "Kickass"); var actual = sut.Process(client, frame); actual.Headers["message"].Should().NotBeNullOrEmpty(); }
public void always_accept_when_authentication_is_turned_off() { var authService = Substitute.For <IAuthenticationService>(); var frame = new BasicFrame("STOMP"); var client = Substitute.For <IStompClient>(); frame.Headers["accept-version"] = "2.0"; client.SessionKey.Returns(Guid.NewGuid().ToString()); var sut = new ConnectHandler(authService, "Kickass"); var actual = sut.Process(client, frame); actual.Should().NotBeNull(); actual.Headers["version"].Should().Be("2.0"); actual.Headers["server"].Should().Be("Kickass"); actual.Headers["session"].Should().NotBeNullOrEmpty(); client.ReceivedWithAnyArgs().SetAsAuthenticated(null); }
public ConnectHandler AttachSpotifyConnect( ISpotifyDevice device, uint initialVolume, int volumeSteps) { WaitAuthLock(); var player = new SpotifyPlayer( this, device, initialVolume, volumeSteps); var connectHandler = new ConnectHandler(this, player); return(connectHandler); }
public static void Switch(NatNegServer server, byte[] message) { BasePacket basePacket = new BasePacket(message); try { //BytesRecieved[7] is nnpacket.PacketType. switch (basePacket.PacketType) { case NatPacketType.PreInit: //NatNegHandler.PreInitResponse(this, packet, nnpacket); break; case NatPacketType.Init: InitHandler.InitResponse(server, message); break; case NatPacketType.AddressCheck: AddressHandler.AddressCheckResponse(server, message); break; case NatPacketType.NatifyRequest: NatifyHandler.NatifyResponse(server, message); break; case NatPacketType.ConnectAck: ConnectHandler.ConnectResponse(server, message); break; case NatPacketType.Report: ReportHandler.ReportResponse(server, message); break; default: server.UnknownDataRecived(message); break; } } catch (Exception e) { LogWriter.Log.WriteException(e); } }
public Handler( InitializeHandler initialize, TerminateHandler terminate, LoginHandler login, ConnectHandler connect, LatencyHandler latency, DisconnectHandler disconnect, DataHandler data, ForeignDataHandler foreignData, LogHandler log) { Initialize = initialize; Terminate = terminate; Login = login; Connect = connect; Latency = latency; Disconnect = disconnect; Data = data; ForeignData = foreignData; Log = log; }
public void using_authentication_but_with_incorrect_password() { var authService = Substitute.For <IAuthenticationService>(); authService.IsActivated.Returns(true); authService.Login("hello", "world").Returns(new LoginResponse() { IsSuccessful = false, Token = "mamma", Reason = "Incorrect password" }); var frame = new BasicFrame("STOMP"); var client = Substitute.For <IStompClient>(); frame.Headers["accept-version"] = "2.0"; frame.Headers["login"] = "******"; frame.Headers["passcode"] = "world"; client.SessionKey.Returns(Guid.NewGuid().ToString()); var sut = new ConnectHandler(authService, "Kickass"); var actual = sut.Process(client, frame); actual.Headers["message"].Should().Be("Incorrect password"); }
/// <summary> /// /// </summary> internal ClientSocketManager( Connecter connecter, ConnectHandler connectHandler, ReceiveQueue receiveBuffer ) { if ( connecter == null ) throw new Exception( "ClientSocketHandler.ClientSocketManager(...) - listener == null error!" ); if ( connectHandler == null ) throw new Exception( "ClientSocketHandler.ClientSocketManager(...) - serviceHandle == null error!" ); if ( receiveBuffer == null ) throw new Exception( "ClientSocketHandler.ClientSocketManager(...) - receiveBuffer == null error!" ); m_Connecter = connecter; m_ConnectHandle = connectHandler; m_ReceiveBuffer = receiveBuffer; { // 清空数据 m_ReceiveBuffer.Clear(); } // 初始化数据 表示还没调用过Free(...)函数 m_LockFree.SetValid(); }
/// <summary> /// Begins listening for new connections on the specified port. Note that the OnConnect method will /// only be called for new connections from previously unknown IPEndPoint's. If stored, the returned listener /// can eventually be used to end listening. /// </summary> public static Listener Listen(int Port, ConnectHandler OnConnect) { return new Listener(Port, OnConnect); }
public bool RemoveConnectHandler(ConnectHandler handler) { return(this.m_connectHandlers.Remove(handler)); }
public void Update() { object mutex = this.m_mutex; lock (mutex) { foreach (ConnectionEvent <PacketType> event2 in this.m_connectionEvents) { ConnectHandler <PacketType>[] handlerArray; int num3; IConnectionListener <PacketType> listener; this.PrintConnectionException(event2); switch (event2.Type) { case ConnectionEventTypes <PacketType> .OnConnected: if (event2.Error == BattleNetErrors.ERROR_OK) { break; } this.DisconnectSocket(); this.m_connectionState = ConnectionState <PacketType> .ConnectionFailed; goto Label_0071; case ConnectionEventTypes <PacketType> .OnDisconnected: { if (event2.Error != BattleNetErrors.ERROR_OK) { this.Disconnect(); } foreach (DisconnectHandler <PacketType> handler2 in this.m_disconnectHandlers.ToArray()) { handler2(event2.Error); } continue; } case ConnectionEventTypes <PacketType> .OnPacketCompleted: num3 = 0; goto Label_0138; default: { continue; } } this.m_connectionState = ConnectionState <PacketType> .Connected; Label_0071: handlerArray = this.m_connectHandlers.ToArray(); for (int i = 0; i < handlerArray.Length; i++) { ConnectHandler <PacketType> handler = handlerArray[i]; handler(event2.Error); } continue; Label_0105: listener = this.m_listeners[num3]; object state = this.m_listenerStates[num3]; listener.PacketReceived(event2.Packet, state); num3++; Label_0138: if (num3 < this.m_listeners.Count) { goto Label_0105; } } this.m_connectionEvents.Clear(); } if ((this.m_socket != null) && (this.m_connectionState == ConnectionState <PacketType> .Connected)) { this.SendQueuedPackets(); } }
public bool RemoveConnectHandler(ConnectHandler <PacketType> handler) { return(this.m_connectHandlers.Remove(handler)); }
public void Update() { object mutex = this.m_mutex; lock (mutex) { using (List <ClientConnection <PacketType> .ConnectionEvent> .Enumerator enumerator = this.m_connectionEvents.GetEnumerator()) { while (enumerator.MoveNext()) { ClientConnection <PacketType> .ConnectionEvent current = enumerator.get_Current(); this.PrintConnectionException(current); switch (current.Type) { case ClientConnection <PacketType> .ConnectionEventTypes.OnConnected: { if (current.Error != BattleNetErrors.ERROR_OK) { this.DisconnectSocket(); this.m_connectionState = ClientConnection <PacketType> .ConnectionState.ConnectionFailed; } else { this.m_connectionState = ClientConnection <PacketType> .ConnectionState.Connected; } ConnectHandler[] array = this.m_connectHandlers.ToArray(); for (int i = 0; i < array.Length; i++) { ConnectHandler connectHandler = array[i]; connectHandler(current.Error); } break; } case ClientConnection <PacketType> .ConnectionEventTypes.OnDisconnected: { if (current.Error != BattleNetErrors.ERROR_OK) { this.Disconnect(); } DisconnectHandler[] array2 = this.m_disconnectHandlers.ToArray(); for (int j = 0; j < array2.Length; j++) { DisconnectHandler disconnectHandler = array2[j]; disconnectHandler(current.Error); } break; } case ClientConnection <PacketType> .ConnectionEventTypes.OnPacketCompleted: for (int k = 0; k < this.m_listeners.get_Count(); k++) { IClientConnectionListener <PacketType> clientConnectionListener = this.m_listeners.get_Item(k); object state = this.m_listenerStates.get_Item(k); clientConnectionListener.PacketReceived(current.Packet, state); } break; } } } this.m_connectionEvents.Clear(); } if (this.m_socket == null || this.m_connectionState != ClientConnection <PacketType> .ConnectionState.Connected) { return; } this.SendQueuedPackets(); }
/// <summary> /// Tries, asynchronously, to connect a UDPX client to the given endpoint. The connect handler will be called with /// null if no connection can be established. /// </summary> public static void Connect(IPEndPoint EndPoint, ConnectHandler OnConnect) { // Create sequence number int seq = _CreateInitialSequence(); byte[] handshake = new byte[5]; handshake[0] = (byte)PacketType.Handshake; _WriteInt(seq, handshake, 1); UdpClient cli = new UdpClient(); int attempts = 5; double attemptinterval = 0.5; double timeout = 1.0; // Set up request timer Timer timer = new Timer(attemptinterval * 1000.0); timer.Elapsed += delegate { lock (cli) { if (OnConnect != null) { if (attempts > 0) { Send(cli, EndPoint, handshake); attempts--; } else { timer.Dispose(); timer = new Timer(timeout * 1000.0); timer.AutoReset = false; timer.Elapsed += delegate { lock (cli) { if (OnConnect != null) { // Timeout OnConnect(null); OnConnect = null; ((IDisposable)cli).Dispose(); } timer.Dispose(); } }; timer.Start(); } } else { timer.Dispose(); } } }; timer.AutoReset = true; // Send initial attempt to open receiving port. Send(cli, EndPoint, handshake); attempts--; // Create receive callback ReceiveRawPacketHandler receivepacket = null; List<byte[]> queue = new List<byte[]>(); Receive(cli, receivepacket = delegate(IPEndPoint From, byte[] Data) { lock (cli) { if (OnConnect != null) { if (From.Equals(EndPoint)) { if (Data.Length == 5 && Data[0] == (byte)PacketType.HandshakeAck) { int recvseq = _ReadInt(Data, 1); _ClientConnection cc = new _ClientConnection(seq, recvseq, cli, EndPoint); OnConnect(cc); // Give the new connection the messages intended for it foreach (byte[] qdata in queue) { cc.ReceiveRaw(qdata); } OnConnect = null; } else { // Add data to packet queue and try again queue.Add(Data); Receive(cli, receivepacket); } } else { // Not the packet we were looking for, try again... Receive(cli, receivepacket); } } } }); // Begin sending more attempts timer.Start(); }
/// <summary> /// /// </summary> internal ClientSocketManager( Connecter connecter, ConnectHandler connectHandler, ReceiveQueue receiveBuffer ) { if ( connecter == null ) throw new ArgumentNullException( "ClientSocketHandler.ClientSocketManager(...) - listener == null error!" ); if ( connectHandler == null ) throw new ArgumentNullException( "ClientSocketHandler.ClientSocketManager(...) - serviceHandle == null error!" ); if ( receiveBuffer == null ) throw new ArgumentNullException( "receiveBuffer", "ClientSocketHandler.ClientSocketManager(...) - receiveBuffer == null error!" ); m_Connecter = connecter; m_ConnectHandle = connectHandler; m_ReceiveBuffer = receiveBuffer; { // ������� m_ReceiveBuffer.Clear(); } // ��ʼ������ ��ʾ��û���ù�Free(...)���� m_LockFree.SetValid(); }
/// <summary> Constructor for SocketServer Suppport </summary> /// <param name="socketServer"> A Reference to the parent SocketServer </param> /// <param name="clientSocket"> The Socket object we are encapsulating </param> /// <param name="socketListArray"> The index of the SocketServer Socket List Array </param> /// <param name="ipAddress"> The IpAddress of the remote server </param> /// <param name="port"> The Port of the remote server </param> /// <param name="messageHandler"> Reference to the user defined message handler function </param> /// <param name="closeHandler"> Reference to the user defined close handler function </param> /// <param name="errorHandler"> Reference to the user defined error handler function </param> /// <param name="sizeOfRawBuffer"> The size of the raw buffer </param> /// <param name="userArg"> A Reference to the Users arguments </param> public SocketClient(SocketServer socketServer, Socket clientSocket, string ipAddress, int port, int sizeOfRawBuffer, object userArg, MessageHandler messageHandler, CloseHandler closeHandler, ErrorHandler errorHandler, ConnectHandler connectHandler) :this(sizeOfRawBuffer,userArg, messageHandler,closeHandler,errorHandler, connectHandler) { // Set reference to SocketServer this.socketServer = socketServer; // Init the socket references this.clientSocket = clientSocket; // Set the Ipaddress and Port this.ipAddress = ipAddress; this.port = port; // Init the NetworkStream reference this.networkStream = new NetworkStream(this.clientSocket); // Set these socket options this.clientSocket.SetSocketOption(System.Net.Sockets.SocketOptionLevel.Socket, System.Net.Sockets.SocketOptionName.ReceiveBuffer, this.receiveBufferSize); this.clientSocket.SetSocketOption(System.Net.Sockets.SocketOptionLevel.Socket, System.Net.Sockets.SocketOptionName.SendBuffer, this.sendBufferSize); this.clientSocket.SetSocketOption(System.Net.Sockets.SocketOptionLevel.Socket, System.Net.Sockets.SocketOptionName.DontLinger, 1); this.clientSocket.SetSocketOption(System.Net.Sockets.SocketOptionLevel.Tcp, System.Net.Sockets.SocketOptionName.NoDelay, 1); // Wait for a message Receive(); }
/// <summary> /// Overloaded constructor for client support /// </summary> /// <param name="sendBufferSize"></param> /// <param name="receiveBufferSize"></param> /// <param name="sizeOfRawBuffer"> The size of the raw buffer </param> /// <param name="userArg"> A Reference to the Users arguments </param> /// <param name="messageHandler"> Reference to the user defined message handler method </param> /// <param name="closeHandler"> Reference to the user defined close handler method </param> /// <param name="errorHandler"> Reference to the user defined error handler method </param> public SocketClient(int sendBufferSize, int receiveBufferSize, int sizeOfRawBuffer, object userArg, MessageHandler messageHandler, CloseHandler closeHandler, ErrorHandler errorHandler, ConnectHandler conenectHandler ) : this(sizeOfRawBuffer, userArg, messageHandler, closeHandler, errorHandler, conenectHandler) { //Set the size of the send/receive buffers this.sendBufferSize = sendBufferSize; this.receiveBufferSize = receiveBufferSize; }
public void Update() { SslSocket.Process(); List <SslClientConnection.ConnectionEvent> connectionEvents = this.m_connectionEvents; lock (connectionEvents) { using (List <SslClientConnection.ConnectionEvent> .Enumerator enumerator = this.m_connectionEvents.GetEnumerator()) { while (enumerator.MoveNext()) { SslClientConnection.ConnectionEvent current = enumerator.get_Current(); switch (current.Type) { case SslClientConnection.ConnectionEventTypes.OnConnected: { if (current.Error != BattleNetErrors.ERROR_OK) { this.Disconnect(); this.m_connectionState = SslClientConnection.ConnectionState.ConnectionFailed; } else { this.m_connectionState = SslClientConnection.ConnectionState.Connected; } ConnectHandler[] array = this.m_connectHandlers.ToArray(); for (int i = 0; i < array.Length; i++) { ConnectHandler connectHandler = array[i]; connectHandler(current.Error); } break; } case SslClientConnection.ConnectionEventTypes.OnDisconnected: { if (current.Error != BattleNetErrors.ERROR_OK) { this.Disconnect(); } DisconnectHandler[] array2 = this.m_disconnectHandlers.ToArray(); for (int j = 0; j < array2.Length; j++) { DisconnectHandler disconnectHandler = array2[j]; disconnectHandler(current.Error); } break; } case SslClientConnection.ConnectionEventTypes.OnPacketCompleted: for (int k = 0; k < this.m_listeners.get_Count(); k++) { IClientConnectionListener <BattleNetPacket> clientConnectionListener = this.m_listeners.get_Item(k); object state = this.m_listenerStates.get_Item(k); clientConnectionListener.PacketReceived(current.Packet, state); } break; } } } this.m_connectionEvents.Clear(); } if (this.m_sslSocket == null || this.m_connectionState != SslClientConnection.ConnectionState.Connected) { return; } while (this.m_outQueue.get_Count() > 0) { if (this.OnlyOneSend && !this.m_sslSocket.m_canSend) { return; } BattleNetPacket packet = this.m_outQueue.Dequeue(); this.SendPacket(packet); } }
public Listener(int Port, ConnectHandler OnConnect) { this._Client = new UdpClient(Port); this._Connections = new Dictionary<IPEndPoint, _LConnection>(); this._OnConnect = OnConnect; this._BeginListen(); }