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);
}
}
});
}