c#Socket异步通信源码.docx

c#Socket异步通信源码.docx

《c#Socket异步通信源码.docx》由会员分享，可在线阅读，更多相关《c#Socket异步通信源码.docx（15页珍藏版）》请在冰豆网上搜索。

c#Socket异步通信源码

服务器端代码：

namespaceServer

{

publicpartialclassServer2:

Form

{

delegatevoidMsgRef（stringmsg）;

publicServer2（）

{

InitializeComponent（）;

}

AsySocketlistener=null;

SortedListclients=newSortedList（）;

delegatevoidCallBackRef（stringmsg）;

privatevoidbutton1_Click（objectsender,EventArgse）

{

//监听

listener=newAsySocket（this.textBox1.Text,Int32.Parse（textBox2.Text））;

listener.OnAccept+=newAcceptEventHandler（listener_OnAccept）;

listener.Listen（10）;

this.button1.Enabled=false;

}

voidlistener_OnAccept（AsySocketAcceptedSocket）

{

//注册事件

AcceptedSocket.OnStringDataAccept+=newStringDataAcceptHandler（AcceptedSocket_OnStringDataAccept）;

AcceptedSocket.OnClosed+=newAsySocketClosedEventHandler（AcceptedSocket_OnClosed）;

AcceptedSocket.BeginAcceptData（）;

//加入

clients.Add（AcceptedSocket.ID,AcceptedSocket）;

}

voidAcceptedSocket_OnClosed（stringSocketID,stringErrorMessage）

{

//客户端关闭

clients.Remove（SocketID）;

}

privatevoidAddMsg（stringmsg）

{

if（txtMsg.InvokeRequired）

{

CallBackRefc=newCallBackRef（AddMsgCallBack）;

this.Invoke（c,newobject[]{msg}）;

}

else

{

txtMsg.Text+=Environment.NewLine+msg;

}

}

privatevoidAddMsgCallBack（stringmsg）

{

txtMsg.Text+=Environment.NewLine+msg;

}

voidAcceptedSocket_OnStringDataAccept（stringAccepterID,stringAcceptData）

{

try

{

//显示

//this.txtMsg.Text+=AccepterID+":

"+AcceptData+Environment.NewLine;

MsgRefm=newMsgRef（AddMsg）;

this.Invoke（m,newobject[]{AcceptData}）;

//转发

for（inti=0;i

{

if（clients.Values[i].ID!

=AccepterID）

{

clients.Values[i].ASend（AcceptData）;

}

}

}

catch（Exceptione）

{

MessageBox.Show（e.Message）;

}

}

privatevoidbtnSend_Click（objectsender,EventArgse）

{

if（txtSend.Text==""）

return;

//转发

for（inti=0;i

{

clients.Values[i].ASend（"服务器:

"+txtSend.Text+AsySocket.EndChar）;

}

//txtMsg.Text+="发送:

"+txtSend.Text+Environment.NewLine;

AddMsg（"发送:

"+txtSend.Text）;

txtSend.Text="";

txtSend.Focus（）;

}

}

}

客户端代码：

namespaceClient

