精华内容
下载资源
问答
  • Socket 同步和异步模式

    千次阅读 2016-04-21 15:04:10
    学习socket 的一些笔记,希望大家一起讨论 。 一.什么是socket  所谓socket通常也称作"套接字",应用程序通常通过"套接字"向网络发出请求或者应答网络请求。 以J2SDK-1.3为例,SocketServerSocket类库位于java ...

     

     学习socket 的一些笔记,希望和大家一起讨论 。
    一.什么是socket
      所谓socket通常也称作"套接字",应用程序通常通过"套接字"向网络发出请求或者应答网络请求。 以J2SDK-1.3为例,Socket和ServerSocket类库位于java .net包中。ServerSocket用于服务器端,Socket是建立网络连接时使用的。在连接成功时,应用程序两端都会产生一个Socket实例,操作这个实例,完成所需的会话。对于一个网络连接来说,套接字是平等的,并没有差别,不因为在服务器端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl类及其子类完成的。

    二 .开发原理:
      服务器,使用ServerSocket监听指定的端口,端口可以随意指定(由于1024以下的端口通常属于保留端口,在一些操作系统中不可以随意使用,所以建议使用大于1024的端口),等待客户连接请求,客户连接后,会话产生;在完成会话后,关闭连接。   客户端,使用Socket对网络上某一个服务器的某一个端口发出连接请求,一旦连接成功,打开会话;会话完成后,关闭Socket。客户端不需要指定打开的端口,通常临时的、动态的分配一个1024以上的端口。Socket接口是TCP/IP网络的API,Socket接口定义了许多函数或例程,程序员可以用它们来开发TCP/IP网络上的应用程序。要学Internet上的TCP/IP网络编程,必须理解Socket接口。 Socket接口设计者最先是将接口放在Unix操作系统里面的。如果了解Unix系统的输入和输出的话,就很容易了解Socket了。网络的Socket数据传输是一种特殊的I/O,Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用Socket(),该函数返回一个整型的Socket描述符,随后的连接建立、数据传输等操作都是通过该Socket实现的。

    三.简单的socket 同步代码,目前代码没有上服务器测试,不知道同步和异步的效果怎么样!

      需求

       1.客户端是公司内部的机器200台计算机。
       2.可以同时连接,长连接。
       3.服务器接受到客户端发来的信息,发送 socket数据  发送给总公司socket服务器 ,总公司返回数据。

     socket 同步简单代码

    复制代码
      public  class Server
         {
              
    static void Main(string[] args)
              {

                   IPEndPoint localEndPoint 
    = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9050);
                   
    //创建 socket Tcp 
                   Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                   
    try
                   {    
                        listener.Bind(localEndPoint);
                        listener.Listen(
    10);
                        
    while (true)
                        {
                             Socket connection 
    = listener.Accept();
                             SocketProxy sp 
    = new SocketProxy(connection);
                             Thread thread 
    = new Thread(new ThreadStart(sp.TcpSendData));
                             thread.Name 
    = connection.RemoteEndPoint.ToString();
                             thread.Start();

                        }

                   }
                   
    catch (Exception ex)
                   {
                        Console.WriteLine(ex.StackTrace);
                   }
              }
         }

      
    public class SocketProxy
         {

              
    private Socket _socket;
              
    public SocketProxy(Socket connection)
              {
                   
    this._socket = connection;
              }

              
    public void TcpSendData()
              {
                   
    byte[] bytes;
                   
    string data = string.Empty;
                   
    while (true)
                   {

                        bytes 
    = new byte[1024];
                        
    // Receive client data 
                        int bytesRec = this._socket.Receive(bytes);
                        
    // convert bytes to  string
                        data = Encoding.ASCII.GetString(bytes, 0, bytesRec);
                        Console.WriteLine(data);

                   }
              }
         }


    复制代码

     异步代码

    复制代码
         internal class SocketServer
         {
              
    static void Main(string[] args)
              {

                   SocketTcpListener listener 
    = new SocketTcpListener();
                   listener.StartListening();

              }
         }
         
        
         
    internal class SocketTcpListener
         {

              
    public static ManualResetEvent allDone = new ManualResetEvent(false);
              //开始监听
              
    public void StartListening()
              {
                   
    //Data buffer for incoming data.
                   byte[] bytes = new Byte[1024];

                   
    //Establish the local endpoint for the socket.
                   
    //The DNS name of the computer
                   
    //running the listener is "host.contoso.com".
                   
    //IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
                   IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
                   IPEndPoint localEndPoint 
    = new IPEndPoint(ipAddress, 9050);

                   
    // Create a TCP/IP socket.
                   Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                   
    // Bind the socket to the local endpoint and listen for incoming connections.
                   try
                   {
                        listener.Bind(localEndPoint);
                        listener.Listen(
    10);
                        
    while (true)
                        {
                             
    // Set the event to nonsignaled state.
                             allDone.Reset();
                             
    // Start an asynchronous socket to listen for connections.
                             Console.WriteLine("Waiting for a connection");
                             StateObject state 
    = new StateObject();
                             listener.BeginAccept(
    new AsyncCallback(AcceptCallback), listener);
                             
                             
                             
    // Wait until a connection is made before continuing.
                             allDone.WaitOne();
                        }

                   }
                   
    catch (Exception e)
                   {
                        Console.WriteLine(e.ToString());
                   }


              }


              
    //异步接受 
              private static void AcceptCallback(IAsyncResult ar)
              {
                   
    // Signal the main thread to continue.
                   allDone.Set();

                   
    // Get the socket that handles the client request.
                   Socket listener = (Socket)ar.AsyncState;
                   Socket handler 
    = listener.EndAccept(ar);
                   
    // Create the state object.
                   StateObject state = new StateObject();
                   state.workSocket 
    = handler;

                   Array.Clear(state.buffer, 
    0, state.buffer.Length); // 清空缓存,避免脏读

                   handler.BeginReceive(state.buffer, 
    0, StateObject.BufferSize, 0new AsyncCallback(ReadCallback), state);
              }


              
    //异步读取
              public static void ReadCallback(IAsyncResult ar)
              {
                   String content 
    = String.Empty;
                   String resultdata 
    = string.Empty;
                   
    // Retrieve the state object and the handler socket
                   
    // from the asynchronous state object.
                   StateObject state = (StateObject)ar.AsyncState;
                   Socket handler 
    = state.workSocket;

                   
    // Read data from the client socket. 
                   int bytesRead = handler.EndReceive(ar);

                   
    if (bytesRead > 0)
                   {
                        
    // There  might be more data, so store the data received so far.
                        
    // state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));

                        
    // Check for end-of-file tag. If it is not there, read 
                        
    // more data.


                        content 
    = Encoding.ASCII.GetString(state.buffer, 0, bytesRead);
                        Array.Clear(state.buffer, 
    0, state.buffer.Length); // 清空缓存,避免脏读




                        Console.WriteLine(content);
                    
     if (content.Length > -1)
                        {

                             
    // All the data has been read from the 
                             
    // client. Display it on the console.
                             
    //Console.WriteLine("Read {0} bytes from socket. \n Data : {1}", content.Length, content);
                             
    // Echo the data back to the client.

                             
    //SocketTcpClient.CreateSocketObjest();

                             
    // get caac data  
                             
    // 0 如果是第一次,需要创建socket对象,发送登陆信息,匹配出用户名(<name,socket>),存放到集合
                             
    // 1.如果用户存在,需要使用用户名来匹配socket对象,如果没有连接配置,需要创建socket对象,保存到集合以便下次使用连接对象,避免再次的登陆
                             
    // 2.发送数据完,远程服务器会返回信息给Socket Server 
                             
    // 3.Socket Server 返回信息给 Clinet


                             state.ResultData 
    = content;
                             state.SocketName 
    = "Jackyong";
                             
                             resultdata 
    =SocketTcpClient.Send(handler, content);



                             
    // send client


                             
    //Send(handler, resultdata);
                             Send(state);


                        }
                        
    //else
                        
    //{
                        
    //     // Not all data received. Get more.
                        
    //     handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,new AsyncCallback(ReadCallback), state);
                        
    //}
                   }
              }


              
    //发送数据
              private static void Send(StateObject state)
              {
                   Array.Clear(state.buffer, 
    0, state.buffer.Length); // 清空缓存,避免脏读
                   
    // Convert the string data to byte data using ASCII encoding.
                   byte[] byteData = Encoding.ASCII.GetBytes(state.ResultData);
                   
    // Begin sending the data to the remote device.
                   state.workSocket.BeginSend(byteData, 0, byteData.Length, 0new AsyncCallback(SendCallback), state);
              }

              // 异步发送数据给client 
              
    private static void SendCallback(IAsyncResult ar)
              {
                   
    try
                   {
                        
    // Retrieve the socket from the state object.
                        
    // Socket handler = (Socket)ar.AsyncState;
                        StateObject state = (StateObject)ar.AsyncState;

                        
    // Complete sending the data to the remote device.
                        int bytesSent = state.workSocket.EndSend(ar);

                        
    // if detect exceptoin  socket shut down /close
                        
    //  handler.Shutdown(SocketShutdown.Both);
                        
    //  handler.Close();

                        
    // continue to listener
                        
    //StateObject state = new StateObject();
                        
    //state.workSocket = handler;
                        
                        Array.Clear(state.buffer, 
    0, state.buffer.Length); // 清空缓存,避免脏读
                        state.workSocket.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0new AsyncCallback(ReadCallback), state);

                   }
                   
    catch (Exception e)
                   {
                        Console.WriteLine(e.ToString());
                   }
              }

         }

       
    internal class SocketTcpClient
         {
              
    /// <summary>
              
    /// create socket object  ,client send server 
              
    /// </summary>
              
    /// <param name="command">command</param>
              
    /// <returns>data</returns>
              public static Socket CreateSocketObjest()
              {
                   
    //需要存储这个连接对象 

                   
    string receivemsg = string.Empty;
                   
    byte[] data = new byte[1024];
                   
    string IP = "127.0.0.1";
                   
    int Port = 9050;
                   IPEndPoint ie 
    = new IPEndPoint(IPAddress.Parse(IP), Port);//服务器的IP和端口  
                   Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                   
    try
                   {
                        
    //因为客户端只是用来向特定的服务器发送信息,所以不需要绑定本机的IP和端口。不需要监听。  
                        client.Connect(ie);
                   }
                   
    catch (SocketException e)
                   {
                        
    //close  socket and writing error exception
                        Console.WriteLine(e.ToString());

                   }
                   
    return client;
              }

              
    /// <summary>
              
    /// client send command server
              
    /// </summary>
              
    /// <param name="client">socket</param>
              
    /// <param name="command">command</param>
              
    /// <returns>data</returns>
              public static string Send(Socket client, string command)
              {
                   
    byte[] data = new byte[1024];
                   
    string result = string.Empty;
                   
    //send command
                   ClientSendDataServer(client, command);

                   
    if (client.Poll(-1, SelectMode.SelectRead))
                   {    
    //如果传递过来的是string.empty 字符串也是0 

                        
    int recv = client.Receive(data);
                        
    if (recv == 0)
                        {
                             
    //socket连接已断开
                        }
                        result 
    = Encoding.ASCII.GetString(data, 0, recv);
                        Console.WriteLine(result);
                   }

                   
    return result;
              }



              
    /// <summary>
              
    /// client to server 
              
    /// </summary>
              
    /// <param name="handler">socket </param>
              
    /// <param name="data">comand</param>
              private static void ClientSendDataServer(Socket client, String command)
              {
                   
    // Convert the string data to byte data using ASCII encoding.
                   byte[] byteData = Encoding.ASCII.GetBytes(command);
                   
    // Begin sending the data to the remote device.
                   client.Send(byteData);
              }


         }

       
    /// <summary>
         
    /// 存放客户端与总公司的登陆信息
         
    /// </summary>
         internal class SocketUser
         {
              
    private System.Collections.Generic.Dictionary<string, Socket> _sockets;
              
              
    public SocketUser()
              {
                   _sockets 
    = new Dictionary<string, Socket>();
              }

              
    /// <summary>
              
    /// select client user
              
    /// </summary>
              
    /// <param name="key"></param>
              
    /// <returns></returns>
              public Socket Find(string key)
              {
                   Socket socket 
    = null; ;
                   
    if (key == null || key == string.Empty)
                   {

                   }
                   
    if (_sockets[key] != null)
                   {
                        socket 
    = _sockets[key] as Socket;
                   }
                   
    return socket;
              }


              
    /// <summary>
              
    /// add  client in  sockets 
              
    /// </summary>
              
    /// <param name="key"></param>
              
    /// <param name="sk"></param>
              public void Add(string key, Socket sk)
              {
                   _sockets.Add(key, sk);

              }

              
    /// <summary>
              
    /// Remove client  user 
              
    /// </summary>
              
    /// <param name="key"></param>
              public void Remove(string key)
              {
                   _sockets.Remove(key);
              }




         }

       // socket state
        internal class StateObject
         {
              
    // socket name 
              public string SocketName { getset; }
              
    // Client  socket.
              public Socket workSocket = null;
              
    // Size of receive buffer.
              public const int BufferSize = 1024;
              
    // Receive buffer.
              public byte[] buffer = new byte[BufferSize];
              
    // Received data string.
              public string ResultData { getset; }
         }
    展开全文
  • Socket 同步和异步模式

    千次阅读 2010-12-01 13:51:00
    以J2SDK-1.3为例,SocketServerSocket类库位于java .net包中。ServerSocket用于服务器端,Socket是建立网络连接时使用的。在连接成功时,应用程序两端都会产生一个Socket实例,操作这个实例,完成所需的会话。...

       学习socket 的一些笔记,希望和大家一起讨论 。
    一.什么是socket
      所谓socket通常也称作"套接字",应用程序通常通过"套接字"向网络发出请求或者应答网络请求。 以J2SDK-1.3为例,Socket和ServerSocket类库位于java .net包中。ServerSocket用于服务器端,Socket是建立网络连接时使用的。在连接成功时,应用程序两端都会产生一个Socket实例,操作这个实例,完成所需的会话。对于一个网络连接来说,套接字是平等的,并没有差别,不因为在服务器端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl类及其子类完成的。

    二 .开发原理:
      服务器,使用ServerSocket监听指定的端口,端口可以随意指定(由于1024以下的端口通常属于保留端口,在一些操作系统中不可以随意使用,所以建议使用大于1024的端口),等待客户连接请求,客户连接后,会话产生;在完成会话后,关闭连接。   客户端,使用Socket对网络上某一个服务器的某一个端口发出连接请求,一旦连接成功,打开会话;会话完成后,关闭Socket。客户端不需要指定打开的端口,通常临时的、动态的分配一个1024以上的端口。Socket接口是TCP/IP网络的API,Socket接口定义了许多函数或例程,程序员可以用它们来开发TCP/IP网络上的应用程序。要学Internet上的TCP/IP网络编程,必须理解Socket接口。 Socket接口设计者最先是将接口放在Unix操作系统里面的。如果了解Unix系统的输入和输出的话,就很容易了解Socket了。网络的Socket数据传输是一种特殊的I/O,Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用Socket(),该函数返回一个整型的Socket描述符,随后的连接建立、数据传输等操作都是通过该Socket实现的。

     

    三.简单的socket 同步代码,目前代码没有上服务器测试,不知道同步和异步的效果怎么样!

      需求

       1.客户端是公司内部的机器200台计算机。
       2.可以同时连接,长连接。
       3.服务器接受到客户端发来的信息,发送 socket数据  发送给总公司socket服务器 ,总公司返回数据。

     

     

     socket 同步简单代码

     

    代码
      public  class Server
         {
              
    static void Main(string[] args)
              {

                   IPEndPoint localEndPoint 
    = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9050);
                   
    //创建 socket Tcp 
                   Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                   
    try
                   {    
                        listener.Bind(localEndPoint);
                        listener.Listen(
    10);
                        
    while (true)
                        {
                             Socket connection 
    = listener.Accept();
                             SocketProxy sp 
    = new SocketProxy(connection);
                             Thread thread 
    = new Thread(new ThreadStart(sp.TcpSendData));
                             thread.Name 
    = connection.RemoteEndPoint.ToString();
                             thread.Start();

                        }

                   }
                   
    catch (Exception ex)
                   {
                        Console.WriteLine(ex.StackTrace);
                   }
              }
         }

      
    public class SocketProxy
         {

              
    private Socket _socket;
              
    public SocketProxy(Socket connection)
              {
                   
    this._socket = connection;
              }

              
    public void TcpSendData()
              {
                   
    byte[] bytes;
                   
    string data = string.Empty;
                   
    while (true)
                   {

                        bytes 
    = new byte[1024];
                        
    // Receive client data 
                        int bytesRec = this._socket.Receive(bytes);
                        
    // convert bytes to  string
                        data = Encoding.ASCII.GetString(bytes, 0, bytesRec);
                        Console.WriteLine(data);

                   }
              }
         }


     

     异步代码

     

         internal class SocketServer
         {
              
    static void Main(string[] args)
              {

                   SocketTcpListener listener 
    = new SocketTcpListener();
                   listener.StartListening();

              }
         }
         
        
         
    internal class SocketTcpListener
         {

              
    public static ManualResetEvent allDone = new ManualResetEvent(false);
              //开始监听
              
    public void StartListening()
              {
                   
    //Data buffer for incoming data.
                   byte[] bytes = new Byte[1024];

                   
    //Establish the local endpoint for the socket.
                   
    //The DNS name of the computer
                   
    //running the listener is "host.contoso.com".
                   
    //IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
                   IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
                   IPEndPoint localEndPoint 
    = new IPEndPoint(ipAddress, 9050);

                   
    // Create a TCP/IP socket.
                   Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                   
    // Bind the socket to the local endpoint and listen for incoming connections.
                   try
                   {
                        listener.Bind(localEndPoint);
                        listener.Listen(
    10);
                        
    while (true)
                        {
                             
    // Set the event to nonsignaled state.
                             allDone.Reset();
                             
    // Start an asynchronous socket to listen for connections.
                             Console.WriteLine("Waiting for a connection");
                             StateObject state 
    = new StateObject();
                             listener.BeginAccept(
    new AsyncCallback(AcceptCallback), listener);
                             
                             
                             
    // Wait until a connection is made before continuing.
                             allDone.WaitOne();
                        }

                   }
                   
    catch (Exception e)
                   {
                        Console.WriteLine(e.ToString());
                   }


              }


              
    //异步接受 
              private static void AcceptCallback(IAsyncResult ar)
              {
                   
    // Signal the main thread to continue.
                   allDone.Set();

                   
    // Get the socket that handles the client request.
                   Socket listener = (Socket)ar.AsyncState;
                   Socket handler 
    = listener.EndAccept(ar);
                   
    // Create the state object.
                   StateObject state = new StateObject();
                   state.workSocket 
    = handler;

                   Array.Clear(state.buffer, 
    0, state.buffer.Length); // 清空缓存,避免脏读

                   handler.BeginReceive(state.buffer, 
    0, StateObject.BufferSize, 0new AsyncCallback(ReadCallback), state);
              }


              
    //异步读取
              public static void ReadCallback(IAsyncResult ar)
              {
                   String content 
    = String.Empty;
                   String resultdata 
    = string.Empty;
                   
    // Retrieve the state object and the handler socket
                   
    // from the asynchronous state object.
                   StateObject state = (StateObject)ar.AsyncState;
                   Socket handler 
    = state.workSocket;

                   
    // Read data from the client socket. 
                   int bytesRead = handler.EndReceive(ar);

                   
    if (bytesRead > 0)
                   {
                        
    // There  might be more data, so store the data received so far.
                        
    // state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));

                        
    // Check for end-of-file tag. If it is not there, read 
                        
    // more data.


                        content 
    = Encoding.ASCII.GetString(state.buffer, 0, bytesRead);
                        Array.Clear(state.buffer, 
    0, state.buffer.Length); // 清空缓存,避免脏读




                        Console.WriteLine(content);
                    
     if (content.Length > -1)
                        {

                             
    // All the data has been read from the 
                             
    // client. Display it on the console.
                             
    //Console.WriteLine("Read {0} bytes from socket. /n Data : {1}", content.Length, content);
                             
    // Echo the data back to the client.

                             
    //SocketTcpClient.CreateSocketObjest();

                             
    // get caac data  
                             
    // 0 如果是第一次,需要创建socket对象,发送登陆信息,匹配出用户名(<name,socket>),存放到集合
                             
    // 1.如果用户存在,需要使用用户名来匹配socket对象,如果没有连接配置,需要创建socket对象,保存到集合以便下次使用连接对象,避免再次的登陆
                             
    // 2.发送数据完,远程服务器会返回信息给Socket Server 
                             
    // 3.Socket Server 返回信息给 Clinet


                             state.ResultData 
    = content;
                             state.SocketName 
    = "Jackyong";
                             
                             resultdata 
    =SocketTcpClient.Send(handler, content);



                             
    // send client


                             
    //Send(handler, resultdata);
                             Send(state);


                        }
                        
    //else
                        
    //{
                        
    //     // Not all data received. Get more.
                        
    //     handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,new AsyncCallback(ReadCallback), state);
                        
    //}
                   }
              }


              
    //发送数据
              private static void Send(StateObject state)
              {
                   Array.Clear(state.buffer, 
    0, state.buffer.Length); // 清空缓存,避免脏读
                   
    // Convert the string data to byte data using ASCII encoding.
                   byte[] byteData = Encoding.ASCII.GetBytes(state.ResultData);
                   
    // Begin sending the data to the remote device.
                   state.workSocket.BeginSend(byteData, 0, byteData.Length, 0new AsyncCallback(SendCallback), state);
              }

              // 异步发送数据给client
              
    private static void SendCallback(IAsyncResult ar)
              {
                   
    try
                   {
                        
    // Retrieve the socket from the state object.
                        
    // Socket handler = (Socket)ar.AsyncState;
                        StateObject state = (StateObject)ar.AsyncState;

                        
    // Complete sending the data to the remote device.
                        int bytesSent = state.workSocket.EndSend(ar);

                        
    // if detect exceptoin  socket shut down /close
                        
    //  handler.Shutdown(SocketShutdown.Both);
                        
    //  handler.Close();

                        
    // continue to listener
                        
    //StateObject state = new StateObject();
                        
    //state.workSocket = handler;
                        
                        Array.Clear(state.buffer, 
    0, state.buffer.Length); // 清空缓存,避免脏读
                        state.workSocket.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0new AsyncCallback(ReadCallback), state);

                   }
                   
    catch (Exception e)
                   {
                        Console.WriteLine(e.ToString());
                   }
              }

         }

       
    internal class SocketTcpClient
         {
              
    /// <summary>
              
    /// create socket object  ,client send server 
              
    /// </summary>
              
    /// <param name="command">command</param>
              
    /// <returns>data</returns>
              public static Socket CreateSocketObjest()
              {
                   
    //需要存储这个连接对象 

                   
    string receivemsg = string.Empty;
                   
    byte[] data = new byte[1024];
                   
    string IP = "127.0.0.1";
                   
    int Port = 9050;
                   IPEndPoint ie 
    = new IPEndPoint(IPAddress.Parse(IP), Port);//服务器的IP和端口  
                   Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                   
    try
                   {
                        
    //因为客户端只是用来向特定的服务器发送信息,所以不需要绑定本机的IP和端口。不需要监听。  
                        client.Connect(ie);
                   }
                   
    catch (SocketException e)
                   {
                        
    //close  socket and writing error exception
                        Console.WriteLine(e.ToString());

                   }
                   
    return client;
              }

              
    /// <summary>
              
    /// client send command server
              
    /// </summary>
              
    /// <param name="client">socket</param>
              
    /// <param name="command">command</param>
              
    /// <returns>data</returns>
              public static string Send(Socket client, string command)
              {
                   
    byte[] data = new byte[1024];
                   
    string result = string.Empty;
                   
    //send command
                   ClientSendDataServer(client, command);

                   
    if (client.Poll(-1, SelectMode.SelectRead))
                   {    
    //如果传递过来的是string.empty 字符串也是0 

                        
    int recv = client.Receive(data);
                        
    if (recv == 0)
                        {
                             
    //socket连接已断开
                        }
                        result 
    = Encoding.ASCII.GetString(data, 0, recv);
                        Console.WriteLine(result);
                   }

                   
    return result;
              }



              
    /// <summary>
              
    /// client to server 
              
    /// </summary>
              
    /// <param name="handler">socket </param>
              
    /// <param name="data">comand</param>
              private static void ClientSendDataServer(Socket client, String command)
              {
                   
    // Convert the string data to byte data using ASCII encoding.
                   byte[] byteData = Encoding.ASCII.GetBytes(command);
                   
    // Begin sending the data to the remote device.
                   client.Send(byteData);
              }


         }

       
    /// <summary>
         
    /// 存放客户端与总公司的登陆信息
         
    /// </summary>
         internal class SocketUser
         {
              
    private System.Collections.Generic.Dictionary<string, Socket> _sockets;
              
              
    public SocketUser()
              {
                   _sockets 
    = new Dictionary<string, Socket>();
              }

              
    /// <summary>
              
    /// select client user
              
    /// </summary>
              
    /// <param name="key"></param>
              
    /// <returns></returns>
              public Socket Find(string key)
              {
                   Socket socket 
    = null; ;
                   
    if (key == null || key == string.Empty)
                   {

                   }
                   
    if (_sockets[key] != null)
                   {
                        socket 
    = _sockets[key] as Socket;
                   }
                   
    return socket;
              }


              
    /// <summary>
              
    /// add  client in  sockets 
              
    /// </summary>
              
    /// <param name="key"></param>
              
    /// <param name="sk"></param>
              public void Add(string key, Socket sk)
              {
                   _sockets.Add(key, sk);

              }

              
    /// <summary>
              
    /// Remove client  user 
              
    /// </summary>
              
    /// <param name="key"></param>
              public void Remove(string key)
              {
                   _sockets.Remove(key);
              }




         }

       // socket state
        internal class StateObject
         {
              
    // socket name 
              public string SocketName { getset; }
              
    // Client  socket.
              public Socket workSocket = null;
              
    // Size of receive buffer.
              public const int BufferSize = 1024;
              
    // Receive buffer.
              public byte[] buffer = new byte[BufferSize];
              
    // Received data string.
              public string ResultData { getset; }
         }







     

    感谢您的阅读  欢迎大家讨论!

    展开全文
  • - (void)jsonRequestSerial {  NSURLRequest *request=[NSURLRequest requestWithURL:[NSURL URLWithString:@"http://192.168.0.124:8080/WYServer/login?user=1222&pwd=kj"]];    NSData *dat

    - (void)jsonRequestSerial

    {

        NSURLRequest *request=[NSURLRequestrequestWithURL:[NSURLURLWithString:@"http://192.168.0.124:8080/WYServer/login?user=1222&pwd=kj"]];

        

        NSData *data=[NSURLConnectionsendSynchronousRequest:request returningResponse:nilerror:nil];

        NSDictionary *dict=[NSJSONSerializationJSONObjectWithData:data options:NSJSONReadingAllowFragmentserror:nil];

       if (dict[@"error"]) {

           NSLog(@"%@",dict[@"error"]);

        }

       else

        {

           NSLog(@"%@",dict[@"%@"]);

        }

    }

    - (void) getAsyn

    {

        NSURL *url=[NSURLURLWithString:@"http://192.168.0.124:8080/WYServer/login?username=333zc&pwd=w444"];

        NSURLRequest *request=[NSURLRequestrequestWithURL:url];

        

        [NSURLConnectionsendAsynchronousRequest:request queue:[[NSOperationQueue alloc] init] completionHandler:^(NSURLResponse *response,NSData *data, NSError *connectionError) {

           NSLog(@"Response=%@",response);

            NSDictionary *dict=[NSJSONSerializationJSONObjectWithData:data options:NSJSONReadingAllowFragmentserror:nil];

           if (dict[@"error"]) {

               NSLog(@"%@",dict[@"error"]);

            }

           else

            {

               NSLog(@"%@",dict[@"success"]);

            }


        }];

    }

    - (void)postAsyn

    {

        NSURL *url=[NSURLURLWithString:@"http://192.168.0.124:8080/WYServer/login"];

        NSMutableURLRequest *mutRequest=[NSMutableURLRequestrequestWithURL:url];

        mutRequest.HTTPMethod=@"POST";

        NSString *str=@"username=wxxc&pwd=w11";

        mutRequest.HTTPBody=[strdataUsingEncoding:NSUTF8StringEncoding];

        

        [NSURLConnectionsendAsynchronousRequest:mutRequest queue:[[NSOperationQueue alloc] init] completionHandler:^(NSURLResponse *response,NSData *data, NSError *connectionError) {

           NSLog(@"Response=%@",response);

            NSDictionary *dict=[NSJSONSerializationJSONObjectWithData:data options:NSJSONReadingAllowFragmentserror:nil];

           if (dict[@"error"]) {

               NSLog(@"%@",dict[@"error"]);

            }

           else

            {

               NSLog(@"%@",dict[@"success"]);

            }


        }];

    }


    展开全文
  • 同步和异步执行模式 ODBC2.0访问数据库时,有同步执行模式与异步执行模式之分。 所谓同步执行模式,是指语句在同步执行模式下,将始终保持对程序流的控制,直至程序结束。例如查询操作,客户机上的应用程序在向...

    同步和异步执行模式  ODBC2.0访问数据库时,有同步执行模式与异步执行模式之分。   所谓同步执行模式,是指语句在同步执行模式下,将始终保持对程序流的控制,直至程序结束。例如查询操作,客户机上的应用程序在向服务器发出查询操作的指令后,将一直等待服务器将查询结果返回客户机端后,才继续进行下一步操作。

    所谓异步执行模式,是指语句在异步执行模式下,各语句执行结束的顺序与语句执行开始的顺序并不一定相同。例如查询操作,客户机上的应用程序在向服务器发出了查询操作的指令后,将立刻执行查询语句的下一条语句,而不需要等到服务器将查询结果返回客户机端后,才继续进行下一步操作。   在一些应用程序开发工具中,在其提供使用数据控制项和数据库对象变量进行编程的同时,并没有很好地考虑到同步执行模式与异步执行模式的重要区别。为了使程序运行速度更快,其语句执行的缺省模式为异步模式。对于一般程序员来说,如果他对同步执行模式与异步执行模式不了解的话,他往往会在对服务器发出一个操作语句(查询或读取一条记录等操作)后,立刻引用服务器返回的执行结果,或者对该结果进行下一步操作;在异步执行模式下,客户机上的后续语句是在该操作语句发出后接着执行的,但由于各种原因,服务器不一定能执行完该操作语句,并在后续语句执行前将结果返回客户机。因此,后续语句在引用前一操作语句的执行结果时,往往会因为该执行结果并不存在而引用了错误的值,造成系统错误或死锁。

    解决上面所提到的问题,可以采取以下两种方案:   ①利用ODBC2.0API,将语句执行状态设置为同步执行模式。ODBC2.0API中,函数SQLSetStmtOption()的功能是设置同步或异步执行模式。我们可以采用以下语句,将语句执行状态设置为同步执行模式: iRetCodeΚSQLSetStmtOption(hStmt,SQL-ASYNC-ENABLE,0) 其中,hStmt是一有效的语句句柄,常数SQL-ASYNC-ENABLE是所要设置的选项,参数0表示该选项(即异步执行模式)关闭。如果iRetCode返回SQL-SUCCESS,则表示语句执行状态已被设置为同步执行模式。   ②利用ODBC2.0API,将语句执行状态设置为异步执行模式,然后在程序中不断查询一个操作语句是否已经执行完毕。   这些函数第一次调用后,将返回值SQL-STILL-EXECUTING,这时应用程序将继续执行后续语句。过了一段时间后,应该再次调用原函数,而且要注意:实参数应传入与第一次调用时相同的语句句柄,其他参数也应一样(但会被忽略)。如果函数返回值为SQL-SUCCESS,则表明该语句已经执行完毕;如果函数返回SQL-STILL-EXECUTING,则表明该语句仍在执行中。   我们可以用一个简单的例子说明如下:

    iRetCodeΚSQLSetStmtOption(hStmt,SQL-ASYNC-ENABLE,1)′置语句执行模式为异步执行模式iRetCodeΚSQLExecDirect(hStmt,″SELECT*FROMemployees″,23)......′执行其他操作iRetCodeΚSQLExecDirect(hStmt,″SELECT*FROMemployees″,23)′判断SQLExecDirect()是否已执行完毕If(iRetCodeΚSQL-STILL-EXECUTING)Then......′该语句未执行完,继续执行其他操作ElseIf(iRetCodeΚSQL-SUCCESS)Then......′该语句已执行完,可对语句操作结果进行处理EndIfEndIf

    同步执行模式可以简化程序编制的复杂性,对ODBC2.0API不十分熟悉的程序员,可以不用过多地了解比较复杂的ODBC2.0API,而只需使用数据控制项和数据库对象变量来编写应用程序,使开发效率大大提高,但程序运行速度比不上异步执行模式的速度。   异步执行模式虽然在编程序时十分复杂,但在这种模式下可以进行多任务并行执行,使执行效率大大提高。

    分享到:

    18e900b8666ce6f233d25ec02f95ee59.png

    72dd548719f0ace4d5f9bca64e1d7715.png

    2012-06-29 11:29

    浏览 2883

    论坛回复 / 浏览 (0 / 4827)

    分类:数据库

    评论

    展开全文
  • 同步异步模式

    2020-04-30 08:59:13
    异步模式中,发出某个请求后不需要等待得到回复,直接return以便于继续后续工作,而同步模式则要求在请求后就得到回复,否则持续在函数内等待且不return进入后续操作。发邮件打电话这两张联系方式很好的体现了...
  • 同步异步模式

    2019-05-22 17:52:00
    在IO模型中:同步和异步的区分在于内核向应用程序通知的是和种IO事件,同步模式下通知的是就绪事件,异步通知的是完成事件,以及到底是谁来完成I/O读写,同步模式下由应用程序来I/O读写完成,而异步模式下由内核帮...
  • 直接上图了,规范性先忽略。 ASIO同步模式。这个相对简单 ASIO异步模式
  • ajax同步模式和异步模式的区别就是在于,xhr.open()方法第3个参数传入的bool值的区别,xhr.open()方法第3个参数的作用就是设置此次请求是否采用异步模式执行,默认为true ,那么同步模式xhr.open()方法第3个参数值...
  • 同步和异步执行模式 ODBC2.0访问数据库时,有同步执行模式与异步执行模式之分。 所谓同步执行模式,是指语句在同步执行模式下,将始终保持对程序流的控制,直至程序结束。例如查询操作,客户机上的应用程序在向...
  • 在纯粹的XMLHttpRequest中可以设置调用是否是异步的。XMLHttpRequest的open函数是有一个是否同步参数,如下:XMLHttpRequest.open(String method, String URL, boolean asynchronous) 其中的asynchronous就是是否...
  • GPU: 多GPU训练的同步模式和异步模式

    千次阅读 2018-10-05 21:11:13
    常用的并行化深度学习模型训练方式有两种:同步模式和异步模式。 下面将介绍这两种模式的工作方式及其优劣。 如下图,深度学习模型的训练是一个迭代的过程。 在每一轮迭代中,前向传播算法会根据当前参数的取值...
  • 本章主要总结关系数据库引擎(sqlite),同步和异步执行模式,创建数据库和表 Adobe AIR 包括一个基于 SQL 的关系数据库引擎(sqlite),该引擎在运行时中运行,数据以本地方式存储在运行 AIR 应用程序的计算机上的...
  • 同步和异步

    2018-03-30 19:04:58
    同步和异步分为数据间的同步异步和线程操作间的同步异步 举个例子:普通B/S模式(同步)AJAX技术(异步) 同步:提交请求->等待服务器处理->处理完返回这个期间客户端浏览器不能干任何事 异步:请求通过事件触发-...
  • 串口同步模式和异步模式It’s been a few months since we released UniTask v2, and we’re now at version 2.0.31, GitHub’s Star is achieved over 1100. We believe it is stable and will be used in ...
  • ajax模式 同步和异步

    2018-03-31 17:37:00
    转载于:https://www.cnblogs.com/liuliang389897172/p/8683179.html
  • Yesterday I was challenged by my colleague: in the CRM Fiori application “My Opportunity”, although the OData request for logo url is set as false ( means Synchronous ), why we still observe in UI ...
  • JS同步和异步 一、单线程模型 JavaScript是一门单线程的语言,所谓"单线程",就是指一次只能完成一件任务。如果有多个任务,就必须排队,前面一个任务完成,再执行后面一个任务。 看下面一段代码在浏览器中的执行的...
  • 一: 同步和异步的问题 同步: 编码简单,逻辑清晰, 但效率低 异步: 效率高,但结构复杂,需处理各种时序和竞争问题 对于网络通信来说异步可以避免大量的阻塞,提高效率, 因此高性能服务器基本都是异步的. 但对于业务处理...
  • 先简单的介绍下同步和异步两个概念: 同步模式:服务器在发送请求时,阻塞等待请求的响应; 优点:实现简单,同步接收数据,方便做各种统计和服务器的切换。缺点:服务不平稳,容易受到冲击,造成雪崩; 异步模式:...
  •   Solution 半同步半异步模式分成三层: ...同步队列,是为了在同步和异步层进行任务同步。   Structure 半同步半异步模式中包含以下各部分: 同步任务层执行高层处理任务。同步层的任务...
  • 异步模式编程复杂 但是IO利用率高 此模式综合了同步异步的优缺点 高层中使用同步IO模型,简化编程。低层使用异步IO模型 高效执行 2.应用场景 1.系统必须响应处理外部异步发生的事件 2、一个或多个任务必须在单独的...
  • 同步异步模式:出现原因: 异步线程执行效率高,但是编写复杂,同步线程效率低,但是逻辑简单。服务器要求好的实时性同时处理多用户的请求,英雌采用两者结合的形式。 具体情况: 过程: 异步线程见听到...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,349
精华内容 1,739
关键字:

同步和异步模式