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();
}
}
static void Main(string[] args)
{
H调试.初始化();
if (!Environment.UserInteractive)
{
var ServicesToRun = new ServiceBase[] { new Service1() };
ServiceBase.Run(ServicesToRun);
return;
}
if (System.Diagnostics.Debugger.IsAttached)
{
var __B控制器 = new B控制器();
__B控制器.配置();
__B控制器.开启();
Application.Run(new F对话框_确定("程序处于调试模式, 按确定键关闭", "GIS服务器 - 调试模式 " + H调试.查询版本()));
__B控制器.关闭();
return;
}
HUI线程.初始化();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
H容器.注入 <ID数据库, D数据库>();
H容器.注入 <IB数据库, B数据库>();
Application.Run(new F空窗口(new F主窗口(), "GIS服务器 - 运行环境 " + H调试.查询版本()));
}
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 处理事件()
{
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);
}
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;
}
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();
}
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}", 务名称, 进程名称));
}
}
}
}
}
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状态.停止显示);
}
static void Main()
{
H调试.初始化();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new F主窗口());
}
private int 批量增加GPS(ref string __当前表)
{
var __上报数据列表 = new List <M号码位置>();
M号码位置 __上报数据;
//while ((_上报数据列表.TryTake(out __上报数据) || _上报数据列表.IsAddingCompleted) && !_上报数据列表.IsCompleted)
while (_数据缓存.TryTake(out __上报数据))
{
__上报数据列表.Add(__上报数据);
}
if (__上报数据列表.Count == 0)
{
return(0);
}
foreach (var __分组 in __上报数据列表.GroupBy(x => x.GPS.时间.Date))
{
var __表名 = _表前缀 + __分组.Key.ToString("yyyyMMdd");
if (__当前表 != __表名)
{
var __sql = string.Format(_建一天位置表, __表名);
Let.Us.Retry(1000, 100, null, exs => H调试.记录致命("建一天位置表失败:" + exs.Last().Message)).Do(() =>
{
using (var __连接 = new SqlConnection(_连接字符串))
{
SQLHelper.ExecuteNonQuery(__连接, __sql);
}
});
__当前表 = __表名;
}
批量增加(__表名, __上报数据列表);
}
return(__上报数据列表.Count);
}
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);
}
}
static void Main()
{
H调试.初始化();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
//Application.Run(new F空窗口(new F主窗口(), "地图应用示例"));
Application.Run(new F空窗口(new F登录(), "连接到GIS服务器"));
}
static void Main()
{
H调试.初始化();
H日志输出.设置(__日志 => H调试.记录(__日志.概要, __日志.等级, __日志.详细, __日志.方法, __日志.文件, __日志.行号), TraceEventType.Warning);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new F主窗口());
}
public void 关闭()
{
H调试.记录提示("关闭");
if (_监听器 != null)
{
_监听器.Close();
}
已开启 = false;
}
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", __失败列表)));
}
}
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)
{
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;
}
void 设置连接状态()
{
if (this.InvokeRequired)
{
this.BeginInvoke(new Action(设置连接状态));
return;
}
if (_F主窗口 != null)
{
_F主窗口.标题 = "GIS服务器管理工具 " + H调试.查询版本() + (_IT客户端.连接正常 ? "" : " | 断开");
}
}
void _IV_请求隐藏号码(string __号码)
{
if (!_当前显示号码集.ContainsKey(__号码))
{
H调试.记录(_类型名 + ": _IV_请求隐藏号码", __号码 + "不在当前显示号码集中");
return;
}
if (_当前显示号码集[__号码].绘图标识.HasValue)
{
_IF地图.除点(_当前显示号码集[__号码].绘图标识.Value);
}
_当前显示号码集.Remove(__号码);
}
void 开始加载()
{
H调试.记录(_类型名 + ": 开始加载");
//订阅事件
_IB订阅.位置更新 += _IB订阅_GPS数据上报;
_IB订阅.GPS更新状态变化 += _IB订阅_GPS更新状态变化;
_IV.处理定位号码 = _IV_请求定位号码;
_IV.处理定位号码集 = _IV_请求定位号码集;
_IV.处理显示号码 = _IV_请求显示号码;
_IV.处理显示号码集 = _IV_请求显示号码集;
_IV.处理隐藏号码 = _IV_请求隐藏号码;
_IV.处理隐藏号码集 = _IV_请求隐藏号码集;
_IV.处理矩形圈选结束 = _IV_矩形圈选结束;
_IV.处理圆形圈选结束 = _IV_圆形圈选结束;
_IF地图 = _IV.IF地图;
_IF地图.进入点 += IF地图_进入点;
_IF地图.离开点 += IF地图_离开点;
_IF地图.单击点 += IF地图_单击点;
//初始化资源
var __地图路径列表 = _IB地图路径.查询();
if (__地图路径列表.Count == 0)
{
_IV.显示操作失败("拷贝地图文件到程序目录的\"GIS资源\\离线地图\"目录!");
}
else if (!__地图路径列表.Values.ToList().Contains(true))
{
_IV.显示操作失败("请配置地图路径!");
}
else
{
try
{
foreach (var kv in __地图路径列表)
{
if (kv.Value)
{
_IV.IF地图.加载地图(kv.Key);
}
}
_IV.IF地图.应用地图(_IV.IF地图.所有地图源[0]);
}
catch (Exception ex)
{
_IV.显示操作失败(ex.Message);
}
}
}
/// <summary>
/// EXCEPTION_EXECUTE_HANDLER == 1 表示我已经处理了异常,可以优雅地结束了
/// EXCEPTION_CONTINUE_SEARCH == 0 表示我不处理,其他人来吧,于是windows调用默认的处理程序显示一个错误框,并结束
/// EXCEPTION_CONTINUE_EXECUTION e== -1 表示错误已经被修复,请从异常发生处继续执行。
/// </summary>
/// <param name="a"></param>
/// <returns></returns>
private static Int32 最后处理异常(ref long a)
{
var __文件名 = "未处理异常";
if (!_获取是否DotNet异常())
{
H调试.记录致命("！！！跨平台(P/INVOKE)调用异常 ！！！");
__文件名 = "跨平台调用异常";
}
__文件名 += DateTime.Now.ToString("yyyy年MM月dd日 HH时mm分ss秒");
记录(string.Format("{0}\\{1}.dmp", H调试.日志目录, __文件名));
H调试.截屏(__文件名);
return(1);
}
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 static void 设置()
{
if (!_已初始化)
{
_已初始化 = true;
}
else
{
return;
}
H调试.初始化();
H容器.注入 <IB服务器配置, B服务器配置>();
H容器.注入 <IBGPS状态配置, BGPS状态配置>();
H容器.注入 <IB地图路径配置, B地图路径配置>();
H容器.注入 <IB回放_按时间, B回放_按时间>();
H容器.注入 <IB回放_按频率, B回放_按频率>();
}
public static void 开启(string __服务名, System.TimeSpan __超时)
{
var __服务 = ServiceController.GetServices().ToList().Find(q => q.ServiceName == __服务名);
if (__服务 != null && __服务.Status != ServiceControllerStatus.Running)
{
__服务.Start();
__服务.WaitForStatus(ServiceControllerStatus.Running, __超时);
}
else
{
if (__服务 == null)
{
H调试.记录提示(string.Format("服务 {0} 不存在", __服务名));
return;
}
H调试.记录提示(string.Format("服务 {0} 正在运行, 无需开启", __服务名));
}
}
public static void 关闭(string __服务名, System.TimeSpan __超时)
{
var __服务 = ServiceController.GetServices().ToList().Find(q => q.ServiceName == __服务名);
if (__服务 != null && __服务.Status == ServiceControllerStatus.Running)
{
__服务.Stop();
__服务.WaitForStatus(ServiceControllerStatus.Stopped, __超时);
}
else
{
if (__服务 == null)
{
H调试.记录提示(string.Format("服务 {0} 不存在", __服务名));
return;
}
H调试.记录提示(string.Format("服务 {0} 没在运行中, 当前状态: {1}", __服务名, __服务.Status));
}
}
public bool 执行(T请求 __业务, T上下文 __上下文)
{
foreach (var __审批 in __步骤列表)
{
try
{
var __结束 = __审批.处理(__业务, ref __上下文);
if (__结束)
{
return(true);
}
}
catch (Exception ex)
{
H调试.记录异常(ex);
}
}
return(true);
}
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();
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
this.out标题.Text += " " + Assembly.GetExecutingAssembly().GetName().Version;
this.out设备列表.ShowNodeToolTips = true;
this.out设备列表.NodeMouseDoubleClick += out设备列表_NodeMouseDoubleClick;
this.do设备_断开.Click += do设备_断开_Click;
this.out设备菜单.Opening += out设备菜单_Opening;
this.out设备列表.MouseDown += TV_MouseDown;
this.do编辑设备.Click += do编辑设备_Click;
this.do折叠.Click += (sender, e1) => this.splitContainer1.Panel1Collapsed = !this.splitContainer1.Panel1Collapsed;
H日志输出.设置(__日志 => H调试.记录(__日志.概要, __日志.等级, __日志.详细, __日志.方法, __日志.文件, __日志.行号));
加载设备列表();
}
