/// <summary>
/// 读写ModBus服务器的基础方法，支持任意的数据操作
/// </summary>
/// <param name="socket">网络服务数据</param>
/// <param name="send">发送的字节数据</param>
/// <param name="result">结果对象</param>
/// <returns></returns>
private bool ReadFromModBusSocket(System.Net.Sockets.Socket socket, byte[] send, OperateResult <byte[]> result)
{
if (!SendBytesToSocket(socket, send, result, "发送数据到服务器失败"))
{
return(false);
}
HslTimeOut hslTimeOut = new HslTimeOut();
hslTimeOut.WorkSocket = socket;
hslTimeOut.DelayTime = 2000; // 2秒内接收到数据
try
{
System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(
ThreadPoolCheckConnect), hslTimeOut);
byte[] head = NetSupport.ReadBytesFromSocket(socket, 6);
int length = head[4] * 256 + head[5];
byte[] data = NetSupport.ReadBytesFromSocket(socket, length);
byte[] buffer = new byte[6 + length];
head.CopyTo(buffer, 0);
data.CopyTo(buffer, 6);
hslTimeOut.IsSuccessful = true;
result.Content = buffer;
}
catch (Exception ex)
{
socket?.Close();
result.Message = "从服务器接收结果数据的时候发生错误：" + ex.Message;
return(false);
}
return(true);
}
/// <summary>
/// 接收服务器的反馈数据的规则
/// </summary>
/// <param name="socket"></param>
/// <param name="response"></param>
/// <param name="result"></param>
/// <returns></returns>
protected override bool ReceiveResponse(Socket socket, out byte[] response, OperateResult result)
{
try
{
byte[] head = NetSupport.ReadBytesFromSocket(socket, 6);
if (head[4] == 0x00 && head[5] == 0x00)
{
// 数据异常，再接收一个字节，防止有些比较坑的设备新增一个额外的字节来防止读取
for (int i = 0; i < head.Length - 1; i++)
{
head[i] = head[i + 1];
}
socket.Receive(head, 5, 1, SocketFlags.None);
}
int length = head[4] * 256 + head[5];
byte[] data = NetSupport.ReadBytesFromSocket(socket, length);
byte[] buffer = new byte[6 + length];
head.CopyTo(buffer, 0);
data.CopyTo(buffer, 6);
response = buffer;
return(true);
}
catch (Exception ex)
{
LogNet?.WriteException(LogHeaderText, ex);
socket?.Close();
response = null;
result.Message = ex.Message;
return(false);
}
}
/// <summary>
/// 接收一行命令数据
/// </summary>
/// <param name="socket">网络套接字</param>
/// <returns>带有结果对象的数据信息</returns>
public static OperateResult <byte[]> ReceiveCommandLine(Socket socket)
{
List <byte> bufferArray = new List <byte>( );
try
{
// 接收到\n为止
while (true)
{
byte[] head = NetSupport.ReadBytesFromSocket(socket, 1);
bufferArray.AddRange(head);
if (head[0] == '\n')
{
break;
}
}
// 指令头已经接收完成
return(OperateResult.CreateSuccessResult(bufferArray.ToArray( )));
}
catch (Exception ex)
{
return(new OperateResult <byte[]>(ex.Message));
}
}
/// <summary>
/// 向PLC写入数据，数据格式为原始的字节类型
/// </summary>
/// <param name="type">写入的数据类型</param>
/// <param name="address">初始地址</param>
/// <param name="data">原始的字节数据</param>
/// <returns>结果</returns>
public OperateResult WriteIntoPLC(MelsecDataType type, ushort address, byte[] data)
{
OperateResult <byte[]> result = new OperateResult <byte[]>();
byte[] _PLCCommand = GetWriteCommand(type, address, data);
Array.Copy(data, 0, _PLCCommand, 21, data.Length);
//测试指令数据
//string test = ByteToHexString(_PLCCommand);
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
HslTimeOut timeout = new HslTimeOut()
{
WorkSocket = socket
};
try
{
ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadPoolCheckConnect), timeout);
socket.Connect(new IPEndPoint(PLCIpAddress, PortWrite));
timeout.IsSuccessful = true;
}
catch
{
result.Message = StringResources.ConnectedFailed;
socket.Close();
return(result);
}
byte[] DataHead = null;
try
{
socket.Send(_PLCCommand);
//先接收满9个数据
int NeedReceived = 9;
DataHead = NetSupport.ReadBytesFromSocket(socket, NeedReceived);
NeedReceived = BitConverter.ToUInt16(DataHead, 7);
DataHead = NetSupport.ReadBytesFromSocket(socket, NeedReceived);
result.ErrorCode = BitConverter.ToUInt16(DataHead, 0);
result.IsSuccess = true;
}
catch (Exception ex)
{
result.Message = StringResources.SocketIOException + ex.Message;
Thread.Sleep(10);
socket.Close();
return(result);
}
socket.Shutdown(SocketShutdown.Both);
Thread.Sleep(10);
socket.Close();
socket = null;
if (result.ErrorCode > 0)
{
result.IsSuccess = false;
}
return(result);
}
/// <summary>
/// 读写ModBus服务器的基础方法，支持任意的数据操作
/// </summary>
/// <param name="send">发送的字节数据</param>
/// <returns></returns>
public OperateResult <byte[]> ReadFromModBusServer(byte[] send)
{
OperateResult <byte[]> result = new OperateResult <byte[]>();
readModbusLock.Enter();
if (!CreateSocketAndConnect(out System.Net.Sockets.Socket socket, iPEndPoint, result))
{
readModbusLock.Leave();
socket = null;
return(result);
}
if (!SendBytesToSocket(socket, send, result, "发送数据到服务器失败"))
{
readModbusLock.Leave();
return(result);
}
HslTimeOut hslTimeOut = new HslTimeOut();
hslTimeOut.WorkSocket = socket;
hslTimeOut.DelayTime = 5000; // 2秒内接收到数据
try
{
System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(
ThreadPoolCheckConnect), hslTimeOut);
byte[] head = NetSupport.ReadBytesFromSocket(socket, 6);
int length = head[4] * 256 + head[5];
byte[] data = NetSupport.ReadBytesFromSocket(socket, length);
byte[] buffer = new byte[6 + length];
head.CopyTo(buffer, 0);
data.CopyTo(buffer, 6);
hslTimeOut.IsSuccessful = true;
result.Content = buffer;
}
catch (Exception ex)
{
socket?.Close();
result.Message = "从服务器接收结果数据的时候发生错误：" + ex.Message;
readModbusLock.Leave();
return(result);
}
socket?.Close();
readModbusLock.Leave();
result.IsSuccess = true;
return(result);
}
private void ContentReceiveCallBack(IAsyncResult ar)
{
if (ar.AsyncState is DeviceState stateone)
{
try
{
int count = stateone.WorkSocket.EndReceive(ar);
if (count > 0)
{
MemoryStream ms = new MemoryStream( );
byte next = stateone.Buffer[0];
while (next != endByte)
{
ms.WriteByte(next);
next = NetSupport.ReadBytesFromSocket(stateone.WorkSocket, 1)[0];
}
// 接收完成
stateone.WorkSocket.BeginReceive(stateone.Buffer, 0, stateone.Buffer.Length, SocketFlags.None,
new AsyncCallback(ContentReceiveCallBack), stateone);
string read = Encoding.ASCII.GetString(ms.ToArray( ));
ms.Dispose( );
lock_list.Enter( );
stateone.ReceiveTime = DateTime.Now;
lock_list.Leave( );
AcceptString?.Invoke(stateone, read);
}
else
{
stateone.WorkSocket.BeginReceive(stateone.Buffer, 0, stateone.Buffer.Length, SocketFlags.None,
new AsyncCallback(ContentReceiveCallBack), stateone);
}
}
catch (Exception ex)
{
//登录前已经出错
RemoveClient(stateone);
LogNet?.WriteException(LogHeaderText, StringResources.NetClientLoginFailed, ex);
}
}
}
public void ReadBytesFromSocketExample1( )
{
#region ReadBytesFromSocketExample1
// 创建socket
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(IPAddress.Parse("192.168.0.7"), 1000);
// 准备接收指定长度的数据，假设为20个长度
byte[] receive = NetSupport.ReadBytesFromSocket(socket, 20);
// 根据需要选择是否关闭连接
socket.Close( );
// 接下来就可以对receive进行操作了
#endregion
}
private bool ReceiveBytesFromSocket(Socket socket, out byte[] data)
{
try
{
// 先接收4个字节的数据
byte[] head = NetSupport.ReadBytesFromSocket(socket, 4);
int receive = head[2] * 256 + head[3];
data = new byte[receive];
head.CopyTo(data, 0);
NetSupport.ReadBytesFromSocket(socket, receive - 4).CopyTo(data, 4);
return(true);
}
catch
{
socket?.Close();
data = null;
return(false);
}
}
public void ReadBytesFromSocketExample3( )
{
#region ReadBytesFromSocketExample3
// 创建socket
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(IPAddress.Parse("192.168.0.7"), 1000);
// 准备接收指定长度的数据，假设为4个长度，然后输出进度
byte[] head = NetSupport.ReadBytesFromSocket(socket, 4);
int length = BitConverter.ToInt32(head, 0);
byte[] content = NetSupport.ReadBytesFromSocket(socket, length);
// 根据需要选择是否关闭连接
socket.Close( );
// 接下来就可以对content进行操作了
#endregion
}
/// <summary>
/// 接收一行字符串的信息
/// </summary>
/// <param name="socket">网络套接字</param>
/// <param name="length">字符串的长度</param>
/// <returns>带有结果对象的数据信息</returns>
public static OperateResult <byte[]> ReceiveCommandString(Socket socket, int length)
{
try
{
List <byte> bufferArray = new List <byte>( );
bufferArray.AddRange(NetSupport.ReadBytesFromSocket(socket, length));
OperateResult <byte[]> commandTail = ReceiveCommandLine(socket);
if (!commandTail.IsSuccess)
{
return(commandTail);
}
bufferArray.AddRange(commandTail.Content);
return(OperateResult.CreateSuccessResult(bufferArray.ToArray( )));
}
catch (Exception ex)
{
return(new OperateResult <byte[]>(ex.Message));
}
}
/// <summary>
/// 接收服务器的反馈数据的规则
/// </summary>
/// <param name="socket"></param>
/// <param name="response"></param>
/// <param name="result"></param>
/// <returns></returns>
protected override bool ReceiveResponse(Socket socket, out byte[] response, OperateResult result)
{
try
{
byte[] head = NetSupport.ReadBytesFromSocket(socket, 6);
int length = head[4] * 256 + head[5];
byte[] data = NetSupport.ReadBytesFromSocket(socket, length);
byte[] buffer = new byte[6 + length];
head.CopyTo(buffer, 0);
data.CopyTo(buffer, 6);
response = buffer;
return(true);
}
catch (Exception ex)
{
socket?.Close();
response = null;
result.Message = ex.Message;
return(false);
}
}
public void ReadBytesFromSocketExample2( )
{
#region ReadBytesFromSocketExample2
// 创建socket
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(IPAddress.Parse("192.168.0.7"), 1000);
// 准备接收指定长度的数据，假设为10000个长度，然后输出进度
Action <long, long> report = (long rece, long totle) =>
{
Console.WriteLine("总数据量：" + totle + " 当前接收字节数：" + rece);
};
byte[] receive = NetSupport.ReadBytesFromSocket(socket, 10000, report, false, false);
// 根据需要选择是否关闭连接
socket.Close( );
// 接下来就可以对receive进行操作了
#endregion
}
/// <summary>
/// 接收一行字符串的信息
/// </summary>
/// <param name="socket">网络套接字</param>
/// <param name="length">字符串的长度</param>
/// <returns>带有结果对象的数据信息</returns>
public static OperateResult <byte[]> ReceiveCommandString(Socket socket, int length)
{
try
{
List <byte> bufferArray = new List <byte>( );
bufferArray.AddRange(NetSupport.ReadBytesFromSocket(socket, length));
while (true)
{
byte[] head = NetSupport.ReadBytesFromSocket(socket, 1);
bufferArray.AddRange(head);
if (head[0] == '\n')
{
break;
}
}
return(OperateResult.CreateSuccessResult(bufferArray.ToArray( )));
}
catch (Exception ex)
{
return(new OperateResult <byte[]>(ex.Message));
}
}
/// <summary>
/// 从三菱PLC中读取想要的数据，返回读取结果
/// </summary>
/// <param name="type">想要读取的数据类型</param>
/// <param name="address">读取数据的起始地址</param>
/// <param name="length">读取的数据长度，字最大值960，位最大值7168</param>
/// <returns>带数据头的字节数组</returns>
public OperateResult <byte[]> ReadFromPLC(MelsecDataType type, ushort address, ushort length)
{
OperateResult <byte[]> result = new OperateResult <byte[]>();
//获取指令
byte[] _PLCCommand = GetReadCommand(type, address, length);
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
HslTimeOut timeout = new HslTimeOut()
{
WorkSocket = socket
};
try
{
ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadPoolCheckConnect), timeout);
socket.Connect(new IPEndPoint(PLCIpAddress, GetPort()));
timeout.IsSuccessful = true;
}
catch
{
ChangePort();
result.Message = StringResources.ConnectedFailed;;
socket.Close();
return(result);
}
byte[] DataHead = null;
try
{
socket.Send(_PLCCommand);
//先接收满9个数据
int NeedReceived = 9;
DataHead = NetSupport.ReadBytesFromSocket(socket, NeedReceived);
NeedReceived = BitConverter.ToUInt16(DataHead, 7);
DataHead = NetSupport.ReadBytesFromSocket(socket, NeedReceived);
//获取读取代码
result.ErrorCode = BitConverter.ToUInt16(DataHead, 0);
result.Content = new byte[DataHead.Length - 2];
Array.Copy(DataHead, 2, result.Content, 0, DataHead.Length - 2);
if (type.DataType == 1)
{
result.Content = ReceiveBytesTranslate(result.Content);
}
result.IsSuccess = true;
}
catch (Exception ex)
{
result.Message = StringResources.SocketIOException + ex.Message;
socket.Close();
return(result);
}
socket.Shutdown(SocketShutdown.Both);
socket.Close();
socket = null;
if (result.ErrorCode > 0)
{
result.IsSuccess = false;
}
return(result);
}
/// <summary>
/// 从西门子PLC中读取想要的数据，返回结果类说明
/// </summary>
/// <param name="type">想要读取的数据类型</param>
/// <param name="address">读取数据的起始地址</param>
/// <param name="lengh">读取的数据长度</param>
/// <returns>返回读取结果</returns>
public OperateResult <byte[]> ReadFromPLC(SiemensDataType type, ushort address, ushort lengh)
{
OperateResult <byte[]> result = new OperateResult <byte[]>();
byte[] _PLCCommand = new byte[16];
_PLCCommand[0] = 0x53;
_PLCCommand[1] = 0x35;
_PLCCommand[2] = 0x10;
_PLCCommand[3] = 0x01;
_PLCCommand[4] = 0x03;
_PLCCommand[5] = 0x05;
_PLCCommand[6] = 0x03;
_PLCCommand[7] = 0x08;
//指定数据区
_PLCCommand[8] = type.DataCode;
_PLCCommand[9] = 0x00;
//指定数据地址
_PLCCommand[10] = (byte)(address / 256);
_PLCCommand[11] = (byte)(address % 256);
//指定数据长度
_PLCCommand[12] = (byte)(lengh / 256);
_PLCCommand[13] = (byte)(lengh % 256);
_PLCCommand[14] = 0xff;
_PLCCommand[15] = 0x02;
//超时验证的线程池技术
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
HslTimeOut timeout = new HslTimeOut()
{
WorkSocket = socket
};
try
{
ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadPoolCheckConnect), timeout);
socket.Connect(new IPEndPoint(PLCIpAddress, GetPort()));
timeout.IsSuccessful = true;
}
catch
{
ChangePort();
result.Message = StringResources.ConnectedFailed;
Thread.Sleep(10);
socket?.Close();
return(result);
}
try
{
//连接成功，发送数据
socket.Send(_PLCCommand);
byte[] rec_head = NetSupport.ReadBytesFromSocket(socket, 16);
if (rec_head[8] != 0x00)
{
result.ErrorCode = rec_head[8];
Thread.Sleep(10);
socket?.Close();
return(result);
}
result.Content = NetSupport.ReadBytesFromSocket(socket, lengh);
result.IsSuccess = true;
result.Message = "读取成功";
}
catch (Exception ex)
{
result.Message = StringResources.SocketIOException + ex.Message;
Thread.Sleep(10);
socket?.Close();
return(result);
}
Thread.Sleep(10);
socket?.Close();
//所有的数据接收完成，进行返回
return(result);
}
/// <summary>
/// 向PLC中写入数据，返回值说明
/// </summary>
/// <param name="type">要写入的数据类型</param>
/// <param name="address">要写入的数据地址</param>
/// <param name="data">要写入的实际数据</param>
/// <exception cref="ArgumentNullException">写入的数据不能为空</exception>
/// <returns>返回写入结果</returns>
public OperateResult <byte[]> WriteIntoPLC(SiemensDataType type, ushort address, byte[] data)
{
var result = new OperateResult <byte[]>();
byte[] _PLCCommand = new byte[16 + data.Length];
_PLCCommand[0] = 0x53;
_PLCCommand[1] = 0x35;
_PLCCommand[2] = 0x10;
_PLCCommand[3] = 0x01;
_PLCCommand[4] = 0x03;
_PLCCommand[5] = 0x03;
_PLCCommand[6] = 0x03;
_PLCCommand[7] = 0x08;
//指定数据区
_PLCCommand[8] = type.DataCode;
_PLCCommand[9] = 0x00;
//指定数据地址
_PLCCommand[10] = (byte)(address / 256);
_PLCCommand[11] = (byte)(address % 256);
//指定数据长度
_PLCCommand[12] = (byte)(data.Length / 256);
_PLCCommand[13] = (byte)(data.Length % 256);
_PLCCommand[14] = 0xff;
_PLCCommand[15] = 0x02;
//放置数据
Array.Copy(data, 0, _PLCCommand, 16, data.Length);
//超时验证的线程池技术
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
var timeout = new HslTimeOut()
{
WorkSocket = socket
};
try
{
ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadPoolCheckConnect), timeout);
socket.Connect(new IPEndPoint(PLCIpAddress, PortWrite));
timeout.IsSuccessful = true;
}
catch
{
result.Message = StringResources.ConnectedFailed;
Thread.Sleep(10);
socket?.Close();
return(result);
}
try
{
//连接成功，发送数据
socket.Send(_PLCCommand);
byte[] rec_head = NetSupport.ReadBytesFromSocket(socket, 16);
//分析数据
if (rec_head[8] != 0x00)
{
result.ErrorCode = rec_head[8];
Thread.Sleep(10);
socket?.Close();
return(result);
}
socket.Shutdown(SocketShutdown.Both);
socket.Close();
result.IsSuccess = true;
result.Message = "写入成功";
}
catch (Exception ex)
{
result.Message = StringResources.SocketIOException + ex.Message;
Thread.Sleep(10);
socket?.Close();
return(result);
}
return(result);
}
/*****************************************************************************
*
* 说明：
* 下面的三个模块代码指示了如何接收数据，如何发送数据，如何连接网络
*
********************************************************************************/
#region Reveive Content
/// <summary>
/// 接收固定长度的字节数组
/// </summary>
/// <remarks>
/// Receive Special Length Bytes
/// </remarks>
/// <param name="socket">网络通讯的套接字</param>
/// <param name="length">准备接收的数据长度</param>
/// <returns>包含了字节数据的结果类</returns>
protected OperateResult <byte[]> Receive(Socket socket, int length)
{
if (length == 0)
{
return(OperateResult.CreateSuccessResult(new byte[0]));
}
//try
//{
// return OperateResult.CreateSuccessResult( NetSupport.ReadBytesFromSocket( socket, length ) );
//}
//catch(Exception ex)
//{
// return new OperateResult<byte[]>( ex.Message );
//}
//#if NET35
if (UseSynchronousNet)
{
try
{
byte[] data = NetSupport.ReadBytesFromSocket(socket, length);
return(OperateResult.CreateSuccessResult(data));
}
catch (Exception ex)
{
socket?.Close( );
return(new OperateResult <byte[]>(ex.Message));
}
}
OperateResult <byte[]> result = new OperateResult <byte[]>( );
ManualResetEvent receiveDone = null;
StateObject state = null;
try
{
receiveDone = new ManualResetEvent(false);
state = new StateObject(length);
}
catch (Exception ex)
{
return(new OperateResult <byte[]>(ex.Message));
}
try
{
state.WaitDone = receiveDone;
state.WorkSocket = socket;
// Begin receiving the data from the remote device.
socket.BeginReceive(state.Buffer, state.AlreadyDealLength,
state.DataLength - state.AlreadyDealLength, SocketFlags.None,
new AsyncCallback(ReceiveCallback), state);
}
catch (Exception ex)
{
// 发生了错误，直接返回
LogNet?.WriteException(ToString( ), ex);
result.Message = ex.Message;
receiveDone.Close( );
socket?.Close( );
return(result);
}
// 等待接收完成，或是发生异常
receiveDone.WaitOne( );
receiveDone.Close( );
// 接收数据失败
if (state.IsError)
{
socket?.Close( );
result.Message = state.ErrerMsg;
return(result);
}
// 远程关闭了连接
if (state.IsClose)
{
// result.IsSuccess = true;
result.Message = StringResources.Language.RemoteClosedConnection;
socket?.Close( );
return(result);
}
// 正常接收到数据
result.Content = state.Buffer;
result.IsSuccess = true;
state.Clear( );
state = null;
return(result);
//#else
//SocketAsyncEventArgs eventArgs = new SocketAsyncEventArgs( );
//byte[] buffer = new byte[length];
//eventArgs.SetBuffer( buffer, 0, length );
//int receiveCount = 0;
//while (true)
//{
// socket.ReceiveAsync( eventArgs );
// receiveCount += eventArgs.BytesTransferred;
// if (receiveCount == length) break;
//}
//return OperateResult.CreateSuccessResult( buffer );
//#endif
}
/// <summary>
/// 根据指令来读取设备的信息，如果命令数据为空，则传入null即可，注意，所有的命令不带换行符
/// </summary>
/// <param name="command">命令的内容</param>
/// <param name="commandData">命令数据内容</param>
/// <returns>最终的结果内容，需要对IsSuccess进行验证</returns>
public OperateResult <string> ReadByCommand(string command, string commandData)
{
InteractiveLock.Enter( );
// 获取有用的网络通道，如果没有，就建立新的连接
OperateResult <Socket> resultSocket = GetAvailableSocket( );
if (!resultSocket.IsSuccess)
{
IsSocketError = true;
if (AlienSession != null)
{
AlienSession.IsStatusOk = false;
}
InteractiveLock.Leave( );
return(OperateResult.CreateFailedResult <string>(resultSocket));
}
// 先发送命令
string sendCommand = string.IsNullOrEmpty(commandData) ? $"HOSTCTRL_REQUEST {command} 0\r\n" : $"HOSTCTRL_REQUEST {command} {commandData.Length}\r\n";
OperateResult <string> readCommand = ReadFromCoreServer(resultSocket.Content, sendCommand);
if (!readCommand.IsSuccess)
{
IsSocketError = true;
if (AlienSession != null)
{
AlienSession.IsStatusOk = false;
}
InteractiveLock.Leave( );
return(OperateResult.CreateFailedResult <string>(readCommand));
}
// 检查命令是否返回成功的状态
if (!readCommand.Content.StartsWith("OK:"))
{
if (!isPersistentConn)
{
resultSocket.Content?.Close( );
}
InteractiveLock.Leave( );
return(new OperateResult <string>(readCommand.Content.Remove(readCommand.Content.Length - 2)));
}
// 在必要的情况下发送命令数据
if (!string.IsNullOrEmpty(commandData))
{
byte[] send2 = Encoding.ASCII.GetBytes($"{commandData}\r");
LogNet?.WriteDebug(ToString( ), StringResources.Language.Send + " : " + BasicFramework.SoftBasic.ByteToHexString(send2, ' '));
OperateResult sendResult2 = Send(resultSocket.Content, send2);
if (!sendResult2.IsSuccess)
{
resultSocket.Content?.Close( );
IsSocketError = true;
if (AlienSession != null)
{
AlienSession.IsStatusOk = false;
}
InteractiveLock.Leave( );
return(OperateResult.CreateFailedResult <string>(sendResult2));
}
}
// 接收数据信息，先接收到\r为止，再根据实际情况决定是否接收\r
OperateResult <byte[]> resultReceive2 = NetSupport.ReceiveCommandLineFromSocket(resultSocket.Content, (byte)'\r');
if (!resultReceive2.IsSuccess)
{
IsSocketError = true;
if (AlienSession != null)
{
AlienSession.IsStatusOk = false;
}
InteractiveLock.Leave( );
return(OperateResult.CreateFailedResult <string>(resultReceive2));
}
string commandDataReturn = Encoding.ASCII.GetString(resultReceive2.Content);
if (commandDataReturn.StartsWith("ERROR:"))
{
if (!isPersistentConn)
{
resultSocket.Content?.Close( );
}
InteractiveLock.Leave( );
NetSupport.ReadBytesFromSocket(resultSocket.Content, 1);
return(new OperateResult <string>(commandDataReturn));
}
else if (commandDataReturn.StartsWith("0000\r"))
{
if (!isPersistentConn)
{
resultSocket.Content?.Close( );
}
NetSupport.ReadBytesFromSocket(resultSocket.Content, 1);
InteractiveLock.Leave( );
return(OperateResult.CreateSuccessResult("0000"));
}
else
{
if (!isPersistentConn)
{
resultSocket.Content?.Close( );
}
InteractiveLock.Leave( );
return(OperateResult.CreateSuccessResult(commandDataReturn.Remove(commandDataReturn.Length - 1)));
}
}
/// <summary>
/// 系统的登录方法
/// </summary>
/// <param name="obj"></param>
protected override void ThreadPoolLogin(object obj)
{
Socket socket = obj as Socket;
try
{
//为了兼容原来旧的升级服务，暂时停止令牌功能
//接收令牌 2017-03-14 10:02:20
//InfoTcp infoTcp = new InfoTcp()
//{
// Worksocket = socket,
//};
//
//ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadPoolCheckConnect), infoTcp);
//try
//{
// byte[] token = ReadFromSocket(socket, 16);
// infoTcp.IsConnect = true;
// if (!IsTwoBytesEquel(KeyToken.ToByteArray(), token))
// {
// socket.Close();
// log_record.SaveNormal("接收到验证失败的连接");
// return;
// }
//}
//catch (Exception ex)
//{
// socket?.Close();
// log_record.SaveNormal("令牌接收出错：" + ex.Message);
// return;
//}
byte[] ReceiveByte = NetSupport.ReadBytesFromSocket(socket, 4);
int Protocol = BitConverter.ToInt32(ReceiveByte, 0);
if (Protocol == 0x1001 || Protocol == 0x1002)
{
// 安装系统和更新系统
if (Protocol == 0x1001)
{
LogNet?.WriteInfo(StringResources.SystemInstallOperater + ((IPEndPoint)socket.RemoteEndPoint).Address.ToString());
}
else
{
LogNet?.WriteInfo(StringResources.SystemUpdateOperater + ((IPEndPoint)socket.RemoteEndPoint).Address.ToString());
}
if (Directory.Exists(FileUpdatePath))
{
string[] files = Directory.GetFiles(FileUpdatePath);
List <string> Files = new List <string>(files);
for (int i = Files.Count - 1; i >= 0; i--)
{
FileInfo finfo = new FileInfo(Files[i]);
if (finfo.Length > 200000000)
{
Files.RemoveAt(i);
}
if (Protocol == 0x1002)
{
if (finfo.Name == "软件自动更新.exe")
{
Files.RemoveAt(i);
}
}
}
files = Files.ToArray();
socket.BeginReceive(new byte[4], 0, 4, SocketFlags.None, new AsyncCallback(ReceiveCallBack), socket);
socket.Send(BitConverter.GetBytes(files.Length));
for (int i = 0; i < files.Length; i++)
{
// 传送数据包含了本次数据大小，文件数据大小，文件名（带后缀）
FileInfo finfo = new FileInfo(files[i]);
string fileName = finfo.Name;
byte[] ByteName = Encoding.Unicode.GetBytes(fileName);
int First = 4 + 4 + ByteName.Length;
byte[] FirstSend = new byte[First];
FileStream fs = new FileStream(files[i], FileMode.Open, FileAccess.Read);
Array.Copy(BitConverter.GetBytes(First), 0, FirstSend, 0, 4);
Array.Copy(BitConverter.GetBytes((int)fs.Length), 0, FirstSend, 4, 4);
Array.Copy(ByteName, 0, FirstSend, 8, ByteName.Length);
socket.Send(FirstSend);
Thread.Sleep(10);
byte[] buffer = new byte[4096];
int sended = 0;
while (sended < fs.Length)
{
int count = fs.Read(buffer, 0, 4096);
socket.Send(buffer, 0, count, SocketFlags.None);
sended += count;
}
fs.Close();
fs.Dispose();
Thread.Sleep(20);
}
}
}
else
{
// 兼容原先版本的更新，新的验证方式无需理会
socket.Send(BitConverter.GetBytes(10000f));
Thread.Sleep(20);
socket?.Shutdown(SocketShutdown.Both);
socket?.Close();
}
}
catch (Exception ex)
{
Thread.Sleep(20);
socket?.Shutdown(SocketShutdown.Both);
socket?.Close();
LogNet?.WriteException(StringResources.FileSendClientFailed, ex);
}
}
/*****************************************************************************
*
* 说明：
* 下面的三个模块代码指示了如何接收数据，如何发送数据，如何连接网络
*
********************************************************************************/
#region Reveive Content
/// <summary>
/// 接收固定长度的字节数组
/// </summary>
/// <remarks>
/// Receive Special Length Bytes
/// </remarks>
/// <param name="socket">网络通讯的套接字</param>
/// <param name="length">准备接收的数据长度</param>
/// <returns>包含了字节数据的结果类</returns>
protected OperateResult <byte[]> Receive(Socket socket, int length)
{
if (length == 0)
{
return(OperateResult.CreateSuccessResult(new byte[0]));
}
if (UseSynchronousNet)
{
try
{
byte[] data = NetSupport.ReadBytesFromSocket(socket, length);
return(OperateResult.CreateSuccessResult(data));
}
catch (Exception ex)
{
socket?.Close();
LogNet?.WriteException(ToString(), "Receive", ex);
return(new OperateResult <byte[]>(ex.Message));
}
}
OperateResult <byte[]> result = new OperateResult <byte[]>();
ManualResetEvent receiveDone = null;
StateObject state = null;
try
{
receiveDone = new ManualResetEvent(false);
state = new StateObject(length);
}
catch (Exception ex)
{
return(new OperateResult <byte[]>(ex.Message));
}
try
{
state.WaitDone = receiveDone;
state.WorkSocket = socket;
// Begin receiving the data from the remote device.
socket.BeginReceive(state.Buffer, state.AlreadyDealLength,
state.DataLength - state.AlreadyDealLength, SocketFlags.None,
new AsyncCallback(ReceiveCallback), state); // 接收数据异步返回的方法
}
catch (Exception ex)
{
// 发生了错误，直接返回
LogNet?.WriteException(ToString(), ex);
result.Message = ex.Message;
receiveDone.Close();
socket?.Close();
return(result);
}
// 等待接收完成，或是发生异常
receiveDone.WaitOne();
receiveDone.Close();
// 接收数据失败
if (state.IsError)
{
socket?.Close();
result.Message = state.ErrerMsg;
return(result);
}
// 远程关闭了连接
if (state.IsClose)
{
// result.IsSuccess = true;
result.Message = StringResources.Language.RemoteClosedConnection;
socket?.Close();
return(result);
}
// 正常接收到数据
result.Content = state.Buffer;
result.IsSuccess = true;
state.Clear();
state = null;
return(result);
}
/// <summary>
/// 从Redis服务器接收一条数据信息
/// </summary>
/// <param name="socket">套接字信息</param>
/// <returns>接收的结果对象</returns>
protected OperateResult <byte[]> ReceiveRedisMsg(Socket socket)
{
List <byte> bufferArray = new List <byte>( );
try
{
//byte[] buffer1 = new byte[2048];
//int count1 = socket.Receive( buffer1 );
//for (int i = 0; i < count1; i++)
//{
// bufferArray.Add( buffer1[i] );
//}
//return OperateResult.CreateSuccessResult( bufferArray.ToArray( ) );
byte[] head = NetSupport.ReadBytesFromSocket(socket, 1);
bufferArray.AddRange(head);
if (head[0] == '-' || head[0] == '+' || head[0] == ':')
{
// 接收到\n为止
while (true)
{
head = NetSupport.ReadBytesFromSocket(socket, 1);
bufferArray.AddRange(head);
if (head[0] == '\n')
{
break;
}
}
}
else if (head[0] == '$')
{
// 接收到两次\n为止
int receiveCount = 0;
while (true)
{
head = NetSupport.ReadBytesFromSocket(socket, 1);
bufferArray.AddRange(head);
if (head[0] == '\n')
{
if (receiveCount == 0)
{
if (bufferArray[1] == '-')
{
break;
}
}
receiveCount++;
if (receiveCount == 2)
{
break;
}
}
}
}
else
{
byte[] buffer = new byte[2048];
int count = socket.Receive(buffer);
for (int i = 0; i < count; i++)
{
bufferArray.Add(buffer[i]);
}
}
return(OperateResult.CreateSuccessResult(bufferArray.ToArray( )));
}
catch (Exception ex)
{
return(new OperateResult <byte[]>(ex.Message));
}
}