/// <summary>
        /// GetWindowTabEventInfos
        /// </summary>
        /// <param name="windowTabId"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public IList <WindowTabEventInfo> GetWindowTabEventInfos(string windowTabId, WindowTabEventManagerType type)
        {
            return(Cache.TryGetCache <IList <WindowTabEventInfo> >(GetCacheKey <WindowTabEventInfo>(windowTabId, type.ToString()), new Func <IList <WindowTabEventInfo> >(delegate()
            {
                IList <WindowTabEventInfo> list = GetInfos <WindowTabEventInfo>("ParentWindowTab.ID = :windowTabId and ManagerType = :type",
                                                                                new Dictionary <string, object> {
                    { "windowTabId", windowTabId }, { "type", type }
                });

                return list;
            })));
        }
Exemple #2
0
        private void AddEvent(WindowTabInfo tabInfo, object manager, WindowTabEventManagerType type)
        {
            var list = ADInfoBll.Instance.GetWindowTabEventInfos(tabInfo.Name, type);

            foreach (var info in list)
            {
                System.Reflection.EventInfo eventInfo = manager.GetType().GetEvent(info.EventName);

                Type handlerType = eventInfo.EventHandlerType;
                //MethodInfo invokeMethod = handlerType.GetMethod("Invoke");
                //ParameterInfo[] parms = invokeMethod.GetParameters();
                //Type[] parmTypes = new Type[parms.Length];
                //for (int i = 0; i < parms.Length; i++)
                //{
                //    parmTypes[i] = parms[i].ParameterType;
                //}
                //Type dType = Expression.GetActionType(parmTypes);
                Delegate d = null;
                switch (type)
                {
                case WindowTabEventManagerType.SearchManager:
                    switch (info.EventName)
                    {
                    case "DataLoaded":
                    {
                        EventHandler <DataLoadedEventArgs> d1 = (sender, e) =>
                        {
                            EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
                        };
                        d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
                    }
                    break;

                    case "DataLoading":
                    {
                        EventHandler <DataLoadingEventArgs> d1 = (sender, e) =>
                        {
                            EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
                        };
                        d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
                    }
                    break;

                    default:
                        throw new ArgumentException("invalid EventName of " + info.EventName);
                    }
                    break;

                case WindowTabEventManagerType.DisplayManager:
                    switch (info.EventName)
                    {
                    case "PositionChanging":
                    {
                        EventHandler <System.ComponentModel.CancelEventArgs> d1 = (sender, e) =>
                        {
                            EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
                        };
                        d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
                    }
                    break;

                    case "PositionChanged":
                    {
                        EventHandler d1 = (sender, e) =>
                        {
                            EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
                        };
                        d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
                    }
                    break;

                    case "SelectedDataValueChanged":
                    {
                        EventHandler <SelectedDataValueChangedEventArgs> d1 = (sender, e) =>
                        {
                            EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
                        };
                        d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
                    }
                    break;

                    default:
                        throw new ArgumentException("invalid EventName of " + info.EventName);
                    }
                    break;

                case WindowTabEventManagerType.ControlManager:
                    switch (info.EventName)
                    {
                    case "BeginningEdit":
                    case "EditBegun":
                    case "EndingEdit":
                    case "EditEnded":
                    case "EditCanceled":
                    case "StateChanged":
                    {
                        EventHandler d1 = (sender, e) =>
                        {
                            EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
                        };
                        d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
                    }
                    break;

                    case "CancellingEdit":
                    {
                        EventHandler <System.ComponentModel.CancelEventArgs> d1 = (sender, e) =>
                        {
                            EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
                        };
                        d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
                    }
                    break;

                    default:
                        throw new ArgumentException("invalid EventName of " + info.EventName);
                    }

                    break;

                case WindowTabEventManagerType.BusinessLayer:
                    break;

                default:
                    throw new ArgumentException("invalid WindowTabEventManagerType of " + type);
                }
                if (d != null)
                {
                    eventInfo.AddEventHandler(manager, d);
                }
            }
        }
        private void AddEvent(WindowTabInfo tabInfo, object manager, WindowTabEventManagerType type)
        {
            var list = ADInfoBll.Instance.GetWindowTabEventInfos(tabInfo.Name, type);
            foreach (var info in list)
            {
                System.Reflection.EventInfo eventInfo = manager.GetType().GetEvent(info.EventName);

                Type handlerType = eventInfo.EventHandlerType;
                //MethodInfo invokeMethod = handlerType.GetMethod("Invoke");
                //ParameterInfo[] parms = invokeMethod.GetParameters();
                //Type[] parmTypes = new Type[parms.Length];
                //for (int i = 0; i < parms.Length; i++)
                //{
                //    parmTypes[i] = parms[i].ParameterType;
                //}
                //Type dType = Expression.GetActionType(parmTypes);
                Delegate d = null;
                switch (type)
                {
                    case WindowTabEventManagerType.SearchManager:
                        switch (info.EventName)
                        {
                            case "DataLoaded":
                                {
                                    EventHandler<DataLoadedEventArgs> d1 = (sender, e) =>
                                    {
                                        EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
                                    };
                                    d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
                                }
                                break;
                            case "DataLoading":
                                {
                                    EventHandler<DataLoadingEventArgs> d1 = (sender, e) =>
                                    {
                                        EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
                                    };
                                    d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
                                }
                                break;
                            default:
                                throw new ArgumentException("invalid EventName of " + info.EventName);
                        }
                        break;
                    case WindowTabEventManagerType.DisplayManager:
                        switch (info.EventName)
                        {
                            case "PositionChanging":
                                {
                                    EventHandler<System.ComponentModel.CancelEventArgs> d1 = (sender, e) =>
                                    {
                                        EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
                                    };
                                    d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
                                }
                                break;
                            case "PositionChanged":
                                {
                                    EventHandler d1 = (sender, e) =>
                                    {
                                        EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
                                    };
                                    d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
                                }
                                break;
                            case "SelectedDataValueChanged":
                                {
                                    EventHandler<SelectedDataValueChangedEventArgs> d1 = (sender, e) =>
                                    {
                                        EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
                                    };
                                    d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
                                }
                                break;
                            default:
                                throw new ArgumentException("invalid EventName of " + info.EventName);
                        }
                        break;
                    case WindowTabEventManagerType.ControlManager:
                        switch (info.EventName)
                        {
                            case "BeginningEdit":
                            case "EditBegun":
                            case "EndingEdit":
                            case "EditEnded":
                            case "EditCanceled":
                            case "StateChanged":
                                {
                                    EventHandler d1 = (sender, e) =>
                                    {
                                        EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
                                    };
                                    d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
                                }
                                break;
                            case "CancellingEdit":
                                {
                                    EventHandler<System.ComponentModel.CancelEventArgs> d1 = (sender, e) =>
                                    {
                                        EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
                                    };
                                    d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
                                }
                                break;
                            default:
                                throw new ArgumentException("invalid EventName of " + info.EventName);
                        }

                        break;
                    case WindowTabEventManagerType.BusinessLayer:
                        break;
                    default:
                        throw new ArgumentException("invalid WindowTabEventManagerType of " + type);
                }
                if (d != null)
                {
                    eventInfo.AddEventHandler(manager, d);
                }
            }
        }