/// <summary>
/// 调用模块
/// </summary>
/// <param name="data"></param>
/// <returns>true 属于次模块,false 不属于此模块数据</returns>
public bool CallModule(byte[] data, RPCUserInfo e, bool isTaskQueue, out ReadBytes read, out int cmd)
{
cmd = -1;
read = new ReadBytes(data);
int lengt;
if (read.ReadInt32(out lengt) && read.Length == lengt && read.ReadInt32(out cmd))
{
switch (cmd)
{
case 1001000:
{
RPCCallPack tmp;
if (read.ReadObject <RPCCallPack>(out tmp))
{
if (isTaskQueue)
{
Task.Factory.StartNew((pack) => Call(pack as RPCCallPack, e)
, tmp, CancellationToken.None, TaskCreationOptions.None, e.Scheduler).ContinueWith(p =>
{
try
{
p.Wait();
}
catch
{
}
});
return(true);
}
else
{
Call(tmp, e);
}
}
}
break;
case 1001001:
{
Result_Have_Return val;
if (read.ReadObject <Result_Have_Return>(out val))
{
e.RPC_Call.SetReturnValue(val);
return(true);
}
}
break;
}
}
return(false);
}
void client_DataOn(byte[] Data)
{
ReadBytes read = new ReadBytes(Data);
int length;
int cmd;
if (read.ReadInt32(out length) && read.ReadInt32(out cmd) && length == read.Length)
{
switch (cmd)
{
case 800: //PING命令
{
Ping p;
if (read.ReadObject <Ping>(out p))
{
if (p != null)
{
this.BeginInvoke(new EventHandler((o, x) =>
{
Ping nn = o as Ping;
if (nn != null)
{
toolStripStatusLabel1.Text = string.Format("Ping:{0} ({1})", //计算并显示PING
(DateTime.Now - nn.UserSendTime).Milliseconds,
(DateTime.Now - nn.ServerReviceTime).Milliseconds);
}
}), p);
}
}
}
break;
case 1002:
ReadDataSet dox;
if (read.ReadObject <ReadDataSet>(out dox)) //获取服务器发送过来的 DATASET
{
if (dox != null)
{
this.BeginInvoke(new EventHandler((o, x) =>
{
ReadDataSet nn = o as ReadDataSet;
if (nn != null)
{
this.dataGridView1.DataSource = nn.Data; //绑定到视图
this.dataGridView1.Update();
}
}), dox);
}
}
break;
}
}
}
void client_DataOn(byte[] Data)
{
ReadBytes read = new ReadBytes(Data);
int length;
int cmd;
if (read.ReadInt32(out length) && read.ReadInt32(out cmd) && length == read.Length)
{
switch (cmd)
{
case 800: //PING命令
{
Ping p;
if (read.ReadObject<Ping>(out p))
{
if(p!=null)
this.BeginInvoke(new EventHandler((o, x) =>
{
Ping nn = o as Ping;
if (nn != null)
{
toolStripStatusLabel1.Text = string.Format("Ping:{0} ({1})", //计算并显示PING
(DateTime.Now - nn.UserSendTime).Milliseconds,
(DateTime.Now - nn.ServerReviceTime).Milliseconds);
}
}),p);
}
}
break;
case 1002:
ReadDataSet dox;
if (read.ReadObject<ReadDataSet>(out dox)) //获取服务器发送过来的 DATASET
{
if (dox != null)
{
this.BeginInvoke(new EventHandler((o, x) =>
{
ReadDataSet nn = o as ReadDataSet;
if (nn != null)
{
this.dataGridView1.DataSource = nn.Data; //绑定到视图
this.dataGridView1.Update();
}
}), dox);
}
}
break;
}
}
}
/// <summary>
/// 输入包输入处理
/// </summary>
/// <param name="Data"></param>
void SocketManager_DataInput(byte[] Data)
{
ReadBytes read = new ReadBytes(Data);
int length;
int cmd;
if (read.ReadInt32(out length) && read.ReadInt32(out cmd) && length == read.Length)
{
switch (cmd)
{
case 500: //如果是Message类型数据包
BuffLibrary.Message ms;
if (read.ReadObject<BuffLibrary.Message>(out ms))
{
if (ms != null)
{
if (ms.Type == 1) //1登入失败
MessageBox.Show(ms.MessageStr);
else if (ms.Type == 2) //2登入成功
{
Logins = true; //设置 LOGINS
this.BeginInvoke(new EventHandler((o, p) => Close())); //关闭窗口
}
}
}
break;
}
}
}
static void DataOn(ref ReadBytes read, IFiberRw <string> fiberRw)
{
var cmd = read.ReadInt32();
var p1 = read.ReadInt32();
var p2 = read.ReadInt64();
var p3 = read.ReadDouble();
var p4 = read.ReadSingle();
var p5 = read.ReadBoolean();
var p6 = read.ReadBoolean();
var p7 = read.ReadString();
var p8 = read.ReadMemory();
var p9 = read.ReadInt16();
var p10 = read.ReadObject <List <Guid> >();
read.Dispose();
using (WriteBytes writeBytes = new WriteBytes(fiberRw))
{
writeBytes.WriteLen();
writeBytes.Cmd(cmd);
writeBytes.Write(p1);
writeBytes.Write(p2);
writeBytes.Write(p3);
writeBytes.Write(p4);
writeBytes.Write(p5);
writeBytes.Write(p6);
writeBytes.Write(p7);
writeBytes.Write(p8);
writeBytes.Write(p9);
writeBytes.Write(p10);
writeBytes.Flush();
}
}
/// <summary>
/// 输入包输入处理
/// </summary>
/// <param name="Data"></param>
void SocketManager_DataInput(byte[] Data)
{
ReadBytes read = new ReadBytes(Data);
int length;
int cmd;
if (read.ReadInt32(out length) && read.ReadInt32(out cmd) && length == read.Length)
{
switch (cmd)
{
case 500: //如果是Message类型数据包
BuffLibrary.Message ms;
if (read.ReadObject <BuffLibrary.Message>(out ms))
{
if (ms != null)
{
if (ms.Type == 1) //1登入失败
{
MessageBox.Show(ms.MessageStr);
}
else if (ms.Type == 2) //2登入成功
{
Logins = true; //设置 LOGINS
this.BeginInvoke(new EventHandler((o, p) => Close())); //关闭窗口
}
}
}
break;
}
}
}
public void _RegSession(ZYNetServer Server, ReadBytes read, ZYNetSession session)
{
RegSession regSession;
if (read.ReadObject <RegSession>(out regSession))
{
session.LANIP = regSession.LocalHost;
session.Group = regSession.Group;
if (!Server.SessionDiy.ContainsKey(session.Id))
{
regSession.Id = session.Id;
regSession.IsSuccess = true;
regSession.Port = Server.RegPort;
Server.SessionDiy.AddOrUpdate(session.Id, session, (a, b) => session);
Server.Send(session, BufferFormat.FormatFCA(regSession));
AddSession add = new AddSession()
{
Id = regSession.Id
};
Server.SendAll(BufferFormat.FormatFCA(add));
}
else
{
regSession.IsSuccess = false;
regSession.Msg = "User Id Is Have";
Server.Send(session, BufferFormat.FormatFCA(regSession));
Server.Service.Disconnect(session.Asyn.AcceptSocket);
}
}
}
public void ReadDataSet(ZYSocketSuper server, ReadBytes read, SocketAsyncEventArgs socketAsync)
{
ReadDataSet rd;
if (read.ReadObject <ReadDataSet>(out rd)) //读取请求DATASET 数据包
{
if (rd != null)
{
rd.Data = new List <DataValue>();
rd.TableName = "table1";
rd.Data.Add(new DataValue()
{
V1 = "第1个",
V2 = "第2个",
V3 = "第3个",
V4 = "第4个",
V5 = "第5个"
});
rd.Data.Add(new DataValue()
{
V1 = "第6个",
V2 = "第7个",
V3 = "第8个",
V4 = "第9个",
V5 = "第10个"
});
rd.Data.Add(new DataValue()
{
V1 = "第11个",
V2 = "第12个",
V3 = "第13个",
V4 = "第14个",
V5 = "第15个"
});
rd.Data.Add(new DataValue()
{
V1 = "第16个",
V2 = "第17个",
V3 = "第18个",
V4 = "第19个",
V5 = "第20个"
});
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(rd)); //发送
Console.WriteLine((socketAsync.UserToken as User.UserInfo).UserName + " 读取了" + rd.TableName);
}
}
}
public void Ping(ZYSocketSuper server, ReadBytes read, SocketAsyncEventArgs socketAsync)
{
Ping pdata;
if (read.ReadObject <Ping>(out pdata)) //读取PING 数据包
{
if (pdata != null)
{
pdata.ServerReviceTime = DateTime.Now; //设置服务器时间
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(pdata)); //发送返回
}
}
}
/// <summary>
/// 数据包输入 以处理
/// </summary>
/// <param name="data"></param>
/// <param name="session"></param>
private void DataOn(byte[] data, ZYNetSession session)
{
ReadBytes read = new ReadBytes(data);
int length;
int cmd;
if (read.ReadInt32(out length) && length == read.Length && read.ReadInt32(out cmd))
{
if (cmd != -2000)
{
if (!CmdToCallManager <ZYNetServer, ReadBytes, ZYNetSession> .GetInstance().pointerRun(this, cmd, read, session))
{
LLOG("Not Find CMD:" + cmd, EventLogType.ERR);
}
}
else
{
ProxyData tmp;
if (read.ReadObject <ProxyData>(out tmp))
{
if (tmp.Source == session.Id)
{
if (tmp.Ids != null)
{
if (tmp.Ids.Contains(0))
{
if (UserDataInput != null)
{
UserDataInput(session, tmp.Data);
}
}
foreach (var Id in tmp.Ids)
{
if (Id != 0 && SessionDiy.ContainsKey(Id))
{
Service.SendData(SessionDiy[Id].Asyn.AcceptSocket, data);
}
}
}
}
}
}
}
}
public void LogOn(ZYSocketSuper server, ReadBytes read, SocketAsyncEventArgs socketAsync)
{
Login p;
if (read.ReadObject<Login>(out p))
{
if (p != null)
{
if (User.UserManger.GetUserDataManger().CheckUser(p.UserName, p.PassWord))//检查用户名密码是否正确
{
User.UserInfo user = new User.UserInfo() //建立一个新的用户对象 并且初始化 用户名
{
UserName = p.UserName
};
socketAsync.UserToken = user; //设置USERTOKEN
Message err = new Message() //初始化MESSAGE数据包类
{
Type = 2,
MessageStr = "登入成功"
};
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(err)); //发送此类
Console.WriteLine(user.UserName + " 登入");
}
else
{
Message err = new Message() //初始化用户名密码错误数据包
{
Type = 1,
MessageStr = "用户名或密码错误"
};
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(err));
}
}
}
}
public void _GetAllSession(ZYNetServer Server, ReadBytes read, ZYNetSession session)
{
GetAllSession pack;
if (read.ReadObject <GetAllSession>(out pack))
{
var userlist = Server.SessionDiy.Values.Where(p => p.Group == session.Group && p.Id != session.Id);
pack.UserIds = new List <long>();
foreach (var item in userlist)
{
pack.UserIds.Add(item.Id);
}
pack.IsSuccess = true;
Server.Send(session, BufferFormat.FormatFCA(pack));
}
}
private void Client_DataInput(long Id, byte[] data)
{
ReadBytes read = new ReadBytes(data);
int cmd;
int lengt;
if (read.ReadInt32(out lengt) && read.ReadInt32(out cmd) && lengt == read.Length)
{
switch (cmd)
{
case 1000:
{
if (Id == 0)
{
DrawBoardPACK.LogOn tmp;
if (read.ReadObject <DrawBoardPACK.LogOn>(out tmp))
{
if (tmp.Success)
{
MessageBox.Show("登入成功");
IsLogOn = true;
this.BeginInvoke(new EventHandler((a, b) =>
{
this.Close();
}));
Names = tmp.UserName;
}
else
{
MessageBox.Show("登入失败");
}
}
}
}
break;
}
}
}
public void LogOn(ZYSocketSuper server, ReadBytes read, SocketAsyncEventArgs socketAsync)
{
Login p;
if (read.ReadObject <Login>(out p))
{
if (p != null)
{
if (User.UserManger.GetUserDataManger().CheckUser(p.UserName, p.PassWord)) //检查用户名密码是否正确
{
User.UserInfo user = new User.UserInfo() //建立一个新的用户对象 并且初始化 用户名
{
UserName = p.UserName
};
socketAsync.UserToken = user; //设置USERTOKEN
Message err = new Message() //初始化MESSAGE数据包类
{
Type = 2,
MessageStr = "登入成功"
};
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(err)); //发送此类
Console.WriteLine(user.UserName + " 登入");
}
else
{
Message err = new Message() //初始化用户名密码错误数据包
{
Type = 1,
MessageStr = "用户名或密码错误"
};
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(err));
}
}
}
}
static void DataOn(byte[] data, SocketAsyncEventArgs e)
{
try
{
Console.WriteLine(Marshal.SizeOf(typeof(ID3V1)));
Console.WriteLine(Marshal.SizeOf(typeof(PPo)));
Console.WriteLine("---------------------------------------------------------------------------");
var stream = new MemoryStream(data);
using (var reader = new BinaryReader(stream))
{
reader.BaseStream.Seek(-1 * Marshal.SizeOf(typeof(PPo)), SeekOrigin.End);
var id3Tag = reader.ReadMarshal<PPo>();
Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n \r\n\r\n", id3Tag.Id,UTF8ToGB2312(id3Tag.Message), id3Tag.Guid);
//Console.WriteLine(WordsIScn(id3Tag.Message).ToString());
var s = Encoding.Default.GetBytes(id3Tag.Message);
Console.WriteLine(Encoding.UTF8.GetString(s));
}
//建立一个读取数据包的类 参数是数据包
//这个类的功能很强大,可以读取数据包的数据,并可以把你发送过来的对象数据,转换对象引用
ReadBytes read = new ReadBytes(data);
int lengt; //数据包长度,用于验证数据包的完整性
int cmd; //数据包命令类型
//注意这里一定要这样子写,这样子可以保证所有你要度的数据是完整的,如果读不出来 Raed方法会返回FALSE,从而避免了错误的数据导致崩溃
if (read.ReadInt32(out lengt) && read.Length == lengt)
{ //read.Read系列函数是不会产生异常的
int id;
string mn;
SocketClinetTest.PPo temp;
//if (read.ReadInt32(out id) && read.ReadObject<SocketClinetTest.PPo>(out temp))
//{
// if (temp != null)
// {
// Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n DataLength:{3} \r\n\r\n", temp.Id, temp.Message, temp.guid, read.Length);
// }
//}
if (read.ReadObject<SocketClinetTest.PPo>(out temp))
{
if (temp != null)
{
Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n DataLength:{3} \r\n\r\n", temp.Id, temp.Message, temp.Guid, read.Length);
}
}
//根据命令读取数据包
//switch (cmd)
//{
// case 1000:
// testClass.PPo temp;
// if (read.ReadObject<testClass.PPo>(out temp))
// {
// if (temp != null)
// {
// Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n DataLength:{3} \r\n\r\n", temp.Id, temp.Message, temp.guid, read.Length);
// }
// }
// break;
// case 1001:
// {
// int id;
// string mn;
// Guid guid;
// if (read.ReadInt32(out id) && read.ReadString(out mn) && read.ReadObject<Guid>(out guid))
// {
// Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n DataLength:{3} \r\n\r\n", id, mn, guid, read.Length);
// }
// }
// break;
// case 1002:
// {
// int id;
// string mn;
// string guid;
// if (read.ReadInt32(out id) && read.ReadString(out mn) && read.ReadString(out guid))
// {
// Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n DataLength:{3} \r\n\r\n", id, mn, guid, read.Length);
// }
// }
// break;
// case 1003:
// {
// server.SendData(e.AcceptSocket, data);
// }
// break;
//}
}
}
catch (Exception er)
{
Console.WriteLine(er.ToString());
}
}
static void DataOn(byte[] data, SocketAsyncEventArgs socketAsync)
{
ReadBytes read = new ReadBytes(data);
int length;
int cmd;
if (read.ReadInt32(out length) && read.ReadInt32(out cmd) && length == read.Length)
{
switch (cmd)
{
case 800:
Ping pdata;
if (read.ReadObject<Ping>(out pdata)) //读取PING 数据包
{
if (pdata != null)
{
pdata.ServerReviceTime = DateTime.Now; //设置服务器时间
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(pdata)); //发送返回
}
}
break;
case 1002:
ReadDataSet rd;
if (read.ReadObject<ReadDataSet>(out rd)) //读取请求DATASET 数据包
{
if (rd != null)
{
rd.Data = new List<DataValue>();
rd.TableName = "table1";
rd.Data.Add(new DataValue()
{
V1 = "第1个",
V2 = "第2个",
V3 = "第3个",
V4 = "第4个",
V5 = "第5个"
});
rd.Data.Add(new DataValue()
{
V1 = "第6个",
V2 = "第7个",
V3 = "第8个",
V4 = "第9个",
V5 = "第10个"
});
rd.Data.Add(new DataValue()
{
V1 = "第11个",
V2 = "第12个",
V3 = "第13个",
V4 = "第14个",
V5 = "第15个"
});
rd.Data.Add(new DataValue()
{
V1 = "第16个",
V2 = "第17个",
V3 = "第18个",
V4 = "第19个",
V5 = "第20个"
});
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(rd)); //发送
Console.WriteLine((socketAsync.UserToken as User.UserInfo).UserName + " 读取了" + rd.TableName);
}
}
break;
}
}
}
/// <summary>
/// 数据包输入
/// </summary>
/// <param name="data">输入数据</param>
/// <param name="socketAsync">该数据包的通讯SOCKET</param>
static void BinaryInputHandler(byte[] data, SocketAsyncEventArgs socketAsync)
{
if (socketAsync.UserToken == null) //如果用户第一次登入
{
ReadBytes read = new ReadBytes(data);
int length;
int cmd;
if (read.ReadInt32(out length) && length == read.Length && read.ReadInt32(out cmd))
{
if (cmd == 1000) //如果用户发送的是登入数据包
{
Login p;
if (read.ReadObject <Login>(out p))
{
if (p != null)
{
if (User.UserManger.GetUserDataManger().CheckUser(p.UserName, p.PassWord)) //检查用户名密码是否正确
{
User.UserInfo user = new User.UserInfo() //建立一个新的用户对象 并且初始化 用户名
{
UserName = p.UserName
};
socketAsync.UserToken = user; //设置USERTOKEN
Message err = new Message() //初始化MESSAGE数据包类
{
Type = 2,
MessageStr = "登入成功"
};
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(err)); //发送此类
Console.WriteLine(user.UserName + " 登入");
}
else
{
Message err = new Message() //初始化用户名密码错误数据包
{
Type = 1,
MessageStr = "用户名或密码错误"
};
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(err));
}
}
}
}
else //现在还没登入 如果有其他命令的请求那么 断开连接
{
server.Disconnect(socketAsync.AcceptSocket);
}
}
else //无法读取数据包 断开连接
{
server.Disconnect(socketAsync.AcceptSocket);
}
}
else
{
User.UserInfo user = socketAsync.UserToken as User.UserInfo; //读取用户USERTRKEN
if (user != null)
{
user.BuffManger.Write(data);
byte[] pdata;
while (user.BuffManger.Read(out pdata))
{
DataOn(pdata, socketAsync);
}
}
}
}
private static void Server_UserDataInput(ZYSocket.ZYNet.ZYNetSession session, byte[] data)
{
ReadBytes read = new ReadBytes(data);
int lengt;
int cmd;
if (read.ReadInt32(out lengt) && read.ReadInt32(out cmd) && read.Length == lengt)
{
switch (cmd)
{
case 1000:
{
LogOn logon;
if (read.ReadObject <LogOn>(out logon))
{
UserInfo tmp = new UserInfo()
{
Name = logon.UserName,
Session = session
};
session.UserToken = tmp;
UserList.Add(tmp);
logon.Success = true;
Server.SendDataToClient(session, BufferFormat.FormatFCA(logon));
Console.WriteLine(tmp.Name + "登入");
}
}
break;
case 2000:
{
if (session.UserToken == null)
{
return;
}
DrawPoint tmp;
if (read.ReadObject <DrawPoint>(out tmp))
{
if (Map == null)
{
Map = new Bitmap(848, 609);
gs = Graphics.FromImage(Map);
}
Brush br = new SolidBrush(Color.FromArgb(tmp.Color));
gs.FillEllipse(br, tmp.X, tmp.Y, 2, 2);
gs.Flush();
gs.Save();
}
}
break;
case 3000:
{
if (session.UserToken == null)
{
return;
}
ClecrColor tmp;
if (read.ReadObject <ClecrColor>(out tmp))
{
gs.Clear(Color.FromArgb(tmp.Color));
gs.Flush();
gs.Save();
}
}
break;
case 4000:
{
if (session.UserToken == null)
{
return;
}
SaveImg tmp;
if (read.ReadObject <SaveImg>(out tmp))
{
string path = (new System.IO.FileInfo(System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName)).Directory.FullName + "\\SAVE\\";
if (!System.IO.Directory.Exists(path))
{
System.IO.Directory.CreateDirectory(path);
}
Map.Save(path + tmp.FileName);
}
}
break;
}
}
}
public void ReadDataSet(ZYSocketSuper server, ReadBytes read, SocketAsyncEventArgs socketAsync)
{
ReadDataSet rd;
if (read.ReadObject<ReadDataSet>(out rd)) //读取请求DATASET 数据包
{
if (rd != null)
{
rd.Data = new List<DataValue>();
rd.TableName = "table1";
rd.Data.Add(new DataValue()
{
V1 = "第1个",
V2 = "第2个",
V3 = "第3个",
V4 = "第4个",
V5 = "第5个"
});
rd.Data.Add(new DataValue()
{
V1 = "第6个",
V2 = "第7个",
V3 = "第8个",
V4 = "第9个",
V5 = "第10个"
});
rd.Data.Add(new DataValue()
{
V1 = "第11个",
V2 = "第12个",
V3 = "第13个",
V4 = "第14个",
V5 = "第15个"
});
rd.Data.Add(new DataValue()
{
V1 = "第16个",
V2 = "第17个",
V3 = "第18个",
V4 = "第19个",
V5 = "第20个"
});
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(rd)); //发送
Console.WriteLine((socketAsync.UserToken as User.UserInfo).UserName + " 读取了" + rd.TableName);
}
}
}
static void DataOn(byte[] data, SocketAsyncEventArgs socketAsync)
{
ReadBytes read = new ReadBytes(data);
int length;
int cmd;
if (read.ReadInt32(out length) && read.ReadInt32(out cmd) && length == read.Length)
{
switch (cmd)
{
case 800:
Ping pdata;
if (read.ReadObject <Ping>(out pdata)) //读取PING 数据包
{
if (pdata != null)
{
pdata.ServerReviceTime = DateTime.Now; //设置服务器时间
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(pdata)); //发送返回
}
}
break;
case 1002:
ReadDataSet rd;
if (read.ReadObject <ReadDataSet>(out rd)) //读取请求DATASET 数据包
{
if (rd != null)
{
rd.Data = new List <DataValue>();
rd.TableName = "table1";
rd.Data.Add(new DataValue()
{
V1 = "第1个",
V2 = "第2个",
V3 = "第3个",
V4 = "第4个",
V5 = "第5个"
});
rd.Data.Add(new DataValue()
{
V1 = "第6个",
V2 = "第7个",
V3 = "第8个",
V4 = "第9个",
V5 = "第10个"
});
rd.Data.Add(new DataValue()
{
V1 = "第11个",
V2 = "第12个",
V3 = "第13个",
V4 = "第14个",
V5 = "第15个"
});
rd.Data.Add(new DataValue()
{
V1 = "第16个",
V2 = "第17个",
V3 = "第18个",
V4 = "第19个",
V5 = "第20个"
});
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(rd)); //发送
Console.WriteLine((socketAsync.UserToken as User.UserInfo).UserName + " 读取了" + rd.TableName);
}
}
break;
}
}
}
public void BinaryInput(byte[] data)
{
ReadBytes read = new ReadBytes(data);
int lengt;
int cmd;
if (read.ReadInt32(out lengt) && read.Length == lengt && read.ReadInt32(out cmd))
{
switch (cmd)
{
case 1001001:
{
ZYClient_Result_Return val;
if (read.ReadObject <ZYClient_Result_Return>(out val))
{
RPC_Call.SetReturnValue(val);
}
}
break;
case 1001000:
{
ThreadPool.QueueUserWorkItem((o) =>
{
RPCCallPack tmp;
ReadBytes pread = (ReadBytes)o;
if (pread.ReadObject <RPCCallPack>(out tmp))
{
object returnValue;
CallContext.SetData("Current", this);
if (RPC_Call.RunModule(tmp, out returnValue))
{
if (tmp.IsNeedReturn)
{
ZYClient_Result_Return var = new ZYClient_Result_Return()
{
Id = tmp.Id,
CallTime = tmp.CallTime,
Arguments = tmp.Arguments
};
if (returnValue != null)
{
var.Return = Serialization.PackSingleObject(returnValue.GetType(), returnValue);
var.ReturnType = returnValue.GetType();
}
Client.Send(BufferFormat.FormatFCA(var));
}
}
}
}, read);
}
break;
default:
{
if (DataOn != null)
{
DataOn(cmd, read);
}
}
break;
}
}
}
private void Client_DataInput(long Id, byte[] data)
{
ReadBytes read = new ReadBytes(data);
int lengt;
int cmd;
if (read.ReadInt32(out lengt) && read.ReadInt32(out cmd) && lengt == read.Length)
{
switch (cmd)
{
case 2000:
{
DrawPoint tmp;
if (read.ReadObject <DrawPoint>(out tmp))
{
this.BeginInvoke(new EventHandler((a, b) =>
{
Brush br = new SolidBrush(Color.FromArgb(tmp.Color));
gs.FillEllipse(br, tmp.X, tmp.Y, 2, 2);
gs.Flush();
gs.Save();
gs2.FillEllipse(br, tmp.X, tmp.Y, 2, 2);
gs2.Flush();
gs2.Save();
}));
}
}
break;
case 3000:
{
this.BeginInvoke(new EventHandler((a, b) =>
{
gs.Clear(Color.White);
gs2.Clear(Color.White);
}));
}
break;
case 5000:
{
if (Id != 0) //id=0表示服务器 其他没有特殊需要别管
{
return;
}
UserCount tmp;
if (read.ReadObject <UserCount>(out tmp))
{
this.BeginInvoke(new EventHandler((a, b) =>
{
this.label1.Text = "当前人数:" + tmp.Count;
}));
}
}
break;
}
}
}
static void DataOn(byte[] data, SocketAsyncEventArgs e)
{
Console.WriteLine("ThreadId:" + System.Threading.Thread.CurrentThread.ManagedThreadId);
try
{
//建立一个读取数据包的类 参数是数据包
//这个类的功能很强大,可以读取数据包的数据,并可以把你发送过来的对象数据,转换对象引用
ReadBytes read = new ReadBytes(data);
int lengt; //数据包长度,用于验证数据包的完整性
int cmd; //数据包命令类型
//注意这里一定要这样子写,这样子可以保证所有你要度的数据是完整的,如果读不出来 Raed方法会返回FALSE,从而避免了错误的数据导致崩溃
if (read.ReadInt32(out lengt) && read.Length == lengt && read.ReadInt32(out cmd))
{ //read.Read系列函数是不会产生异常的
//根据命令读取数据包
switch (cmd)
{
case 1000:
{
int version = read.ReadInt32();
long data1 = read.ReadInt64();
float data2 = read.ReadFloat();
double db1 = read.ReadDouble();
bool b1 = read.ReadBoolean();
bool b2 = read.ReadBoolean();
short s1 = read.ReadInt16();
byte sb1 = read.ReadByte();
string str1 = read.ReadString();
string str2 = read.ReadString();
byte[] datax = read.ReadByteArray();
TestData tm2 = read.ReadObject <TestData>();
Console.WriteLine("int:" + version);
Console.WriteLine("long:" + data1);
Console.WriteLine("float:" + data2);
Console.WriteLine("double:" + db1);
Console.WriteLine("bool TRUE:" + b1);
Console.WriteLine("bool False:" + b2);
Console.WriteLine("short:" + s1);
Console.WriteLine("byte:" + sb1);
Console.WriteLine("string:" + str1);
Console.WriteLine("string:" + str2);
Console.WriteLine("bytes lengt:" + datax.Length);
BufferFormat buffer = new BufferFormat(1000);
buffer.AddItem(version);
buffer.AddItem(data1);
buffer.AddItem(data2);
buffer.AddItem(db1);
buffer.AddItem(b1);
buffer.AddItem(b2);
buffer.AddItem(s1);
buffer.AddItem(sb1);
buffer.AddItem(str1);
buffer.AddItem(str2);
buffer.AddItem(datax);
TestData tmx = new TestData()
{
Id = 1,
Data = new List <string>()
{
"123123", "32123123"
},
Data2 = new List <Test2>()
{
new Test2 {
A = 1, B = 2
}, new Test2 {
A = 3, B = 4
}
}
};
buffer.AddItem(tmx);
server.SendData(e.AcceptSocket, buffer.Finish());
}
break;
}
}
}
catch (Exception er)
{
Console.WriteLine(er.ToString());
}
}
public void BinaryInput(byte[] data)
{
ReadBytes read = new ReadBytes(data);
int lengt;
int cmd;
if (read.ReadInt32(out lengt) && read.Length == lengt && read.ReadInt32(out cmd))
{
switch (cmd)
{
case 1001001:
{
Result_Have_Return val;
if (read.ReadObject <Result_Have_Return>(out val))
{
RPC_Call.SetReturnValue(val);
}
}
break;
case 1001000:
{
ThreadPool.QueueUserWorkItem((o) =>
{
RPCCallPack tmp;
ReadBytes pread = (ReadBytes)o;
if (pread.ReadObject <RPCCallPack>(out tmp))
{
object returnValue;
try
{
if (RPC_Call.RunModule(tmp, tmp.NeedReturn, out returnValue))
{
if (tmp.NeedReturn)
{
Result_Have_Return var = new Result_Have_Return()
{
Id = tmp.Id,
Arguments = tmp.Arguments
};
if (returnValue != null)
{
var.Return = Serialization.PackSingleObject(returnValue.GetType(), returnValue);
}
Client.BeginSendData(BufferFormat.FormatFCA(var));
}
}
}
catch (Exception er)
{
LogAction.Err(er.ToString());
}
}
}, read);
}
break;
default:
{
if (DataOn != null)
{
DataOn(cmd, read);
}
}
break;
}
}
}
/// <summary>
/// 调用模块
/// </summary>
/// <param name="data"></param>
/// <returns>true 属于次模块,false 不属于此模块数据</returns>
public bool CallModule(byte[] data, RPCUserInfo e, bool isTaskQueue, out ReadBytes read, out int cmd)
{
cmd = -1;
read = new ReadBytes(data);
int lengt;
if (read.ReadInt32(out lengt) && read.Length == lengt && read.ReadInt32(out cmd))
{
switch (cmd)
{
case 1001000:
{
RPCCallPack tmp;
if (read.ReadObject <RPCCallPack>(out tmp))
{
if (isTaskQueue)
{
System.Threading.Tasks.Task.Factory.StartNew((pack) => Call(pack as RPCCallPack, e)
, tmp, CancellationToken.None, TaskCreationOptions.None, e.Scheduler).ContinueWith(p =>
{
try
{
p.Wait();
}
catch (Exception er)
{
if (MsgOut != null)
{
if (e.Asyn.RemoteEndPoint != null)
{
MsgOut(e.Asyn.RemoteEndPoint.ToString() + "::" + tmp.CallModule + "->" + tmp.Method + "\r\n" + er.ToString(), MsgOutType.Err);
}
else
{
MsgOut(tmp.CallModule + "->" + tmp.Method + "\r\n" + er.ToString(), MsgOutType.Err);
}
}
}
});
return(true);
}
else
{
Call(tmp, e);
}
}
}
break;
case 1001001:
{
ZYClient_Result_Return val;
if (read.ReadObject <ZYClient_Result_Return>(out val))
{
e.RPC_Call.SetReturnValue(val);
return(true);
}
}
break;
}
}
return(false);
}
/// <summary>
/// 调用模块
/// </summary>
/// <param name="data"></param>
/// <returns>true 属于次模块,false 不属于此模块数据</returns>
public bool CallModule(byte[] data, RPCUserInfo e, out ReadBytes read, out int cmd)
{
cmd = -1;
read = new ReadBytes(data);
int lengt;
if (read.ReadInt32(out lengt) && read.Length == lengt && read.ReadInt32(out cmd))
{
switch (cmd)
{
case 1001000:
{
RPCCallPack tmp;
if (read.ReadObject <RPCCallPack>(out tmp))
{
System.Threading.Tasks.Task.Factory.StartNew(() =>
{
object returnValue;
CallContext.SetData("Current", e);
if (e.RPC_Call.RunModule(tmp, out returnValue))
{
if (tmp.IsNeedReturn)
{
ZYClient_Result_Return var = new ZYClient_Result_Return()
{
Id = tmp.Id,
CallTime = tmp.CallTime,
Arguments = tmp.Arguments
};
if (returnValue != null)
{
var.Return = Serialization.PackSingleObject(returnValue.GetType(), returnValue);
var.ReturnType = returnValue.GetType();
}
e.EnsureSend(BufferFormat.FormatFCA(var));
}
}
}, CancellationToken.None, TaskCreationOptions.None, e.QueueScheduler).ContinueWith(p =>
{
try
{
p.Wait();
}
catch (Exception er)
{
if (MsgOut != null)
{
MsgOut(er.ToString());
}
}
});
return(true);
}
}
break;
case 1001001:
{
ZYClient_Result_Return val;
if (read.ReadObject <ZYClient_Result_Return>(out val))
{
e.RPC_Call.SetReturnValue(val);
return(true);
}
}
break;
}
}
return(false);
}
public void BinaryInput(byte[] data)
{
ReadBytes read = new ReadBytes(data);
int lengt;
int cmd;
if (read.ReadInt32(out lengt) && read.Length == lengt && read.ReadInt32(out cmd))
{
switch (cmd)
{
case 1001001:
{
ZYClient_Result_Return val;
if (read.ReadObject <ZYClient_Result_Return>(out val))
{
RPC_Call.SetReturnValue(val);
}
}
break;
case 1001000:
{
System.Threading.Tasks.Task.Factory.StartNew(() =>
{
RPCCallPack tmp;
if (read.ReadObject <RPCCallPack>(out tmp))
{
object returnValue;
CallContext.SetData("Current", this);
if (RPC_Call.RunModule(tmp, out returnValue))
{
if (tmp.IsNeedReturn)
{
ZYClient_Result_Return var = new ZYClient_Result_Return()
{
Id = tmp.Id,
CallTime = tmp.CallTime,
Arguments = tmp.Arguments
};
if (returnValue != null)
{
var.Return = Serialization.PackSingleObject(returnValue.GetType(), returnValue);
var.ReturnType = returnValue.GetType();
}
Client.Send(BufferFormat.FormatFCA(var));
}
}
}
}, CancellationToken.None, TaskCreationOptions.None, OrderSchedulerRead);
}
break;
default:
{
if (DataOn != null)
{
DataOn(cmd, read);
}
}
break;
}
}
}
public void BinaryInput(byte[] data)
{
ReadBytes read = new ReadBytes(data);
int lengt;
int cmd;
if (read.ReadInt32(out lengt) && read.Length == lengt && read.ReadInt32(out cmd))
{
switch (cmd)
{
case 1001001:
{
ZYClient_Result_Return val;
if (read.ReadObject <ZYClient_Result_Return>(out val))
{
RPC_Call.SetReturnValue(val);
}
}
break;
case 1001000:
{
RPCCallPack tmp;
if (read.ReadObject <RPCCallPack>(out tmp))
{
System.Threading.Tasks.Task.Factory.StartNew((pack) =>
{
CallContext.SetData("Current", this);
string msg;
object returnValue;
if (RPC_Call.RunModule(pack as RPCCallPack, out msg, out returnValue))
{
ZYClient_Result_Return var = new ZYClient_Result_Return()
{
Id = tmp.Id,
CallTime = tmp.CallTime,
Arguments = tmp.Arguments
};
if (returnValue != null)
{
var.Return = Serialization.PackSingleObject(returnValue.GetType(), returnValue);
}
Client.BeginSendData(BufferFormat.FormatFCA(var));
}
else
{
if (MsgOut != null)
{
MsgOut(tmp.CallModule + "->" + tmp.Method + " Call Failure");
}
}
}, tmp, CancellationToken.None, TaskCreationOptions.None, OrderSchedulerRead).ContinueWith(task =>
{
try
{
task.Wait();
}
catch (Exception er)
{
if (MsgOut != null)
{
MsgOut(er.ToString());
}
}
});
}
}
break;
default:
{
if (DataOn != null)
{
DataOn(cmd, read);
}
}
break;
}
}
}
/// <summary>
/// 数据包输入
/// </summary>
/// <param name="data">输入数据</param>
/// <param name="socketAsync">该数据包的通讯SOCKET</param>
static void BinaryInputHandler(byte[] data, SocketAsyncEventArgs socketAsync)
{
if (socketAsync.UserToken == null) //如果用户第一次登入
{
ReadBytes read = new ReadBytes(data);
int length;
int cmd;
if (read.ReadInt32(out length) && length == read.Length && read.ReadInt32(out cmd))
{
if (cmd == 1000) //如果用户发送的是登入数据包
{
Login p;
if (read.ReadObject <Login>(out p))
{
if (p != null)
{
if (User.UserManger.GetUserDataManger().CheckUser(p.UserName, p.PassWord))//检查用户名密码是否正确
{
User.UserInfo user = new User.UserInfo() //建立一个新的用户对象 并且初始化 用户名
{
UserName = p.UserName
};
socketAsync.UserToken = user; //设置USERTOKEN
Message err = new Message() //初始化MESSAGE数据包类
{
Type = 2,
MessageStr = "登入成功"
};
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(err)); //发送此类
Console.WriteLine(user.UserName + " 登入");
}
else
{
Message err = new Message() //初始化用户名密码错误数据包
{
Type = 1,
MessageStr = "用户名或密码错误"
};
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(err));
}
}
}
}
else //现在还没登入 如果有其他命令的请求那么 断开连接
{
server.Disconnect(socketAsync.AcceptSocket);
}
}
else //无法读取数据包 断开连接
{
server.Disconnect(socketAsync.AcceptSocket);
}
}
else
{
User.UserInfo user = socketAsync.UserToken as User.UserInfo; //读取用户USERTRKEN
if (user != null)
{
user.BuffManger.Write(data);
byte[] pdata;
while (user.BuffManger.Read(out pdata))
{
DataOn(pdata, socketAsync);
}
}
}
}
static void DataOn(byte[] data, SocketAsyncEventArgs e)
{
try
{
//建立一个读取数据包的类 参数是数据包
//这个类的功能很强大,可以读取数据包的数据,并可以把你发送过来的对象数据,转换对象引用
ReadBytes read = new ReadBytes(data);
int lengt; //数据包长度,用于验证数据包的完整性
int cmd; //数据包命令类型
//注意这里一定要这样子写,这样子可以保证所有你要度的数据是完整的,如果读不出来 Raed方法会返回FALSE,从而避免了错误的数据导致崩溃
if (read.ReadInt32(out lengt) && read.Length == lengt && read.ReadInt32(out cmd))
{ //read.Read系列函数是不会产生异常的
//根据命令读取数据包
switch (cmd)
{
case 1000:
testClass.PPo temp;
if (read.ReadObject<testClass.PPo>(out temp))
{
if (temp != null)
{
Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n DataLength:{3} \r\n\r\n", temp.Id, temp.Message, temp.guid, read.Length);
}
}
break;
case 1001:
{
int id;
string mn;
Guid guid;
if (read.ReadInt32(out id) && read.ReadString(out mn) && read.ReadObject<Guid>(out guid))
{
Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n DataLength:{3} \r\n\r\n", id, mn, guid, read.Length);
}
}
break;
case 1002:
{
int id;
string mn;
string guid;
if (read.ReadInt32(out id) && read.ReadString(out mn) && read.ReadString(out guid))
{
Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n DataLength:{3} \r\n\r\n", id, mn, guid, read.Length);
}
}
break;
case 1003:
{
server.SendData(e.AcceptSocket, data);
}
break;
}
}
}
catch (Exception er)
{
Console.WriteLine(er.ToString());
}
}
public void Ping(ZYSocketSuper server, ReadBytes read, SocketAsyncEventArgs socketAsync)
{
Ping pdata;
if (read.ReadObject<Ping>(out pdata)) //读取PING 数据包
{
if (pdata != null)
{
pdata.ServerReviceTime = DateTime.Now; //设置服务器时间
server.SendData(socketAsync.AcceptSocket, BufferFormat.FormatFCA(pdata)); //发送返回
}
}
}
static void DataOn(byte[] data, SocketAsyncEventArgs e)
{
try
{
//建立一个读取数据包的类 参数是数据包
//这个类的功能很强大,可以读取数据包的数据,并可以把你发送过来的对象数据,转换对象引用
ReadBytes read = new ReadBytes(data);
int lengt; //数据包长度,用于验证数据包的完整性
int cmd; //数据包命令类型
//注意这里一定要这样子写,这样子可以保证所有你要度的数据是完整的,如果读不出来 Raed方法会返回FALSE,从而避免了错误的数据导致崩溃
if (read.ReadInt32(out lengt) && read.Length == lengt && read.ReadInt32(out cmd))
{ //read.Read系列函数是不会产生异常的
//根据命令读取数据包
switch (cmd)
{
case 1000:
testClass.PPo temp;
if (read.ReadObject <testClass.PPo>(out temp))
{
if (temp != null)
{
Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n DataLength:{3} \r\n\r\n", temp.Id, temp.Message, temp.guid, read.Length);
}
}
break;
case 1001:
{
int id;
string mn;
Guid guid;
if (read.ReadInt32(out id) && read.ReadString(out mn) && read.ReadObject <Guid>(out guid))
{
Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n DataLength:{3} \r\n\r\n", id, mn, guid, read.Length);
}
}
break;
case 1002:
{
int id;
string mn;
string guid;
if (read.ReadInt32(out id) && read.ReadString(out mn) && read.ReadString(out guid))
{
Console.WriteLine("Id:{0}\r\n Mn:{1} \r\n Guid:{2} \r\n DataLength:{3} \r\n\r\n", id, mn, guid, read.Length);
}
}
break;
case 1003:
{
server.SendData(e.AcceptSocket, data);
}
break;
}
}
}
catch (Exception er)
{
Console.WriteLine(er.ToString());
}
}
/// <summary>
/// 调用模块
/// </summary>
/// <param name="data"></param>
/// <returns>true 属于次模块,false 不属于此模块数据</returns>
public bool CallModule(byte[] data, RPCUserInfo e,out ReadBytes read,out int cmd)
{
cmd = -1;
read = new ReadBytes(data);
int lengt;
if (read.ReadInt32(out lengt) && read.Length == lengt && read.ReadInt32(out cmd))
{
switch (cmd)
{
case 1001000:
{
RPCCallPack tmp;
if (read.ReadObject<RPCCallPack>(out tmp))
{
System.Threading.Tasks.Task.Factory.StartNew(() =>
{
object returnValue;
CallContext.SetData("Current", e);
if (e.RPC_Call.RunModule(tmp, out returnValue))
{
if (tmp.IsNeedReturn)
{
ZYClient_Result_Return var = new ZYClient_Result_Return()
{
Id = tmp.Id,
CallTime = tmp.CallTime,
Arguments = tmp.Arguments
};
if (returnValue != null)
{
var.Return = Serialization.PackSingleObject(returnValue.GetType(), returnValue);
var.ReturnType = returnValue.GetType();
}
e.EnsureSend(BufferFormat.FormatFCA(var));
}
}
}, CancellationToken.None, TaskCreationOptions.None, e.QueueScheduler).ContinueWith(p =>
{
try
{
p.Wait();
}
catch (Exception er)
{
if (MsgOut != null)
MsgOut(er.ToString());
}
});
return true;
}
}
break;
case 1001001:
{
ZYClient_Result_Return val;
if (read.ReadObject<ZYClient_Result_Return>(out val))
{
e.RPC_Call.SetReturnValue(val);
return true;
}
}
break;
}
}
return false;
}
