初步 增加 推送线程

schangxiang@126.com

2025-09-17 c9c91ad3e3ac218d81c86809c93a35622b51a686

初步 增加 推送线程

 DBScript/01_DDL/01_DDL_TABLE_WGQ.sql

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,43 @@
use WGQ_WB19011_CORE
go

/*==============================================================*/
/* Table: Wms_outInStockRecord_V2_Mes                               */
/* Description: å‡ºå…¥åº“记录(为推送MES)                */
/* Author:shaocx                                                */
/* CreateTime:2025-09-17                                */
/*==============================================================*/
IF NOT EXISTS( SELECT 1 FROM SYSOBJECTS  WHERE ID = OBJECT_ID('Wms_outInStockRecord_V2_Mes') AND TYPE = 'U')
create table Wms_outInStockRecord_V2_Mes(
   ID            int       IDENTITY(1,1) NOT NULL, -- ä¸»é”®

   OutInFlagName      VARCHAR(10)   ,---  å‡ºå…¥åº“类型 1 å…¥åº“ 2 å‡ºåº“
   
   ListNo    NVARCHAR(128)    NULL , -- å‡ºå…¥å•å·
   Code    NVARCHAR(128)    NULL , -- åž‹æå”¯ä¸€ç¼–码
   Name    NVARCHAR(128)    NULL , -- ç‰©æ–™åç§°
   
   SerialNo    NVARCHAR(128)    NULL , -- åˆ†æ®µå·
   IssueProjectNo    NVARCHAR(128)    NULL , -- å‘放工程号
   
   PlaceCode   VARCHAR(100)     NULL , -- åº“位编码
   OccurrenceTime    datetime    NULL , -- å‘生时间
  
   
   IsSendToMes  int    NULL , -- æŽ¨é€çŠ¶æ€
   IsSendToMesStr VARCHAR(100)     NULL , -- æŽ¨é€çŠ¶æ€
   SendToMesCount  int    NULL , -- æŽ¨ç»™MES次数
   SendToMesTime datetime    null, -- æŽ¨ç»™MES时间
   MesRet  NVARCHAR(128)    NULL , -- MES返回结果
   
   
   Remark    NVARCHAR(128)    NULL , -- å¤‡æ³¨
   Creator        varchar(128)    null,-- åˆ›å»ºäºº
   CreateTime        datetime    null, -- åˆ›å»ºæ—¶é—´
   LastModifier        varchar(128)    null,-- ä¿®æ”¹äºº
   LastModifyTime   datetime    null -- ä¿®æ”¹æ—¶é—´
   
   constraint PK_Wms_outInStockRecord_V2_Mes primary key (ID) 
)
GO


 DBScript/01_DDL/02_DDL_TABLE_Edit_WGQ.sql

 DBScript/01_DDL/03_DDL_VIEW_WGQ.sql

 DBScript/01_DDL/04_DDL_INDEX_WGQ.sql

 DBScript/02_DML/01_InitData.sql

 DEmon/iWareCc/Service1.cs

@@ -413,6 +413,8 @@
            //ReSendThread.Name = "向WIP重新推送报文";
            //StartThread(ReSendThread);

            //开启推送给MES的出入库完成线程 ã€Editby shaocx,2025-09-17】
            new Thread(mesDataTranfficForRealMes.Handler).Start();

        }


 DEmon/iWareCc/SystemInteraction/HTTPService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,493 @@
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Text;

namespace iWareCc
{
    public class HTTPService
    {
        private string BaseURI = "";
        public HTTPService(string baseURI)
        {
            this.BaseURI = baseURI;
        }

        #region GET调用webapi公共方法

