Exemple #1
0
        protected override T OnCreateInstance()
        {
            T result = default(T);

            TransactionPublic.Run("远程调用", () =>
            {
                var remoteService = CreateRemoteService();
                var proxy         = new RemoteProxy(typeof(T), remoteService, ServiceName);
                result            = (T)proxy.GetTransparentProxy();
            });
            return(result);
        }
Exemple #2
0
        /// <summary>
        /// 调用服务方法
        /// </summary>
        /// <param name="serviceName">服务名称</param>
        /// <param name="functionName">方法名称</param>
        /// <param name="header">协议头</param>
        /// <param name="inputParameters">输入参数</param>
        /// <returns></returns>
        public static byte[] CallService(Dictionary <string, Ref <PaoObject> > serviceList, string serviceName, string functionName, Header header, object[] inputParameters)
        {
            // 获取头信息
            header.CheckNotNullOrEmpty("协议头读取错误!");


            // 设置线程用户
            SecurityPublic.ThreadUser = header.UserToken;

            byte[] result      = null;
            Action callService = () =>
            {
                if (!serviceList.ContainsKey(serviceName))
                {
                    throw new Exception("找不到指定的服务").AddExceptionData("服务名称", serviceName);
                }
                var serviceObject = serviceList[serviceName].Value;
                if (serviceObject == null)
                {
                    throw new Exception("找不到指定的服务").AddExceptionData("服务名称", serviceName);
                }

                // 获取方法
                var method = serviceObject.GetType().GetMethod(functionName
                                                               , BindingFlags.Public | BindingFlags.Instance);
                if (method == null)
                {
                    throw new Exception("找不到指定的服务方法")
                          .AddExceptionData("服务名称", serviceName)
                          .AddExceptionData("方法名称", functionName);
                }

                // 调用方法
                var resultObj = method.Invoke(serviceObject, inputParameters);
                result = Serialize <object>(resultObj);
            };

            // 在事务中调用服务
            var transName = String.Format("{0}.{1}", serviceName, functionName);

            if (header != null && header.Transaction != null)
            {
                TransactionPublic.RunService(header.Transaction, transName, callService);
            }
            else
            {
                TransactionPublic.Run(transName, callService);
            }

            return(result);
        }
Exemple #3
0
        public void Initialize(MDIApplication application)
        {
            _MDIApplication = application;

            Text = _MDIApplication.Caption;

            // 添加菜单项
            if (_MDIApplication.MenuItems.IsNotNullOrEmpty())
            {
                foreach (var menuItem in _MDIApplication.MenuItems)
                {
                    _MDIApplication.MainForm.AddMenuItem(menuItem.Value);
                }
            }

            if (_MDIApplication.Controllers.IsNotNullOrEmpty())
            {
                foreach (var controllerRef in _MDIApplication.Controllers)
                {
                    var controller = controllerRef.Value;
                    TransactionPublic.Run(String.Format("打开控制器:{0}", controller), () =>
                    {
                        controller.CreateAndOpenView(this);
                    });
                }
            }

            // 显示当前用户
            var securityService = _MDIApplication.SecurityService.Value;
            var userInfo        = securityService.GetUserInfo();

            MenuCurrentUser.Caption = userInfo.UserName;

            if (MenuFunction.ItemLinks.Count <= 0)
            {
                MenuFunction.Visibility = DevExpress.XtraBars.BarItemVisibility.Never;
            }
            else
            {
                MenuFunction.Visibility = DevExpress.XtraBars.BarItemVisibility.Always;
            }

            DefaultLayoutData = this.DockManager.GetLayoutData();
            ExtendAddonPublic.SetAddonExtendProperties(_MDIApplication);

            // 加载布局数据
            this.DockManager.SetLayoutData(_MDIApplication.LayoutData);
        }
