public B数据库()
{
地址 = H程序配置.获取字符串("数据库地址");
称 = H程序配置.获取字符串("数据库名称");
账号 = H程序配置.获取字符串("数据库账号");
密码 = H程序配置.获取字符串("数据库密码");
}
public void 初始化()
{
配置通用访问("数据库");
Task.Factory.StartNew(() =>
{
while (true)
{
检测状态();
Thread.Sleep(10000);
}
});
Task.Factory.StartNew(() =>
{
Thread.Sleep(_清除过期数据延迟);
while (true)
{
try
{
if (GIS数据库正常)
{
On清除过期数据(H程序配置.获取Int32值("保留天数"));
}
}
catch (Exception ex)
{
H日志.记录异常(ex);
}
Thread.Sleep(_清除过期数据频率);
}
});
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
this.do连接.Click += do连接_Click;
this.inIP.SelectedIndexChanged += inIP_SelectedIndexChanged;
_访问记录 = H序列化.FromJSON字符串 <List <M访问记录> >(H程序配置.获取字符串("访问记录"));
if (_访问记录.Count > 0)
{
this.inIP.Items.AddRange(_访问记录.Select(q => string.Format("{0}:{1}", q.IP, q.端口号)).ToArray());
this.inIP.SelectedIndex = 0;
}
this.ParentForm.FormClosing += OnClosing;
var __参数 = Environment.GetCommandLineArgs();
if (__参数.Length > 2)
{
var __地址 = __参数[1];
var __端口号 = __参数[2];
this.inIP2.Text = __地址;
this.in端口号.Text = __端口号;
this.do连接.PerformClick();
}
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
_根节点 = this.out单位列表.Nodes[0];
_根节点.Nodes.Clear();
this.out显示号码.Controls.Add(_F显示号码);
this.out单位列表.AfterCheck += out单位列表_AfterCheck;
this.do重新加载.Click += do重新加载_Click;
this.do清空号码.Click += do清空号码_Click;
this.do重新加载.PerformClick();
this.do折叠.Click += (sender1, e1) => this.splitContainer1.Panel1Collapsed = !this.splitContainer1.Panel1Collapsed;
_F显示号码.out个号列表.CellMouseDoubleClick += Out个号列表_CellMouseDoubleClick;
_F显示号码.out组号列表.CellMouseDoubleClick += Out组号列表_CellMouseDoubleClick;
_F显示号码.out组号列表.CellMouseClick += Out组号列表_CellMouseClick;
_F显示号码.显示GPS.单击标识 += 显示GPS_单击标识;
if (H程序配置.获取Bool值("圈选"))
{
添加简单圈选(_F显示号码._FGPS.地图);
}
}
void do保存_Click(object sender, EventArgs e)
{
H程序配置.设置(new Dictionary <string, string>
{
{ "端口号", this.in端口号.Text },
{ "管理工具路径", this.in管理工具路径.Text }
});
}
public BGPS过滤()
{
_MGPS过滤 = HJSON.反序列化 <MGPS过滤>(H程序配置.获取字符串("GPS过滤"));
var __省 = _MGPS过滤.省;
var __市 = _MGPS过滤.市;
设置区域(__省, __市);
配置通用访问("GPS过滤");
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
this.in端口号.Text = H程序配置.获取字符串("端口号");
this.in管理工具路径.Text = H程序配置.获取字符串("管理工具路径");
this.do保存.Click += do保存_Click;
this.do选择.Click += Do选择_Click;
}
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(__连接, _建最后位置表);
}
});
DataTable __位置表;
Dictionary <int, DataRow> __位置映射;
_最后位置 = 查询最后位置(out __位置表, out __位置映射);
Task.Factory.StartNew(() =>
{
var __当前表 = "";
while (true)
{
var __更新数量 = 0;
Let.Us.DoAndSleep(_批量增加GPS频率, __耗时 => H调试.记录(string.Format("批量增加GPS {1} 条, 耗时 {0} 毫秒", __耗时, __更新数量)))
.Do(() => __更新数量 = 批量增加GPS(ref __当前表));
}
});
Task.Factory.StartNew(() =>
{
while (true)
{
var __更新数量 = 0;
Let.Us.DoAndSleep(_批量更新最后GPS频率, __耗时 => H调试.记录(string.Format("批量更新最后GPS {1} 条, 耗时 {0} 毫秒", __耗时, __更新数量)))
.Do(() => { __更新数量 = 批量更新最后GPS(__位置表, __位置映射); });
//var __秒表 = new Stopwatch();
//__秒表.Start();
//var __更新数量 = 批量更新最后GPS(__位置表, __位置映射);
//__秒表.Stop();
//H调试.记录(string.Format("批量更新最后GPS {1} 耗时 {0} 毫秒", __秒表.Elapsed.TotalMilliseconds, __更新数量));
//var __休眠 = _批量更新最后GPS频率 - (int)__秒表.Elapsed.TotalMilliseconds;
//if (__休眠 > 0)
//{
// Thread.Sleep(__休眠);
//}
}
});
}
void do连接_Click(object sender, EventArgs e)
{
var __ip = this.inIP2.Text;
var __port = this.in端口号.Text;
var __最后访问 = _访问记录.Find(q => q.IP.ToString() == __ip && q.端口号.ToString() == __port);
if (__最后访问 == null)
{
if (!H检测网络.IsHostAlive(__ip, int.Parse(__port), 2000))
{
new F对话框_确定("连接失败").ShowDialog();
return;
}
else
{
__最后访问 = new M访问记录 {
IP = __ip, 端口号 = int.Parse(__port)
};
}
}
else
{
_访问记录.Remove(__最后访问);
}
_访问记录.Insert(0, __最后访问);
H程序配置.设置("访问记录", H序列化.ToJSON字符串(_访问记录));
H日志输出.设置(q =>
{
if (q.等级 <= TraceEventType.Information)
{
if (q.异常 != null)
{
H日志.记录异常(q.异常, q.概要, q.详细, q.等级, q.方法, q.文件, q.行号);
}
else
{
H日志.记录(q.概要, q.等级, q.详细, q.方法, q.文件, q.行号);
}
}
});
_IT客户端 = FT通用访问工厂.创建客户端();
H容器.注入 <IT客户端>(_IT客户端, false);
_IT客户端.自动重连 = true;
_IT客户端.已断开 += q => 设置连接状态();
_IT客户端.已连接 += 设置连接状态;
_IT客户端.连接(new IPEndPoint(IPAddress.Parse(__ip), int.Parse(__port)));
this.ParentForm.ShowInTaskbar = false;
this.ParentForm.Visible = false;
_F主窗口 = new F空窗口(new F主窗口(), "");
设置连接状态();
_F主窗口.FormClosing += OnClosing;
_F主窗口.ShowDialog();
}
public void 设置(List <M插件配置> __配置)
{
__配置.ForEach(q =>
{
var __匹配 = _所有插件.Find(k => k.目录 == q.目录);
if (__匹配 != null)
{
__匹配.启用 = q.启用;
}
});
H程序配置.设置("插件配置", HJSON.序列化(__配置, false).Replace('"', '\''));
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
this.Text += " - " + Assembly.GetExecutingAssembly().GetName().Version.ToString();
this.out来源_文件.Enabled = false;
var __网卡列表 = CaptureDeviceList.Instance.ToList();
this.in网卡.Properties.DisplayFormat.Format = new B显示声卡();
this.in网卡.Properties.Items.AddRange(__网卡列表);
var __当前网卡索引 = H程序配置.获取Int32值("当前网卡索引");
if (__网卡列表.Count > __当前网卡索引)
{
this.in网卡.SelectedIndex = __当前网卡索引;
}
var __项目列表 = _B项目.获取所有();
this.in项目.Properties.Items.AddRange(__项目列表);
var __当前项目索引 = H程序配置.获取Int32值("当前项目索引");
if (__项目列表.Count > __当前项目索引)
{
this.in项目.SelectedIndex = __当前项目索引;
}
_当前项目 = 浅复制(__项目列表[__当前项目索引]);
_设备类型列表.AddRange(_当前项目.设备类型列表);
//this.in设备类型1.DataSource = _设备类型列表;
//this.in设备类型2.DataSource = _设备类型列表;
this.in设备类型11.Items.AddRange(_设备类型列表);
this.in设备类型22.Items.AddRange(_设备类型列表);
this._数据源 = new BindingSource {
DataSource = _当前项目.当前通信设备, AllowNew = true
};
//this.out设备.DataSource = _数据源;
this.out表格控件.DataSource = _数据源;
this.do分析.Click += do分析_Click;
this.do仅录像.Click += do仅录像_Click;
this.do加载模板.Click += do加载模板_Click;
this.do网卡_详细信息.Click += do网卡_详细信息_Click;
this.do文件_导入文件.Click += do文件_导入文件_Click;
this.in项目.SelectedIndexChanged += in项目_SelectedIndexChanged;
this.in来源_文件.CheckedChanged += in来源_CheckedChanged;
//this.in来源_网卡.CheckedChanged += in来源_CheckedChanged;
this.out列表.ValidatingEditor += out列表_ValidatingEditor;
SplashScreenManager.CloseForm(false);
}
void 配置通用访问(string __对象名称)
{
if (!H容器.可取出 <IT服务端>())
{
return;
}
var __IT服务端 = H容器.取出 <IT服务端>();
var __对象 = new M对象(__对象名称, null);
__对象.添加方法("设置连接参数", __实参列表 =>
{
var __账号 = __实参列表["账号"];
var __密码 = __实参列表["密码"];
var __数据源 = __实参列表["数据源"];
保存连接参数(__账号, __密码, __数据源);
return("");
}, E角色.工程, new List <M形参> {
new M形参("账号", "string"), new M形参("密码", "string"), new M形参("数据源", "string")
});
__对象.添加属性("账号", () => 账号, E角色.工程);
__对象.添加属性("密码", () => 密码, E角色.工程);
__对象.添加属性("数据源", () => 地址, E角色.工程);
__对象.添加属性("保留天数", () => H程序配置.获取字符串("保留天数"), E角色.工程);
__对象.添加方法("设置保留天数", __实参列表 =>
{
var __天数 = __实参列表["天数"];
H程序配置.设置("保留天数", __天数);
return("");
}, E角色.工程, new List <M形参> {
new M形参("天数", "int")
});
__对象.添加方法("检测连接", __实参列表 =>
{
var __账号 = __实参列表["账号"];
var __密码 = __实参列表["密码"];
var __数据源 = __实参列表["数据源"];
if (_D数据库.连接SQLSERVER(__账号, __密码, __数据源))
{
if (_D数据库.存在GIS数据库(__账号, __密码, __数据源, 称))
{
return("连接 MS SQL SERVER 成功, GIS数据库已存在");
}
return("连接 MS SQL SERVER 成功, GIS数据库未创建");
}
return("连接 MS SQL SERVER 失败");
}, E角色.工程, new List <M形参> {
new M形参("账号", "string"), new M形参("密码", "string"), new M形参("数据源", "string")
});
__IT服务端.添加对象(__对象名称, () => __对象);
}
private void Do管理工具_Click(object sender, EventArgs e)
{
var __路径 = H程序配置.获取字符串("管理工具路径");
var __绝对路径 = H路径.获取绝对路径(__路径);
if (!H路径.验证文件是否存在(__绝对路径))
{
new F对话框_确定("管理工具不存在").ShowDialog();
return;
}
var __端口号 = H程序配置.获取字符串("端口号");
Process.Start(__绝对路径, "127.0.0.1 " + __端口号);
}
public void 配置()
{
var __调试编解码 = H程序配置.获取Bool值("调试编解码");
H日志输出.设置(q =>
{
if (q.等级 < TraceEventType.Information || __调试编解码)
{
if (q.异常 != null)
{
H日志.记录异常(q.异常, q.概要, q.详细, q.等级, q.方法, q.文件, q.行号);
}
else
{
H日志.记录(q.概要, q.等级, q.详细, q.方法, q.文件, q.行号);
}
}
}, TraceEventType.Verbose);
_IT服务端 = FT通用访问工厂.创建服务端();
_IT服务端.端口 = H程序配置.获取Int32值("端口号");
H容器.注入(_IT服务端, false);
B通用命令.配置(_IT服务端);
H容器.注入 <IB数据库, B数据库>();
H容器.注入 <IB插件, B插件>();
H容器.注入 <IB订阅, B订阅>();
H容器.注入 <IBGPS数据, BGPS数据>();
if (H程序配置.获取Bool值("内存数据库"))
{
H容器.注入 <ID数据库, D数据库_内存>();
H容器.注入 <IDGPS数据, DGPS数据_内存>(__拦截: false);
H容器.注入 <IB日志, B日志_内存>(__拦截: false);
}
else
{
H容器.注入 <ID数据库, D数据库>();
H容器.注入 <IDGPS数据, DGPS数据>(__拦截: false);
H容器.注入 <IB日志, B日志_内存>(__拦截: false); //未保存到数据库
}
H容器.注入 <IBGPS过滤, BGPS过滤>(__拦截: false);
H容器.取出 <IB数据库>().初始化();
H容器.取出 <IB订阅>().初始化();
H容器.取出 <IB插件>().初始化();
H容器.取出 <IBGPS数据>().初始化();
H容器.取出 <IB日志>().初始化();
}
void do分析_Click(object sender, EventArgs e)
{
var __配置 = new M抓包配置
{
项目 = _当前项目,
录像 = this.in来源_文件.Checked
};
_B项目.保存项目映射(_当前项目.称, _当前项目.当前通信设备);
H程序配置.设置("当前项目索引", this.in项目.SelectedIndex.ToString());
if (__配置.录像)
{
var __录像名 = this.in文件.Text.Trim();
if (!File.Exists(__录像名))
{
XtraMessageBox.Show("请选择文件!");
return;
}
var __放映机 = new CaptureFileReaderDevice(__录像名);
__配置.网卡 = __放映机;
显示抓包列表窗口(__配置);
__放映机.Close();
}
else
{
__配置.网卡 = (ICaptureDevice)this.in网卡.SelectedItem;
if (__配置.网卡 == null)
{
XtraMessageBox.Show("请选择网卡!");
return;
}
H程序配置.设置("当前网卡索引", this.in网卡.SelectedIndex.ToString());
var __录像目录 = H路径.获取绝对路径("录像\\");
if (!Directory.Exists(__录像目录))
{
Directory.CreateDirectory(__录像目录);
}
var __录像机 = new CaptureFileWriterDevice(Path.Combine(__录像目录, _当前项目.称 + " " + DateTime.Now.ToString("yyyy-MM-dd hh-mm-ss")));
PacketArrivalEventHandler __处理抓包 = (object sender1, CaptureEventArgs e1) => __录像机.Write(e1.Packet);
__配置.网卡.OnPacketArrival += __处理抓包;
显示抓包列表窗口(__配置);
__配置.网卡.OnPacketArrival -= __处理抓包;
__录像机.Close();
}
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
var __内存数据库 = H程序配置.获取Bool值("内存数据库");
this.in内存数据库.Checked = __内存数据库;
this.inMSSQLSERVER.Checked = !__内存数据库;
this.inMSSQLSERVER.CheckedChanged += InMSSQLSERVER_CheckedChanged;
this.doSQLServer检测.Click += (sender1, e1) => this.outSQL状态.Text = 检测SQLServer();
this.do保存.Click += do保存_Click;
this.doGIS检测.Click += (sender1, e1) => this.outGIS状态.Text = 检测GIS数据库();
this.doGIS创建.Click += doGIS创建_Click;
this.doGIS删除.Click += doGIS删除_Click;
刷新MSSQLSERVER显示();
}
public static void 连接(IPEndPoint __服务器地址, bool __自动重连 = true)
{
if (_IT客户端 == null)
{
H日志输出.设置(q =>
{
if (H程序配置.获取Bool值("调试编解码"))
{
H日志.记录(q.概要, q.等级, q.详细, q.方法, q.文件, q.行号);
}
}, System.Diagnostics.TraceEventType.Verbose);
_IT客户端 = FT通用访问工厂.创建客户端();
_IT客户端.自动重连 = __自动重连;
_IT客户端.已连接 += On已连接;
_IT客户端.已断开 += On已断开;
}
_IT客户端.连接(__服务器地址);
}
private void 配置通用访问(string __对象名称)
{
var __对象 = new M对象(__对象名称, null);
__对象.添加属性("启用", () => _MGPS过滤.启用.ToString(), E角色.工程);
__对象.添加属性("省", () => _MGPS过滤.省, E角色.工程);
__对象.添加属性("市", () => _MGPS过滤.市, E角色.工程);
__对象.添加方法("设置", q =>
{
_MGPS过滤.启用 = bool.Parse(q["启用"]);
_MGPS过滤.省 = q["省"];
_MGPS过滤.市 = q["市"];
H程序配置.设置("GPS过滤", HJSON.序列化(_MGPS过滤, false).Replace('"', '\''));
设置区域(_MGPS过滤.省, _MGPS过滤.市);
return(null);
}, E角色.工程, new List <M形参> {
new M形参("启用", "bool"), new M形参("省", "string"), new M形参("市", "string")
});
_IT服务端.添加对象(__对象名称, () => __对象);
}
public static void 配置(IT服务端 __IT服务端)
{
H容器.注入 <IB名片_S, B名片_S>(true, false, "", __IT服务端);
H容器.注入 <IB系统_S, B系统_S>(true, false, "", __IT服务端);
H容器.注入 <IB状态_S, B状态_S>(true, false, "", __IT服务端);
H容器.注入 <IBFTP_S, BFTP_S>(true, false, "", __IT服务端);
var __版本号 = H程序配置.获取字符串("版本号");
if (string.IsNullOrEmpty(__版本号))
{
__版本号 = H调试.查询版本();
}
H容器.取出 <IB名片_S>().初始化(
new M名片 {
称 = "GIS服务器", 描述 = "", 版本号 = __版本号, 版本时间 = H程序配置.获取字符串("版本时间")
},
new List <M参数>
{
new M参数("IP列表", HJSON.序列化(H网络配置.获取IP配置())),
new M参数("操作系统", Environment.OSVersion.ToString()),
new M参数("64位系统", Environment.Is64BitOperatingSystem.ToString()),
new M参数("登录账号", Environment.UserName),
});
H容器.取出 <IB状态_S>().初始化(null, DateTime.Now);
H容器.取出 <IBFTP_S>();
H容器.取出 <IB系统_S>().初始化(() =>
{
H日志.记录提示("重启");
H服务管理.重启("GIS服务器", new TimeSpan(0, 1, 0));
}, () =>
{
H日志.记录提示("关闭");
H服务管理.关闭("GIS服务器", new TimeSpan(0, 1, 0));
}, () => new List <M版本记录>
{
//new M版本记录{ 版本号 = "1.0.0.0", 修改记录 = "xxx", 标签 = new List<string>{ "a", "b"}},
//new M版本记录{ 版本号 = "1.0.1.0", 修改记录 = "yyy", 标签 = new List<string>{ "a1", "b1"}},
});
}
void do登录_Click(object sender, EventArgs e)
{
var __ip = this.inIP2.Text;
var __port = this.in端口号.Text;
var __最后访问 = _访问记录.Find(q => q.IP.ToString() == __ip && q.端口号.ToString() == __port);
if (__最后访问 == null)
{
if (!H检测网络.IsHostAlive(__ip, int.Parse(__port), 2000))
{
new F对话框_确定("连接失败").ShowDialog();
return;
}
else
{
__最后访问 = new M访问记录 {
IP = __ip, 端口号 = int.Parse(__port)
};
}
}
else
{
_访问记录.Remove(__最后访问);
}
_访问记录.Insert(0, __最后访问);
H程序配置.设置("访问记录", H序列化.ToJSON字符串(_访问记录));
B入口.已断开 += q => 设置连接状态();
B入口.已连接 += 设置连接状态;
B入口.连接(new IPEndPoint(IPAddress.Parse(__ip), int.Parse(__port)), true);
this.ParentForm.ShowInTaskbar = false;
this.ParentForm.Visible = false;
_窗口 = new F空窗口(new F主窗口(), 获取标题())
{
允许设置 = true,
点击设置 = () => new F空窗口(new F配置(), "配置").ShowDialog()
};
_窗口.ShowDialog();
Application.Exit();
}
public F主窗口()
{
InitializeComponent();
this.uTab1.添加("号码本", new F实时显示_号码本(() => H外部服务.获取部门())
{
Dock = DockStyle.Fill
});
//this.uTab1.添加("号码段", new F实时显示_号码段 { Dock = DockStyle.Fill });
this.uTab1.添加("按频率回放", new F按频率回放 {
Dock = DockStyle.Fill
});
this.uTab1.添加("按时间回放", new F按时间回放 {
Dock = DockStyle.Fill
});
if (H程序配置.获取Bool值("开启扩展界面"))
{
this.uTab1.添加("扩展", new F扩展 {
Dock = DockStyle.Fill
});
}
this.uTab1.激活("号码本");
}
static H外部服务()
{
_号码簿地址 = H程序配置.获取字符串("号码簿地址");
}
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.初始化();
});
}
public void 保存连接参数(string __账号, string __密码, string __数据源)
{
H程序配置.设置(new Dictionary <string, string> {
{ "数据库地址", __数据源 }, { "数据库账号", __账号 }, { "数据库密码", __密码 }
});
}
private void InMSSQLSERVER_CheckedChanged(object sender, EventArgs e)
{
刷新MSSQLSERVER显示();
H程序配置.设置("内存数据库", this.in内存数据库.Checked.ToString());
}
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);
}
}
});
}
