/// <summary>
/// 设置请求头
/// </summary>
/// <param name="response"></param>
/// <param name="headers"></param>
public static void SetHeaders(HttpResponse response, Dictionary <string, string> headers)
{
if (headers != null)
{
foreach (var item in headers)
{
try
{
switch (item.Key)
{
case "Content-Type":
response.ContentType = item.Value;
break;
default:
response.Headers.Add(item.Key, item.Value);
break;
}
}
catch (Exception ex)
{
Log4netHelper.Fatal("SetHeaders异常" + item.Key, ex);
}
}
}
}
/// <summary>
/// 设置会话的心跳包
/// </summary>
/// <param name="dueTime">延迟的时间量（以毫秒为单位）</param>
/// <param name="period">时间间隔（以毫秒为单位）</param>
/// <returns></returns>
public bool TrySetKeepAlive(int dueTime, int period)
{
var outOptionValue = new byte[12];
var inOptionValue = new byte[] { 1, 0, 0, 0, 0x20, 0x4e, 0, 0, 0xd0, 0x07, 0, 0 };
try
{
this.Socket.IOControl(IOControlCode.KeepAliveValues, inOptionValue, outOptionValue);
return(true);
}
catch (NotSupportedException ex)
{
this.Socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, inOptionValue);
Log4netHelper.Fatal("设置心跳包异常", ex);
return(true);
}
catch (NotImplementedException ex)
{
this.Socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, inOptionValue);
Log4netHelper.Fatal("设置心跳包异常", ex);
return(true);
}
catch (Exception ex)
{
Log4netHelper.Fatal("设置心跳包异常", ex);
return(false);
}
}
//值为空或者占位符的验证
public void Dgd_CellValidating(object sender, DataGridViewCellValidatingEventArgs e)
{
try
{
DataGridView dgd = sender as DataGridView;
if (e.ColumnIndex != 1)
{
return;
}
string Cellvalue_str = e.FormattedValue.ToString();
if (string.IsNullOrEmpty(Cellvalue_str.Trim()) || Cellvalue_str.Contains("&") || Cellvalue_str.Contains(";") || Cellvalue_str.Contains(":"))
{
e.Cancel = true;//数据格式不正确则还原
dgd.CancelEdit();
}
else
{
e.Cancel = false;
}
}
catch (Exception ex)
{
Log4netHelper.Fatal(this.GetType(), "CellValidating验证时发生异常:" + ex.Message);
}
}
/// <summary>
/// 获取指定枚举的所有字段值以及描述
/// </summary>
/// <param name="enumType"></param>
/// <returns></returns>
public static Dictionary <ValueType, string> GetList(Type type)
{
if (CACHE_TYPE.ContainsKey(type))
{
return(CACHE_TYPE[type]);
}
else
{
var ret = new Dictionary <ValueType, string>();
var fieldInfo = type.GetFields();
foreach (var field in fieldInfo)
{
var atts = field.GetCustomAttributes(typeof(DescriptionAttribute), false);
foreach (DescriptionAttribute att in atts)
{
var value = field.GetValue(type) as ValueType;
if (ret.ContainsKey(value))
{
Log4netHelper.Fatal(string.Format("类型{0}拥有相同的Value{1}", type.FullName, value));
}
else
{
ret.Add(value, att.Description);
}
break;
}
}
CACHE_TYPE[type] = ret;
return(ret);
}
}
public void Dgd_CellErrorTextNeeded(object sender, DataGridViewCellErrorTextNeededEventArgs e)
{
if (e.ColumnIndex == 1)
{
try
{
if (e.RowIndex == 0)
{
Regex reg = new Regex(@"^[+-]?([0-9]*\.?[0-9]+|[0-9]+\.?[0-9]*)([eE][+-]?[0-9]+)?$");
if (tabControl1.SelectedTabIndex == 0)
{
//检查是否有数字外的字符
Match ma1 = reg.Match(dataGridViewX1.Rows[e.RowIndex].Cells[e.ColumnIndex].Value.ToString());
if (!ma1.Success)
{
dataGridViewX1.Rows[e.RowIndex].Cells[e.ColumnIndex].ErrorText = "非法字符";
return;
}
}
else
{
Match ma2 = reg.Match(dataGridViewX2.Rows[e.RowIndex].Cells[e.ColumnIndex].Value.ToString());
if (!ma2.Success)
{
dataGridViewX2.Rows[e.RowIndex].Cells[e.ColumnIndex].ErrorText = "非法字符";
}
}
}
}
catch (Exception ex)
{
Log4netHelper.Fatal(this.GetType(), "文本内容检测时发生异常：" + ex);
}
}
}
private static void InitialSgBom(object sgobject)
{
TreeNode sgnode = sgobject as TreeNode;
try
{
DataTable dt_sgbom = sqlconnection.ExecuteDataTable(Constant.strConnectSQL_T, CommandType.Text, string.Format("select distinct sgseriesbom from {0}", Constant.SGseries_sqlname), null);
for (int i = 0; i < dt_sgbom.Rows.Count; i++)
{
TreeNode sgbomnode = new TreeNode();
sgbomnode.Text = dt_sgbom.Rows[i][0].ToString();
sgbomnode.ImageIndex = 4;
sgnode.Nodes.Add(sgbomnode);
}
//加载完成后，计数
Finished_Counter++;
while (!Opened_flag)
{
Thread.Sleep(1000);
}
UpdateTV(sgnode);
}
catch (Exception ex)
{
Log4netHelper.Fatal(new TreeNodeHelper().GetType(), string.Format("初始化{0}节点信息时发生异常", sgnode.Text), ex);
MessageBox.Show(ex.Message);
}
}
/// <summary>
/// 关闭连接
/// </summary>
/// <param name="ex">异常信息，如果主动关闭未Null，如果异常引发关闭则是异常信息</param>
public void Close(Exception ex = null)
{
if (!this.IsDisposable)
{
lock (Socket)
{
if (!this.IsDisposable)
{
Log4netHelper.Debug($"正在关闭客户端与服务端的链接:{IPE.Address.ToString()}");
Socket.Shutdown(SocketShutdown.Both);
Socket.Close();
Socket.Dispose();
IsDisposable = true;
if (CloseCallback != null)
{
try
{
CloseCallback(ex);
}
catch (Exception close_ex)
{
Log4netHelper.Fatal($"客户端接收到消息但执行DisposeCallback异常", close_ex);
}
}
}
}
}
}
/// <summary>
/// 开始接受消息
/// </summary>
private void Receive()
{
while (this.Socket.Connected)
{
var buffer = Receive(null);
if (buffer != null && buffer.Length > 0)
{
var message_content = Encoding.UTF8.GetString(buffer).TrimEnd('\0');
while (!message_content.EndsWith(SocketCommand.MessageSeparator))//如果不是一条完整的消息，继续接收
{
buffer = Receive(buffer);
message_content = Encoding.UTF8.GetString(buffer).TrimEnd('\0');
}
var message_list = message_content.ToListData(separator: SocketCommand.MessageSeparator);
foreach (var message_item in message_list)
{
var message_item_content = string.Empty;
try
{
message_item_content = message_item.DecryptBase64(encode: Encoding.UTF8);
ReceiveCallbackAsync(message_item_content);
}
catch (Exception ex)
{
Log4netHelper.Fatal($"接受到消息:{message_item}解密异常", ex);
continue;
}
}
}
}
}
private static void InitialBoxtype(object obj)
{
TreeNode typenode = obj as TreeNode;
try
{
DataTable dt_boxtype = sqlconnection.ExecuteDataTable(Constant.strConnectSQL_T, CommandType.Text, string.Format("select sgboxtype from {0}", Constant.Boxtype_sqlname), null);
for (int m = 0; m < dt_boxtype.Rows.Count; m++)
{
TreeNode subnode = new TreeNode();
subnode.Text = Convert.ToString(dt_boxtype.Rows[m][0]);
subnode.ImageIndex = 2;
typenode.Nodes.Add(subnode);
}
Finished_Counter++;
while (!Opened_flag)
{
Thread.Sleep(1000);
}
UpdateTV(typenode);
}
catch (Exception ex)
{
Log4netHelper.Fatal(new TreeNodeHelper().GetType(), string.Format("初始化{0}节点信息时发生异常:{1}", typenode.Text, ex.StackTrace), ex);
MessageBox.Show(ex.Message);
}
}
/// <summary>
/// 设置请求头
/// </summary>
/// <param name="request"></param>
/// <param name="headers"></param>
public static void SetHeaders(HttpWebRequest request, Dictionary <string, string> headers)
{
if (headers != null)
{
foreach (var item in headers)
{
try
{
switch (item.Key)
{
case "Referer":
request.Referer = item.Value;
break;
case "Connection":
break;
case "Keep-Alive":
break;
case "Content-Length":
request.ContentLength = item.Value.ToLong();
break;
case "Content-Type":
request.ContentType = item.Value;
break;
case "Accept":
request.Accept = item.Value;
break;
case "Host":
request.Host = item.Value;
break;
case "User-Agent":
request.UserAgent = item.Value;
break;
case "Expect":
request.Expect = item.Value;
break;
default:
request.Headers.Add(item.Key, item.Value);
break;
}
}
catch (Exception ex)
{
Log4netHelper.Fatal("SetHeaders异常" + item.Key, ex);
}
}
}
}
/// <summary>
///接收消息
/// </summary>
/// <returns></returns>
private byte[] Receive(byte[] buffer)
{
int receiveBytes = 0;
try
{
var receive_buffer = new byte[Receive_Buffer_Size];
receiveBytes = this.Socket.Receive(receive_buffer); //receiveBytes长度小于等于buffer的长度
byte[] add_buffer = null; //新接收到的数据
byte[] transfer_buffer = null; //中转变量，存储已经接收到的数据
while (this.Socket.Available > 0)
{
add_buffer = new byte[Receive_Buffer_Size];
var add_receiveBytes = this.Socket.Receive(add_buffer);
receiveBytes += add_receiveBytes;
//创建新增存储对象
transfer_buffer = new byte[receiveBytes];
//将历史数据复制到新的存储对象
Array.Copy(receive_buffer, 0, transfer_buffer, 0, receiveBytes - add_receiveBytes);
//将新增的数据复制打中转存储对象
Array.Copy(add_buffer, 0, transfer_buffer, receiveBytes - add_receiveBytes, add_receiveBytes);
receive_buffer = transfer_buffer;
}
if (receiveBytes <= 0)
{
Log4netHelper.Debug($"接受到服务端{this.ToJson()}{receiveBytes}个字节，自动关闭连接");
this.Close(new Exception($"接受到服务端{receiveBytes}个字节,自动关闭连接"));
}
if (buffer != null)
{
transfer_buffer = new byte[buffer.Length + receive_buffer.Length];
Array.Copy(buffer, 0, transfer_buffer, 0, buffer.Length);
Array.Copy(receive_buffer, 0, transfer_buffer, buffer.Length, receive_buffer.Length);
return(transfer_buffer);
}
else
{
if (receiveBytes < receive_buffer.Length)
{
return(receive_buffer.Take(receiveBytes).ToArray());
}
return(receive_buffer);
}
}
catch (Exception ex)
{
Log4netHelper.Fatal($"客户端{this.ToJson()}接受消息时异常,自动关闭连接", ex);
this.Close(ex);
if (this.ReciveExceptionCallback != null)
{
this.ReciveExceptionCallback(ex);
}
}
return(null);
}
public static string HttpPost(string url, Dictionary <string, string> param, Dictionary <string, string> headers = null, string charset = "UTF-8", int timeout = 15000)
{
var data = GenderParamString(param);
return(Policy.Handle <WebException>().WaitAndRetry(5, retryAttempt => TimeSpan.FromSeconds(Math.Pow(1, retryAttempt)), (ex, timer, c, context) =>
{
Log4netHelper.Fatal("HttpPost异常", ex);
Log4netHelper.Fatal($"执行失败! 重试次数 {c} timer={timer.ToString()}i={context.ToJson()}");
}).Execute(() =>
{
return HttpPost(url, data, headers, charset, timeout);
}));
}
/// <summary>
/// 启动
/// </summary>
public void Start()
{
Task.Run(() =>
{
try
{
Receive();
}
catch (Exception ex)
{
Log4netHelper.Fatal($"会话在接受消息是发生异常{Environment.NewLine}会话={JsonHelper.SerializeObject(this)}", ex);
}
});
}
/// <summary>
/// 以任务的形式运行指定委托方法
/// 不引发异常，异步执行
/// </summary>
/// <param name="action"></param>
public static void TaskRun(Action action)
{
Task.Run(() =>
{
try
{
action();
}
catch (Exception ex)
{
Log4netHelper.Fatal(ex);
}
});
}
/// <summary>
/// 以任务的形式运行指定委托方法
/// 不引发异常，异步执行
/// </summary>
/// <param name="action"></param>
public static void TaskRun(WaitCallback action, object state)
{
ThreadPool.QueueUserWorkItem((_state) =>
{
try
{
action(_state);
}
catch (Exception ex)
{
Log4netHelper.Fatal(ex);
}
}, state);
}
/// <summary>
/// 启动全部
/// </summary>
public void StartAll()
{
foreach (var client in GetList())
{
ThreadPool.QueueUserWorkItem((id) =>
{
Policy.Handle <Exception>().WaitAndRetryForever(retryAttempt => TimeSpan.FromSeconds(Math.Pow(1, retryAttempt)), (policy_ex, timer) =>
{
Log4netHelper.Fatal($"连接服务端失败 timer={timer.TotalSeconds} ex={policy_ex.Message}", policy_ex);
}).Execute(() =>
{
Start(id.ToString());
});
}, client.Id);
}
}
/// <summary>
/// 发送POTS 请求
/// </summary>
/// <param name="url"></param>
/// <param name="data"></param>
/// <param name="headers"></param>
/// <param name="charset"></param>
/// <returns></returns>
private static string HttpPost(string url, string data, Dictionary <string, string> headers = null, string charset = "UTF-8", int timeout = 15000)
{
#if DEBUG
timeout = 1000 * 60 * 10;
#endif
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded";
request.Accept = "*/*";
request.Timeout = timeout;
request.AllowAutoRedirect = false;
SetHeaders(request, headers);
byte[] paramBytes = Encoding.GetEncoding(charset).GetBytes(data);
request.ContentLength = paramBytes.Length;
string responseStr = string.Empty;
using (Stream requestStream = request.GetRequestStream())
{
requestStream.Write(paramBytes, 0, paramBytes.Length);
requestStream.Close();
try
{
var response = request.GetResponse();
if (response != null)
{
using (StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8))
{
responseStr = reader.ReadToEnd();
}
}
}
catch (WebException ex)
{
Log4netHelper.Fatal("HttpPost异常", ex);
var response = (HttpWebResponse)ex.Response;
using (Stream stream = response.GetResponseStream())
{
using (StreamReader reader = new StreamReader(stream))
{
responseStr = reader.ReadToEnd();
}
}
Log4netHelper.Debug(url, responseStr);
throw ex;
}
return(responseStr);
}
}
public void Copy(object sender, EventArgs e)
{
try
{
dataGridViewX1.EndEdit();
if (tabControl1.SelectedTabIndex == 0)
{
DgdDealHelper.SetDataGridVIewToClipboard(dataGridViewX1);
//UIHelper.ToastNotify(true, "正式生产表数据已复制到粘贴板！", tabControl1);
}
}
catch (Exception ex)
{
Log4netHelper.Fatal(this.GetType(), "复制时发生异常:", ex);
}
}
private void SecondInitalCheckbox(object obj)
{
FlowLayoutPanel flowpanel = obj as FlowLayoutPanel;
try
{
if (!this.IsHandleCreated || this.IsDisposed)
{
return;
}
if (InvokeRequired)
{
this.Invoke((MethodInvoker) delegate
{
for (int i = 0; i < flowpanel.Controls.Count; i++)
{
CheckBox update_ck = flowpanel.Controls[i] as CheckBox;
if (old_capacity_str.Contains(update_ck.Text))
{
update_ck.Checked = true;
}
if (flowpanel.Name == "Analog")
{
Analog_flowpanel.Controls.Add(update_ck);
}
else
{
Digital_flowpanel.Controls.Add(update_ck);
}
progressBarX1.Value += 1;
progressBarX1.Text = ((double)progressBarX1.Value / progressBarX1.Maximum).ToString("P");
if (progressBarX1.Value == progressBarX1.Maximum)
{
progressBarX1.Visible = false;
}
Application.DoEvents();
}
});
}
}
catch (Exception ex)
{
Log4netHelper.Fatal(this.GetType(), "再次载入传感器容量时异常:", ex);
throw ex;
}
}
/// <summary>
/// 异步运行接受消息回调
/// </summary>
/// <param name="msg"></param>
void ReceiveCallbackAsync(SocketSession session, string msg)
{
if (ReceiveCallback == null)
{
return;
}
Task.Run(() =>
{
try
{
ReceiveCallback(session, msg);
}
catch (Exception ex)
{
Log4netHelper.Fatal($"服务端接收到消息但执行ReceiveCallback异常:{msg}", ex);
}
});
}
public static void CreateBomNode(TreeNode BOMnode)
{
try
{
for (int k = 0; k < Constant.MainTree_list.Count; k++)
{
TreeNode bominfo_node = new TreeNode();
bominfo_node.Text = Constant.MainTree_list[k];
bominfo_node.Tag = BOMnode.Tag;//加载唯一识别号
bominfo_node.ImageIndex = 1;
BOMnode.Nodes.Add(bominfo_node);
}
}
catch (Exception ex)
{
Log4netHelper.Fatal(new TreeNodeHelper().GetType(), string.Format("创建物料号BOM{0}节点信息时发生异常", BOMnode.Text), ex);
MessageBox.Show(ex.Message);
}
}
/// <summary>
/// 自动清理缓存项
/// </summary>
public void AutoClear(object sender, ElapsedEventArgs e)
{
try
{
var nowTime = DateTime.Now;
if (this.Timeout > 0)
{
if (this.ExpireType == CacheExpireTypeEnum.Absolute)
{
foreach (var cache in this.CACHE_POOL)
{
DateTime createTime;
if (this.CACHE_POOL_CreateTime.TryGetValue(cache.Key, out createTime))
{
if (createTime.AddMinutes(this.Timeout) < nowTime)
{
this.Remove(cache.Key);
}
}
}
}
if (this.ExpireType == CacheExpireTypeEnum.Adjustable)
{
foreach (var cache in this.CACHE_POOL)
{
DateTime lastAccessTime;
if (this.CACHE_POOL_LastAccessTime.TryGetValue(cache.Key, out lastAccessTime))
{
if (lastAccessTime.AddMinutes(this.Timeout) < nowTime)
{
this.Remove(cache.Key);
}
}
}
}
}
}
catch (Exception ex)
{
Log4netHelper.Fatal("缓存自动清理异常", ex);
}
}
public static void InitialBasicNode(object obj)
{
try
{
TreeNode typenode = new TreeNode();
typenode.Text = Constant.Boxtype_dt.TableName;//修改名称
typenode.ImageIndex = 1;
TreeNode classnode0 = new TreeNode();
classnode0.Text = "模拟传感器";
classnode0.ImageIndex = 1;
TreeNode classnode1 = new TreeNode();
classnode1.Text = "数字传感器";
classnode1.ImageIndex = 1;
TreeNode gluenode = new TreeNode();
gluenode.Text = Constant.Sgglue_dt.TableName;
gluenode.ImageIndex = 1;
TreeNode sgnode = new TreeNode();
sgnode.Text = Constant.Sgseries_dt.TableName;
sgnode.ImageIndex = 1;
ThreadPool.QueueUserWorkItem(new WaitCallback(InitialBoxtype), typenode);
ThreadPool.QueueUserWorkItem(new WaitCallback(InitialProductClass), classnode0);
ThreadPool.QueueUserWorkItem(new WaitCallback(InitialProductClass), classnode1);
ThreadPool.QueueUserWorkItem(new WaitCallback(InitialGlueBom), gluenode);
ThreadPool.QueueUserWorkItem(new WaitCallback(InitialSgBom), sgnode);
}
catch (Exception ex)
{
Log4netHelper.Fatal(new TreeNodeHelper().GetType(), "初始化基本导航信息时发生异常", ex);
MessageBox.Show(ex.Message);
}
}
/// <summary>
/// 启动
/// </summary>
public void Start()
{
try
{
Socket.Connect(IPE);
if (!Socket.Connected)
{
throw new Exception($"{this.LocalAddress}与{IPE.Address.ToString()}建立连接失败,状态为={this.Socket.Connected}");
}
}
catch (Exception ex)
{
if (this.ConnectCallback != null)
{
this.ConnectCallback(ex);
}
throw ex;
}
this.LocalAddress = ((System.Net.IPEndPoint) this.Socket.LocalEndPoint).ToString();
Log4netHelper.Debug($"{this.LocalAddress}已建立与{IPE.Address.ToString()}的连接");
if (this.ConnectCallback != null)
{
this.ConnectCallback(null);
}
TrySetKeepAlive(5, 5);
Task.Run(() =>
{
try
{
Receive();
}
catch (Exception ex)
{
Log4netHelper.Fatal("Recive异常", ex);
}
});
}
/// <summary>
/// 接受连接
/// </summary>
/// <param name="ar"></param>
private void BeginAcceptConnection(IAsyncResult ar)
{
if (this.IsDisposable)
{
return;
}
var socket = SOCKET_SERVER.EndAccept(ar);
var remoteEndPoint = ((System.Net.IPEndPoint)socket.RemoteEndPoint);
Log4netHelper.Debug($"{remoteEndPoint.Address.ToString()}连接到了本服务端");
var session = new SocketSession(socket)
{
Id = Guid.NewGuid().ToString(),
RemoteEndPoint = socket.RemoteEndPoint,
ReceiveCallback = (obj, msg) =>
{
try
{
ReceiveEvent(obj, msg);
}
catch (Exception ex)
{
Log4netHelper.Fatal($"服务端在执行ReceiveEvent事件时发生异常{Environment.NewLine}消息内容{msg}{Environment.NewLine}会话{JsonHelper.SerializeObject(obj)}", ex);
}
},
DisposeCallback = (obj) =>
{
SESSIONS.Remove(obj);
},
};
session.Start();
SESSIONS.Add(session);
SOCKET_SERVER.BeginAccept(new AsyncCallback(BeginAcceptConnection), null);
AcceptConnectionEvent(session, null);
}
private void InitialCheckbox(object lc_dt)
{
DataTable capacity_dt = lc_dt as DataTable;
try
{
Constant.Capacity_Combine_str = "";
for (int i = 0; i < capacity_dt.Rows.Count; i++)
{
if (!this.IsHandleCreated || this.IsDisposed)
{
return;
}
if (InvokeRequired)
{
this.Invoke((MethodInvoker) delegate
{
CheckBox chkBox = new CheckBox();
chkBox.Name = string.Format("checkbox{0}", i + 1);
if (!string.IsNullOrEmpty(capacity_dt.Rows[i][0].ToString()))
{
chkBox.Text = capacity_dt.Rows[i][0].ToString().Replace("-", "");
if (old_capacity_str.Contains(chkBox.Text))
{
chkBox.Checked = true;
}
chkBox.AutoSize = true; //若不设置此属性，会出现比较多的白色边框，比较难看
chkBox.Location = new System.Drawing.Point(-1, -1); //相对位置：左上角
//chkBox.Image = global::GageRobot.Properties.Resources.robot3;
//chkBox.Font = new System.Drawing.Font("宋体", 8F);
//chkBox.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
//chkBox.TextImageRelation = System.Windows.Forms.TextImageRelation.ImageBeforeText;
chkBox.CheckedChanged += new System.EventHandler(this.checkbox_CheckedChanged);
if (capacity_dt.TableName == "模拟传感器")
{
Analog_flowpanel.Controls.Add(chkBox);
}
else
{
Digital_flowpanel.Controls.Add(chkBox);
}
progressBarX1.Value += 1;
progressBarX1.Text = ((double)progressBarX1.Value / progressBarX1.Maximum).ToString("P");
if (progressBarX1.Value == progressBarX1.Maximum)
{
progressBarX1.Visible = false;
}
}
Application.DoEvents();
});
}
}
}
catch (Exception ex)
{
Log4netHelper.Fatal(this.GetType(), "载入传感器容量时异常:", ex);
throw ex;
}
}
/// <summary>
/// 转发
/// </summary>
/// <returns></returns>
private async Task Relay(ClientModel clientModel, SocketClient socketClient, Log log, string message)
{
RequestModel request = null;
ResponseModel response = null;
#region 解析消息
try
{
request = JsonHelper.DeserializeObject <RequestModel>(message);
}
catch (Exception ex)
{
log.Stage = "解析请求参数异常";
AsyncHelper.TaskRun(() =>
{
ProcessCallback(clientModel, socketClient, log);
});
ex = Log4netHelper.GetRealException(ex);
response = new ResponseModel()
{
Response = Encoding.UTF8.GetBytes(ex.Message),
};
log.Content += $"{Environment.NewLine}解析消息异常：{ex}";
Log4netHelper.Fatal($"解析消息异常：{message}", ex);
}
log.Request = request;
#endregion
#region 转发
if (request != null)
{
try
{
log.StartHttpRelayTime = DateTime.Now;
var url = clientModel.HandleUrl;
url = string.Format("{0}{1}", clientModel.HandleUrl, request.UrlPathAndQuery);
log.Stage = "开始转发请求";
AsyncHelper.TaskRun(() =>
{
ProcessCallback(clientModel, socketClient, log);
});
response = await HttpRelayHelper.HttpRelayAsync(url, request);
log.Stage = "收到请求响应";
AsyncHelper.TaskRun(() =>
{
ProcessCallback(clientModel, socketClient, log);
});
log.EndHttpRelayTime = DateTime.Now;
log.Relay = true;
}
catch (Exception ex)
{
log.Stage = "转发请求异常";
AsyncHelper.TaskRun(() =>
{
ProcessCallback(clientModel, socketClient, log);
});
response = new ResponseModel()
{
Response = Encoding.UTF8.GetBytes(ex.Message),
Id = request.Id,
};
log.Relay = false;
log.Content += $"{Environment.NewLine}转发消息异常：{ex}";
}
}
#endregion
log.Response = response;
SocketClient reply_socket = null;
Policy.Handle <Exception>().WaitAndRetryForever(retryAttempt => TimeSpan.FromSeconds(Math.Pow(1, retryAttempt)), (policy_ex, timer) =>
{
log.Stage = "回复异常";
AsyncHelper.TaskRun(() =>
{
ProcessCallback(clientModel, socketClient, log);
});
}).Execute(() =>
{
#region 确保当前客户端状态可用
if (socketClient.IsDisposable || !socketClient.Socket.Connected)
{
log.Content += $"{Environment.NewLine}客户端已被释放，开始创建新的客户端";
reply_socket = clientModel.GetOneFreeOnlineClient();
if (reply_socket != null)
{
if (reply_socket.IsDisposable || !reply_socket.Socket.Connected)
{
log.Content += $"{Environment.NewLine}客户端已被释放，开始创建新的客户端";
Policy.Handle <Exception>().WaitAndRetryForever(retryAttempt => TimeSpan.FromSeconds(Math.Pow(1, retryAttempt)), (policy_ex, timer) =>
{
log.Stage = "无可用客户端，创建客户端异常";
AsyncHelper.TaskRun(() =>
{
ProcessCallback(clientModel, socketClient, log);
});
log.Content += $"{Environment.NewLine}创建新的客户端异常：{policy_ex}";
}).Execute(() =>
{
reply_socket = clientModel.CreateSession();
});
}
}
else
{
reply_socket = clientModel.CreateSession();
}
}
else
{
reply_socket = socketClient;
}
#endregion
#region 回复
log.Stage = "开始回复";
AsyncHelper.TaskRun(() =>
{
ProcessCallback(clientModel, socketClient, log);
});
reply_socket.Send(response);
#endregion
});
log.Stage = "回复完毕";
AsyncHelper.TaskRun(() =>
{
ProcessCallback(clientModel, socketClient, log);
});
log.Reply = true;
log.ResponseDateTime = DateTime.Now;
if (ProcessedCallback != null)
{
ProcessedCallback(clientModel, reply_socket, log);
}
}
public static async Task <ResponseModel> HttpRelayAsync(string url, RequestModel param)
{
var ret = new ResponseModel()
{
Id = param.Id,
};
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
request.Method = param.HttpMethod;
foreach (var item in param.Headers)
{
try
{
switch (item.Key)
{
case "Referer":
request.Referer = item.Value;
break;
case "Connection":
break;
case "Keep-Alive":
break;
case "Content-Length":
request.ContentLength = item.Value.ToLong();
break;
case "Content-Type":
request.ContentType = item.Value;
break;
case "Accept":
request.Accept = item.Value;
break;
case "Host":
request.Host = item.Value;
break;
case "User-Agent":
request.UserAgent = item.Value;
break;
default:
request.Headers.Add(item.Key, item.Value);
break;
}
}
catch (Exception ex)
{
Log4netHelper.Fatal($"设置头信息{item.Key}={item.Value}异常", ex);
}
}
if (param.InputStream.Length > 0)
{
byte[] param_form_bytes = param.InputStream;
request.ContentLength = param_form_bytes.Length;
using (Stream requestStream = await request.GetRequestStreamAsync())
{
try
{
requestStream.Write(param_form_bytes, 0, param_form_bytes.Length);
requestStream.Close();
}
catch (Exception ex)
{
Log4netHelper.Fatal($"写入请求流异常", ex);
throw;
}
}
}
HttpWebResponse response = null;
try
{
response = (HttpWebResponse)await request.GetResponseAsync();
}
catch (WebException ex)
{
response = (HttpWebResponse)ex.Response;
}
finally
{
if (response != null)
{
ret.StatusCode = response.StatusCode;
if (response.ContentLength > 0)
{
ret.Response = new byte[response.ContentLength];
var responseStream = response.GetResponseStream();
var conetntLength = (int)response.ContentLength;
var read_byte = await responseStream.ReadAsync(ret.Response, 0, conetntLength);
while (read_byte != response.ContentLength)
{
read_byte += await responseStream.ReadAsync(ret.Response, read_byte, conetntLength - read_byte);
}
}
else
{
ret.Response = new byte[0];
}
ret.Headers = response.Headers.ToDictionary();
if (response.Cookies != null && response.Cookies.Count > 0)
{
ret.HttpCookies = new List <Models.Http.HttpCookie>(response.Cookies.Count);
foreach (Cookie cookie in response.Cookies)
{
ret.HttpCookies.Add(new Models.Http.HttpCookie()
{
Domain = cookie.Domain,
Expires = cookie.Expires,
HttpOnly = cookie.HttpOnly,
Name = cookie.Name,
Path = cookie.Path,
Secure = cookie.Secure,
Value = cookie.Value,
});
}
}
}
}
return(ret);
}
/// <summary>
/// 上传文件
/// </summary>
/// <param name="url"></param>
/// <param name="data"></param>
/// <param name="filePath"></param>
/// <param name="headers"></param>
/// <param name="charset"></param>
/// <returns></returns>
public static string UploadFile(string url, Dictionary <string, string> data, string filePath, Dictionary <string, string> headers = null, string charset = "UTF-8")
{
var policy = Policy.Handle <WebException>().WaitAndRetry(5,
retryAttempt => TimeSpan.FromSeconds(Math.Pow(1, retryAttempt)),
(ex, timer, c, context) =>
{
Log4netHelper.Fatal("UploadFile异常", ex);
Log4netHelper.Fatal($"执行失败! 重试次数 {c} timer={timer.ToString()}i={context.ToJson()}");
});
return(policy.Execute(() =>
{
// 设置参数
HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
request.AllowAutoRedirect = true;
request.Method = "POST";
SetHeaders(request, headers);
string boundary = DateTime.Now.Ticks.ToString("X"); // 随机分隔线
request.ContentType = "multipart/form-data;charset=utf-8;boundary=" + boundary;
byte[] start_BoundaryBytes = Encoding.UTF8.GetBytes("\r\n--" + boundary + "\r\n");
byte[] end_BoundaryBytes = Encoding.UTF8.GetBytes("\r\n--" + boundary + "--\r\n");
string fileName = FileHelper.GetFileName(filePath, true);
//请求头部信息
StringBuilder sbHeader = new StringBuilder(string.Format("Content-Disposition:form-data;name=\"file\";filename=\"{0}\"\r\nContent-Type:application/octet-stream\r\n\r\n", fileName));
byte[] postHeaderBytes = Encoding.UTF8.GetBytes(sbHeader.ToString());
//POST请求数据
var postData = new List <byte[]>();
if (data != null)
{
foreach (var item in data)
{
var str = string.Format("\r\n--{0}\r\nContent-Disposition: form-data; name=\"{1}\"\r\n\r\n{2}", boundary, item.Key, item.Value);
byte[] postBytes = Encoding.GetEncoding(charset).GetBytes(str);
postData.Add(postBytes);
}
}
using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
byte[] bArr = new byte[fs.Length];
fs.Read(bArr, 0, bArr.Length);
request.ContentLength = start_BoundaryBytes.Length + postHeaderBytes.Length + bArr.Length + end_BoundaryBytes.Length;
if (postData.ExistsData())
{
request.ContentLength = request.ContentLength + postData.Sum(row => row.Length);
}
using (Stream postStream = request.GetRequestStream())
{
postStream.Write(start_BoundaryBytes, 0, start_BoundaryBytes.Length);
postStream.Write(postHeaderBytes, 0, postHeaderBytes.Length);
postStream.Write(bArr, 0, bArr.Length);
if (postData.ExistsData())
{
postData.ForEach(item =>
{
postStream.Write(item, 0, item.Length);
});
}
postStream.Write(end_BoundaryBytes, 0, end_BoundaryBytes.Length);
//发送请求并获取相应回应数据
using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
{
//直到request.GetResponse()程序才开始向目标网页发送Post请求
using (Stream instream = response.GetResponseStream())
{
using (StreamReader sr = new StreamReader(instream, Encoding.UTF8))
{
//返回结果网页（html）代码
string content = sr.ReadToEnd();
return content;
}
}
}
}
}
}));
}
private void Initial_ListView(object obj)
{
DataTable capacity_dt = obj as DataTable;
int Listview_count = 0;
int Average_count = 0;
if (capacity_dt.TableName == "模拟传感器")
{
Listview_count = 4;
}
else
{
Listview_count = 3;
}
Average_count = capacity_dt.Rows.Count / Listview_count;
try
{
if (!this.IsHandleCreated || this.IsDisposed)
{
return;
}
if (InvokeRequired)
{
this.Invoke((MethodInvoker) delegate
{
for (int i = 0; i < Listview_count + 1; i++)
{
ListViewEx lv = new ListViewEx();
lv.Height = Analog_flowpanel.Height - 10;
lv.Width = (tabControl1.Width / (Listview_count + 1)) - 15;
lv.View = View.Details;
lv.FullRowSelect = true;
lv.HeaderStyle = ColumnHeaderStyle.Clickable;
lv.View = View.Details;
lv.SmallImageList = this.imageList1; //将listView的图标集与imageList1绑定
lv.CheckBoxes = true;
lv.View = View.Details;
lv.GridLines = true; //显示网格线
lv.Items.Clear(); //所有的项
lv.Columns.Clear(); //标题
lv.Columns.Add("容量选择", 120, HorizontalAlignment.Left); //增加标题
lv.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize); //调整列的宽度
lv.ItemChecked += new System.Windows.Forms.ItemCheckedEventHandler(this.listViewEx_ItemChecked);
if (capacity_dt.TableName == "模拟传感器")
{
Analog_flowpanel.Controls.Add(lv);
}
else
{
Digital_flowpanel.Controls.Add(lv);
}
for (int j = i * Average_count; j < (i + 1) * Average_count; j++)
{
if (j < (i + 1) * Average_count && j < capacity_dt.Rows.Count)
{
if (string.IsNullOrEmpty(Convert.ToString(capacity_dt.Rows[j][0])))
{
UIHelper.ToastNotify(false, "有容量为空!", tabControl1);
}
ListViewItem lvi = new ListViewItem(capacity_dt.Rows[j][0].ToString());
lvi.ImageIndex = 0;
if (old_capacity_str.Contains(lvi.Text.Replace("-", "")))
{
lvi.Checked = true;
}
lv.Items.Add(lvi);
//进度条
progressBarX1.Value += 1;
progressBarX1.Text = ((double)progressBarX1.Value / progressBarX1.Maximum).ToString("P");
if (progressBarX1.Value == progressBarX1.Maximum)
{
progressBarX1.Visible = false;
}
Application.DoEvents();
}
else
{
break;
}
}
}
});
}
}
catch (Exception ex)
{
Log4netHelper.Fatal(this.GetType(), "初始化Listview时异常:" + ex.Message);
throw ex;
}
}