{

publicdelegatevoidStreamDataAcceptHandler（stringAccepterID,byte[]AcceptData）;

publicdelegatevoidStringDataAcceptHandler（stringAccepterID,stringAcceptData）;

publicdelegatevoidAsySocketEventHandler（stringSenderID,stringEventMessage）;

publicdelegatevoidAcceptEventHandler（AsySocketAcceptedSocket）;

publicdelegatevoidAsySocketClosedEventHandler（stringSocketID,stringErrorMessage）;

///

publicclassStateObject

{

//Clientsocket.

publicSocketworkSocket=null;

//Sizeofreceivebuffer.

publicconstintBufferSize=1024;

//Receivebuffer.

publicbyte[]buffer=newbyte[BufferSize];

//Receiveddatastring.

publicStringBuildersb=newStringBuilder（）;

}

///

publicclassAsySocket

{

publicAsySocket（stringLocalIP,intLocalPort）

{

mSocket=newSocket（AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp）;

try

{

IPAddressip=Dns.GetHostAddresses（LocalIP）[0];

IPEndPointipe=newIPEndPoint（ip,LocalPort）;

mID=Guid.NewGuid（）.ToString（）;

mSocket.Bind（ipe）;

}

catch（Exceptione）

{

//ErrLog.RecordErr（e,ModuleName,"AsySocket",""）;

}

}

///指定的Socket连接

publicAsySocket（SocketlinkObject）

{mSocket=linkObject;

mID=Guid.NewGuid（）.ToString（）;

}

#region私有字段

privateSocketmSocket=null;

stringmID="";

privateconststringModuleName="GYGameServer.AsySocket";

privateStreamDataAcceptHandleronStreamData=null;

privateStringDataAcceptHandleronStringData=null;

privateAsySocketEventHandleronSended=null;

privateAsySocketEventHandleronSendTo=null;

privateAcceptEventHandleronAccept=null;

privateAsySocketClosedEventHandleronClosed=null;

#endregion

#region公共属性

publicstaticstringEndChar

{

get

{

returnnewstring（（char）0,1）;

}

}

publicstringID

{

get

{

returnmID;

}

}

///

publicstaticcharLastSign

{

get

{

return（char）0;

}

}

///

publicSocketLinkObject

{

get

{

returnmSocket;

}

set

{

mSocket=value;

}

}

#endregion

#region公共方法

///

publicvoidListen（intbacklog）

{

if（mSocket==null）

thrownewArgumentNullException（"连接不存在"）;

mSocket.Listen（backlog）;

mSocket.BeginAccept（newAsyncCallback（AcceptCallBack）,null）;//异步

}

///

publicvoidBeginAcceptData（）

{

if（mSocket==null）

thrownewArgumentNullException（"连接对象为空"）;

//开始接收数据

StateObjectstate=newStateObject（）;

state.workSocket=mSocket;

mSocket.BeginReceive（state.buffer,0,StateObject.BufferSize,0,newAsyncCallback（ReceiveCallback）,state）;

//receiveDone.WaitOne（）;

}

///

///

publicvoidASend（byte[]SendData）

{

if（mSocket==null）

thrownewArgumentNullException（"连接不存在"）;

if（SendData==null）

return;

mSocket.BeginSend（SendData,0,SendData.Length,0,newAsyncCallback（SendCallBack）,mSocket）;

//sendDone.WaitOne（）;

}

///

///

publicvoidASend（stringSendData）

{

if（SendData.Length==0）

return;

this.ASend（UTF8Encoding.UTF8.GetBytes（SendData））;

}

///

///

///目标端点

publicvoidASendTo（byte[]SendData,IPEndPointEndPoint）

{

if（mSocket==null）

thrownewArgumentNullException（"连接不存在"）;

if（SendData==null）

return;

mSocket.BeginSendTo（SendData,0,SendData.Length,0,EndPoint,newAsyncCallback（SendToCallBack）,null）;

//sendToDone.WaitOne（）;

}

///

///

///

publicvoidASendTo（stringSendData,IPEndPointEndPoint）

{

if（SendData.Length==0）

return;

ASendTo（UTF8Encoding.UTF8.GetBytes（SendData）,EndPoint）;

}

#endregion

#region私有方法

privatevoidAcceptCallBack（IAsyncResultar）

{

Sockethandler=mSocket.EndAccept（ar）;

AsySocketNewSocket=newAsySocket（handler）;

//激发事件

if（onAccept!

=null）

onAccept（NewSocket）;

//重新监听

mSocket.BeginAccept（newAsyncCallback（AcceptCallBack）,null）;

}

privatevoidReceiveCallback（IAsyncResultar）

{

try

{

StateObjectstate=ar.AsyncStateasStateObject;

//读取数据

intbytesRead=mSocket.EndReceive（ar）;

if（bytesRead>0）

{

state.sb.Append（UTF8Encoding.UTF8.GetString（state.buffer,0,bytesRead））;

stringsb=state.sb.ToString（）;

if（sb.Substring（sb.Length-1,1）==EndChar）

{

//接收完成

//激发事件

if（onStreamData!

=null）

onStreamData（mID,UTF8Encoding.UTF8.GetBytes（sb））;

if（onStringData!

=null）

onStringData（mID,sb）;

//

state=newStateObject（）;

state.workSocket=mSocket;

}

//Gettherestofthedata.

mSocket.BeginReceive（state.buffer,0,StateObject.BufferSize,0,newAsyncCallback（ReceiveCallback）,state）;

}

}

catch（SocketExceptionse）

{

if（onClosed!

=null）

onClosed（ID,se.Message）;

}

catch（Exceptione）

{

thrownewApplicationException（e.Message）;

}

}

privatevoidSendCallBack（IAsyncResultar）

{

try

{

mSocket.EndSend（ar）;

//sendDone.Set（）;

//触发事件

if（onSended!

=null）

onSended（mID,"OK"）;

}

catch（SocketExceptionse）

{

if（onClosed!

=null）

onClosed（ID,se.Message）;

}

catch（Exceptione）

{

//thrownewApplicationException（e.Message）;

}

}

privatevoidSendToCallBack（IAsyncResultar）

{

try

{

mSocket.EndSendTo（ar）;

//sendToDone.Set（）;

if（onSendTo!

=null）

onSendTo（mID,"OK"）;

}

catch（SocketExceptionse）

{

if（onClosed!

=null）

onClosed（ID,se.Message）;

}

catch（Exceptione）

{

thrownewApplicationException（e.Message）;

}

}

#endregion

#region事件

///

publiceventAsySocketClosedEventHandlerOnClosed

{

add

{

onClosed+=value;

}

remove

{

onClosed-=value;

}

}

///

publiceventAcceptEventHandlerOnAccept

{

add

{

onAccept+=value;

}

remove

{

onAccept-=value;

}

}

///

publiceventStreamDataAcceptHandlerOnStreamDataAccept

{

add

{

this.onStreamData+=value;

}

remove

{

this.onStreamData-=value;

}

}

///

publiceventStringDataAcceptHandlerOnStringDataAccept

{

add

{

onStringData+=value;

}

remove

{

onStringData-=value;

}

}

///

publiceventAsySocketEventHandlerOnSended

{

add

{

onSended+=value;

}

remove

{

onSended-=value;

}

}

///

publiceventAsySocketEventHandlerOnSendTo

{

add

{

onSendTo+=value;

}

remove

{

onSendTo-=value;

}

}

#endregion

}

}