        /// <summary>
        /// é€šè¿‡GET方法调用HTTP服务
        /// </summary>
        /// <typeparam name="T">入参类型</typeparam>
        /// <param name="url">服务地址</param>
        /// <param name="requestId">发起请求的行为标识</param>
        /// <param name="timeout">超时时间，单位：秒，默认为30秒</param>
        /// <returns></returns>
        public T getContent<T>(string url, Guid requestId, int timeout = 30)
        {
            try
            {
                var client = new HttpClient();

                client.BaseAddress = new Uri(this.BaseURI);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("RequestId", requestId.ToString());
                client.Timeout = new TimeSpan(0, 0, timeout);

                using (HttpResponseMessage response = client.GetAsync(url).Result)
                {
                    if (response.IsSuccessStatusCode)
                    {
                        var str_result = response.Content.ReadAsStringAsync().Result;
                        T result = JsonConvert.DeserializeObject<T>(str_result);
                        return result;
                    }
                    else if (response.StatusCode == HttpStatusCode.InternalServerError)
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常");
                    }
                    else
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常{" + response.StatusCode + "}");
                    }
                }
            }
            catch
            {
                throw;
            }
        }

        /// <summary>
        /// é€šè¿‡GET方法调用HTTP服务
        /// </summary>
        /// <param name="url">服务地址</param>
        /// <param name="requestId">发起请求的行为标识</param>
        /// <param name="timeout">超时时间，单位：秒，默认为30秒</param>
        /// <returns></returns>
        public string getContentForString(string url, Guid requestId, int timeout = 30)
        {
            try
            {
                var client = new HttpClient();

                client.BaseAddress = new Uri(this.BaseURI);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("RequestId", requestId.ToString());
                client.Timeout = new TimeSpan(0, 0, timeout);

                using (HttpResponseMessage response = client.GetAsync(url).Result)
                {
                    if (response.IsSuccessStatusCode)
                    {
                        var result = response.Content.ReadAsStringAsync().Result;
                        return result;
                    }
                    else if (response.StatusCode == HttpStatusCode.InternalServerError)
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常,response:" + JsonConvert.SerializeObject(response));
                    }
                    else
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常{" + response.StatusCode + "},response:" + JsonConvert.SerializeObject(response));
                    }
                }
            }
            catch
            {
                throw;
            }
        }
        #endregion

        #region POST调用webapi公共方法

        /// <summary>
        /// é€šè¿‡POST方法调用HTTP服务
        /// </summary>
        /// <typeparam name="T">入参类型</typeparam>
        /// <typeparam name="T2">出参类型</typeparam>
        /// <param name="url">服务地址</param>
        /// <param name="parameter">入参</param>
        /// <param name="requestId">发起请求的行为标识</param>
        /// <param name="timeout">超时时间，单位：秒，默认为30秒</param>
        /// <returns></returns>
        public T2 postContent<T, T2>(string url, T parameter, Guid requestId, int timeout = 30)
        {
            try
            {
                var client = new HttpClient();

                client.BaseAddress = new Uri(this.BaseURI);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("RequestId", requestId.ToString());
                client.DefaultRequestHeaders.Add("Authorization", "123456");
                client.Timeout = new TimeSpan(0, 0, timeout);

                string str = JsonConvert.SerializeObject(parameter);
                var httpContent = new StringContent(str, Encoding.UTF8);
                httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };
                using (HttpResponseMessage response = client.PostAsync(url, httpContent).Result)
                {
                    if (response.IsSuccessStatusCode)
                    {
                        var str_result = response.Content.ReadAsStringAsync().Result;
                        T2 result = JsonConvert.DeserializeObject<T2>(str_result);
                        return result;
                    }
                    else if (response.StatusCode == HttpStatusCode.InternalServerError)
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常");
                    }
                    else
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常{" + response.StatusCode + "}");
                    }
                }
            }
            catch
            {
                throw;
            }
        }

        /// <summary>
        /// é€šè¿‡POST方法调用HTTP服务
        /// </summary>
        /// <param name="url">服务地址</param>
        /// <param name="parameter">入参</param>
        /// <param name="requestId">发起请求的行为标识</param>
        /// <param name="timeout">超时时间，单位：秒，默认为30秒</param>
        /// <returns></returns>
        public string postContentForString(string url, IDictionary<string, string> parameter, Guid requestId, int timeout = 30)
        {
            try
            {
                var client = new HttpClient();

                client.BaseAddress = new Uri(this.BaseURI);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("RequestId", requestId.ToString());
                client.Timeout = new TimeSpan(0, 0, timeout);

                string str = JsonConvert.SerializeObject(parameter);
                var httpContent = new StringContent(str, Encoding.UTF8);
                httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };
                using (HttpResponseMessage response = client.PostAsync(url, httpContent).Result)
                {
                    if (response.IsSuccessStatusCode)
                    {
                        var result = response.Content.ReadAsStringAsync().Result;
                        return result;
                    }
                    else if (response.StatusCode == HttpStatusCode.InternalServerError)
                    {
                        return response.StatusCode.ToString();
                       // throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常");
                    }
                    else
                    {
                        return response.StatusCode.ToString();
                       // throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常{" + response.StatusCode + "}");
                    }
                }
            }
            catch
            {
                throw;
            }
        }

        /// <summary>
        /// é€šè¿‡POST方法调用HTTP服务
        /// </summary>
        /// <param name="url">服务地址</param>
        /// <param name="parameter">入参字符串</param>
        /// <param name="requestId">发起请求的行为标识</param>
        /// <param name="timeout">超时时间，单位：秒，默认为30秒</param>
        /// <returns></returns>
        public string postContentForString(string url, string parameter, Guid requestId, int timeout = 30)
        {
            try
            {
                var client = new HttpClient();

                client.BaseAddress = new Uri(this.BaseURI);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("RequestId", requestId.ToString());
                client.Timeout = new TimeSpan(0, 0, timeout);
                var ee = new { name = parameter };
                if (parameter=="")
                {
                    parameter = ee.ToString();
                }
              
                var httpContent = new StringContent(parameter, Encoding.UTF8);
                httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };
                using (HttpResponseMessage response = client.PostAsync(url, httpContent).Result)
                {
                    if (response.IsSuccessStatusCode)
                    {
                        var result = response.Content.ReadAsStringAsync().Result;
                        return result;
                    }
                    else if (response.StatusCode == HttpStatusCode.InternalServerError)
                    {
                        return response.StatusCode.ToString();
                       // throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常");
                    }
                    else
                    {
                        return response.StatusCode.ToString();
                       // throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常{" + response.StatusCode + "}");
                    }
                }
            }
            catch (Exception ex)
            {
                throw;
            }
        }

        /// <summary>
        /// é€šè¿‡POST方法调用HTTP服务(AGV专用)
        /// </summary>
        /// <param name="url">服务地址</param>
        /// <param name="parameter">入参字符串</param>
        /// <param name="requestId">发起请求的行为标识</param>
        /// <param name="timeout">超时时间，单位：秒，默认为30秒</param>
        /// <returns></returns>
        public string postContentForStringForAgv(string url, string parameter, Guid requestId, int timeout = 30)
        {
            try
            {
                var client = new HttpClient();

                client.BaseAddress = new Uri(this.BaseURI);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("RequestId", requestId.ToString());
                client.Timeout = new TimeSpan(0, 0, timeout);
                var ee = new { name = parameter };
                if (parameter == "")
                {
                    parameter = ee.ToString();
                }

                var httpContent = new StringContent(parameter, Encoding.UTF8);
                httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };
                using (HttpResponseMessage response = client.PostAsync(url, httpContent).Result)
                {
                    var result = response.Content.ReadAsStringAsync().Result;
                    return result;
                }
            }
            catch (Exception ex)
            {
                throw;
            }
        }


        /// <summary>
        /// é€šè¿‡POST方法调用HTTP服务
        /// </summary>
        /// <param name="url">服务地址</param>
        /// <param name="parameter">入参字符串</param>
        /// <param name="requestId">发起请求的行为标识</param>
        /// <param name="timeout">超时时间，单位：秒，默认为30秒</param>
        /// <returns></returns>
        public string postContentForStringWithToken(string url, string parameter,
            Guid requestId, string token, int timeout = 30)
        {
            try
            {
                var client = new HttpClient();

                client.BaseAddress = new Uri(this.BaseURI);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("RequestId", requestId.ToString());
                client.DefaultRequestHeaders.Add("Authorization", token.ToString());
                client.Timeout = new TimeSpan(0, 0, timeout);

                var httpContent = new StringContent(parameter, Encoding.UTF8);
                httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };
                using (HttpResponseMessage response = client.PostAsync(url, httpContent).Result)
                {
                    if (response.IsSuccessStatusCode)
                    {
                        var result = response.Content.ReadAsStringAsync().Result;
                        return result;
                    }
                    else if (response.StatusCode == HttpStatusCode.InternalServerError)
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常");
                    }
                    else
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常{" + response.StatusCode + "}");
                    }
                }
            }
            catch
            {
                throw;
            }
        }

        #endregion

        #region PUT调用webapi公共方法

        /// <summary>
        /// é€šè¿‡PUT方法调用HTTP服务
        /// </summary>
        /// <typeparam name="T">入参类型</typeparam>
        /// <typeparam name="T2">出参类型</typeparam>
        /// <param name="url">服务地址</param>
        /// <param name="parameter">入参</param>
        /// <param name="requestId">发起请求的行为标识</param>
        /// <param name="timeout">超时时间，单位：秒，默认为30秒</param>
        /// <returns></returns>
        public T2 putContent<T, T2>(string url, T parameter, Guid requestId, int timeout = 30)
        {
            try
            {
                var client = new HttpClient();

                client.BaseAddress = new Uri(this.BaseURI);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("RequestId", requestId.ToString());
                client.Timeout = new TimeSpan(0, 0, timeout);

                string str = JsonConvert.SerializeObject(parameter);
                var httpContent = new StringContent(str, Encoding.UTF8);
                httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };
                using (HttpResponseMessage response = client.PutAsync(url, httpContent).Result)
                {
                    if (response.IsSuccessStatusCode)
                    {
                        var str_result = response.Content.ReadAsStringAsync().Result;
                        T2 result = JsonConvert.DeserializeObject<T2>(str_result);
                        return result;
                    }
                    else if (response.StatusCode == HttpStatusCode.InternalServerError)
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常");
                    }
                    else
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常{" + response.StatusCode + "}");
                    }
                }
            }
            catch
            {
                throw;
            }
        }

        /// <summary>
        /// é€šè¿‡PUT方法调用HTTP服务
        /// </summary>
        /// <param name="url">服务地址</param>
        /// <param name="parameter">入参</param>
        /// <param name="requestId">发起请求的行为标识</param>
        /// <param name="timeout">超时时间，单位：秒，默认为30秒</param>
        /// <returns></returns>
        public string putContentForString(string url, IDictionary<string, string> parameter,
            Guid requestId, int timeout = 30)
        {
            try
            {
                var client = new HttpClient();

                client.BaseAddress = new Uri(this.BaseURI);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("RequestId", requestId.ToString());
                client.Timeout = new TimeSpan(0, 0, timeout);

                string str = JsonConvert.SerializeObject(parameter);
                var httpContent = new StringContent(str, Encoding.UTF8);
                httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };
                using (HttpResponseMessage response = client.PutAsync(url, httpContent).Result)
                {
                    if (response.IsSuccessStatusCode)
                    {
                        var result = response.Content.ReadAsStringAsync().Result;
                        return result;
                    }
                    else if (response.StatusCode == HttpStatusCode.InternalServerError)
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常");
                    }
                    else
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常{" + response.StatusCode + "}");
                    }
                }
            }
            catch
            {
                throw;
            }
        }

        /// <summary>
        /// é€šè¿‡POST方法调用HTTP服务
        /// </summary>
        /// <param name="url">服务地址</param>
        /// <param name="parameter">入参字符串</param>
        /// <param name="requestId">发起请求的行为标识</param>
        /// <param name="timeout">超时时间，单位：秒，默认为30秒</param>
        /// <returns></returns>
        public string putContentForString(string url, string parameter,
            Guid requestId, int timeout = 30)
        {
            try
            {
                var client = new HttpClient();

                client.BaseAddress = new Uri(this.BaseURI);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("RequestId", requestId.ToString());
                client.Timeout = new TimeSpan(0, 0, timeout);

                var httpContent = new StringContent(parameter, Encoding.UTF8);
                httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };
                using (HttpResponseMessage response = client.PutAsync(url, httpContent).Result)
                {
                    if (response.IsSuccessStatusCode)
                    {
                        var result = response.Content.ReadAsStringAsync().Result;
                        return result;
                    }
                    else if (response.StatusCode == HttpStatusCode.InternalServerError)
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常");
                    }
                    else
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常{" + response.StatusCode + "}");
                    }
                }
            }
            catch
            {
                throw;
            }
        }
        #endregion
    }
}

 DEmon/iWareCc/SystemInteraction/PushMesHandler.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,112 @@
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;

