protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
this.out标题.Text = _设备列表[0].分组;
this.out容器.Controls.Clear();
_设备列表.ForEach(__设备 =>
{
var __按钮 = new U按钮
{
大小 = new Size(170, 26),
Tag = __设备,
ContextMenuStrip = this.contextMenuStrip1,
Text = __设备.设备标识,
颜色 = Color.Gray
};
__按钮.Click += 设备_Click;
var __提示 = new StringBuilder();
__提示
.AppendFormat("IP: {0}", __设备.IP).AppendLine()
.AppendFormat("端口号: {0}", __设备.端口号).AppendLine();
this.toolTip1.SetToolTip(__按钮, __提示.ToString());
this.out容器.Controls.Add(__按钮);
__设备.访问入口 = FT通用访问工厂.创建客户端();
__设备.访问入口.自动重连 = true;
__设备.访问入口.已连接 += () => 访问入口_已连接(__设备, __按钮);
__设备.访问入口.已断开 += q => 访问入口_已断开(__设备, __按钮);
ThreadPool.QueueUserWorkItem((arg =>
{
__设备.访问入口.连接(new IPEndPoint(__设备.IP, __设备.端口号));
}));
});
this.do编辑设备.Click += do编辑设备_Click;
}
public F模块列表(IPEndPoint __地址, string __名称)
{
InitializeComponent();
_地址 = __地址;
_名称 = __名称;
访问入口 = FT通用访问工厂.创建客户端();
连接();
this.uTab1.添加("命令行", new F命令行(访问入口)
{
Dock = DockStyle.Fill
});
this.uTab1.添加("FTP", new FFTP(访问入口)
{
Dock = DockStyle.Fill
});
this.uTab1.添加("进程管理", new F进程管理(访问入口)
{
Dock = DockStyle.Fill
});
this.uTab1.添加("监控", new F监控主界面(访问入口)
{
Dock = DockStyle.Fill
});
this.uTab1.激活("命令行");
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
this.out标题.Text += " " + Assembly.GetExecutingAssembly().GetName().Version;
this.do断开设备.Enabled = false;
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.out对象菜单.Opening += out对象菜单_Opening;
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.do客户.Click += do客户_Click;
FT通用访问工厂.设置日志输出(记录信息, 记录异常);
加载设备列表();
}
public static void 连接(IPEndPoint __服务器地址, bool __自动重连 = true)
{
if (_IT客户端 == null)
{
_IT客户端 = FT通用访问工厂.创建客户端();
_IT客户端.自动重连 = __自动重连;
_IT客户端.已连接 += On已连接;
_IT客户端.已断开 += On已断开;
}
_IT客户端.连接(__服务器地址);
}
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 配置()
{
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日志>().初始化();
}
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客户端.连接(__服务器地址);
}
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服务端.添加对象("业务日志", () => __业务日志对象);
}
static void Main()
{
H调试.初始化();
IT服务端 __IT服务端 = FT通用访问工厂.创建服务端();
H容器.注入 <IT服务端>(__IT服务端);
H容器.注入 <IB基本状态, B基本状态>();
H容器.注入 <IB业务, B业务>();
H容器.注入 <IB调试信息, B调试信息>();
var __对象 = new B测试().创建对象();
__IT服务端.添加对象("测试", () => __对象);
__IT服务端.端口 = 8888;
__IT服务端.开启();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
F主窗口 = new F主窗口();
Application.Run(F主窗口);
}
private void 加载设备(IPEndPoint __地址, string __名称 = "")
{
//加载对象
_当前设备 = new M设备 {
IP = __地址.Address, 端口号 = __地址.Port, 称 = __名称
};
this.do断开设备.Enabled = true;
Action __显示连接异常 = () => this.BeginInvoke(new Action(() =>
{
_当前设备.工程对象列表控件.ForeColor = Color.Red;
_当前设备.开发对象列表控件.ForeColor = Color.Red;
_当前设备.客户对象列表控件.ForeColor = Color.Red;
}));
Action __显示连接正常 = () => this.BeginInvoke(new Action(() =>
{
_当前设备.工程对象列表控件.ForeColor = Color.Black;
_当前设备.开发对象列表控件.ForeColor = Color.Black;
_当前设备.客户对象列表控件.ForeColor = Color.Black;
}));
if (_当前设备.访问入口 == null)
{
_当前设备.工程对象列表控件 = new TreeView {
BackColor = Color.WhiteSmoke, BorderStyle = BorderStyle.None, Dock = DockStyle.Fill, ShowNodeToolTips = true, ContextMenuStrip = this.out对象菜单
};
_当前设备.工程对象列表控件.NodeMouseDoubleClick += out对象列表_NodeMouseDoubleClick;
_当前设备.工程对象列表控件.MouseDown += TV_MouseDown;
_当前设备.开发对象列表控件 = new TreeView {
BackColor = Color.WhiteSmoke, BorderStyle = BorderStyle.None, Dock = DockStyle.Fill, ShowNodeToolTips = true, ContextMenuStrip = this.out对象菜单
};
_当前设备.开发对象列表控件.NodeMouseDoubleClick += out对象列表_NodeMouseDoubleClick;
_当前设备.开发对象列表控件.MouseDown += TV_MouseDown;
_当前设备.客户对象列表控件 = new TreeView {
BackColor = Color.WhiteSmoke, BorderStyle = BorderStyle.None, Dock = DockStyle.Fill, ShowNodeToolTips = true, ContextMenuStrip = this.out对象菜单
};
_当前设备.客户对象列表控件.NodeMouseDoubleClick += out对象列表_NodeMouseDoubleClick;
_当前设备.客户对象列表控件.MouseDown += TV_MouseDown;
this.out对象列表容器.添加控件(_当前设备.工程对象列表控件);
this.out对象列表容器.添加控件(_当前设备.开发对象列表控件);
this.out对象列表容器.添加控件(_当前设备.客户对象列表控件);
this.out对象列表容器.激活控件(_当前设备.工程对象列表控件);
_当前设备.对象明细控件 = new UTab()
{
Dock = DockStyle.Fill
};
this.out对象明细容器.添加控件(_当前设备.对象明细控件);
this.out对象明细容器.激活控件(_当前设备.对象明细控件);
var __通知控件 = new F监听事件()
{
Dock = DockStyle.Fill
};
_当前设备.对象明细控件.添加("事件通知", __通知控件);
_当前设备.访问入口 = FT通用访问工厂.创建客户端();
_当前设备.访问入口.收到了事件 += q =>
{
__通知控件.处理通知(q);
};
_当前设备.访问入口.已断开 += __主动 =>
{
if (!__主动)
{
__显示连接异常();
}
};
_当前设备.访问入口.已连接 += __显示连接正常;
初始化对象列表();
__显示连接正常();
//this.do工程.PerformClick();
this.do客户_Click(this.do工程, EventArgs.Empty);
}
else
{
this.out对象明细容器.激活控件(_当前设备.对象明细控件);
if (!_当前设备.访问入口.连接正常)
{
初始化对象列表();
__显示连接正常();
if (_当前设备.视图 == E角色.工程)
{
this.do工程_Click(this.do工程, EventArgs.Empty);
}
if (_当前设备.视图 == E角色.开发)
{
this.do开发_Click(this.do开发, EventArgs.Empty);
}
if (_当前设备.视图 == E角色.客户)
{
this.do客户_Click(this.do开发, EventArgs.Empty);
}
}
}
}
static void 务端()
{
//创建服务器
var __服务端 = FT通用访问工厂.创建服务端();
__服务端.端口 = 8888;
__服务端.开启();
//实际对象
var __基本状态 = new M基本状态();
__基本状态.版本 = "1.0.0.0";
__基本状态.待处理问题.Add(new M问题 {
等级 = E重要性.普通, 内容 = "xxxx"
});
__基本状态.待处理问题.Add(new M问题 {
等级 = E重要性.重要, 内容 = "yyyy"
});
__基本状态.开启时间 = DateTime.Now;
__基本状态.连接设备.Add(new M设备连接 {
IP = IPAddress.Parse("192.168.0.1"), 标识 = "X1", 类型 = "X", 连接中 = true
});
__基本状态.连接设备.Add(new M设备连接 {
IP = IPAddress.Parse("192.168.0.2"), 标识 = "Y1", 类型 = "Y", 连接中 = true
});
__基本状态.位置 = "威尼斯";
__基本状态.业务状态 = new Dictionary <string, string> {
{ "参数1", "参数1值" }, { "参数2", "参数2值" }
};
//可通信对象
var __对象 = new M对象("基本状态", "");
__对象.添加属性("版本", () => __基本状态.版本, E角色.所有, null);//最后一个参数是元数据定义
__对象.添加属性("位置", () => __基本状态.位置, E角色.所有, null);
__对象.添加属性("开启时间", () => __基本状态.开启时间.ToString(), E角色.所有, null);
__对象.添加属性("待处理问题", () => HJSON.序列化(__基本状态.待处理问题), E角色.所有, null);
__对象.添加属性("连接设备", () => HJSON.序列化(__基本状态.连接设备), E角色.所有, null);
__对象.添加属性("业务状态", () => HJSON.序列化(__基本状态.业务状态), E角色.所有, null);
__对象.添加方法("重启", __实参 => {
//处理实参
return(string.Empty); //返回空字符串或者json格式的对象
}, E角色.所有, null, null); //最后两个参数是对参数和返回值的元数据定义
__对象.添加事件("发生了重要变化", E角色.所有, null);
//将对象加入到服务器
__服务端.添加对象("基本状态", () => __对象);
//触发服务器端事件
__服务端.触发事件("基本状态", "发生了重要变化", null, null);//最后两个参数是实参和客户端地址列表(可选)
//创建客户端
var __客户端 = FT通用访问工厂.创建客户端();
__客户端.连接(new IPEndPoint(IPAddress.Any, 8888));
var __版本 = __客户端.查询属性值("基本状态", "版本");
var __待处理问题 = HJSON.反序列化 <List <M问题> >(__客户端.查询属性值("基本状态", "待处理问题"));
__客户端.执行方法("基本状态", "重启", null); //最后一个参数是实参
__客户端.订阅事件("基本状态", "发生了重要变化", __实参 => {
//处理实参
});
}
void 加载设备(IPEndPoint __地址, string __名称 = "")
{
//加载对象
var __设备 = new M设备 {
IP = __地址.Address, 端口号 = __地址.Port, 称 = __名称
};
this.out提示.Visible = false;
this.do断开设备.Enabled = true;
Action __显示连接异常 = () => this.BeginInvoke(new Action(() =>
{
__设备.工程对象列表控件.ForeColor = Color.Red;
__设备.开发对象列表控件.ForeColor = Color.Red;
__设备.客户对象列表控件.ForeColor = Color.Red;
}));
Action __显示连接正常 = () => this.BeginInvoke(new Action(() =>
{
__设备.工程对象列表控件.ForeColor = Color.Black;
__设备.开发对象列表控件.ForeColor = Color.Black;
__设备.客户对象列表控件.ForeColor = Color.Black;
}));
_当前设备 = __设备;
if (__设备.访问入口 == null)
{
__设备.工程对象列表控件 = new TreeView {
BackColor = Color.WhiteSmoke, BorderStyle = BorderStyle.None, Dock = DockStyle.Fill, ShowNodeToolTips = true, ContextMenuStrip = this.out对象菜单
};
__设备.工程对象列表控件.NodeMouseDoubleClick += out对象列表_NodeMouseDoubleClick;
__设备.工程对象列表控件.MouseDown += TV_MouseDown;
__设备.开发对象列表控件 = new TreeView {
BackColor = Color.WhiteSmoke, BorderStyle = BorderStyle.None, Dock = DockStyle.Fill, ShowNodeToolTips = true, ContextMenuStrip = this.out对象菜单
};
__设备.开发对象列表控件.NodeMouseDoubleClick += out对象列表_NodeMouseDoubleClick;
__设备.开发对象列表控件.MouseDown += TV_MouseDown;
__设备.客户对象列表控件 = new TreeView {
BackColor = Color.WhiteSmoke, BorderStyle = BorderStyle.None, Dock = DockStyle.Fill, ShowNodeToolTips = true, ContextMenuStrip = this.out对象菜单
};
__设备.客户对象列表控件.NodeMouseDoubleClick += out对象列表_NodeMouseDoubleClick;
__设备.客户对象列表控件.MouseDown += TV_MouseDown;
this.out对象列表容器.添加控件(__设备.工程对象列表控件);
this.out对象列表容器.添加控件(__设备.开发对象列表控件);
this.out对象列表容器.添加控件(__设备.客户对象列表控件);
this.out对象列表容器.激活控件(__设备.工程对象列表控件);
__设备.对象明细控件 = new UTab()
{
Dock = DockStyle.Fill
};
this.out对象明细容器.添加控件(__设备.对象明细控件);
this.out对象明细容器.激活控件(__设备.对象明细控件);
var __通知控件 = new F通知()
{
Dock = DockStyle.Fill
};
__设备.对象明细控件.添加("通知", __通知控件);
__设备.访问入口 = FT通用访问工厂.创建客户端();
__设备.访问入口.收到了通知 += __通知控件.处理通知;
__设备.访问入口.收到了事件 += q => __通知控件.处理通知(new M通知 {
对象 = q.对象名称, 角色 = E角色.所有, 重要性 = "普通", 概要 = q.事件名称, 详细 = q.实参列表 == null ? "" : string.Join(",", q.实参列表.Select(k => string.Format("{0}:{1}", k.称, k.值)))
});
__设备.访问入口.已断开 += __主动 =>
{
if (!__主动)
{
__显示连接异常();
}
};
__设备.访问入口.已连接 += __显示连接正常;
初始化对象列表(__设备);
__显示连接正常();
//this.do工程.PerformClick();
this.do客户_Click(this.do工程, EventArgs.Empty);
}
else
{
this.out对象明细容器.激活控件(__设备.对象明细控件);
if (!__设备.访问入口.连接正常)
{
初始化对象列表(__设备);
__显示连接正常();
if (__设备.视图 == E角色.工程)
{
this.do工程_Click(this.do工程, EventArgs.Empty);
}
if (__设备.视图 == E角色.开发)
{
this.do开发_Click(this.do开发, EventArgs.Empty);
}
if (__设备.视图 == E角色.客户)
{
this.do客户_Click(this.do开发, EventArgs.Empty);
}
}
}
}
static void Main()
{
H调试.初始化();
H日志输出.设置(__日志 => H调试.记录(__日志.概要, __日志.等级, __日志.详细, __日志.方法, __日志.文件, __日志.行号), TraceEventType.Warning);
var __服务端列表 = new List <IT服务端>();
var __随机数 = new Random();
for (int __端口 = 8001; __端口 <= 8001; __端口++)
{
#region 初始化环境
IT服务端 __IT服务端 = FT通用访问工厂.创建服务端();
__IT服务端.端口 = __端口;
__服务端列表.Add(__IT服务端);
#endregion
#region 配置通用命令
var __标识 = __端口.ToString();
H容器.注入 <IB名片_S, B名片_S>(true, true, __标识, __IT服务端);
H容器.注入 <IB系统_S, B系统_S>(true, true, __标识, __IT服务端);
H容器.注入 <IB状态_S, B状态_S>(true, true, __标识, __IT服务端);
H容器.注入 <IBFTP_S, BFTP_S>(true, true, __标识, __IT服务端);
H容器.取出 <IB名片_S>(__标识).初始化(
new M名片 {
称 = "设备1", 描述 = "描述1", 版本号 = "1.0.0.0", 版本时间 = DateTime.Now.ToString()
},
new List <M参数> {
new M参数("IP列表", "192.168.1.1,202.195.114.1"), new M参数("系统", "Windows 7")
});
H容器.取出 <IB状态_S>(__标识).初始化(null, DateTime.Now);
H容器.取出 <IBFTP_S>(__标识);
H容器.取出 <IB系统_S>(__标识).初始化(() =>
{
Console.WriteLine("重启");
}, () =>
{
Console.WriteLine("关闭");
}, () =>
{
Console.WriteLine("查询版本记录");
return(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"
}
},
});
});
#endregion
#region 交互
//H容器.取出<IBFTP_S>(__标识).开启();
H容器.取出 <IB状态_S>(__标识).设置属性("类别1", "属性1", () => new M业务概要 {
类别 = "类别1", 属性 = "属性1", 当前值 = "1", 正常 = true
});
H容器.取出 <IB状态_S>(__标识).设置属性("类别1", "属性2", () => new M业务概要 {
类别 = "类别1", 属性 = "属性2", 当前值 = "1", 正常 = false
});
Task.Factory.StartNew(() =>
{
for (int i = 0; i < 100; i++)
{
if (i % 8 < 4)
{
H容器.取出 <IB状态_S>(__标识).新增告警(new M上报告警
{
标识 = i.ToString(),
产生时间 = DateTime.Now,
来源设备类型 = "来源设备类型",
来源设备标识 = "来源设备标识",
重要性 = (通用命令.状态.E重要性)(i % 4),
类别 = "类别",
描述 = "描述",
原因 = "原因",
解决方案 = "解决方案"
});
}
else
{
H容器.取出 <IB状态_S>(__标识).清除告警(new M上报清除
{
标识 = (i / 8 * 8 + (8 - i % 8)).ToString(),
来源设备类型 = "来源设备类型",
来源设备标识 = "来源设备标识",
});
}
Thread.Sleep(1000 * __随机数.Next(3, 3));
}
});
#endregion
//break;
}
__服务端列表.ForEach(q => q.开启());
Console.WriteLine("启动完毕, 按回车键关闭");
Console.ReadLine();
Console.WriteLine("关闭中");
__服务端列表.ForEach(q => q.关闭());
Console.WriteLine("按回车键退出");
Console.ReadLine();
}
private void 加载设备(IPEndPoint __地址, string __名称 = "")
{
//加载对象
_当前设备 = new M设备 {
IP = __地址.Address, 端口号 = __地址.Port, 称 = __名称
};
this.do断开设备.Enabled = true;
Action __显示连接异常 = () => this.BeginInvoke(new Action(() =>
{
_当前设备.命令列表控件.ForeColor = Color.Red;
}));
Action __显示连接正常 = () => this.BeginInvoke(new Action(() =>
{
_当前设备.命令列表控件.ForeColor = Color.Black;
}));
if (_当前设备.访问入口 == null)
{
_当前设备.命令列表控件 = new TreeView
{
BackColor = Color.WhiteSmoke,
BorderStyle = BorderStyle.None,
Dock = DockStyle.Fill,
ShowNodeToolTips = true,
HideSelection = false,
ContextMenuStrip = this.out对象菜单
};
_当前设备.命令列表控件.NodeMouseDoubleClick += out对象列表_NodeMouseDoubleClick;
_当前设备.命令列表控件.MouseDown += TV_MouseDown;
this.out命令列表容器.添加控件(_当前设备.命令列表控件);
this.out命令列表容器.激活控件(_当前设备.命令列表控件);
_当前设备.访问入口 = FT通用访问工厂.创建客户端();
_当前设备.命令执行控件 = new F执行方法(_当前设备.访问入口)
{
Dock = DockStyle.Fill
};
this.out命令明细容器.添加控件(_当前设备.命令执行控件);
this.out命令明细容器.激活控件(_当前设备.命令执行控件);
_当前设备.访问入口.收到了事件 +=
q =>
_当前设备.命令执行控件.输出(string.Format("\r\n{0} 收到事件: {1}\r\n", DateTime.Now.ToLongTimeString(),
HJSON.序列化(q)));
_当前设备.访问入口.已断开 += __主动 =>
{
if (!__主动)
{
__显示连接异常();
_当前设备.命令执行控件.输出(string.Format("\r\n{0} 断开连接\r\n", DateTime.Now.ToLongTimeString()));
}
};
_当前设备.访问入口.已连接 += __显示连接正常;
_当前设备.视图 = E角色.客户;
do客户_Click(null, null); //设置样式
__显示连接正常();
}
else
{
this.out命令列表容器.激活控件(_当前设备.命令列表控件);
this.out命令明细容器.激活控件(_当前设备.命令执行控件);
if (_当前设备.视图 == E角色.客户)
{
do客户_Click(null, null);
}
if (_当前设备.视图 == E角色.工程)
{
do工程_Click(null, null);
}
if (_当前设备.视图 == E角色.开发)
{
do开发_Click(null, null);
}
}
}
void out设备列表_NodeMouseDoubleClick(object sender, TreeNodeMouseClickEventArgs e)
{
//加载对象
var __设备 = e.Node.Tag as M设备;
if (__设备 == null)
{
return;
}
if (_当前设备节点 != null)
{
_当前设备节点.BackColor = Color.Gainsboro;
}
_当前设备节点 = e.Node;
_当前设备节点.BackColor = Color.Yellow;
this.out提示.Visible = false;
this.do断开设备.Enabled = true;
Action __显示连接异常 = () => this.BeginInvoke(new Action(() =>
{
e.Node.ForeColor = Color.Red;
__设备.命令列表控件.ForeColor = Color.Red;
}));
Action __显示连接正常 = () => this.BeginInvoke(new Action(() =>
{
e.Node.ForeColor = Color.Black;
__设备.命令列表控件.ForeColor = Color.Black;
}));
_当前设备 = __设备;
if (__设备.访问入口 == null)
{
__设备.命令列表控件 = new TreeView {
BackColor = Color.WhiteSmoke, BorderStyle = BorderStyle.None, Dock = DockStyle.Fill, ShowNodeToolTips = true, HideSelection = false, ContextMenuStrip = this.out对象菜单
};
__设备.命令列表控件.NodeMouseDoubleClick += out对象列表_NodeMouseDoubleClick;
__设备.命令列表控件.MouseDown += TV_MouseDown;
this.out命令列表容器.添加控件(__设备.命令列表控件);
this.out命令列表容器.激活控件(__设备.命令列表控件);
__设备.访问入口 = FT通用访问工厂.创建客户端();
__设备.命令执行控件 = new F执行方法(__设备.访问入口)
{
Dock = DockStyle.Fill
};
this.out命令明细容器.添加控件(__设备.命令执行控件);
this.out命令明细容器.激活控件(__设备.命令执行控件);
__设备.访问入口.收到了通知 += q => __设备.命令执行控件.输出(string.Format("\r\n{0} {1} [{2}] {3} 详细: {4}\r\n", DateTime.Now.ToLongTimeString(), q.重要性, q.对象, q.概要, q.详细));
__设备.访问入口.收到了事件 += q => __设备.命令执行控件.输出(string.Format("\r\n{0} 收到事件: {1}\r\n", DateTime.Now.ToLongTimeString(), HJSON.序列化(q)));
__设备.访问入口.已断开 += __主动 =>
{
if (!__主动)
{
__显示连接异常();
__设备.命令执行控件.输出(string.Format("\r\n{0} 断开连接\r\n", DateTime.Now.ToLongTimeString()));
}
};
__设备.访问入口.已连接 += __显示连接正常;
__设备.视图 = E角色.工程;
do工程_Click(null, null);//设置样式
__显示连接正常();
}
else
{
this.out命令列表容器.激活控件(_当前设备.命令列表控件);
this.out命令明细容器.激活控件(__设备.命令执行控件);
if (__设备.视图 == E角色.工程)
{
do工程_Click(null, null); //设置样式
}
else
{
do开发_Click(null, null); //设置样式
}
}
}
