public B服务器配置()
{
var __绝对路径 = H路径.获取绝对路径(_路径);
_XML文档 = XDocument.Load(__绝对路径);
_根节点 = _XML文档.Root.Element("服务器");
}
public B项目()
{
var __绝对路径 = H路径.获取绝对路径(_路径);
_XML文档 = XDocument.Load(__绝对路径);
_根节点 = _XML文档.Root;
}
public D命令()
{
if (H路径.验证文件是否存在(_文件名))
{
_缓存 = H序列化.FromJSON字符串 <List <M命令> >(File.ReadAllText(H路径.获取绝对路径(_文件名), Encoding.UTF8));
}
}
static H业务日志()
{
if (!Directory.Exists(H路径.获取绝对路径("日志")))
{
Directory.CreateDirectory(H路径.获取绝对路径("日志"));
}
}
public BGPS状态配置()
{
var __绝对路径 = H路径.获取绝对路径(_路径);
_XML文档 = XDocument.Load(__绝对路径);
_根节点 = _XML文档.Root.Element("GPS状态配置");
}
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(__对象);
}
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, __日志目录, __绑定.称));
}
}
void 加载图片(PictureBox __图片框, string __图片路径)
{
if (H路径.验证文件是否存在(__图片路径, true))
{
__图片框.ImageLocation = H路径.获取绝对路径(__图片路径, true);
}
}
public static void 注册(string __程序集文件路径, string __注册类, string __注册方法 = "设置")
{
var __业务层注册类 = Assembly.LoadFrom(H路径.获取绝对路径(__程序集文件路径)).GetType(__注册类);
var __业务层注册类实例 = Activator.CreateInstance(__业务层注册类);
__业务层注册类.GetMethod(__注册方法).Invoke(__业务层注册类实例, null);
}
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
});
}
}
}
}
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";
}
}
public void 保存(List <string> 已选择的路径)
{
var __绝对路径 = H路径.获取绝对路径(_路径);
_根节点.RemoveAll();
已选择的路径.ForEach(q => _根节点.Add(new XElement("已选择路径", Path.GetFileNameWithoutExtension(q))));
_XML文档.Save(__绝对路径);
}
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(__绝对路径);
}
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);
}
}
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 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 保存()
{
_缓存.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(__对象);
}
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("编辑设备列表出错");
}
}
public static List <M部门> 获取部门()
{
var __webapi地址 = string.Format("http://{0}/numberbook.k", _号码簿地址);
try
{
var __json = HttpClient.发送请求(__webapi地址, null, "GET", Encoding.UTF8);
File.WriteAllText(H路径.获取绝对路径("部门数据.json", true), __json, Encoding.UTF8);
return(H序列化.FromJSON字符串 <List <M部门> >(__json, false, 50000000) ?? new List <M部门>());
}
catch (Exception ex)
{
H日志.记录提示(string.Format("从webapi {0} 同步失败", __webapi地址), ex.Message);
}
if (!H路径.验证文件是否存在("部门数据.json", true))
{
//File.WriteAllText(H路径.获取绝对路径("部门数据.json", true), HJSON.序列化(H部门测试数据.部门列表), Encoding.UTF8);
return(new List <M部门>());
}
return(H序列化.FromJSON字符串 <List <M部门> >(File.ReadAllText(H路径.获取绝对路径("部门数据.json", true), Encoding.UTF8), false, 20000000) ?? new List <M部门>());
}
private void do仅录像_Click(object sender, EventArgs e)
{
var _网卡 = (ICaptureDevice)this.in网卡.SelectedItem;
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 += __处理抓包;
_网卡.Open();
_网卡.Filter = H公共.获取过滤表达式(_当前项目.当前通信设备);
_网卡.StartCapture();
XtraMessageBox.Show(string.Format("开始时间: {0}, 按OK键终止录像!", DateTime.Now), "录像中", MessageBoxButtons.OK, MessageBoxIcon.Information);
_网卡.OnPacketArrival -= __处理抓包;
_网卡.Close();
__录像机.Close();
}
/// <summary>
/// 该类初始化时, 会自动清除"日志"目录下过期调试文件
/// </summary>
public static void 清除过期调试文件(string __路径, int __保留天数 = 7, int __清除频率小时 = 24)
{
ThreadPool.QueueUserWorkItem(
arg =>
{
while (true)
{
//记录明细("清除调试文件");
try
{
var __日志文件路径 = H路径.获取绝对路径(__路径);
if (Directory.Exists(__日志文件路径))
{
var __目录 = new DirectoryInfo(__日志文件路径);
foreach (var __文件 in __目录.GetFiles())
{
if (__文件.LastWriteTime.AddDays(__保留天数) < DateTime.Now)
{
try
{
__文件.Delete();
}
catch (Exception ex)
{
记录异常(ex);
}
}
}
}
}
catch (Exception ex)
{
//非核心线程,出错仅记录
记录异常(ex);
}
Thread.Sleep(new TimeSpan(__清除频率小时, 0, 0));//一天执行一次
}
});
}
private static void 配置日志文件输出()
{
var __程序集名称 = Assembly.GetEntryAssembly().GetName();
var __日志名称 = __程序集名称.Name + " " + __程序集名称.Version + " ";
_详细日志 = 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,
Filter = new EventTypeFilter(SourceLevels.All),
};
Trace.Listeners.Add(_详细日志);
_错误日志 = 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),
};
Trace.Listeners.Add(_错误日志);
}
public Dictionary <string, bool> 查询()
{
var __结果 = new Dictionary <string, bool>();
var __地图目录 = H路径.获取绝对路径("离线地图");
if (!H路径.验证目录是否存在(__地图目录))
{
return(__结果);
}
var __地图文件列表 = Directory.GetFiles(__地图目录, "*.gmdb");
if (__地图文件列表.Length == 0)
{
return(__结果);
}
foreach (var __文件路径 in __地图文件列表)
{
__结果[__文件路径] = false;
}
var __复制对象 = __结果.DeepClone();
foreach (var xElement in _根节点.Elements("已选择路径"))
{
var __已选择文件 = xElement.Value;
foreach (var kv in __复制对象)
{
var __文件路径 = kv.Key;
var __文件名 = Path.GetFileNameWithoutExtension(__文件路径);
if (__文件名 == __已选择文件)
{
__结果[__文件路径] = true;
}
}
}
return(__结果);
}