namespace iWareCc
{
    /// <summary>
    /// MES推送接口
    /// </summary>
    public class PushMesHandler
    {
        public static string mes_api_url = "";// ConfigHelper.GetConfigString("MesUrl");//修改为配置文件 ã€EditBy shaocx,2022-01-27】
        static HTTPService mes_api = new HTTPService(mes_api_url);//mes基地址

        /// <summary>
        /// ç»™MES推送入库信息
        /// </summary>
        /// <param name="pushData"></param>
        /// <returns></returns>
        public static ApiResponse<string> Mes_InStockSend(List<InboundStockInfoToMes> pushData)
        {
            ApiResponse<string> res = null;
            var funName = "Mes_InStockSend";
            try
            {
                MesRequest<List<InboundStockInfoToMes>> mesRequest = new MesRequest<List<InboundStockInfoToMes>>();
                mesRequest.Datas = pushData;
                mesRequest.TableName = "T_WMS_Inbound_Record";
                mesRequest.PrimaryKeys = "identifier";

                string paprm = JsonConvert.SerializeObject(mesRequest);
                //Log4NetHelper.WriteInfoLog(_logType, $"{funName},准备参数:{paprm}");
                Guid guid = System.Guid.NewGuid();

                //模拟
                if (1 == 2)
                {//模拟环境
                    res = new ApiResponse<string>();
                    res.Code = 500;
                    res.Success = false;
                    res.Message = "系统模拟完成";
                }
                else
                {
                    var resStr = mes_api.postContentForString("", paprm, guid);
                    //Log4NetHelper.WriteInfoLog(_logType, $"{funName},结果返回:{resStr}");
                    res = JsonConvert.DeserializeObject<ApiResponse<string>>(resStr);
                }

                //Log4NetHelper.WriteInfoLog(_logType, $"{funName},参数:{paprm},返回:{JsonConvert.SerializeObject(res)}");
            }
            catch (Exception ex)
            {
                //Log4NetHelper.WriteErrorLog(_logType, $"{funName},异常:" + ex.Message, ex);
                res.Code = 500;
                res.Success = false;
                res.Message = "wms发送异常:" + ex.Message;
            }
            return res;

        }


