Socket（Tcp）通信服务端

又是一段时间了，感觉最近挺乱的，今天有些时间，搞了下socket的服务器。

先来看下服务端和客户端的流程如下：



我个人比较偏爱异步通信，今天主要以异步通信来讲一讲socket

1、Socket的构造函数来创建Socket：
Socket(AddressFamily,SocketType, ProtocolType)
AddressFamily：指定的地址族
SocketType：套接字类型
ProtocolType：协议类型
参考：_listener = newSocket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);

2、Bind()绑定端口和IP
public void Bind
(
EndPoint localEP
)
参考：
IPAddress_ipAddress = IPAddress.Parse("192.168.1.216");
IPEndPoint_ipEndPoint = new IPEndPoint(_ipAddress , 2222);
_listener.Bind(_ipEndPoint);

3、listen()监听socket

public void Listen

(

int backlog

)

参考：_listener.Listen(10)

4、accept()接收来自客户端的请求

public IAsyncResult BeginAccept

(

AsyncCallback callback,

Object state

)

参考：_listener.BeginAccept(newAsyncCallback(AcceptCallBack),_listener);

5、receive()从socket中读取字符

public IAsyncResult BeginReceive(

byte[] buffer,// Byte 类型的数组，它是存储接收到的数据的位置。

int offset,// buffer 参数中存储所接收数据的位置，该位置从零开始计数。

int size,//要接收的字节数。

SocketFlags socketFlags,// SocketFlags 值的按位组合。

AsyncCallback callback,//一个 AsyncCallback 委托，它引用操作完成时要调用的方法。

Object state//一个用户定义对象，其中包含接收操作的相关信息。 当操作完成时，此对象会被传递给 EndReceive 委托。

)

参考：_handlerEnd.BeginReceive(_state._buffer,0,StateObject._bufferSize,0,newAsyncCallback(ReceiveCallBack),_state);

6、close()关闭socket，并释放资源

public void Close()

参考：_handlerEnd.Close();

注意： PC端汉字传输时，需要的格式如下

string Message = "Lee";

byte[] bytes =Encoding.GetEncoding("GB2312").GetBytes(Message);

完整参考代码如下：

usingUnityEngine;
usingSystem.Collections;
usingSystem;
usingSystem.Net;
usingSystem.Net.Sockets;
usingSystem.Threading;
usingSystem.Text;
usingSystem.Collections.Generic;

///<summary>
///StateObject为BeginReceive时的一种状态，用来存储数据
///</summary>
publicclass StateObject
{
public Socket _workSocket;

public const int _bufferSize = 1024;

public byte[] _buffer = new byte[_bufferSize];

public StringBuilder _sb = newStringBuilder();
}

publicclass TcpSever
{
public static ManualResetEvent _allOne= new ManualResetEvent(false);

public static TcpSever _inSingle;

private Socket _listener;
public List<Socket> _clientList =new List<Socket>();

/// <summary>
/// 单例模式的类
/// </summary>
/// <returns>Theinsigle.</returns>
public static TcpSever GetInsigle()
{
if(_inSingle == null)
{
_inSingle = newTcpSever();
}
return _inSingle;

}

public TcpSever ()
{
IPAddress _ipAddress =IPAddress.Parse("192.168.1.216");
IPEndPoint _ipEndPoint = newIPEndPoint(_ipAddress , 2222);

_listener = newSocket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);

_listener.Bind(_ipEndPoint);

/// <summary>
/// 新建_threadListenFunciton线程，用来监听客户端连接
/// </summary>
Thread _threadListenFunciton= new Thread(new ThreadStart(ListenFuncition));
_threadListenFunciton.IsBackground= true;
_threadListenFunciton.Start();
}
void ListenFuncition()
{
try
{
_listener.Listen(10);

while(true)
{
_allOne.Reset();
_listener.BeginAccept(newAsyncCallback(AcceptCallBack),_listener);
_allOne.WaitOne();
}
}
catch
{}
}

/// <summary>
///异步Accept的回调函数
/// </summary>
/// <paramname="_ar">_ar.</param>
void AcceptCallBack(IAsyncResult _ar)
{
_allOne.Set();

Socket _listenerSelf =(Socket)_ar.AsyncState;
Socket _handlerEnd =_listenerSelf.EndAccept(_ar);

/// <summary>
///用于向客户端发送消息的Socket,全部放入泛型列表中
/// </summary>
_clientList.Add(_handlerEnd);

StateObject _state = newStateObject ();
_state._workSocket =_handlerEnd;

_handlerEnd.BeginReceive(_state._buffer,0,StateObject._bufferSize,0,newAsyncCallback(ReceiveCallBack),_state);

}

/// <summary>
/// 异步Receive的回调函数
/// </summary>
/// <paramname="_ar">_ar.</param>
void ReceiveCallBack(IAsyncResult _ar)
{
StateObject _state =(StateObject )_ar.AsyncState;

Socket _handlerEnd =_state._workSocket;

int _receiveLength =_handlerEnd.EndReceive(_ar);

if(_receiveLength >0 )
{

string _receiveData= Encoding.ASCII.GetString(_state._buffer,0,_receiveLength);
ReceiveData(_receiveData);

///<summary>
///字符串拼接
///</summary>
_state._sb.Append(Encoding.ASCII.GetString(_state._buffer,0,_receiveLength));
string _ReceiveData= _state._sb.ToString();
ReceiveData(_ReceiveData);

_handlerEnd.BeginReceive(_state._buffer,0,StateObject._bufferSize,0,newAsyncCallback(ReceiveCallBack),_state);
}
}

/// <summary>
///向客户端发送消息
/// </summary>
void SendMessage( Socket_handlerEnd,string _value)
{
byte[] _sendData =Encoding.ASCII.GetBytes(_value);

_handlerEnd.BeginSend(_sendData,0,_sendData.Length,0,newAsyncCallback(SendCallBack),_handlerEnd);
}

/// <summary>
/// 异步Send的回调函数
/// </summary>
void SendCallBack(IAsyncResult _ar)
{
Socket _handlerEnd =(Socket)_ar.AsyncState;

int _sendLength =  _handlerEnd.EndSend(_ar);

///<summary>
///当通讯结束时，Shutdown()禁止该套接字上的发送和接收,Close()关闭套接字并释放资源
///</summary>
//_handlerEnd.Shutdown(SocketShutdown.Both);
//_handlerEnd.Close();
Debug.Log("发送"+_sendLength+"个字节");
}

public string  ReceiveData(string _data)
{
Debug.Log(_data);
return _data;
}
public void SendData(string _data)
{
Debug.Log(_data);
//向每个客户端发送数据
foreach(Socket _client in_clientList)
{
SendMessage(_client,_data);

//客户端IP和Port信息
EndPointtempRemoteEP = _client.RemoteEndPoint;
IPEndPointtempRemoteIP = ( IPEndPoint )tempRemoteEP ;

stringrempip=tempRemoteIP.Address.ToString();
stringremoport=tempRemoteIP.Port.ToString();
Debug.Log(rempip+":"+remoport);
}

}
}

调用代码如下：

usingUnityEngine;
usingSystem.Collections;

publicclass TcpServeTest : MonoBehaviour {

// Use this for initialization
void Start ()
{
TcpSever.GetInsigle();

}

// Update is called once per frame
void Update ()
{
if(Input.GetMouseButtonDown(0))
{
TcpSever.GetInsigle().SendData("ddd");
}

}
}