Пример #1
0
        public void 触发事件(string __对象名称, string __事件名称, Dictionary <string, string> __参数列表 = null, List <IPEndPoint> __地址列表 = null)
        {
            var __事件标识 = string.Format(_事件标识结构, __对象名称, __事件名称);

            List <IPEndPoint> __订阅地址列表;

            if (!_所有事件订阅.TryGetValue(__事件标识, out __订阅地址列表))
            {
                return;
            }
            if (__地址列表 == null)
            {
                __地址列表 = new List <IPEndPoint>(__订阅地址列表);
            }
            __地址列表.ForEach(__远端 =>
            {
                if (客户端列表.Contains(__远端))
                {
                    _IN上下文.发送通知(__远端, new M接收事件
                    {
                        对象名称 = __对象名称,
                        实参列表 = M实参.字典转列表(__参数列表),
                        事件名称 = __事件名称,
                    });
                    H日志输出.记录("触发[M订阅事件]", string.Format("{3}-{4}[{0}] {1}.{2}", __远端, __对象名称, __事件名称, 客户端列表.Count, __地址列表.Count), TraceEventType.Information);
                }
                else
                {
                    _所有事件订阅[__事件标识].Remove(__远端);
                }
            });
        }
Пример #2
0
        private bool 处理执行方法(N会话参数 __会话参数)
        {
            var __请求   = __会话参数.负载 as M方法执行请求;
            var __对象名称 = __请求.对象名称;
            var __方法名称 = __请求.方法名称;
            var __参数   = __请求.实参列表;

            if (_所有对象.ContainsKey(__对象名称))
            {
                var __对象 = _所有对象[__对象名称]();
                var __方法 = __对象.明细.方法列表.Find(q => q.称 == __方法名称);
                if (__方法 != null)
                {
                    var __执行成功 = true;
                    var __执行描述 = "";
                    var __返回值  = "";
                    try
                    {
                        __返回值 = __对象.执行方法(__方法名称, M实参.列表转字典(__参数), __会话参数.远端);
                    }
                    catch (Exception ex)
                    {
                        H日志输出.记录(ex);
                        __执行描述 = ex.Message;
                        __执行成功 = false;
                    }
                    var 响应 = new M方法执行结果 {
                        成功 = __执行成功, 描述 = __执行描述, 返回值 = __返回值
                    };
                    __会话参数.发送响应(响应);
                }
            }
            return(true);
        }
Пример #3
0
        public void 处理事件(N会话参数 __会话参数)
        {
            var __事件 = __会话参数.负载 as M接收事件;
            var __键  = string.Format(_事件标识结构, __事件.对象名称, __事件.事件名称);

            if (_事件订阅.查询订阅者数量(__键) == 0)
            {
                //H日志输出.记录("注销[M订阅事件]", string.Format("[{0}] {1}.{2}", __会话参数.远端, __事件.对象名称, __事件.事件名称), TraceEventType.Information);
                if (连接正常)
                {
                    _N主动会话.通知(new M注销事件 {
                        对象名称 = __事件.对象名称, 事件名称 = __事件.事件名称
                    });
                }
                return;
            }
            //H日志输出.记录("触发[M订阅事件]", string.Format("[{0}] {1}.{2}", __会话参数.远端, __事件.对象名称, __事件.事件名称), TraceEventType.Information);
            _事件订阅.触发(__键, M实参.列表转字典(__事件.实参列表));
            On收到了事件(__事件);
        }