        ///// <summary>
        ///// ç»™MES推送出库信息
        ///// </summary>
        ///// <param name="pushData"></param>
        ///// <returns></returns>
        //public static ApiResponse Mes_OutStockSend(List<InboundStockInfoToMes> pushData, LogType _logType)
        //{
        //    ApiResponse<string> res = null;
        //    var funName = "Mes_OutStockSend";
        //    try
        //    {
        //        MesRequest<List<InboundStockInfoToMes>> mesRequest = new MesRequest<List<InboundStockInfoToMes>>();
        //        mesRequest.Datas = pushData;
        //        mesRequest.TableName = "T_WMS_Outbound_Record";
        //        mesRequest.PrimaryKeys = "identifier";

        //        string paprm = JsonConvert.SerializeObject(mesRequest);
        //        //Log4NetHelper.WriteInfoLog(_logType, $"{funName},准备参数:{paprm}");
        //        Guid guid = System.Guid.NewGuid();
        //        //模拟
        //        if (Form1.isvirtual)
        //        {//模拟环境
        //            res = new ApiResponse<string>();
        //            res.ErrorCode = 0;
        //            res.ErrorMsg = "系统模拟完成";
        //        }
        //        else
        //        {
        //            var resStr = mes_api.postContentForString("", paprm, guid);
        //            //Log4NetHelper.WriteInfoLog(_logType, $"{funName},结果返回:{resStr}");
        //            res = JsonConvert.DeserializeObject<ApiResponse<string>>(resStr);
        //        }

