protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
_BFTP = new BFTP(_客户端);
_BFTP.开关变化 += _BFTP_状态变化;
this.in服务器目录.Items.AddRange(new object[] { "c:", "d:", "e:", "f:", "g:", "/home" });
File.ReadAllLines(H路径.获取绝对路径("默认FTP目录.txt"), Encoding.UTF8).ForEach(q => this.out常用列表.Nodes.Add(q.Replace('\\', '/')));
this.do开启.Click += Do开启_Click;
this.do关闭.Click += Do关闭_Click;
this.do浏览.Click += Do浏览_Click;
this.do编辑.Click += Do编辑_Click;
this.out常用列表.NodeMouseDoubleClick += Out常用列表_NodeMouseDoubleClick;
this.do清空.Click += (sender1, e1) => this.in客户端目录.Clear();
var __运行中 = _BFTP.运行中;
this.out状态.Text = __运行中 ? "运行中" : "未启动";
this.do开启.Enabled = !__运行中;
this.do关闭.Enabled = __运行中;
if (__运行中)
{
this.in端口.Text = _BFTP.端口号.ToString();
this.in服务器目录.Text = _BFTP.目录;
}
else
{
this.in端口.Text = "2121";
}
}
private void 导入(string __文件名)
{
var __json = File.ReadAllText(H路径.获取绝对路径(__文件名), Encoding.UTF8);
var __命令列表 = H序列化.FromJSON字符串 <List <M命令> >(__json);
__命令列表.Sort(new Comparison <M命令>((m, n) => m.类别.CompareTo(n.类别)));
this.out命令列表.Nodes.Clear();
this.out命令列表.Tag = __文件名;
var __所有操作系统 = __命令列表.GroupBy <M命令, string>(q => q.操作系统).OrderBy(q => q.Key);
foreach (var __操作系统 in __所有操作系统)
{
var __父节点 = this.out命令列表.Nodes.Add(__操作系统.Key.IsNotNullOrEmpty() ? __操作系统.Key : "未分类");
var __所有分组 = __操作系统.GroupBy <M命令, string>(q => q.类别).OrderBy(q => q.Key);
foreach (var __分组 in __所有分组)
{
var __子节点 = __父节点.Nodes.Add(__分组.Key.IsNotNullOrEmpty() ? __分组.Key : "未分类");
var __排序分组 = __分组.OrderBy(q => q.称);
foreach (M命令 item in __排序分组)
{
__子节点.Nodes.Add(new TreeNode(item.称)
{
Tag = item, ToolTipText = item.ToString(), BackColor = item.常用 ? Color.LightYellow : Color.White
});
}
}
}
}
private List <M日志文件> 查询日志文件列表(M日志文件查询条件 __条件)
{
if (_日志文件查询 == null)
{
var __日志路径 = H路径.验证目录是否存在("日志") ? "日志" : "";
if (string.IsNullOrEmpty(__日志路径))
{
__日志路径 = H路径.验证目录是否存在("log") ? "log" : "";
}
if (string.IsNullOrEmpty(__日志路径))
{
__日志路径 = H路径.验证目录是否存在("logs") ? "logs" : "";
}
var __文件列表 = Directory.EnumerateFiles(Path.Combine(H路径.序目录, __日志路径), "*.*", SearchOption.AllDirectories).ToList();
// .Select(q => q.Replace(H路径.程序目录 + "\\", ""));
var __结果 = new List <M日志文件>();
__文件列表.ForEach(q =>
{
var __文件 = new FileInfo(q);
__结果.Add(new M日志文件
{
路径 = q.Replace(H路径.序目录 + "\\", ""),
大小 = __文件.Length,
最后修改时间 = __文件.LastWriteTime
});
});
return(__结果);
}
else
{
return(_日志文件查询(__条件));
}
}
void out互联插件_CellContentClick(object sender, DataGridViewCellEventArgs e)
{
if (e.RowIndex < 0)
{
return;
}
if (e.ColumnIndex == this.out互联插件.ColumnCount - 1)
{
var __绑定 = this.out互联插件.Rows[e.RowIndex].Tag as M插件参数;
if (!__绑定.管理界面)
{
return;
}
var __配置程序路径 = string.Format("插件\\{0}.管理工具\\管理工具.exe", __绑定.称);
var __绝对路径 = H路径.获取绝对路径(__配置程序路径, true);
if (!H路径.验证文件是否存在(__绝对路径))
{
new F对话框_确定(__绝对路径 + "不存在, 无法配置").ShowDialog();
return;
}
var __服务器地址 = _IT客户端.设备地址;
var __日志目录 = H路径.获取绝对路径("日志");
Process.Start(__绝对路径, string.Format("{0} {1} {2} {3}", __服务器地址.Address, __服务器地址.Port, __日志目录, __绑定.称));
}
}
public D命令()
{
if (H路径.验证文件是否存在(_文件名))
{
_缓存 = H序列化.FromJSON字符串 <List <M命令> >(File.ReadAllText(H路径.获取绝对路径(_文件名), Encoding.UTF8));
}
}
void 加载图片(PictureBox __图片框, string __图片路径)
{
if (H路径.验证文件是否存在(__图片路径, true))
{
__图片框.ImageLocation = H路径.获取绝对路径(__图片路径, true);
}
}
public BGPS状态配置()
{
var __绝对路径 = H路径.获取绝对路径(_路径);
_XML文档 = XDocument.Load(__绝对路径);
_根节点 = _XML文档.Root.Element("GPS状态配置");
}
public static void 注册(string __程序集文件路径, string __注册类, string __注册方法 = "设置")
{
var __业务层注册类 = Assembly.LoadFrom(H路径.获取绝对路径(__程序集文件路径)).GetType(__注册类);
var __业务层注册类实例 = Activator.CreateInstance(__业务层注册类);
__业务层注册类.GetMethod(__注册方法).Invoke(__业务层注册类实例, null);
}
public B项目()
{
var __绝对路径 = H路径.获取绝对路径(_路径);
_XML文档 = XDocument.Load(__绝对路径);
_根节点 = _XML文档.Root;
}
M对象 创建对象(IT服务端 __IT服务端, B资源监控 __监控, string __对象名称 = "资源监控", string __分类 = "")
{
var __对象 = new M对象(__对象名称, __分类);
__对象.添加属性("配置", () => HJSON.序列化(__监控.配置), E角色.客户, null);
__对象.添加属性("总内存", () => string.Format("{0} GB", __监控.总内存 / 1024), E角色.客户, null);
__对象.添加方法("设置配置", __实参列表 =>
{
var __配置 = HJSON.反序列化 <M资源监控配置>(__实参列表["配置"]);
__监控.配置 = __配置;
File.WriteAllText(H路径.获取绝对路径("资源监控配置.txt"), HJSON.序列化(__配置), Encoding.UTF8);
return("");
}, E角色.客户, null, null);
__对象.添加方法("查询状态", __实参列表 =>
{
return(HJSON.序列化(__监控.查询状态()));
}, E角色.客户, null, null);
__对象.添加事件("告警", E角色.客户, new List <M形参> {
new M形参("描述", "string")
});
__监控.阈值告警 += __描述 =>
{
H业务日志.记录("进程", __描述);
__IT服务端.触发事件(__对象名称, "告警", new Dictionary <string, string> {
{ "描述", __描述 }
});
};
return(__对象);
}
public B服务器配置()
{
var __绝对路径 = H路径.获取绝对路径(_路径);
_XML文档 = XDocument.Load(__绝对路径);
_根节点 = _XML文档.Root.Element("服务器");
}
static H业务日志()
{
if (!Directory.Exists(H路径.获取绝对路径("日志")))
{
Directory.CreateDirectory(H路径.获取绝对路径("日志"));
}
}
void do从文件加载_Click(object sender, EventArgs e)
{
var __窗口 = new OpenFileDialog()
{
Filter = "XML(.xml)|*.xml"
};
if (__窗口.ShowDialog() == DialogResult.OK)
{
var __文件 = __窗口.FileName;
//限制界面
var __等待面板 = new F等待();
this.out设备列表.创建局部覆盖控件(__等待面板, null);
List <M设备> __设备列表 = null;
//配置任务
var __任务 = new Task(() =>
{
//执行后台任务
if (H路径.验证文件是否存在("设备列表.xml"))
{
__设备列表 = 查询设备列表(__文件);
}
});
__任务.ContinueWith(task =>
{
//成功后提示, 并取消限制
__等待面板.隐藏();
if (__设备列表.Count > 0)
{
_设备列表 = __设备列表;
this.out设备列表.加载(__设备列表);
return;
}
},
CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion,
TaskScheduler.FromCurrentSynchronizationContext());
__任务.ContinueWith(task =>
{
//失败后提示, 并取消限制
__等待面板.隐藏();
task.Exception.Handle(q => true);
if (__设备列表 == null)
{
new F对话框_确定("配置文件格式错误!").ShowDialog();
return;
}
},
CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted,
TaskScheduler.FromCurrentSynchronizationContext());
//开始任务
__任务.Start();
}
}
public void 保存(List <string> 已选择的路径)
{
var __绝对路径 = H路径.获取绝对路径(_路径);
_根节点.RemoveAll();
已选择的路径.ForEach(q => _根节点.Add(new XElement("已选择路径", Path.GetFileNameWithoutExtension(q))));
_XML文档.Save(__绝对路径);
}
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 void 保存(MGPS状态配置 参数)
{
var __绝对路径 = H路径.获取绝对路径(_路径);
_根节点.Element("短期未更新间隔").Value = 参数.短期未更新间隔.ToString();
_根节点.Element("很久未更新间隔").Value = 参数.很久未更新间隔.ToString();
_根节点.Element("停止显示间隔").Value = 参数.停止显示间隔.ToString();
_XML文档.Save(__绝对路径);
}
public void 保存(M服务器 配置)
{
_连接配置 = 配置;
var __绝对路径 = H路径.获取绝对路径(_路径);
_根节点.Element("IP").Value = 配置.务器IP.ToString();
_根节点.Element("端口号").Value = 配置.务器端口号.ToString();
_XML文档.Save(__绝对路径);
}
void do撤销_Click(object sender, EventArgs e)
{
if (H路径.验证文件是否存在(_文件名))
{
this.in文本.LoadFile(_文件名);
}
else
{
this.in文本.Clear();
}
}
public static void 记录(string __类别, string __描述)
{
var __文件 = H路径.获取绝对路径(string.Format("日志{1}业务日志 {0}.txt", DateTime.Now.Date.ToString("yyyy-MM-dd"), Program.IsWindows ? "\\" : "/"));
File.AppendAllText(__文件, string.Format("{0} || {1} || {2}\r\n", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), __类别, __描述), Encoding.UTF8);
_缓存.Add(new M业务日志 {
时间 = DateTime.Now, 描述 = __描述, 类别 = __类别
});
if (_缓存.Count > 缓存上限)
{
_缓存.RemoveAt(0);
}
}
public static void 截屏(string __文件名 = null)
{
if (__文件名 == null)
{
__文件名 = string.Format("未处理异常 {0}", DateTime.Now.ToString("yyyy年MM月dd日 HH时mm分ss秒"));
}
Image myImg = new Bitmap(Screen.AllScreens[0].Bounds.Width, Screen.AllScreens[0].Bounds.Height);
Graphics g = Graphics.FromImage(myImg);
g.CopyFromScreen(new Point(0, 0), new Point(0, 0), Screen.AllScreens[0].Bounds.Size);
var __保存路径 = H路径.获取绝对路径(string.Format("{0}\\{1}.jpg", 日志目录, __文件名));
myImg.Save(__保存路径, System.Drawing.Imaging.ImageFormat.Jpeg);
}
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 " + __端口号);
}
private void 保存()
{
_缓存.Sort((n, m) => {
if (m.显示顺序.CompareTo(n.显示顺序) == 0)
{
return(m.文件名.CompareTo(n.文件名));
}
else
{
return(m.显示顺序.CompareTo(n.显示顺序));
}
});
File.WriteAllText(H路径.获取绝对路径(_文件名), H序列化.ToJSON字符串(_缓存), Encoding.UTF8);
}
M对象 创建对象(IT服务端 __IT服务端, B链路监控 __Ping, string __对象名称 = "链路监控", string __分类 = "")
{
var __对象 = new M对象(__对象名称, __分类);
__对象.添加属性("配置", () => HJSON.序列化(__Ping.配置), E角色.客户, null);
__对象.添加方法("查询状态", __实参列表 =>
{
return(HJSON.序列化(__Ping.查询状态()));
}, E角色.客户, null, null);
__对象.添加方法("修改配置", __实参列表 =>
{
var __配置 = HJSON.反序列化 <M链路监控配置>(__实参列表["配置"]);
__Ping.修改配置(__配置);
File.WriteAllText(H路径.获取绝对路径("链路监控配置.txt"), HJSON.序列化(__Ping.配置), Encoding.UTF8);
return("");
}, E角色.客户, new List <M形参>
{
new M形参("配置", new M元数据 {
结构 = E数据结构.对象, 子成员列表 = new List <M子成员> {
new M子成员("超时", new M元数据 {
类型 = "int", 描述 = "毫秒", 默认值 = "1000"
}),
new M子成员("频率", new M元数据 {
类型 = "int", 描述 = "毫秒/次", 默认值 = "1000"
}),
new M子成员("阈值", new M元数据 {
类型 = "int", 描述 = "1-10, 通过10次中成功的次数表示当前通断", 默认值 = "7"
}),
new M子成员("IP列表", new M元数据 {
类型 = "string", 描述 = "ip或域名", 结构 = E数据结构.单值数组
}),
}
}),
}, null);
__对象.添加事件("连接变化", E角色.客户, new List <M形参> {
new M形参("地址", "string"), new M形参("旧", "bool"), new M形参("新", "bool")
});
__Ping.连接变化 += (__地址, __旧, __新) =>
{
H业务日志.记录("链路", string.Format("{0} {1}", __地址, __新 == true ? "通" : "断"));
__IT服务端.触发事件(__对象名称, "连接变化", new Dictionary <string, string> {
{ "地址", __地址 }, { "旧", __旧.ToString() }, { "新", __新.ToString() }
});
};
return(__对象);
}
private void 加载设备列表()
{
this.out设备列表.Nodes.Clear();
var __设备列表 = new List <M设备>();
var __文件 = H路径.打开文件("设备列表.xml");
var __XML文档 = XDocument.Load(__文件);
__文件.Close();
var __根节点 = __XML文档.Root;
foreach (XElement __节点 in __根节点.XPathSelectElements("./设备"))
{
__设备列表.Add(new M设备
{
分类 = __节点.Attribute("分类").Value,
称 = __节点.Attribute("名称").Value,
IP = IPAddress.Parse(__节点.Attribute("IP").Value),
端口号 = int.Parse(__节点.Attribute("端口号").Value)
});
}
var __分类节点 = new Dictionary <string, TreeNode>();
__设备列表.ForEach(q =>
{
var __node = new TreeNode(q.称)
{
Tag = q,
ToolTipText = string.Format("{0}:{1}", q.IP, q.端口号)
};
if (string.IsNullOrEmpty(q.分类))
{
this.out设备列表.Nodes.Add(__node);
}
else
{
if (!__分类节点.ContainsKey(q.分类))
{
__分类节点[q.分类] = this.out设备列表.Nodes.Add(q.分类);
}
__分类节点[q.分类].Nodes.Add(__node);
}
});
if (__设备列表.Count < 30)
{
this.out设备列表.ExpandAll();
}
}
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();
}
}
private static void 配置日志文件输出()
{
var __程序集 = Assembly.GetEntryAssembly() ?? Assembly.GetExecutingAssembly();
var __程序集名称 = __程序集.GetName();
if (string.IsNullOrEmpty(文件名称))
{
文件名称 = __程序集名称.Name + " " + __程序集名称.Version;
}
if (string.IsNullOrEmpty(日志目录))
{
日志目录 = "日志";
}
详细日志 = new H写文件("详细日志")
{
Append = true,
AutoFlush = true,
BaseFileName = 文件名称 + " 详细日志",
Location = LogFileLocation.Custom,
CustomLocation = H路径.获取绝对路径(日志目录, true),
Delimiter = " || ",
DiskSpaceExhaustedBehavior = DiskSpaceExhaustedOption.DiscardMessages,
Encoding = Encoding.UTF8,
LogFileCreationSchedule = LogFileCreationScheduleOption.Daily,
MaxFileSize = 20000000,//20000000
TraceOutputOptions = TraceOptions.ThreadId | TraceOptions.DateTime | TraceOptions.LogicalOperationStack,
Filter = new EventTypeFilter(SourceLevels.All),
};
错误日志 = new H写文件("错误日志")
{
Append = true,
AutoFlush = true,
BaseFileName = 文件名称 + " 错误日志",
Location = LogFileLocation.Custom,
CustomLocation = H路径.获取绝对路径(日志目录, true),
Delimiter = " || ",
DiskSpaceExhaustedBehavior = DiskSpaceExhaustedOption.DiscardMessages,
Encoding = Encoding.UTF8,
LogFileCreationSchedule = LogFileCreationScheduleOption.Daily,
MaxFileSize = 20000000,
TraceOutputOptions = TraceOptions.ThreadId | TraceOptions.DateTime | TraceOptions.LogicalOperationStack,// | TraceOptions.Callstack,
Filter = new EventTypeFilter(SourceLevels.Warning),
};
}
void do编辑设备_Click(object sender, EventArgs e)
{
var __文件名 = H路径.获取绝对路径("设备列表.xml");
try
{
var __原内容 = File.ReadAllText(__文件名, Encoding.UTF8);
Process.Start("notepad.exe", __文件名).WaitForExit();
var __新内容 = File.ReadAllText(__文件名, Encoding.UTF8);
if (__原内容 != __新内容)
{
加载设备列表();
}
}
catch (Exception)
{
throw new ApplicationException("编辑设备列表出错");
}
}
private void Do编辑_Click(object sender, EventArgs e)
{
try
{
var __文件名 = H路径.获取绝对路径("默认FTP目录.txt");
var __原内容 = File.ReadAllText(__文件名, Encoding.UTF8);
Process.Start("notepad.exe", __文件名).WaitForExit();
var __新内容 = File.ReadAllText(__文件名, Encoding.UTF8);
if (__原内容 != __新内容)
{
this.out常用列表.Nodes.Clear();
File.ReadAllLines(H路径.获取绝对路径("默认FTP目录.txt"), Encoding.UTF8).ForEach(q => this.out常用列表.Nodes.Add(q));
}
}
catch (Exception)
{
new F对话框_确定("编辑默认FTP目录出错").ShowDialog();
}
}
public void 配置()
{
INET.H日志输出.设置(q => Console.WriteLine(string.Format("{0}\t{1}\t{2}\n{3}\t{4}({5})\n{6}", q.等级, q.概要, q.详细, q.文件, q.方法, q.行号, q.异常)));
_IT服务端 = FT通用访问工厂.创建服务端();
var __命令行 = new B命令行();
var __命令行对象 = 创建对象(_IT服务端, __命令行);
_IT服务端.添加对象("命令行", () => __命令行对象);
var __进程管理 = new B进程管理();
var __进程管理对象 = 创建对象(_IT服务端, __进程管理);
_IT服务端.添加对象("进程管理", () => __进程管理对象);
var __FTP = new BFTP();
var __FTP对象 = 创建对象(_IT服务端, __FTP);
_IT服务端.添加对象("FTP", () => __FTP对象);
var __链路监控配置 = HJSON.反序列化 <M链路监控配置>(File.ReadAllText(H路径.获取绝对路径("链路监控配置.txt"), Encoding.UTF8));
var __链路监控 = new B链路监控(__链路监控配置);
var __链路监控对象 = 创建对象(_IT服务端, __链路监控);
_IT服务端.添加对象("链路监控", () => __链路监控对象);
var __进程监控配置 = HJSON.反序列化 <M进程监控配置>(File.ReadAllText(H路径.获取绝对路径("进程监控配置.txt"), Encoding.UTF8));
var __进程监控 = new B进程监控(__进程监控配置);
var __进程监控对象 = 创建对象(_IT服务端, __进程监控);
_IT服务端.添加对象("进程监控", () => __进程监控对象);
var __资源监控配置 = HJSON.反序列化 <M资源监控配置>(File.ReadAllText(H路径.获取绝对路径("资源监控配置.txt"), Encoding.UTF8));
var __资源监控 = new B资源监控(__资源监控配置);
var __资源监控对象 = 创建对象(_IT服务端, __资源监控);
_IT服务端.添加对象("资源监控", () => __资源监控对象);
var __业务日志对象 = 创建对象(_IT服务端);
_IT服务端.添加对象("业务日志", () => __业务日志对象);
}
void do编辑设备_Click(object sender, EventArgs e)
{
var __文件名 = H路径.获取绝对路径("设备列表.xml");
try
{
var __原内容 = File.ReadAllText(__文件名);
Process.Start("notepad.exe", __文件名).WaitForExit();
var __新内容 = File.ReadAllText(__文件名);
if (__原内容 != __新内容 && MessageBox.Show("需要重启程序吗?", "重启后生效", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
this.Close();
Process.Start(H路径.获取绝对路径("通用访问工具-命令版.exe"));
}
}
catch (Exception)
{
throw new ApplicationException("编辑设备列表出错");
}
}
