/// <summary> /// Denne metode håndterer kommunikation mellem clienten og serverens på asynkron vis. /// </summary> public void AcceptCallback(IAsyncResult asyncResult) { //Her laves en lokal variable af typen socket, den deklareres her fordi at socketens scope skal persistere udenfor try catch kaldet lige under. Socket tempSocket; //Her forsøges der at placerer en client socket på lokal variablen. try { //Server socketen benytter sig at funktionen som opretter en socket instans som placeres på lokal variablen uden for try catchens scope. tempSocket = ServerSocket.EndAccept(asyncResult); } //Hvis objektet ikke længere eksisterer kastes objectdisposedexceptionen. I tilfælde af det ikke lykkedes at oprette en forbindelse på den lokale socket. catch (ObjectDisposedException x) //Denne exception bliver kastet når at der bliver forsøgt at blive gjort noget på et objekt som allerede er skillet af med. { Debug.WriteLine(x); return; } lock (ClientSocket) { //I dette kald bliver den nyoprettet client socket tilføjet til serverens clientsocket liste. ClientSocket.Add(tempSocket); } //Her begynder den nyoprettet socket at modtage information fra clientens socket. tempSocket.BeginReceive(Buffer, 0, BufferSize, SocketFlags.None /* TODO - Gå hjem og find ud af hvad singlecast og multicast er*/, ReceiveCallBack, tempSocket); Debug.WriteLine("Client forbundet, venter på input"); //Serverens socket kalder beginaccept rekusivt for hele tiden at se om der er nye data og forbindelser mellem client socketen og serverens socket. ServerSocket.BeginAccept(AcceptCallback, null); }
private void SetupServer() { ServerSocket.Bind(new IPEndPoint(IPAddress.Any, Port)); ServerSocket.Listen(0); ServerSocket.BeginAccept(AcceptCallback, null); ServerListening?.Invoke("Server listening on port " + Port); }
private void StartServer() { ServerSocket.Bind(TcpEndPoint); ServerSocket.Listen(10); ServerSocket.BeginAccept(new AsyncCallback(AcceptCallback), ServerSocket); }
// This is the call back function, which will be invoked when a client is connected public void OnClientConnect(IAsyncResult asyn) { try { // Here we complete/end the BeginAccept() asynchronous call // by calling EndAccept() - which returns the reference to // a new Socket object Socket clientSocket = ServerSocket.EndAccept(asyn); AsyncClient asyncClient = new AsyncClient(clientSocket); Clients.Add(asyncClient); AsyncClientsDict.Add(clientSocket, asyncClient); ClientConnected(this, new ServerClientEventArgs(asyncClient)); // Let the worker Socket do the further processing for the // just connected client WaitForData(clientSocket); // Now increment the client count // Since the main Socket is now free, it can go back and wait for // other clients who are attempting to connect ServerSocket.BeginAccept(new AsyncCallback(OnClientConnect), null); } catch (Exception ex) { ServerException(this, new ExceptionEventArgs(ex)); } }
private void AcceptCallback(IAsyncResult ar) { Socket listener = (Socket)ar.AsyncState; Socket handler = listener.EndAccept(ar); StateObject state = new StateObject(); state.workSocket = handler; PersonId++; Person person = new Person(); JsonContainer jsonContainer = new JsonContainer() { CurrentPersonId = new CurrentPersonId(), Messages = new System.Collections.ObjectModel.ObservableCollection <MessageContent>(), Persons = new List <Person>() }; MessageContent messageContent = new MessageContent(); Connect connect = new Connect(PersonId, person, jsonContainer, messageContent, _uIViewModel); connect.FirstTime = true; handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, SocketFlags.None, new AsyncCallback(connect.ReadCallback), state); ReadDone.WaitOne(); ServerSocket.BeginAccept(new AsyncCallback(AcceptCallback), listener); }
public void Start(int port, int backlog) { if (!ServerSocket.Connected) { ServerSocket.Bind(new IPEndPoint(IPAddress.Any, port)); ServerSocket.Listen(backlog); ServerSocket.BeginAccept(new AsyncCallback(OnAccept), ServerSocket); } }
/// <summary> /// Метод асинхронного принятия новых подключений /// </summary> /// <param name="result"></param> private void AcceptCallback(IAsyncResult result) { lock (locker) { if (IsListeningStatus != false) { ConnectionValue connection = new ConnectionValue(); try { // Завершение операции Accept connection.Socket = ServerSocket.EndAccept(result); connection.SocketID = connection.Socket.Handle; connection.Buffer = new byte[SizeBuffer]; connection.RemoteIP = ((IPEndPoint)connection.Socket.RemoteEndPoint).Address.ToString(); connection.RemotePort = ((IPEndPoint)connection.Socket.RemoteEndPoint).Port; lock (Сonnections) Сonnections.Add(connection); // Начало операции Receive и новой операции Accept connection.Socket.BeginReceive(connection.Buffer, 0, connection.Buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), connection); //Сообщаем о новом подключении CallConnected(connection); } catch (SocketException exc) { CallErrorServer(Sockets.ServerErrorType.AcceptError, exc.Message + exc.ToString()); CloseConnection(connection); } catch (Exception exc) { CallErrorServer(Sockets.ServerErrorType.AcceptError, exc.Message + exc.ToString()); CloseConnection(connection); } finally { try { if (ServerSocket != null && ServerSocket.IsBound) { ServerSocket?.BeginAccept(new AsyncCallback(AcceptCallback), null); } } catch (Exception ex) { CallErrorServer(Sockets.ServerErrorType.AcceptError, ex.Message + ex.ToString()); } } } } }
private void OnAccept(IAsyncResult ar) { Socket sock = ServerSocket.EndAccept(ar); Sock.Client client = new Sock.Client(sock, DataBuffer.Length); client.EncryptionKey = EncryptionKey; client.EncryptionSettings = EncryptionSettings; client.UseEncryption = UseEncryption; if (OnClientAccepted != null) { OnClientAccepted(client); } client.ClientSocket.BeginReceive(DataBuffer, 0, DataBuffer.Length, SocketFlags.None, new AsyncCallback(OnReceive), client); ServerSocket.BeginAccept(new AsyncCallback(OnAccept), sock); }
private void AcceptCallback(IAsyncResult ar) { Socket socket; try { socket = ServerSocket.EndAccept(ar); } catch (ObjectDisposedException) // I cannot seem to avoid this (on exit when properly closing sockets) { return; } ClientSockets.Add(socket); socket.BeginReceive(Buffer, 0, BufferSize, SocketFlags.None, ReceiveCallback, socket); // Console.WriteLine("Client connected, waiting for request..."); ClientConnected?.Invoke(); ServerSocket.BeginAccept(AcceptCallback, null); }
private void AcceptNextPendingConnection() { try { ServerSocket.BeginAccept(OnAcceptCallback, null); OnReportingStatus(StatusCode.Info, "Started accepting new TCP connection"); } catch (ObjectDisposedException) { } catch (SocketException socketException) { OnCaughtException(socketException, EventCode.Accept); } catch (Exception exception) { OnCaughtException(exception, EventCode.Other); } }
//开启服务 private void BtnOpenServer_Click(object sender, EventArgs e) { try { if (radioBtnchooseTCP.Checked == true)//选择建立TCP { ServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); } if (radioBtnchooseUDP.Checked == true)//选择建立UDP { ServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); } IP = IPBox.Text; Port = Convert.ToInt32(PortBox.Text); //Assign the any IP of the machine and listen on port number 8080 IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Parse(IP), Port); //Bind and listen on the given address ServerSocket.Bind(ipEndPoint); ServerSocket.Listen(8080); //Accept the incoming clients ServerSocket.BeginAccept(new AsyncCallback(OnAccept), ServerSocket); BtnOpenServer.Enabled = false; BtnCloseServer.Enabled = true; //DebugLog.Debug("socket监听服务打开"); } catch (Exception ex) { //MessageBox.Show(ex.Message, "error",MessageBoxButtons.OK, MessageBoxIcon.Error); Console.WriteLine(ex.Message + "---" + DateTime.Now.ToLongTimeString() + "出错信息:" + "\n"); //DebugLog.Debug(ex); } }
private void AcceptCallback(IAsyncResult AR) { lock (lockAccept) { Socket socket; try { socket = ServerSocket.EndAccept(AR); var session = new SocketSession(socket, BufferSize); ClientSockets.Add(session); socket.BeginReceive(session.SessionStorage, 0, BufferSize, SocketFlags.None, ReceiveCallback, socket); ServerSocket.BeginAccept(AcceptCallback, null); } catch (Exception ex) // I cannot seem to avoid this (on exit when properly closing sockets) { LogController.WriteLog(new ServerLog("*** ERROR ***: \n" + ex.Message, ServerLogType.ERROR)); } } }
public void Start(bool waitForUserTypeExit = true) { if (Started) { throw new Exception("Server already has been started."); } Stopwatch sw = new Stopwatch(); sw.Start(); Initialize(); ServerSocket.Bind(new IPEndPoint(IPAddress.Any, Port)); ServerSocket.Listen(0); ServerSocket.BeginAccept(AcceptCallback, null); Started = true; ServerStarted?.Invoke(); RunServerStartupTasks(); sw.Stop(); LogController.WriteLog(new ServerLog($"Server started in {sw.ElapsedMilliseconds}ms", "Server", "Start")); LogController.WriteLog(new ServerLog($"Running at port {Port}")); Console.WriteLine("Type 'exit' to stop; 'reboot' to send reboot request event..."); string line = ""; if (waitForUserTypeExit) { while (line != "exit") { line = Console.ReadLine(); if (line == "reboot") { RebootRequest?.Invoke(); } } } }
/// <summary> /// Запуск сервера /// </summary> /// <param name="port">порт сервера для прослушивания</param> public void Start(int port) { lock (locker) { Port = port; try { if (SetupServerSocket()) { ServerSocket.BeginAccept(new AsyncCallback(AcceptCallback), ServerSocket); IsListeningStatus = true; CallStatus(ServerStatus.Start); } else { CallErrorServer(ServerErrorType.StartListenError, "Failed to create socket"); } } catch (Exception exс) { CallErrorServer(ServerErrorType.StartListenError, exс.Message); } } }
/// <summary> /// Opens the port and start accepting connections /// </summary> public void Start() { Debug("Opening Socket...", DebugParams); ServerSocket.BeginAccept(new AsyncCallback(OnClientAccept), null); }
private void AcceptClient() { ServerSocket.BeginAccept(ClientJoined, ServerSocket); }