        //        //Log4NetHelper.WriteInfoLog(_logType, $"{funName},参数:{paprm},返回:{JsonConvert.SerializeObject(res)}");
        //    }
        //    catch (Exception ex)
        //    {
        //        //Log4NetHelper.WriteErrorLog(_logType, $"{funName},异常:" + ex.Message, ex);
        //        res.ErrorCode = 4;
        //        res.ErrorMsg = "wms发送异常:" + ex.Message;
        //    }
        //    return res;

        //}


    }
}

 DEmon/iWareCc/SystemInteraction/dto/ApiResponse.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,35 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace iWareCc
{
    /// <summary>
    /// é€šç”¨æ³›åž‹æŽ¥å£å“åº”模型
    /// </summary>
    /// <typeparam name="T">Data å­—段的类型，可以是任意类型，如 string、int、自定义类等</typeparam>
    public class ApiResponse<T>
    {
        /// <summary>
        /// çŠ¶æ€ç ï¼Œä¾‹å¦‚ 200 è¡¨ç¤ºæˆåŠŸ
        /// </summary>
        public int Code { get; set; }

        /// <summary>
        /// æ˜¯å¦æˆåŠŸï¼Œtrue è¡¨ç¤ºæˆåŠŸï¼Œfalse è¡¨ç¤ºå¤±è´¥
        /// </summary>
        public bool Success { get; set; }

        /// <summary>
        /// è¿”回消息，例如："成功" æˆ–错误信息
        /// </summary>
        public string Message { get; set; }

        /// <summary>
        /// è¿”回的数据内容，类型为泛型 T
        /// </summary>
        public T Data { get; set; }
    }
}

 DEmon/iWareCc/SystemInteraction/dto/InboundStockInfoToMes.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,57 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace iWareCc
{
    /// <summary>
    /// æŽ¨é€å…¥åº“接口 - è¯·æ±‚参数中的单个入库记录项
    /// </summary>
    public class InboundStockInfoToMes
    {

        /// <summary>
        /// å‡ºå…¥åº“标记
        /// </summary>
        public string BusinessFlag { get; set; }

        /// <summary>
        /// åˆ†æ®µå·
        /// </summary>
        public string SerialNo { get; set; }

        /// <summary>
        /// èˆ¹å·/发放工程号
        /// </summary>
        public string IssueProjectNo { get; set; }

        /// <summary>
        /// åº“位号
        /// </summary>
        public string PlaceCode { get; set; }

        /// <summary>
        /// ç‰©æ–™ç¼–码
        /// </summary>
        public string Code { get; set; }


        /// <summary>
        /// å‘生时间
        /// </summary>
        public string OccurrenceTime { get; set; }



        /// <summary>
        /// æ—¶é—´æˆ³(参数自动初始化)
        /// </summary>
        public string Timestamp { get; set; } = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");




    }
}

 DEmon/iWareCc/SystemInteraction/dto/MesRequest.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,39 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace iWareCc
{
    /// <summary>
    /// æŽ¨é€ä¿¡æ¯
    /// </summary>
    public class MesRequest<T>
    {
        /// <summary>
        /// æ•°æ®
        /// </summary>
        public T Datas { get; set; }

        /// <summary>
        /// ç³»ç»Ÿç±»åž‹
        /// </summary>
        public string SystemType { get; set; } = "ERP";
        /// <summary>
        /// Secret
        /// </summary>
        public string Secret { get; set; } = "HJY^*HGYIIY";


        /// <summary>
        /// è¡¨å
        /// </summary>
        public string TableName { get; set; }

        /// <summary>
        /// ä¸»é”®
        /// </summary>
        public string PrimaryKeys { get; set; }
    }
}

 DEmon/iWareCc/SystemInteraction/mesDataTranfficForRealMes.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,96 @@
