private void ReceiveCallback(IAsyncResult ar)
{
var ro = ar.AsyncState as ReceiveObject;
if (ro == null)
{
return;
}
var length = ro.Socket.EndReceive(ar);
ro.Bytes.AddRange(ro.TempBuffer.Take(length));
if (length < ReceiveChunkLength)
{
var message = Encoding.UTF8.GetString(ro.Bytes.ToArray());
WriteInfo($"Message from server: {message}");
ro = new ReceiveObject
{
Socket = ro.Socket
};
}
ro.Socket.BeginReceive(
buffer: ro.TempBuffer,
offset: 0,
size: ReceiveChunkLength,
socketFlags: SocketFlags.None,
callback: ReceiveCallback,
state: ro);
}
/// <summary>
/// 格式化接收的Message
/// </summary>
/// <param name="channel">通道名</param>
/// <param name="message">接收的消息</param>
/// <returns>格式化字符串</returns>
private String FormateData(String channel, ReceiveObject message)
{
StringBuilder builder = new StringBuilder();
builder.Append(channel + ",");
builder.Append(message.FrameType.ToString() + ",");
builder.Append(message.ReceiveID.ToString() + ",");
builder.Append((message.TimeStamp * 1.0 / 10000).ToString() + ",");
builder.Append(message.Length.ToString() + ",");
builder.Append(message.ReceiveData[0].ToString("X2") + ",");
builder.Append(message.ReceiveData[1].ToString("X2") + ",");
builder.Append(message.ReceiveData[2].ToString("X2") + ",");
builder.Append(message.ReceiveData[3].ToString("X2") + ",");
builder.Append(message.ReceiveData[4].ToString("X2") + ",");
builder.Append(message.ReceiveData[5].ToString("X2") + ",");
builder.Append(message.ReceiveData[6].ToString("X2") + ",");
builder.Append(message.ReceiveData[7].ToString("X2") + ",");
if (message.IsSelfSend)
{
builder.Append("Tx,");
}
else
{
builder.Append("Rx,");
}
return(builder.ToString());;
}
public void Connect(IPAddress address, int port)
{
if (_connected)
{
throw new InvalidOperationException("Already connected");
}
var socket = new Socket(SocketType.Stream, ProtocolType.IP);
socket.Connect(address, port);
if (!socket.Connected)
{
return;
}
Console.WriteLine("Connected!");
var ro = new ReceiveObject
{
Socket = socket
};
socket.BeginReceive(
buffer: ro.TempBuffer,
offset: 0,
size: ReceiveChunkLength,
socketFlags: SocketFlags.None,
callback: ReceiveCallback,
state: ro);
_connected = true;
}
// 解析包体
private string ReadBody(byte[] bytes, int offset, int length)
{
// CodedInputStream input = new CodedInputStream(bytes, offset, length);
int command = ReadIntFromBytes(bytes, ref offset);
// int command = input.ReadInt32();
MessageParser messageParser = null;
//得到协议的解释器
if (!m_ReceiveParserDic.TryGetValue(command, out messageParser))
{
return("Do Not Register Parser Function For : " + command);
}
//字节转为数据结构
IMessage message = messageParser.ParseFrom(bytes, offset, (int)(length - offset));
//添加到处理队列中
ReceiveObject receiveObject = new ReceiveObject();
receiveObject.command = command;
receiveObject.message = message;
m_ReceiveQueue.Enqueue(receiveObject);
// input.Dispose();
return(string.Empty);
}
public new void Update()
{
while (m_ReceiveQueue.Count > 0)
{
ReceiveObject receiveObject = null;
//从处理队列中得到需要处理的协议对象
if (m_ReceiveQueue.TryDequeue(out receiveObject))
{
ServerMessageReceiveDelegate messageReceiveDelegate = null;
if (m_ReceiveDelegateDic.TryGetValue(receiveObject.command, out messageReceiveDelegate))
{
NetData netData = receiveObject as NetData;
//业务处理
messageReceiveDelegate(netData.clientId, netData.message);
}
continue;
}
}
for (int index = 0; index < m_ClientList.Count; index++)
{
m_ClientList[index].Update();
}
BeginAccept();
}
/// <summary>
/// 插入数据
/// </summary>
/// <param name="channelName">通道名称</param>
/// <param name="message">待插入消息</param>
/// <returns>是否成功</returns>
public Boolean InsertMessageData(String channelName, ReceiveObject message)
{
lock (queueLock)
{
Boolean result = true;
if (this.lastInsertTime.ContainsKey(message.ReceiveID.ToString()) == false)
{
this.lastInsertTime[message.ReceiveID.ToString()] = DateTime.MinValue;
}
if (DateTime.Now < lastInsertTime[message.ReceiveID.ToString()].AddMilliseconds(100))
{
result = false;
}
else
{
if (this.isDisposed == false)
{
messageQueue.Enqueue(new MessageModel()
{
Message = message,
ChannelName = channelName,
});
}
if ((messageQueue.Count > 100) || this.isDisposed)
{
var tempBuffer = messageQueue;
messageQueue = new Queue <MessageModel>();
foreach (var item in tempBuffer)
{
var sql = ConstDefine.InsertData;
SQLiteParameter[] parameters = new SQLiteParameter[]
{
new SQLiteParameter("@FrameType", item.Message.FrameType),
new SQLiteParameter("@ReceiveID", item.Message.ReceiveID),
new SQLiteParameter("@TimeStamp", item.Message.TimeStamp),
new SQLiteParameter("@Length", item.Message.Length),
new SQLiteParameter("@data1", item.Message.ReceiveData[0]),
new SQLiteParameter("@data2", item.Message.ReceiveData[1]),
new SQLiteParameter("@data3", item.Message.ReceiveData[2]),
new SQLiteParameter("@data4", item.Message.ReceiveData[3]),
new SQLiteParameter("@data5", item.Message.ReceiveData[4]),
new SQLiteParameter("@data6", item.Message.ReceiveData[5]),
new SQLiteParameter("@data7", item.Message.ReceiveData[6]),
new SQLiteParameter("@data8", item.Message.ReceiveData[7]),
new SQLiteParameter("@IsSelfSend", item.Message.IsSelfSend),
new SQLiteParameter("@ChannelName", item.ChannelName)
};
var effectLines = SQLExecuteHandler.ExecuteNonQuery(ref this.connection, ref sql, parameters);
if (effectLines < 0)
{
result = false;
}
}
tempBuffer.Clear();
}
}
return(result);
}
}
/// <summary>
/// 根据给定通道索引号
/// 获取通道message
/// </summary>
/// <param name="index">通道索引值(基于0)</param>
/// <param name="channelName">通道Name</param>
/// <param name="message">接收到的消息</param>
/// <returns>状态码</returns>
public static CANError GetSingleChannelMessage(ref Int32 index, ref String channelName, out ReceiveObject message)
{
message = new ReceiveObject();
var result = CanInteraction.CANRcvMsg(index, ref message);
if (result == CANError.ErrNon)
{
OnReceiveMessageEvent(channelName, message);
}
return(result);
}
private void ReceiveCallback(IAsyncResult ar)
{
WebSocketReceiveError error;
ReceiveObject obj = (ReceiveObject)ar.AsyncState;
int receiveLength = obj.Socket.EndReceive(ar);
if (receiveLength > 0)
{
ArraySegment <byte> bytes = new ArraySegment <byte>(obj.Buffer, 0, receiveLength);
WebSocketFragment fragment = messageHandler.Parse(bytes.ToArray(), out error);
if (error != null)
{
Close(error.CloseReason, error.CloseStatusCode);
obj.Error(obj.Session, error);
WebSocketSessionContainer sessions = (WebSocketSessionContainer)obj.State;
sessions.Remove(SessionID);
}
else
{
if (fragment.Opcode == WebSocketOpcode.Ping)
{
WebSocketMessage m = messageHandler.CreatePong(fragment.PayloadData);
Send(m);
}
else if (fragment.Opcode == WebSocketOpcode.Pong)
{
}
else if (fragment.Opcode == WebSocketOpcode.Close)
{
Close("Normal Close", WebSocketCloseStatusCode.Normal);
obj.Error(obj.Session, new WebSocketReceiveError()
{
CloseReason = "Normal Close", CloseStatusCode = WebSocketCloseStatusCode.Normal
});
WebSocketSessionContainer sessions = (WebSocketSessionContainer)obj.State;
sessions.Remove(SessionID);
}
else
{
obj.Message.Fragments.Add(fragment);
if (fragment.IsFinal)
{
obj.Success(obj.Session, obj.Message);
obj.Message = new WebSocketMessage();
}
}
}
}
if (serverSocket.Connected)
{
serverSocket.BeginReceive(obj.Buffer, 0, serverSocket.ReceiveBufferSize, SocketFlags.None, ReceiveCallback, obj);
}
}
/// <summary>
/// 触发接收Message事件
/// </summary>
/// <param name="message">接收到的Message</param>
/// <param name="channelName">通道Name</param>
private static void OnReceiveMessageEvent(String channelName, ReceiveObject message)
{
var tempEvent = receiveMessageEvent;
if (tempEvent != null)
{
Task task = new Task(() =>
{
tempEvent(channelName, message);
});
task.Start();
}
}
public void ReceiveAsync(Action <WebSocketSession, WebSocketMessage> successCallback, Action <WebSocketSession, WebSocketReceiveError> errorCallback, Object state)
{
byte[] buffer = new byte[serverSocket.ReceiveBufferSize];
WebSocketMessage message = new WebSocketMessage();
ReceiveObject obj = new ReceiveObject();
obj.Socket = serverSocket;
obj.Buffer = buffer;
obj.Message = message;
obj.Success = successCallback;
obj.Error = errorCallback;
obj.Session = this;
obj.State = state;
serverSocket.BeginReceive(buffer, 0, serverSocket.ReceiveBufferSize, SocketFlags.None, ReceiveCallback, obj);
}
/// <summary>
/// 查询数据
/// </summary>
/// <param name="connect">数据库连接实体</param>
/// <param name="sql">查询语句</param>
/// <param name="parameters">查询参数</param>
/// <returns>查询结果列表</returns>
public static List <ChannelDataInfo> QueryData(ref SQLiteConnection connect, ref String sql, SQLiteParameter[] parameters = null)
{
var result = new List <ChannelDataInfo>();
lock (dbLock)
{
if (connect.State == System.Data.ConnectionState.Open)
{
using (var command = connect.CreateCommand())
{
command.CommandText = sql;
if (parameters != null)
{
command.Parameters.AddRange(parameters);
}
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var entity = new ChannelDataInfo();
entity.ChannelName = (String)reader["ChannelName"];
ReceiveObject message = new ReceiveObject();
message.FrameType = (FrameType)reader["FrameType"];
message.ReceiveID = (UInt32)reader["ReceiveID"];
message.TimeStamp = (UInt64)reader["TimeStamp"];
message.Length = (UInt16)reader["Length"];
message.IsSelfSend = (Boolean)reader["IsSelfSend"];
message.ReceiveData[0] = (Byte)reader["data1"];
message.ReceiveData[1] = (Byte)reader["data2"];
message.ReceiveData[2] = (Byte)reader["data3"];
message.ReceiveData[3] = (Byte)reader["data4"];
message.ReceiveData[4] = (Byte)reader["data5"];
message.ReceiveData[5] = (Byte)reader["data6"];
message.ReceiveData[6] = (Byte)reader["data7"];
message.ReceiveData[7] = (Byte)reader["data8"];
entity.RecevieMessage = message;
result.Add(entity);
}
}
}
}
}
return(result);
}
//处理接收到的协议
private void Excute()
{
while (true)
{
ReceiveObject receiveObject = null;
//从处理队列中得到需要处理的协议对象
if (m_ReceiveQueue.TryDequeue(out receiveObject))
{
MessageReceiveDelegate messageReceiveDelegate = null;
if (m_ReceiveDelegateDic.TryGetValue(receiveObject.command, out messageReceiveDelegate))
{
//业务处理
messageReceiveDelegate(receiveObject.message);
}
continue;
}
break;
}
}
/// <summary>
/// 获取多个通道的Message
/// 如出现错误则接收Message 为 null
/// </summary>
/// <param name="channelNames">通道Name列表</param>
/// <param name="message">接收到的信息列表</param>
/// <returns>状态码</returns>
public static CANError GetMultiChannelMessage(ref List <String> channelNames, out List <ReceiveObject> message)
{
var result = CANError.ErrNon;
message = new List <ReceiveObject>();
for (Int32 flag = 0; flag < channelNames.Count; flag++)
{
ReceiveObject receive = new ReceiveObject();
result = CanInteraction.CANRcvMsg(flag, ref receive);
if (result == CANError.ErrNon)
{
message.Add(receive);
OnReceiveMessageEvent(channelNames[flag], receive);
}
else if (result != CANError.Err_RcvEmpty)
{
message = null;
break;
}
}
return(result);
}
public static extern CANError CANRcvMsg(Int32 index, ref ReceiveObject message);
/// <summary>
/// 处理接收数据事件
/// </summary>
/// <param name="channelName">通道名称</param>
/// <param name="message">收到的消息</param>
private void OnReceiveEvent(String channelName, ReceiveObject message)
{
this.InsertMessageData(channelName, message);
}
/// <summary>
/// 记录接收的数据
/// </summary>
/// <param name="channelName">通道名</param>
/// <param name="message">接收的消息</param>
private void RecordMessage(String channelName, ReceiveObject message)
{
lock (recordLock)
{
if ((DateTime.Now - lastRecordTime).Milliseconds > this.TimeSpan)
{
var newFile = false;
var filePath = Path.Combine(this.Directory, this.FileName + ConstDefine.FileExtension);
if (System.IO.Directory.Exists(this.Directory) == false)
{
System.IO.Directory.CreateDirectory(this.Directory);
}
if (File.Exists(Path.Combine(this.Directory, this.FileName + ConstDefine.FileExtension)) == false)
{
newFile = true;
}
else
{
if (this.Mode == LimitMode.SizeMode)
{
var fileInfo = new FileInfo(filePath);
if (fileInfo.Length > (FileSizeLimit * ConstDefine.M))
{
this.RenameFile(ref filePath);
newFile = true;
}
}
else
{
if (this.recordLines > this.LineCountLimit)
{
this.RenameFile(ref filePath);
newFile = true;
this.recordLines = 0;
}
}
}
if (this.isDisposed == false)
{
this.messageQueue.Enqueue(new MessageModel()
{
Message = message,
ChannelName = channelName,
});
}
if ((this.messageQueue.Count > 50) || newFile || this.isDisposed)
{
var tempBuffer = this.messageQueue;
this.messageQueue = new Queue <MessageModel>();
using (var writer = new StreamWriter(filePath, true, Encoding.Default))
{
foreach (var item in tempBuffer)
{
if (newFile)
{
writer.WriteLine(ConstDefine.FileHeader);
newFile = false;
}
writer.WriteLine(this.FormateData(item.ChannelName, item.Message));
}
}
}
this.recordLines++;
lastRecordTime = DateTime.Now;
}
}
}
public void Join()
{
TcpClientInfo new_client = null;
try
{
new_client = new TcpClientInfo(new TcpClient(config.IP, config.Port))
{
status = ConnectionStatus.HOSTING
};
clients.Add(new_client);
SetProperty(ref status, ConnectionStatus.JOINED, new List <string>()
{
"CanJoin", "CanHost", "CanLeave"
});
}
catch (Exception e)
{
if (e is ArgumentNullException || e is ArgumentOutOfRangeException)
{
Logger.Log("Invalid port", e.ToString());
}
else if (e is SocketException)
{
Logger.Log("Socket cannot be opened", e.ToString());
}
else
{
Logger.Log("Unexpected error", e.ToString());
}
Shutdown();
return;
}
var receiveObject = new ReceiveObject()
{
tcpclientinfo = new_client
};
try
{
new_client.tcpclient.Client.BeginReceive(receiveObject.buffer, 0, ReceiveObject.BufferSize, SocketFlags.None, Receive, receiveObject);
}
catch (Exception e)
{
if (e is ArgumentNullException || e is ArgumentOutOfRangeException)
{
Logger.Log("Invalid port", e.ToString());
}
else if (e is SocketException)
{
Logger.Log("Socket cannot be read from", e.ToString());
}
else if (e is ObjectDisposedException)
{
Logger.Log("Socket is already closed", e.ToString());
}
else
{
Logger.Log("Unexpected error", e.ToString());
}
Shutdown();
}
}
