//初始化服务 public void InitService(string address, string port, ReceiveCallBack recvCall = null) { try { m_socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); //获取ip地址 IPAddress ip = IPAddress.Parse(address.Trim()); //创建端口号 IPEndPoint point = new IPEndPoint(ip, Convert.ToInt32(port.Trim())); //绑定IP地址和端口号 m_socketWatch.Bind(point); //开始监听:设置最大连接请求数目 m_socketWatch.Listen(10); if (recvCall != null) { m_recvCallBack = recvCall; string strMsg = "开启监听成功!"; byte[] buffer = Encoding.Default.GetBytes(strMsg); m_recvCallBack("", buffer, buffer.Length); } //创建线程 AcceptSocketThread = new Thread(new ParameterizedThreadStart(StartListen)); AcceptSocketThread.IsBackground = true; AcceptSocketThread.Start(m_socketWatch); } catch (SocketException ex) { byte[] buffer = Encoding.Default.GetBytes(ex.Message); m_recvCallBack("", buffer, buffer.Length); } }
public void AsyncConnect(string ip, ushort port, NormalNetCallBack connectBack, NormalNetCallBack sendBack, ReceiveCallBack callBackRecv, NormalNetCallBack disConnect) { // m_error = ErrorSockets.Success; this.m_callBackConnect = connectBack; if (clientSocket != null && clientSocket.Connected) { this.m_callBackConnect(false, ErrorSockets.MutiConnect, "重复连接"); return; } this.m_callBackSend = sendBack; this.m_callBackReceive = callBackRecv; this.m_callBackDisConnect = disConnect; if (clientSocket == null || !clientSocket.Connected) { clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); IPAddress address = IPAddress.Parse(ip); IPEndPoint point = new IPEndPoint(address, port); IAsyncResult connectAr = clientSocket.BeginConnect(point, ConnectCallBack, clientSocket); if (!WriteDot(connectAr)) { connectBack(false, ErrorSockets.ConnectTimeOut, "连接超时"); } } }
// 初始化服务 public void InitService(string address, string port, ReceiveCallBack recvCall = null) { try { m_socketSend = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); IPAddress ip = IPAddress.Parse(address.Trim()); m_socketSend.Connect(ip, Convert.ToInt32(port.Trim())); // 实例化回调 if (recvCall != null) { m_recvCallBack = recvCall; } // 开启一个新的线程不停的接收服务器发送消息的线程 threadReceive = new Thread(new ThreadStart(Receive)); // 设置为后台线程 threadReceive.IsBackground = true; threadReceive.Start(); } catch (SocketException ex) { byte[] buffer = Encoding.Default.GetBytes(ex.Message); if (m_recvCallBack != null) { m_recvCallBack(buffer, buffer.Length); } } }
public SocketClient(string address, int port, ReceiveCallBack callBack) { this.callBack = callBack; this.address = address; this.port = port; connectionStatus = ConnectionStatus.connecting; if (tryConnect()) { startCheckHeartBeat(); startReceiveMessage(); } else { startReconnect(); } }
//初始化服务器信息 public void InitServer(ReceiveCallBack cb) { this.callback = cb; // 1. Socket server_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); // 2. IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, 2222); // 3. server_socket.Bind(endPoint); // 4. server_socket.Listen(10); // 5.开始异步等待客户端的请求链接 server_socket.BeginAccept(new System.AsyncCallback(Accept), server_socket); this.callback("开启服务器" + endPoint.ToString()); }
// Create an uninitialized server instance. // To start the server listening for connection requests // call the Init method followed by Start method // // <param name="numConnections">the maximum number of connections the sample is designed to handle simultaneously</param> // <param name="receiveBufferSize">buffer size to use for each socket I/O operation</param> // <param name="ReceiveCallBack">接收到消息的回调函数</param> public MicrosoftServer(int numConnections, int receiveBufferSize, ReceiveCallBack rcb) { m_totalBytesRead = 0; m_numConnectedSockets = 0; m_numConnections = numConnections; m_receiveBufferSize = receiveBufferSize; receiveCallBack = rcb; // allocate buffers such that the maximum number of sockets can have one outstanding read and //write posted to the socket simultaneously m_bufferManager = new BufferManager(receiveBufferSize * numConnections * opsToPreAlloc, receiveBufferSize); m_readPool = new SocketAsyncEventArgsPool(numConnections); m_writePool = new SocketAsyncEventArgsPool(numConnections); m_maxNumberAcceptedClients = new Semaphore(numConnections, numConnections); m_buffer = new List <Byte>(); }
//初始化客户端Socket信息 public void InitClient(string ip, int port, ReceiveCallBack ccb) { this.clientReceiveCallBack = ccb; this.clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); IPAddress address = IPAddress.Parse(ip); IPEndPoint ep = new IPEndPoint(address, port); try { this.clientSocket.Connect(ep); }catch (SocketException e) { throw e; } //开始异步等待接收服务端消息 this.clientSocket.BeginReceive(Buffer, 0, Buffer.Length, SocketFlags.None, new System.AsyncCallback(ReceiveFromServer), this.clientSocket); }
public void StartReceive(string ip, int port, ReceiveCallBack onReceive, ErrorCallBack onError = null) { Debugger.Log("UDPClient::StartReceive"); //AddressFamily addressFamily; //string connectIP; //NetworkHelper.GetIPType(ip, out connectIP, out addressFamily); _targetIp = new IPEndPoint(IPAddress.Parse(ip), port); _udpClient = new UdpClient(AddressFamily.InterNetwork); if (_SelfIp != null) { _udpClient.Client.Bind(_SelfIp); } _udpClient.Client.SendBufferSize = 1024 * 128; _udpClient.Client.ReceiveBufferSize = 1024 * 128; _receiveCallBack = onReceive; _errorCallBack = onError; _isReceive = true; _recvThread = new Thread(Receive); _recvThread.Start(); }
/// <summary> /// 异步接受请求(Server) /// </summary> /// <param name="callBack">回调函数</param> /// <returns>处理结果</returns> public void Receive(string remoteEndPoint, ReceiveCallBack callBack = null) { Byte[] msg = new byte[1024]; //异步的接受消息 Socket cSocket = clientConnections[remoteEndPoint]; cSocket.BeginReceive(msg, 0, msg.Length, SocketFlags.None, ar => { //连接断开时抛出Socket Exception try { //结束挂起的异步线程 cSocket.EndReceive(ar); //还原字符串 if (callBack != null) { callBack(cSocket.RemoteEndPoint.ToString(), Encoding.UTF8.GetString(msg).Trim('\0', ' ')); } Receive(remoteEndPoint, callBack); } catch (Exception e) { //对于连接断开的异常 移除维持的Socket if (e is SocketException) { clientConnections.Remove(remoteEndPoint); cSocket.Close(); OnClientOffline?.Invoke(remoteEndPoint); } else //对于其他的异常 移除维持的Socket并触发异常事件 { OnException?.Invoke(e); clientConnections.Remove(remoteEndPoint); cSocket.Close(); OnClientOffline?.Invoke(remoteEndPoint); } } }, null); }
private void ReceivedReboot(object data) { ReceiveCallBack d = new ReceiveCallBack(Rebooted); this.Invoke(d, new object[] { data }); }
private void ReceivedFileChange(object data) { ReceiveCallBack d = new ReceiveCallBack(ShowProgressBar); this.Invoke(d, new object[] { data }); }
protected void ReceivedRebootHandle(object data) { ReceiveCallBack d = new ReceiveCallBack(Rebooting); this.Invoke(d, new object[] { data }); }
public void FileTransferHandle(object data) { ReceiveCallBack d = new ReceiveCallBack(FileTransmitting); this.Invoke(d, new object[] { data }); }
/// <summary> /// 接受到信息 /// </summary> public static void DoReceive(Action<JObject> action) { OnReceive += new ReceiveCallBack(action); }