using iWareDataCore.ORM;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;

namespace iWareCc
{
    /// <summary>
    /// MES出入库数据传输(真正的MES)
    /// </summary>
    public class mesDataTranfficForRealMes
    {
        //public static LogType _logType = LogType.mesDataTranfficForRealMes;
        public static async void Handler()
        {
            while (true)
            {
                try
                {
                    Thread.Sleep(5000);

                    using (DbModelCore mod = new DbModelCore())
                    {
                        List<Wms_outInStockRecord_V2_Mes> sendMesData = mod.Wms_outInStockRecord_V2_Mes.Where(x => x.IsSendToMes == 0).OrderBy(x => x.ID).ToList();

                        if (sendMesData.Count > 0)
                        {
                            //SystemWarningMsg.msg_mesDataTranfficForRealMes = $"{MyExtend.MsgTimeStr()},要推送{sendMesData.Count()}条!";
                            foreach (var itemTask in sendMesData)
                            {
                                try
                                {
                                    ApiResponse<string> ret = null;

                                    //获取信息明细
                                    List<InboundStockInfoToMes> pushData = new List<InboundStockInfoToMes>();
                                    pushData.Add(new InboundStockInfoToMes()
                                    {
                                        BusinessFlag = itemTask.OutInFlagName,

                                        OccurrenceTime​ = itemTask.CreateTime?.ToString("yyyy-MM-dd HH:mm:ss"),
                                        Code = itemTask.Code,
                                        PlaceCode = itemTask.PlaceCode,
                                        SerialNo = itemTask.SerialNo,
                                        IssueProjectNo = itemTask.IssueProjectNo,


                                    });


                                    //SystemWarningMsg.msg_mesDataTranfficForRealMes = $"{MyExtend.MsgTimeStr()},已推送结束，返回:{JsonConvert.SerializeObject(ret)}";
                                    if (ret.Success)
                                    {
                                        itemTask.IsSendToMes = 1;//推送成功
                                        itemTask.IsSendToMesStr = "成功";
                                    }
                                    else
                                    {
                                        itemTask.IsSendToMes = 0;//推送失败
                                        itemTask.IsSendToMesStr = "失败";
                                    }
                                    itemTask.SendToMesTime = DateTime.Now;
                                    itemTask.MesRet = ret.Message;
                                    itemTask.SendToMesCount = (itemTask.SendToMesCount ?? 0) + 1;
                                    if (itemTask.IsSendToMes == 0 && itemTask.SendToMesCount > 100)
                                    {
                                        itemTask.IsSendToMes = 3;//表示强制推送成功
                                        itemTask.IsSendToMesStr = "强制成功";
                                    }
                                    mod.SaveChanges();

                                }
                                catch (Exception ex)
                                {
                                    //SystemWarningMsg.msg_mesDataTranfficForRealMes = $"{MyExtend.MsgTimeStr()},推送给MES数据异常:" + JsonConvert.SerializeObject(ex);
                                    //Log4NetHelper.WriteErrorLog(_logType, //SystemWarningMsg.msg_mesDataTranfficForRealMes, ex);
                                }
                            }
                        }
                        else
                        {
                            //SystemWarningMsg.msg_mesDataTranfficForRealMes = $"{MyExtend.MsgTimeStr()},没有数据要推送给MES!";
                        }
                    }
                }
                catch (Exception ex)
                {
                    //SystemWarningMsg.msg_mesDataTranfficForRealMes = $"{MyExtend.MsgTimeStr()},数据要推送给MES出现异常:" + ex.Message;
                    //Log4NetHelper.WriteErrorLog(_logType, //SystemWarningMsg.msg_mesDataTranfficForRealMes, ex);
                }
            }
        }
    }
}

 DEmon/iWareCc/iWareCc.csproj

