[转载]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, 0, new 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, 0, new 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, 0, new 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 { get; set; }
// 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 { get; set; }
}

赞(0) 打赏
分享到: 更多 (0)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