using DataEntity.Device;
|
using DataEntity.Share;
|
using HxEnum;
|
using Newtonsoft.Json;
|
using System;
|
using System.Collections.Generic;
|
using System.Diagnostics;
|
using System.Linq;
|
using System.Net.Sockets;
|
using System.Reflection;
|
using System.Threading;
|
using XCommon.Log;
|
using XImagingXhandler.XDAL;
|
using static HxEnum.StateEnum;
|
|
namespace HxSocketImplement.Sockets
|
{
|
/// <summary>
|
/// 获取统一值---参数
|
/// </summary>
|
public static class HxSocketParameterService
|
{
|
#region 添加默认参数
|
/// <summary>
|
/// 添加默认参数
|
/// </summary>
|
/// <param name="ip">IP</param>
|
/// <param name="port">端口</param>
|
/// <param name="equipmentId">设备ID</param>
|
/// <param name="equipmentType">设备类型</param>
|
/// <param name="virtualConnectionState">虚拟连接状态</param>
|
/// <param name="delaySecondTime">延迟时间(毫秒)</param>
|
/// <returns></returns>
|
public static Result AddSocketDefaultParameter(string equipmentType, string ip, int port, string equipmentId, bool virtualConnectionState = false, int delaySecondTime = 3000)
|
{
|
Result resultModel = new Result();
|
try
|
{
|
var result = AddSocketDefaultParameters(equipmentType, ip, port, equipmentId, virtualConnectionState, delaySecondTime);
|
|
#region 虚拟连接
|
var virtualConnectionStateResult = GetVirtualConnectionState(virtualConnectionState, delaySecondTime);
|
if (virtualConnectionStateResult != null && virtualConnectionStateResult.status == StateEnum_Equipment.Completed)
|
{
|
return virtualConnectionStateResult;
|
}
|
#endregion
|
|
if (result)
|
{
|
resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Completed, msg = "添加默认参数【成功】" });
|
}
|
else
|
{
|
resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = "添加默认参数【失败】" });
|
}
|
}
|
catch (Exception ex)
|
{
|
resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = ex.Message });
|
}
|
return resultModel;
|
}
|
/// <summary>
|
/// 添加统一值方法
|
/// </summary>
|
/// <param name="equipmentType">设备类别</param>
|
/// <param name="ip">IP</param>
|
/// <param name="port">端口</param>
|
/// <param name="equipmentId">设备ID</param>
|
/// <param name="virtualConnectionState">虚拟连接状态</param>
|
/// <param name="delaySecondTime">延迟时间(毫秒)</param>
|
/// <returns></returns>
|
private static bool AddSocketDefaultParameters(string equipmentType, string ip, int port, string equipmentId, bool virtualConnectionState, int delaySecondTime)
|
{
|
SocketParameterModel socketParameterModel = new SocketParameterModel();
|
if (string.IsNullOrWhiteSpace(equipmentType) || string.IsNullOrWhiteSpace(ip) || port <= 0)
|
{
|
return false;
|
}
|
|
#region 防止数据重了
|
if (HxSockServiceExecute.CacheSocketParameterData != null && HxSockServiceExecute.CacheSocketParameterData.Count > 0)
|
{
|
var cacheSocketParameterData = HxSockServiceExecute.CacheSocketParameterData.Where(x => x.Key == equipmentType + ip + port + equipmentId);
|
if (cacheSocketParameterData != null && cacheSocketParameterData.Count() > 0)
|
{
|
return true;
|
}
|
}
|
#endregion
|
|
socketParameterModel = GetSocketParameterModelMethod(equipmentType, ip, port, virtualConnectionState, delaySecondTime, equipmentId);
|
return true;
|
}
|
/// <summary>
|
/// 获取统一参数值方法
|
/// </summary>
|
/// <param name="equipmentType">设备类别</param>
|
/// <param name="ip">IP</param>
|
/// <param name="port">端口</param>
|
/// <param name="virtualConnectionState">虚拟连接状态</param>
|
/// <param name="delaySecondTime">延迟时间(毫秒)</param>
|
/// <param name="equipmentId">设备ID</param>
|
/// <returns></returns>
|
public static SocketParameterModel GetSocketParameterModelMethod(string equipmentType, string ip, int port, bool virtualConnectionState, int delaySecondTime, string equipmentId)
|
{
|
SocketParameterModel socketParameterModel = new SocketParameterModel();
|
socketParameterModel.Socket = null;
|
socketParameterModel.Ip = ip;
|
socketParameterModel.Port = port;
|
socketParameterModel.HeartmessageId = HxSockServiceExecute.InstrunctionId();// "05";
|
socketParameterModel.HeartMessageType = 0;
|
socketParameterModel.HeartEquipmentId = equipmentId;// "id0060";
|
socketParameterModel.SpecifiedDisplay = CommonParameter.SpecifiedDisplay;
|
socketParameterModel.LockReceive = new object();
|
socketParameterModel.Buffer = new byte[1024 * 1024 * 10];
|
socketParameterModel.EquipmentType = equipmentType;
|
socketParameterModel.VirtualConnectionState = virtualConnectionState;
|
socketParameterModel.DelaySecondTime = delaySecondTime;
|
socketParameterModel.EquipmentId = equipmentId;
|
HxSockServiceExecute.CacheSocketParameterData.Add(equipmentType + ip + port + equipmentId, socketParameterModel);
|
|
return socketParameterModel;
|
}
|
#endregion
|
|
#region 获取socket参数
|
/// <summary>
|
/// 获取socket参数
|
/// </summary>
|
/// <param name="equipmentType">类型</param>
|
/// <param name="ip">IP</param>
|
/// <param name="port">端口</param>
|
/// <param name="equipmentId">设备ID</param>
|
/// <returns></returns>
|
public static SocketParameterModel GetSocketParameter(string equipmentType, string ip, int port, string equipmentId)
|
{
|
SocketParameterModel socketParameterModel = new SocketParameterModel();
|
if (HxSockServiceExecute.CacheSocketParameterData != null && HxSockServiceExecute.CacheSocketParameterData.Count > 0)
|
{
|
var cacheSocketParameterData = HxSockServiceExecute.CacheSocketParameterData.Where(x => x.Key == equipmentType + ip + port + equipmentId);
|
if (cacheSocketParameterData != null && cacheSocketParameterData.Count() > 0)
|
{
|
socketParameterModel = cacheSocketParameterData.FirstOrDefault().Value;
|
}
|
}
|
return socketParameterModel;
|
}
|
#endregion
|
|
#region 获取结果信息
|
/// <summary>
|
/// 获取结果信息
|
/// </summary>
|
/// <param name="method">方法名称</param>
|
/// <param name="model">参数</param>
|
/// <returns></returns>
|
public static Result GetResultInfo(string method, Result model)
|
{
|
Result modelResult = new Result();
|
modelResult.status = model.status;
|
modelResult.msg = model.msg;
|
modelResult.data = model.data;
|
//LoggerSocketHelper.DebugLog(Environment.NewLine + "方法名称：" + method + Environment.NewLine + "参数信息：" + JsonConvert.SerializeObject(modelResult));
|
LoggerSocketHelper.DebugLog(string.Format("方法名称：[{0}], 参数信息：{1}", method, JsonConvert.SerializeObject(modelResult)));
|
|
return modelResult;
|
}
|
#endregion
|
|
#region 获取方法信息
|
/// <summary>
|
/// 获取方法信息
|
/// </summary>
|
/// <returns></returns>
|
public static string GetMethodInfo()
|
{
|
StackTrace ss = new StackTrace(true);
|
// index:0为本身的方法；1为调用方法；2为其上上层，依次类推
|
System.Reflection.MethodBase mb = ss.GetFrame(1).GetMethod();
|
////StackFrame[] sfs = ss.GetFrames();
|
//string systemModule = "模块名:" + mb.Module.ToString() + Environment.NewLine;
|
//systemModule += "命名空间名:" + mb.DeclaringType.Namespace + Environment.NewLine;
|
////仅有类名
|
//systemModule += "类名:" + mb.DeclaringType.Name + Environment.NewLine;
|
//systemModule += "方法名:" + mb.Name;
|
|
string systemModule = mb.Name + " 类名:" + mb.DeclaringType.Name;
|
return systemModule;
|
}
|
#endregion
|
|
#region 获取虚拟连接状态
|
/// <summary>
|
/// 获取虚拟连接状态
|
/// </summary>
|
/// <param name="virtualConnectionState">虚拟连接状态</param>
|
/// <param name="delaySecondTime">延迟时间(毫秒)</param>
|
/// <param name="isBreakConnect">是否断开连接（tue断，false连）</param>
|
/// <returns></returns>
|
public static Result GetVirtualConnectionState(bool virtualConnectionState, int delaySecondTime, bool isBreakConnect = false)
|
{
|
if (virtualConnectionState)
|
{
|
//System.Threading.Thread.Sleep(delaySecondTime);
|
|
Result resultModel = new Result();
|
if (isBreakConnect)
|
{
|
return resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Completed, msg = "虚拟连接断开状态【成功】" });
|
}
|
return resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Completed, msg = "虚拟连接状态【成功】" });
|
}
|
return null;
|
}
|
#endregion
|
|
#region 连接
|
/// <summary>
|
/// 连接
|
/// </summary>
|
/// <param name="equipmentType">类型</param>
|
/// <param name="ip">IP</param>
|
/// <param name="port">端口</param>
|
/// <param name="equipmentId">设备ID</param>
|
/// <returns></returns>
|
public static Result Connect(string equipmentType, string ip, int port, string equipmentId)
|
{
|
Result resultModel = new Result();
|
|
var socketParameterModel = GetSocketParameter(equipmentType, ip, port, equipmentId);
|
try
|
{
|
#region 虚拟连接
|
var virtualConnectionStateResult = GetVirtualConnectionState(socketParameterModel.VirtualConnectionState, socketParameterModel.DelaySecondTime);
|
if (virtualConnectionStateResult != null && virtualConnectionStateResult.status == StateEnum_Equipment.Completed)
|
{
|
return virtualConnectionStateResult;
|
}
|
#endregion
|
|
if (HxSockServiceExecute.CheckConnected(socketParameterModel.Socket, socketParameterModel.Ip) == false)
|
{
|
if (socketParameterModel != null && HxSockServiceExecute.Connect(equipmentType, ip, port, equipmentId))
|
{
|
resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Completed, msg = "连接服务器【成功】" });
|
}
|
else
|
{
|
resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = "连接服务器【失败】" });
|
}
|
}
|
else
|
{
|
resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Completed, msg = "连接服务器【成功】" });
|
}
|
}
|
catch (Exception ex)
|
{
|
socketParameterModel.Socket.Shutdown(SocketShutdown.Both);
|
socketParameterModel.Socket.Close();
|
resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = ex.Message });
|
}
|
return resultModel;
|
}
|
/// <summary>
|
/// 检查连接
|
/// </summary>
|
/// <param name="equipmentType">类型</param>
|
/// <param name="ip">IP</param>
|
/// <param name="port">端口</param>
|
/// <param name="equipmentId">设备ID</param>
|
/// <returns></returns>
|
public static Result CheckConnected(string equipmentType, string ip, int port, string equipmentId)
|
{
|
Result resultModel = new Result();
|
try
|
{
|
var socketParameterModel = HxSockServiceExecute.GetSocketParameterModel(equipmentType, ip, port, equipmentId);
|
|
if (socketParameterModel != null)
|
{
|
#region 虚拟连接
|
var virtualConnectionStateResult = GetVirtualConnectionState(socketParameterModel.VirtualConnectionState, socketParameterModel.DelaySecondTime);
|
if (virtualConnectionStateResult != null && virtualConnectionStateResult.status == StateEnum_Equipment.Completed)
|
{
|
return virtualConnectionStateResult;
|
}
|
#endregion
|
|
if (HxSockServiceExecute.CheckConnected(socketParameterModel.Socket, socketParameterModel.Ip))
|
{
|
resultModel.status = StateEnum_Equipment.Completed;
|
resultModel.msg = "检查连接【成功】";
|
//resultModel = GetResultInfo(GetMethodInfo(), new Result { status = EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed), msg = "检查连接【成功】" });
|
}
|
else
|
{
|
resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = "检查连接【失败】" });
|
}
|
}
|
else
|
{
|
resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = "检查连接【失败】默认参数为空" });
|
}
|
}
|
catch (Exception ex)
|
{
|
resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = ex.Message });
|
}
|
return resultModel;
|
}
|
#endregion
|
|
#region 断开
|
/// <summary>
|
/// 断开
|
/// </summary>
|
/// <param name="equipmentType">类型</param>
|
/// <param name="ip">IP</param>
|
/// <param name="port">端口</param>
|
/// <param name="equipmentId">设备ID</param>
|
/// <returns></returns>
|
public static Result BreakConnect(string equipmentType, string ip, int port, string equipmentId)
|
{
|
Result resultModel = new Result();
|
try
|
{
|
var socketParameterModel = HxSockServiceExecute.GetSocketParameterModel(equipmentType, ip, port, equipmentId);
|
if (socketParameterModel == null)
|
{
|
resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = "服务器断开【未连接】" });
|
return resultModel;
|
}
|
|
#region 虚拟连接
|
var virtualConnectionStateResult = GetVirtualConnectionState(socketParameterModel.VirtualConnectionState, socketParameterModel.DelaySecondTime, true);
|
if (virtualConnectionStateResult != null && virtualConnectionStateResult.status == StateEnum_Equipment.Completed)
|
{
|
socketParameterModel.VirtualConnectionState = false;
|
HxSockServiceExecute.CacheSocketParameterData.Remove(equipmentType + ip + port + equipmentId);
|
return virtualConnectionStateResult;
|
}
|
#endregion
|
|
if (HxSockServiceExecute.BreakConnect(equipmentType, ip, port, equipmentId))
|
{
|
HxSockServiceExecute.CacheSocketParameterData.Remove(equipmentType + ip + port + equipmentId);
|
resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Completed, msg = "服务器已断开【成功】" });
|
}
|
else
|
{
|
resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = "服务器已断开【未连接】" });
|
}
|
}
|
catch (Exception ex)
|
{
|
resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = ex.Message });
|
}
|
return resultModel;
|
}
|
#endregion
|
|
#region 获取指令公共模型对象---发送
|
/// <summary>
|
/// 获取指令公共模型对象---发送
|
/// </summary>
|
/// <param name="instructCommonMethodSendModel">参数对像</param>
|
/// <returns></returns>
|
|
public static InstructCommonMethodSendModel GetInstructCommonMethodSendModel(InstructCommonMethodSendModel instructCommonMethodSendModel)
|
{
|
instructCommonMethodSendModel.EquipmentType = instructCommonMethodSendModel.EquipmentType;
|
instructCommonMethodSendModel.Ip = instructCommonMethodSendModel.Ip;
|
instructCommonMethodSendModel.Port = instructCommonMethodSendModel.Port;
|
instructCommonMethodSendModel.EquipmentId = instructCommonMethodSendModel.EquipmentId;
|
|
// wdy
|
//if ((instructCommonMethodSendModel.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.SerialPort) ||
|
// instructCommonMethodSendModel.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.SocketUDP) ||
|
// instructCommonMethodSendModel.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.SocketNonstandard)) &&
|
// instructCommonMethodSendModel.MethodParametersModel.Type == EnumManagement.GetEnumValue(ParameterTypeEnum.Send).ToString() &&
|
// instructCommonMethodSendModel.SendData.parameters != null)
|
//{
|
// Dictionary<string, object> dicParams = (Dictionary<string, object>)instructCommonMethodSendModel.SendData.parameters;
|
// object value = dicParams.Values.First();
|
// instructCommonMethodSendModel.SendData.parameters = value == null ? string.Empty : value.ToString();
|
//}
|
|
if (instructCommonMethodSendModel.SendData.parameters != null)
|
{
|
instructCommonMethodSendModel.SendData.parameters = instructCommonMethodSendModel.SendData.parameters;// new RobotParameterModel { DestinationName = "1", Pose = "2", TargetName = "3", _Rotation = Enum_Rotation.Forward90 };
|
}
|
else
|
{
|
instructCommonMethodSendModel.SendData.parameters = new object();
|
}
|
|
instructCommonMethodSendModel.SendData.message_id = HxSockServiceExecute.InstrunctionId();
|
instructCommonMethodSendModel.SendData.message_type = 2;
|
instructCommonMethodSendModel.SendData.method = instructCommonMethodSendModel.SendData.method;// InstructionEnum_Equipment.Home.ToString();
|
instructCommonMethodSendModel.SendData.equipment_id = instructCommonMethodSendModel.EquipmentId;
|
instructCommonMethodSendModel.SendData.workflow_id = "workflow_id_" + instructCommonMethodSendModel.SendData.message_id;
|
instructCommonMethodSendModel.SendData.experiment_id = instructCommonMethodSendModel.SendData.experiment_id;
|
instructCommonMethodSendModel.SendData.estimate_time = 3;
|
instructCommonMethodSendModel.SendData.timeout = 3;
|
instructCommonMethodSendModel.SendData.description = "description_" + instructCommonMethodSendModel.EquipmentType;
|
instructCommonMethodSendModel.SendData.timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
|
|
int count = SocketInteriorService.dicManualResetEvent.Where(m => m.Key == instructCommonMethodSendModel.SendData.experiment_id).Count();
|
if (count == 0)
|
{
|
SocketInteriorService.dicManualResetEvent.Add(instructCommonMethodSendModel.SendData.experiment_id, new ManualResetEvent(true));
|
}
|
|
return instructCommonMethodSendModel;
|
}
|
#endregion
|
}
|
}
|