Пример #4
0
        byte[] 处理Web接收(HttpListenerContext __上下文, string __页面, Dictionary <string, string> __get参数, Dictionary <string, string> __cookie参数, Dictionary <string, string> __post参数)
        {
            H日志输出.记录(__页面);
            if (__页面 == "/")
            {
                __页面 = "/index.html";
            }
            var __文件名   = __页面.Replace('/', '\\').Remove(0, 1);
            var __最后点位置 = __文件名.LastIndexOf('.');

            if (__最后点位置 < 0)
            {
                return(new byte[0]);
            }
            var __后缀名 = __文件名.Substring(__最后点位置 + 1);

            switch (__后缀名)
            {
            case "png":
                __上下文.Response.ContentType = "image/png";
                break;

            case "html":
                if (__文件名 != "index.html" && (__上下文.Request.Cookies["token"] == null || __上下文.Request.Cookies["token"].Value != _密码))
                {
                    __上下文.Response.Redirect("index.html");
                    return(new byte[0]);
                }
                __上下文.Response.ContentType = "text/html;charset=utf-8";
                break;

            case "k":
                H日志输出.记录(string.Format("页面:{0}, GET参数:{1}, POST参数:{2}", HttpUtility.UrlDecode(__文件名), HJSON.序列化(__get参数, false), HJSON.序列化(__post参数, false)));
                __上下文.Response.ContentType = "application/json;charset=utf-8";
                string __发送;
                switch (__文件名)
                {
                case "login.k":
                    var __密码 = __post参数["password"];
                    if (__密码 == _密码)
                    {
                        var __令牌 = "k";
                        __上下文.Response.Cookies.Add(new Cookie("token", __令牌)
                        {
                            Expires = DateTime.Now.AddDays(1)
                        });
                        __发送 = "{ \"成功\":true}";
                        H日志输出.记录(string.Format("发送 {0}", __发送));
                        return(文本编码(__发送));
                    }
                    __发送 = "{ \"成功\":false, 描述:'密码错误'}";
                    H日志输出.记录(string.Format("发送 {0}", __发送));
                    return(文本编码(__发送));

                case "heart.k":
                    __发送 = HJSON.序列化(DateTime.Now.ToString());
                    return(文本编码(__发送));

                case "objects.k":
                    __发送 = HJSON.序列化(_所有对象().Values.ToList().Select(q => q().概要).ToList().OrderBy(q => q.分类));
                    H日志输出.记录(string.Format("发送 {0}", __发送));
                    return(文本编码(__发送));

                case "object.k":
                    var __对象名称 = __get参数["对象名称"];
                    if (_所有对象().ContainsKey(__对象名称))
                    {
                        var __对象 = _所有对象()[__对象名称]();
                        __发送 = HJSON.序列化(__对象.明细);
                        H日志输出.记录(string.Format("发送 {0}", __发送));
                        return(文本编码(__发送));
                    }
                    return(new byte[0]);

                case "method.k":
                    __对象名称 = __get参数["对象名称"];
                    var __方法名称 = __get参数["方法名称"];
                    var __实参列表 = HJSON.反序列化 <List <M实参> >(__get参数["实参列表"]);
                    if (_所有对象().ContainsKey(__对象名称))
                    {
                        var __对象 = _所有对象()[__对象名称]();
                        var __方法 = __对象.明细.方法列表.Find(q => q.称 == __方法名称);
                        if (__方法 != null)
                        {
                            var __执行成功 = true;
                            var __执行描述 = "";
                            var __返回值  = "";
                            try
                            {
                                __返回值 = __对象.执行方法(__方法名称, M实参.列表转字典(__实参列表), null);
                            }
                            catch (Exception ex)
                            {
                                __执行描述 = ex.Message;
                                __执行成功 = false;
                            }
                            __发送 = HJSON.序列化(new M方法执行结果()
                            {
                                成功 = __执行成功, 描述 = __执行描述, 返回值 = __返回值
                            });
                            H日志输出.记录(string.Format("发送 {0}", __发送));
                            return(文本编码(__发送));
                        }
                    }
                    return(new byte[0]);

                case "property.k":
                    __对象名称 = __get参数["对象名称"];
                    var __属性名称 = __get参数["属性名称"];
                    if (_所有对象().ContainsKey(__对象名称))
                    {
                        var __对象 = _所有对象()[__对象名称]();
                        var __属性 = __对象.明细.属性列表.Find(q => q.称 == __属性名称);
                        if (__属性 != null)
                        {
                            var __执行成功 = true;
                            var __执行描述 = "";
                            var __返回值  = "";
                            try
                            {
                                __返回值 = __对象.计算属性(__属性名称);
                            }
                            catch (Exception ex)
                            {
                                __执行描述 = ex.Message;
                                __执行成功 = false;
                            }
                            __发送 = HJSON.序列化(new M属性值查询结果()
                            {
                                成功 = __执行成功, 描述 = __执行描述, 返回值 = __返回值
                            });
                            H日志输出.记录(string.Format("发送 {0}", __发送));
                            return(文本编码(__发送));
                        }
                    }
                    return(new byte[0]);

                default:
                    return(new byte[0]);
                }

            case "css":
                __上下文.Response.ContentType = "text/css;charset=utf-8";
                break;

            case "js":
                __上下文.Response.ContentType = "application/javascript;charset=utf-8";
                break;

            default:
                return(new byte[0]);
            }
            return(读取资源(string.Format("通用访问.WebUI.{0}", __文件名.Replace('\\', '.'))));
        }
Пример #5
0
        public string 执行方法(string 对象名, string 方法名, Dictionary <string, string> 参数列表 = null, int 超时毫秒 = 3000)
        {
            var __实参列表 = M实参.字典转列表(参数列表);

            return(执行方法(对象名, 方法名, __实参列表, 超时毫秒));
        }