@@ -94,6 +94,7 @@
    <Reference Include="System.Core" />
    <Reference Include="System.Drawing" />
    <Reference Include="System.Management" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Runtime.Serialization" />
    <Reference Include="System.ServiceModel" />
    <Reference Include="System.Xml.Linq" />
@@ -195,6 +196,12 @@
    <Compile Include="Srm\EnumType\ESrmAlarm1.cs" />
    <Compile Include="Srm\Strategy\推送堆垛机告警状态.cs" />
    <Compile Include="Srm\Strategy\推送堆垛机状态.cs" />
    <Compile Include="SystemInteraction\dto\ApiResponse.cs" />
    <Compile Include="SystemInteraction\dto\InboundStockInfoToMes.cs" />
    <Compile Include="SystemInteraction\dto\MesRequest.cs" />
    <Compile Include="SystemInteraction\HTTPService.cs" />
    <Compile Include="SystemInteraction\mesDataTranfficForRealMes.cs" />
    <Compile Include="SystemInteraction\PushMesHandler.cs" />
    <Compile Include="Task\Service\TaskService.cs" />
    <Compile Include="Util\OPCHelper.cs" />
    <Compile Include="Util\SocketClient.cs" />

 DEmon/iWareDataCore/ORM/DbModelCore.cs

@@ -1,9 +1,6 @@
namespace iWareDataCore.ORM
{
    using System;
    using System.Data.Entity;
    using System.ComponentModel.DataAnnotations.Schema;
    using System.Linq;

    public partial class DbModelCore : DbContext
    {
@@ -53,10 +50,30 @@
        public virtual DbSet<WebOrderDetailView> WebOrderDetailView { get; set; }
        public virtual DbSet<MaterialPlaceView> MaterialPlaceView { get; set; }
        public virtual DbSet<BASEMaterialClass> BASEMaterialClass { get; set; }
        