Exemple #4
0
        /// <summary>
        /// 启动应用程序
        /// </summary>
        /// <param name="loadFromConfig">从配置加载</param>
        /// <param name="configFileName">配置文件名,此文件应该放于应用程序目录</param>
        /// <param name="createApplicationFunc">应用创建函数</param>
        /// <param name="applicationPrepareFunc">准备应用程序</param>
        /// <param name="overwriteConfigFile">覆盖配置文件</param>
        public static void StartApplication(bool loadFromConfig
                                            , string configFileName
                                            , Func <PaoApplication> createApplicationFunc
                                            , Action <PaoApplication> applicationPrepareFunc
                                            , bool overwriteConfigFile = false)
        {
            _AppDirectory = AppDomain.CurrentDomain.SetupInformation.ApplicationBase;
            string configFilePath = Path.Combine(_AppDirectory, configFileName);

            //首先添加默认的日志记录器
            EventPublic.ClearEventProcessor();
            EventPublic.AddEventProcessor(DebugLogger.Default);
            EventPublic.AddEventProcessor(EventLogger.Default);
            PaoApplication app = null;

            TransactionPublic.Run("插件引擎启动", () => {
                TransactionPublic.Run("加载插件库", () =>
                {
                    AddonPublic.AddDirectory(AppDirectory);
                    string libPathString = AppDomain.CurrentDomain.SetupInformation.PrivateBinPath;
                    if (!libPathString.IsNullOrEmpty())
                    {
                        string[] libPaths = libPathString.Split(';');
                        foreach (var libDir in libPaths)
                        {
                            var libPath = GetAbsolutePath(libDir);
                            AddonPublic.AddDirectory(libPath);
                        }
                    }
                    // 重建插件类型列表
                    AddonPublic.RebuildAddonTypeList();
                });

                TransactionPublic.Run("加载配置", () =>
                {
                    if (createApplicationFunc == null)
                    {
                        throw new Exception("创建配置的方法不能为空");
                    }

                    if (loadFromConfig && !File.Exists(configFilePath))
                    {
                        app = IOPublic.ReadObjectFromFile(configFilePath).As <PaoApplication>();
                    }
                    else
                    {
                        // 用应用创建函数启动应用
                        app = createApplicationFunc();
                        if (overwriteConfigFile || !File.Exists(configFilePath))
                        {
                            // 保存配置文件
                            IOPublic.WriteObjectToFile(configFilePath, app);
                        }
                    }

                    if (applicationPrepareFunc != null)
                    {
                        applicationPrepareFunc(app);
                    }
                });
            });

            app.Start();
        }
Exemple #5
0
        /// <summary>
        /// 运行
        /// </summary>
        public void Start()
        {
            // 一个应用中只能有一个默认应用程序
            Default = this;
            TransactionPublic.Run("主应用程序", () =>
            {
                TransactionPublic.Run("应用程序初始化", () =>
                {
                    TransactionPublic.Run("准备启动", OnPreparing);

                    TransactionPublic.Run("本地配置加载", () =>
                    {
                        // 加载本地配置存储
                        if (ConfigStorageDirName.IsNotNullOrEmpty())
                        {
                            ConfigStoragePublic.LoadConfigStorages(AppPublic.GetAbsolutePath(ConfigStorageDirName));
                        }

                        // 加载Application扩展属性
                        ExtendAddonPublic.GetAddonExtendProperties(this);
                    });

                    TransactionPublic.Run("检索全局插件", () => {
                        AddonPublic.SearchRuntimeAddons(this);
                    });

                    #region 事件
                    TransactionPublic.Run("事件处理机准备", () =>
                    {
                        if (!EventProcessorList.IsNullOrEmpty())
                        {
                            EventPublic.ClearEventProcessor();
                            foreach (var EventProcessor in EventProcessorList)
                            {
                                var logObj = EventProcessor.Value;
                                EventPublic.AddEventProcessor(logObj);
                            }
                        }
                    });
                    #endregion 日志

                    #region  务器
                    TransactionPublic.Run("启动服务器列表", () =>
                    {
                        if (ServerList.IsNotNullOrEmpty())
                        {
                            foreach (var server in ServerList)
                            {
                                var serverObj = server.Value;
                                if (serverObj == null)
                                {
                                    throw new Exception("服务创建失败");
                                }
                                serverObj.Start();
                                EventPublic.Information("服务{0}启动完毕.", serverObj.ObjectToString());
                            }
                        }
                    });
                    #endregion  务
                });

                #region  序
                TransactionPublic.Run("启动程序", Run);
                #endregion  序

                TransactionPublic.Run("应用程序退出", () =>
                {
                    TransactionPublic.Run("扩展属性保存", () =>
                    {
                        // 保存本地配置存储
                        if (ConfigStorageDirName.IsNotNullOrEmpty())
                        {
                            ConfigStoragePublic.SaveConfigStorages(AppPublic.GetAbsolutePath(ConfigStorageDirName));
                        }
                    });
                });
            }, OnException);
        }