E基本状态 查询服务状态() { ServiceControllerStatus __状态; try { __状态 = H服务管理.查询状态(Program.务名); } catch (M预计异常) { return(E基本状态.未安装); } catch (Exception ex) { H调试.记录异常(ex); throw new M预计异常("查询服务状态失败:{0}", ex.Message); } switch (__状态) { case ServiceControllerStatus.StartPending: case ServiceControllerStatus.Running: return(E基本状态.已启动); case ServiceControllerStatus.StopPending: case ServiceControllerStatus.Stopped: return(E基本状态.未启动); default: throw new ArgumentOutOfRangeException(); } }
private void 处理事件() { var __udp = new UdpClient(_响应地址.Port); __udp.JoinMulticastGroup(_响应地址.Address, 64); new Thread(() => { IPEndPoint __远端 = null; var __响应列表 = new List <IPEndPoint>(); while (true) { var __接收数据 = __udp.Receive(ref __远端); if (__响应列表.Contains(__远端)) { continue; } __响应列表.Add(__远端); var __接收信息 = Encoding.UTF8.GetString(__接收数据); try { var __点名 = HJSON.反序列化 <M点名事件>(__接收信息); On收到事件(__点名); } catch (Exception ex) { H调试.记录异常(ex); } } }) { IsBackground = true }.Start(); }
public void 添加事项 <T>(T __数据, Action <T> __处理数据, H队列性能监控 __监控 = null) { //Debug.WriteLine("{0} 添加事项 {1}", DateTime.Now.ToString("HH:mm:ss.fff"), __数据); var __接收时间 = Environment.TickCount; _任务 = _任务.ContinueWith(q => { if (!_取消标志.IsCancellationRequested) { try { //Debug.WriteLine("{0} 执行事项 {1}", DateTime.Now.ToString("HH:mm:ss.fff"), __数据); if (__监控 == null) { __处理数据(__数据); } else { __监控.监控下执行(_名称, __数据, __接收时间, __处理数据); } } catch (Exception ex) { H调试.记录异常(ex, _名称); } } }, _取消标志.Token); }
private void 响应被点名() { new Thread(() => { var __udp = new UdpClient(_请求地址.Port); __udp.JoinMulticastGroup(_请求地址.Address, 64); IPEndPoint __远端 = null; while (true) { var __接收数据 = __udp.Receive(ref __远端); var __接收信息 = Encoding.UTF8.GetString(__接收数据); try { var __点名条件 = HJSON.反序列化 <M点名条件>(__接收信息); var __事件参数 = _处理被点名 == null ? null : _处理被点名(__点名条件); if (__事件参数 != null) { 发布事件(E事件.点名响应, __事件参数); On设备被点名(__远端); } } catch (Exception ex) { H调试.记录异常(ex); } } }) { IsBackground = true }.Start(); }
private EGPS状态 计算状态(MGPS __位置) { try { var __最后时间 = __位置.时间; var __当前时间 = 时间偏移 == null ? DateTime.Now : 时间偏移(); if (__最后时间.AddSeconds(_失效间隔) < __当前时间) { return(EGPS状态.停止显示); } if (__最后时间.AddSeconds(_很久未更新间隔) < __当前时间) { return(EGPS状态.很久未更新); } if (__最后时间.AddSeconds(_短期未更新间隔) < __当前时间) { return(EGPS状态.短期未更新); } return(EGPS状态.最近更新); } catch (Exception ex) { H调试.记录异常(ex, __位置 == null ? "位置为null" : ""); } return(EGPS状态.停止显示); }
public static void 强制关闭(string 务名称, string 进程名称) { H调试.记录提示(string.Format("准备关闭 {0} 服务", 务名称)); 关闭(务名称); var __服务状态 = 查询状态(务名称); if (__服务状态 != ServiceControllerStatus.Stopped) { H调试.记录提示(string.Format("未能正常关闭服务, 准备关闭 {0} 的进程'{1}'", 务名称, 进程名称)); var __进程列表 = Process.GetProcesses().ToList().FindAll(q => q.ProcessName == 进程名称); H调试.记录提示("找到进程数: " + __进程列表.Count); if (__进程列表.Count > 0) { foreach (var process in __进程列表) { try { process.Kill(); process.WaitForExit(); } catch (Exception ex) { H调试.记录异常(ex, string.Format("关闭服务失败, 服务名称: {0}, 服务进程: {1}", 务名称, 进程名称)); } } } } }
protected override void OnLoad(EventArgs e) { base.OnLoad(e); try { var __对象 = JObject.Parse(_值); var __dic = new Dictionary <string, string>(); foreach (JProperty __属性 in __对象.Properties()) { __dic[__属性.Name] = __属性.Value.ToString(); } if (_元数据列表 != null) { foreach (var __kv in _元数据列表) { var __名称 = __kv.称; var __元数据 = __kv.元数据; this.out值.Rows.Add(__名称, __元数据.类型, __元数据.结构, __dic.ContainsKey(__名称) ? __dic[__名称] : "", __元数据.描述, __元数据.默认值, __元数据.范围); __dic.Remove(__名称); } } foreach (var __kv in __dic) { this.out值.Rows.Add(__kv.Key, "", "", __kv.Value, "", "", ""); } } catch (Exception ex) { MessageBox.Show("行结构解析失败: " + ex.Message + Environment.NewLine + _值); H调试.记录异常(ex, _值); } this.out值.CellDoubleClick += out属性_CellDoubleClick; }
protected override void OnLoad(EventArgs e) { base.OnLoad(e); if (_元数据 != null) { this.out范围.Text = _元数据.范围; this.out类型.Text = _元数据.类型; this.out描述.Text = _元数据.描述; this.out默认值.Text = _元数据.默认值; } else { this.splitContainer1.Panel2Collapsed = true; } try { JArray arr = JArray.Parse(_值); foreach (JValue __值 in arr) { this.out值.Rows.Add(__值.ToString()); } } catch (Exception ex) { MessageBox.Show("列结构解析失败: " + ex.Message + Environment.NewLine + _值); H调试.记录异常(ex, _值); } }
private void 刷新() { try { var __状态 = 查询服务状态(); if (_当前状态 == __状态) { return; } _当前状态 = __状态; switch (__状态) { case E基本状态.未安装: this.u容器1.激活控件(_未安装); break; case E基本状态.未启动: this.u容器1.激活控件(_未启动); break; case E基本状态.已启动: this.u容器1.激活控件(_已启动); break; default: throw new ArgumentOutOfRangeException(); } } catch (Exception ex) { H调试.记录异常(ex); } }
public void 导出日志文件(List <string> 文件列表, string 目录) { IBFTP_C __IBFTP = new BFTP_C(_IT客户端); if (!__IBFTP.运行中) { try { __IBFTP.开启(); } catch (Exception ex) { throw new ApplicationException(string.Format("FTP开启失败, 无法下载:\r\n{0}", ex)); } } var __结果 = 导出日志文件(文件列表); var __失败列表 = new List <string>(); var __下载 = new WebClient(); __结果.ForEach(q => { try { var __最终路径 = Path.Combine(目录, q); var __最终目录 = Path.GetDirectoryName(__最终路径); if (!Directory.Exists(__最终目录)) { Directory.CreateDirectory(__最终目录); } if (H路径.验证文件是否存在("FlashFXP\\flashfxp.exe")) { var __远程路径 = q.Replace('\\', '/'); var __startinfo = new ProcessStartInfo("FlashFXP\\flashfxp.exe", string.Format(" -c4 -download ftp://{0}:{1} -remotepath=\"{2}\" -localpath=\"{3}\"", _IT客户端.设备地址.Address, __IBFTP.端口号, __远程路径, __最终路径)); __startinfo.WindowStyle = ProcessWindowStyle.Hidden; var __进程 = Process.Start(__startinfo); __进程.WaitForExit(2000); __进程.Dispose(); } else { __下载.DownloadFile(string.Format("ftp://{0}:{1}/{2}", _IT客户端.设备地址.Address, __IBFTP.端口号, q), __最终路径); } } catch (Exception ex) { H调试.记录异常(ex); __失败列表.Add(q); } }); __下载.Dispose(); if (__失败列表.Count > 0) { throw new ApplicationException(string.Format("下列文件下载失败:\r\n{0}", string.Join("\r\n", __失败列表))); } }
void do清空_Click(object sender, EventArgs e) { try { _数据表缓存.Clear(); } catch (Exception ex) { H调试.记录异常(ex); } }
protected override void OnLoad(EventArgs e) { base.OnLoad(e); var __数据表 = new DataTable(); var __所有列 = new List <string>(); if (_元数据列表 != null) { foreach (var __kv in _元数据列表) { var __名称 = __kv.称; var __元数据 = __kv.元数据; this.out元数据.Rows.Add(__名称, __元数据.类型, __元数据.结构, __元数据.描述, __元数据.默认值, __元数据.范围); __所有列.Add(__名称); } } else { this.splitContainer1.Panel2Collapsed = true; } try { var __数组 = JArray.Parse(_值); foreach (JObject __对象 in __数组) { foreach (JProperty __属性 in __对象.Properties()) { if (!__所有列.Contains(__属性.Name)) { __所有列.Add(__属性.Name); } } } __所有列.ForEach(q => __数据表.Columns.Add(q)); foreach (JObject __对象 in __数组) { var __row = __数据表.NewRow(); foreach (JProperty __属性 in __对象.Properties()) { __row[__属性.Name] = __属性.Value; } __数据表.Rows.Add(__row); } } catch (Exception ex) { MessageBox.Show("表结构解析失败: " + ex.Message + Environment.NewLine + _值); H调试.记录异常(ex, _值); } this.out值.DataSource = __数据表; this.out值.CellMouseDoubleClick += out值_CellMouseDoubleClick; }
public void 添加事项 <T>(T __数据, Action <T> __处理数据, H队列监控 __监控 = null) { //Debug.WriteLine("{0} 添加事项 {1}", DateTime.Now.ToString("HH:mm:ss.fff"), __数据); if (_已关闭) { return; } var __接收时间 = Environment.TickCount; Action __任务项 = () => { try { //Debug.WriteLine("{0} 执行事项 {1}", DateTime.Now.ToString("HH:mm:ss.fff"), __数据); if (__监控 == null) { __处理数据(__数据); } else { __监控.监控下执行(_名称, __数据, __接收时间, __处理数据); } } catch (Exception ex) { H调试.记录异常(ex, _名称); } }; _队列.Enqueue(__任务项); if (_队列.Count == 1) { Task.Factory.StartNew(() => { Action __事项; while (_队列.TryDequeue(out __事项)) { if (_取消标志.IsCancellationRequested) { break; } __事项(); } if (_已关闭) { _同步信号.Set(); return; } }, _取消标志.Token); } }
public void 开启() { if (!HttpListener.IsSupported) { Debug.WriteLine("Windows XP SP2 or Server 2003 is required to use the HttpListener class."); return; } if (_监听器 != null && _监听器.IsListening) { return; } _监听器 = new HttpListener(); _监听器.Prefixes.Add(string.Format("http://localhost:{0}/", 端口)); _监听器.Prefixes.Add(string.Format("http://127.0.0.1:{0}/", 端口)); var __本机IP列表 = Dns.GetHostAddresses(Dns.GetHostName()).Where(q => q.AddressFamily == AddressFamily.InterNetwork).ToList(); __本机IP列表.ForEach(q => _监听器.Prefixes.Add(string.Format("http://{1}:{0}/", 端口, q))); _监听器.Start(); 已开启 = true; H调试.记录提示("已开启"); new Thread(() => { try { while (_监听器.IsListening) { _监听器.BeginGetContext(处理请求, _监听器).AsyncWaitHandle.WaitOne(); } } catch (Exception ex) { if (已开启) { H调试.记录异常(ex); } } 已开启 = false; }) { IsBackground = true }.Start(); }
public bool 执行(T请求 __业务, T上下文 __上下文) { foreach (var __审批 in __步骤列表) { try { var __结束 = __审批.处理(__业务, ref __上下文); if (__结束) { return(true); } } catch (Exception ex) { H调试.记录异常(ex); } } return(true); }
//private static PerformanceCounter _计数器; public static Dictionary <string, object> 查询当前程序内存消耗() { var __结果 = new Dictionary <string, object>(); try { var __进程 = Process.GetCurrentProcess(); __结果["PrivateMemorySize64"] = __进程.PrivateMemorySize64 / 1024; __结果["WorkingSet64"] = __进程.WorkingSet64 / 1024; //(Physical memory usage) __结果["NonpagedSystemMemorySize64"] = __进程.NonpagedSystemMemorySize64 / 1024; __结果["PagedSystemMemorySize64"] = __进程.PagedSystemMemorySize64 / 1024; __结果["PagedMemorySize64"] = __进程.PagedMemorySize64 / 1024; __结果["VirtualMemorySize64"] = __进程.VirtualMemorySize64 / 1024; __结果["PeakPagedMemorySize64"] = __进程.PeakPagedMemorySize64 / 1024; __结果["PeakVirtualMemorySize64"] = __进程.PeakVirtualMemorySize64 / 1024; __结果["PeakWorkingSet64"] = __进程.PeakWorkingSet64 / 1024; } catch (Exception ex) { H调试.记录异常(ex, "查询当前程序内存消耗"); } return(__结果); }
static void Main() { //Thread.CurrentThread.Name = "UI"; H调试.初始化(); H调试.清除过期调试文件("录像"); H异常.提示不可恢复异常 = 显示不可恢复异常; H异常.提示可恢复异常 = 显示可恢复异常; H异常.自定义处理 = q => { if (q is InvalidOperationException || q is NullReferenceException || q is ArgumentNullException) { H调试.记录异常(q); return(true); } return(false); }; SkinManager.EnableFormSkins(); //DevExpress.UserSkins.BonusSkins.Register(); DevExpress.Utils.AppearanceObject.DefaultFont = new System.Drawing.Font("微软雅黑", 9F); UserLookAndFeel.Default.SetSkinStyle("Office 2013"); //UserLookAndFeel.Default.SetSkinStyle("Metropolis"); Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new F配置()); }
public B订阅_模拟() { var __随机数 = new Random(); Task.Factory.StartNew(() => { int __更新频率 = 8000;//毫秒/次 var __轨迹缓存 = new Dictionary <string, Tuple <double, double> >(); int __数量 = 0; while (true) { try { _订阅列表锁.EnterReadLock(); var __列表 = new List <string>(_订阅列表); if (__列表.Count != __数量) { H调试.记录("模拟订阅数量: " + __列表.Count, TraceEventType.Warning); __数量 = __列表.Count; } _订阅列表锁.ExitReadLock(); var __监视器 = new Stopwatch(); __监视器.Start(); foreach (var __号码 in __列表) { if (!__轨迹缓存.ContainsKey(__号码)) { var __初始经度偏移量 = __随机数.NextDouble() * 0.0002 * __数量 * (__随机数.NextDouble() > 0.5 ? -1 : 1); var __初始纬度偏移量 = __随机数.NextDouble() * 0.0002 * __数量 * (__随机数.NextDouble() > 0.5 ? -1 : 1); __轨迹缓存[__号码] = new Tuple <double, double>(_参照经度 + __初始经度偏移量, _参照纬度 + __初始纬度偏移量); } var __经度 = __轨迹缓存[__号码].Item1 + __随机数.NextDouble() * 0.0005 * (__随机数.NextDouble() > 0.2 ? -1 : 1); var __纬度 = __轨迹缓存[__号码].Item2 + __随机数.NextDouble() * 0.0005 * (__随机数.NextDouble() > 0.2 ? -1 : 1); __轨迹缓存[__号码] = new Tuple <double, double>(__经度, __纬度); On位置更新(__号码, new MGPS { 时间 = DateTime.Now, 精度 = 20, 方向 = 60, 经度 = __经度, 纬度 = __纬度, } ); //Thread.Sleep(__随机数.Next(0, __更新频率 / __数量)); } if (__列表.Count == 0) { Thread.Sleep(1000); } else { __监视器.Stop(); var __耗时 = (int)__监视器.ElapsedMilliseconds; if (__耗时 < __更新频率) { Thread.Sleep(__更新频率 - __耗时); } else { H调试.记录(string.Format("超时: {0}毫秒", __耗时 - __更新频率)); Debug.WriteLine(string.Format("超时: {0}毫秒", __耗时 - __更新频率)); } } } catch (Exception ex) { H调试.记录异常(ex); } } }); }
private void 记录异常(Exception __异常, string __描述 = null, TraceEventType __等级 = TraceEventType.Error) { H调试.记录异常(__异常, __描述, null, __等级); }
public void 初始化() { var __路径 = Path.Combine(Path.GetDirectoryName(Assembly.GetAssembly(typeof(B插件)).Location), "插件"); if (!Directory.Exists(__路径)) { H日志.记录错误("插件目录不存在"); return; } var __子目录 = Directory.GetDirectories(__路径); if (__子目录.Length == 0) { H日志.记录错误("无任何插件"); return; } 配置通用访问("插件"); H日志.记录提示("开始加载插件"); var __插件配置 = HJSON.反序列化 <List <M插件配置> >(H程序配置.获取字符串("插件配置")); Action <string, string> __记录日志 = (__插件名称, __内容) => _IB日志.增加(new DTO.日志.M日志 { 描述 = __内容, 时间 = DateTime.Now, 类别 = __插件名称 }); var __输入插件 = new List <IPluginGPS输入>(); var __输出插件 = new List <IPluginGPS输出>(); for (int i = 0; i < __子目录.Length; i++) { var __目录 = new DirectoryInfo(__子目录[i]).Name; var __入口路径 = Path.Combine(__子目录[i], __目录 + ".dll"); if (!File.Exists(__入口路径)) { continue; } var __输入实例 = H反射.获取实例 <IPluginGPS输入>(__入口路径); if (__输入实例 != null) { __输入插件.Add(__输入实例); var __启用 = 查询启用(__插件配置, __目录); _所有插件.Add(new M插件参数 { 描述 = __输入实例.接口描述, 称 = __输入实例.接口名称, 启用 = __启用, 管理界面 = __输入实例.管理界面, 目录 = __目录 }); if (__启用) { _输入插件列表.Add(__输入实例); } __输入实例.记录日志 = __内容 => __记录日志(__输入实例.接口名称, __内容); } var __输出实例 = H反射.获取实例 <IPluginGPS输出>(__入口路径); if (__输出实例 != null) { __输出插件.Add(__输出实例); var __启用 = 查询启用(__插件配置, __目录); _所有插件.Add(new M插件参数 { 描述 = __输出实例.接口描述, 称 = __输出实例.接口名称, 启用 = __启用, 管理界面 = __输出实例.管理界面, 目录 = __目录 }); if (__启用) { _输出插件列表.Add(__输出实例); } __输出实例.记录日志 = __内容 => __记录日志(__输出实例.接口名称, __内容); } } H日志.记录提示("插件状态", H序列化.ToJSON字符串(_所有插件)); _输入插件列表.ForEach(__插件 => { __插件.GPS上报 += (__号码, __GPS) => { if (!_IBGPS过滤.判断合法(__号码, __GPS)) { return; } OnGps上报(__号码, __GPS); _输出插件列表.ForEach(k => { try { k.接收GPS(__号码, __GPS); } catch (Exception ex) { H调试.记录异常(ex); } }); }; }); _输出插件列表.ForEach(q => { q.初始化(); }); _输入插件列表.ForEach(q => { q.初始化(); }); }
private void 处理原始报文() { while (!_停止后台处理) { var __暂停 = true; lock (_报文处理同步对象) { if (_待处理抓包.Count != 0) { __暂停 = false; } } if (__暂停) { Thread.Sleep(1000); } else { List <RawCapture> __待处理原始报文列表; lock (_报文处理同步对象) { __待处理原始报文列表 = _待处理抓包; _待处理抓包 = new List <RawCapture>(); } Debug.WriteLineIf(__待处理原始报文列表.Count > 100, string.Format("待处理原始报文数量: {0}", __待处理原始报文列表.Count)); if (_配置.录像) { SplashScreenManager.ShowForm(this.FindForm(), typeof(DevExpress.XtraWaitForm.DemoWaitForm), false, true, false); } lock (_数据锁) { _数据表缓存.BeginLoadData(); foreach (RawCapture __原始包 in __待处理原始报文列表) { if (_停止后台处理) { break; } var __原始包缓存 = __原始包; var __基础解析 = Packet.ParsePacket(__原始包缓存.LinkLayerType, __原始包缓存.Data); var __IP层报文 = (IpPacket)__基础解析.Extract(typeof(IpPacket)); if (__IP层报文 == null) { continue; } var __解码前报文 = new M解码前报文 { 时间 = __原始包缓存.Timeval.Date.ToLocalTime(), 发送方IP = __IP层报文.SourceAddress, 接收方IP = __IP层报文.DestinationAddress }; var __udp层报文 = (UdpPacket)__基础解析.Extract(typeof(UdpPacket)); if (__udp层报文 != null) { __解码前报文.TCP = false; __解码前报文.发送方端口号 = __udp层报文.SourcePort; __解码前报文.接收方端口号 = __udp层报文.DestinationPort; __解码前报文.码流 = __udp层报文.PayloadData; } else { var __tcp层报文 = (TcpPacket)__基础解析.Extract(typeof(TcpPacket)); if (__tcp层报文 != null) { __解码前报文.TCP = true; __解码前报文.发送方端口号 = __tcp层报文.SourcePort; __解码前报文.接收方端口号 = __tcp层报文.DestinationPort; __解码前报文.码流 = __tcp层报文.PayloadData; } } if (__解码前报文.码流.Length == 0) { continue; } var __设备映射 = 获取设备类型(__解码前报文.TCP, new IPEndPoint(__解码前报文.发送方IP, __解码前报文.发送方端口号), new IPEndPoint(__解码前报文.接收方IP, __解码前报文.接收方端口号)); if (__设备映射 == null) { continue; } __解码前报文.发送方设备类型 = __设备映射.Item1; __解码前报文.接收方设备类型 = __设备映射.Item2; var __解码后报文 = _配置.项目.解码器(__解码前报文); //验证是否需要过滤 增加解码后报文(__解码后报文); } _数据表缓存.EndLoadData(); _数据表缓存.AcceptChanges(); if (!_配置.录像 && _数据表缓存.Rows.Count > _显示上限) { try { _数据表缓存.Clear(); } catch (Exception ex) { H调试.记录异常(ex, "数据超过上限,清空"); } } if (_锁定最后一行) { this.BeginInvoke(new Action(() => this.out列表.MoveLast())).AsyncWaitHandle.WaitOne(1000);//滚动条始终定位于最下面 } } if (_配置.录像) { SplashScreenManager.CloseForm(false); } } } }
public DGPS数据() { _连接字符串 = new SqlConnectionStringBuilder { DataSource = H程序配置.获取字符串("数据库地址"), UserID = H程序配置.获取字符串("数据库账号"), Password = H程序配置.获取字符串("数据库密码"), InitialCatalog = H程序配置.获取字符串("数据库名称"), IntegratedSecurity = false, UserInstance = false, }.ToString(); Let.Us.Retry(1000, 100, null, exs => H调试.记录致命("建最后位置表失败:" + exs.Last().Message)).Do(() => { using (var __连接 = new SqlConnection(_连接字符串)) { SQLHelper.ExecuteNonQuery(__连接, _建最后位置表); } }); _最后位置 = 查询最后位置(); Task.Factory.StartNew(() => { var __当前表 = ""; while (true) { try { var __更新数量 = 0; Let.Us.DelayAfter(_批量增加GPS频率, __耗时 => { if (__耗时 > 1000) { H调试.记录(string.Format("批量增加GPS {1} 条, 耗时 {0} 毫秒", __耗时, __更新数量)); } }) .Do(() => __更新数量 = 批量增加GPS(ref __当前表)); } catch (Exception ex) { H调试.记录异常(ex); } } }); Task.Factory.StartNew(() => { while (true) { try { var __更新数量 = 0; Let.Us.DelayAfter(_批量更新最后GPS频率, __耗时 => { if (__耗时 > 1000) { H调试.记录(string.Format("批量更新最后GPS {1} 条, 耗时 {0} 毫秒", __耗时, __更新数量)); } }) .Do(() => { __更新数量 = 批量更新最后GPS(); }); } catch (Exception ex) { H调试.记录异常(ex); } } }); }