        public virtual DbSet<Wms_outInStockRecord_V2_Mes> Wms_outInStockRecord_V2_Mes { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Wms_outInStockRecord_V2_Mes>()
              .Property(e => e.OutInFlagName)
              .IsUnicode(false);

            modelBuilder.Entity<Wms_outInStockRecord_V2_Mes>()
                .Property(e => e.PlaceCode)
                .IsUnicode(false);

            modelBuilder.Entity<Wms_outInStockRecord_V2_Mes>()
                .Property(e => e.IsSendToMesStr)
                .IsUnicode(false);

            modelBuilder.Entity<Wms_outInStockRecord_V2_Mes>()
                .Property(e => e.Creator)
                .IsUnicode(false);

            modelBuilder.Entity<Wms_outInStockRecord_V2_Mes>()
                .Property(e => e.LastModifier)
                .IsUnicode(false);

            modelBuilder.Entity<BASEInOutList>()
                .HasMany(e => e.BASEInOutListDetails)
                .WithRequired(e => e.BASEInOutList)

 DEmon/iWareDataCore/ORM/Wms_outInStockRecord_V2_Mes.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,61 @@
namespace iWareDataCore.ORM
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel.DataAnnotations;
    using System.ComponentModel.DataAnnotations.Schema;
    using System.Data.Entity.Spatial;

    public partial class Wms_outInStockRecord_V2_Mes
    {
        public int ID { get; set; }

        [StringLength(10)]
        public string OutInFlagName { get; set; }

        [StringLength(128)]
        public string ListNo { get; set; }

        [StringLength(128)]
        public string Code { get; set; }

        [StringLength(128)]
        public string Name { get; set; }

        [StringLength(128)]
        public string SerialNo { get; set; }

        [StringLength(128)]
        public string IssueProjectNo { get; set; }

        [StringLength(100)]
        public string PlaceCode { get; set; }

        public DateTime? OccurrenceTime { get; set; }

        public int? IsSendToMes { get; set; }

        [StringLength(100)]
        public string IsSendToMesStr { get; set; }

        public int? SendToMesCount { get; set; }

        public DateTime? SendToMesTime { get; set; }

        [StringLength(128)]
        public string MesRet { get; set; }

        [StringLength(128)]
        public string Remark { get; set; }

        [StringLength(128)]
        public string Creator { get; set; }

        public DateTime? CreateTime { get; set; }

        [StringLength(128)]
        public string LastModifier { get; set; }

        public DateTime? LastModifyTime { get; set; }
    }
}

 DEmon/iWareDataCore/Test_ORM/Test_ORM.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,40 @@
//using System;
//using System.ComponentModel.DataAnnotations.Schema;
//using System.Data.Entity;
//using System.Linq;

//namespace iWareDataCore.Test_ORM
//{
//    public partial class Test_ORM : DbContext
//    {
//        public Test_ORM()
//            : base("name=Test_ORM")
//        {
//        }

//        public virtual DbSet<Wms_outInStockRecord_V2_Mes> Wms_outInStockRecord_V2_Mes { get; set; }

//        protected override void OnModelCreating(DbModelBuilder modelBuilder)
//        {
//            modelBuilder.Entity<Wms_outInStockRecord_V2_Mes>()
//                .Property(e => e.OutInFlagName)
//                .IsUnicode(false);

//            modelBuilder.Entity<Wms_outInStockRecord_V2_Mes>()
//                .Property(e => e.PlaceCode)
//                .IsUnicode(false);

//            modelBuilder.Entity<Wms_outInStockRecord_V2_Mes>()
//                .Property(e => e.IsSendToMesStr)
//                .IsUnicode(false);

//            modelBuilder.Entity<Wms_outInStockRecord_V2_Mes>()
//                .Property(e => e.Creator)
//                .IsUnicode(false);

//            modelBuilder.Entity<Wms_outInStockRecord_V2_Mes>()
//                .Property(e => e.LastModifier)
//                .IsUnicode(false);
//        }
//    }
//}

 DEmon/iWareDataCore/iWareDataCore.csproj

@@ -257,6 +257,8 @@
    <Compile Include="TASK\Service\MainTaskViewService.cs" />
    <Compile Include="TASK\Service\PartTaskService.cs" />
    <Compile Include="TASK\Service\PartTaskViewService.cs" />
    <Compile Include="Test_ORM\Test_ORM.cs" />
    <Compile Include="ORM\Wms_outInStockRecord_V2_Mes.cs" />
    <Compile Include="WebDav\Entity\FileInfo.cs" />
    <Compile Include="WebDav\Service\FileService.cs" />
  </ItemGroup>