public override void Setup(ApplicationModulesManager moduleManager) {
     base.Setup(moduleManager);
     if (Application != null) {
         Application.UserDifferencesLoaded += OnUserDifferencesLoaded;
         Application.CreateCustomUserModelDifferenceStore += ApplicationOnCreateCustomUserModelDifferenceStore;
     }
 }

        public override void Setup(ApplicationModulesManager moduleManager) {
            base.Setup(moduleManager);
            var businessClassesList = GetAdditionalClasses(moduleManager);
            WCTypesInfo.Instance.Register(businessClassesList);
            if (Application == null || GetPath() == null)
                return;
            Application.SettingUp += ApplicationOnSettingUp;
            if (FullConnectionString != null) {
                var xpoMultiDataStoreProxy = new SqlMultiDataStoreProxy(FullConnectionString, GetReflectionDictionary());
                using (var dataLayer = new SimpleDataLayer(xpoMultiDataStoreProxy)) {
                    using (var session = new Session(dataLayer)) {
                        using (var unitOfWork = new UnitOfWork(session.DataLayer)) {
                            RunUpdaters(session);
                            AddDynamicModules(moduleManager, unitOfWork);
                        }
                    }
                }
            } else {
                var assemblies = AppDomain.CurrentDomain.GetAssemblies().Where(assembly => assembly.ManifestModule.ScopeName.EndsWith(CompileEngine.XpandExtension));
                foreach (var assembly1 in assemblies) {
                    moduleManager.AddModule(assembly1.GetTypes().Where(type => typeof(ModuleBase).IsAssignableFrom(type)).Single());
                }
            }


            Application.SetupComplete += ApplicationOnSetupComplete;

        }

 void AddLayers(ModelApplicationBase modelApplication, ApplicationModulesManager applicationModulesManager, PathInfo pathInfo) {
     var resourceModelCollector = new ResourceModelCollector();
     var dictionary = resourceModelCollector.Collect(applicationModulesManager.Modules.Select(@base => @base.GetType().Assembly), null);
     AddLayersCore(dictionary.Where(pair => !PredicateLastLayer(pair, pathInfo)), modelApplication);
     ModelApplicationBase lastLayer = modelApplication.CreatorInstance.CreateModelApplication();
     modelApplication.AddLayer(lastLayer);
 }

 public override void Setup(ApplicationModulesManager moduleManager) {
     base.Setup(moduleManager);
     if (RuntimeMode && !_comparerIsLock && typeof(IUser).IsAssignableFrom(Application.Security.UserType)) {
         ObjectAccessComparerBase.SetCurrentComparer(new MemberLevelObjectAccessComparer());
         _comparerIsLock = true;
     }
 }

 public override void Setup(ApplicationModulesManager moduleManager)
 {
     base.Setup(moduleManager);
     var registrator = new ValidationRulesRegistrator(moduleManager);
     registrator.RegisterRule(typeof(RuleRequiredForAtLeast1Property), typeof(IRuleRequiredForAtLeast1PropertyProperties));
     registrator.RegisterRule(typeof(RuleFromIPropertyValueValidator), typeof(IRuleFromIPropertyValueValidatorProperties));
 }

 public override void Setup(ApplicationModulesManager moduleManager) {
     base.Setup(moduleManager);
     if (RuntimeMode) {
         AddToAdditionalExportedTypes("Xpand.Persistent.BaseImpl.ImportExport");
         Core.TypesInfo.Instance.RegisterTypes(GetAdditionalClasses(moduleManager));
     }
 }

 public override void Setup(ApplicationModulesManager moduleManager) {
     base.Setup(moduleManager);
     if (RuntimeMode){
         _authentication = new Authentication();
         _authentication.Attach(this);
     }
 }

 public override void Setup(ApplicationModulesManager moduleManager) {
     base.Setup(moduleManager);
     if (Application != null) {
         Application.LoggedOff += Application_LoggedOff;
         Application.Disposed += Application_Disposed;
     }
 }

 ModelApplicationBase GetModelApplication(ApplicationModulesManager applicationModulesManager, PathInfo pathInfo, FileModelStore fileModelStore) {
     var modelApplication = ModelApplicationHelper.CreateModel(XafTypesInfo.Instance, applicationModulesManager.DomainComponents, applicationModulesManager.Modules, applicationModulesManager.ControllersManager, Type.EmptyTypes, fileModelStore.GetAspects(), null, null);
     AddLayers(modelApplication, applicationModulesManager, pathInfo);
     ModelApplicationBase lastLayer = modelApplication.CreatorInstance.CreateModelApplication();
     fileModelStore.Load(lastLayer);
     ModelApplicationHelper.AddLayer(modelApplication, lastLayer);
     return modelApplication;
 }

        public override void Setup(ApplicationModulesManager moduleManager) {
            base.Setup(moduleManager);
//            if (RuntimeMode)
            if (Application != null) {
                Application.SetupComplete += new EventHandler<EventArgs>(Application_SetupComplete);
                Application.CreateCustomCollectionSource += new EventHandler<CreateCustomCollectionSourceEventArgs>(Application_CreateCustomCollectionSource);
            }
        }

        public override void Setup(ApplicationModulesManager moduleManager) {
            base.Setup(moduleManager);

            var modelDifferenceBaseModule = (ModelDifferenceBaseModule)moduleManager.Modules.Where(
                    mbase => typeof(ModelDifferenceBaseModule).IsAssignableFrom(mbase.GetType())).SingleOrDefault();
            if (modelDifferenceBaseModule != null)
                modelDifferenceBaseModule.CreateCustomModelDifferenceStore += ModelDifferenceBaseModuleOnCreateCustomModelDifferenceStore;
        }

 public override void Setup(ApplicationModulesManager moduleManager) {
     base.Setup(moduleManager);
     if (RuntimeMode) {
         AddToAdditionalExportedTypes(new[] { "Xpand.Persistent.BaseImpl.SequenceObject" });
         SequenceObjectType = AdditionalExportedTypes.Single(type => type.FullName == "Xpand.Persistent.BaseImpl.SequenceObject");
         InitializeSequenceGenerator();
     }
 }

 public override void Setup(ApplicationModulesManager moduleManager) {
     base.Setup(moduleManager);
     if (Application != null) {
         var winApplication = Application as WinApplication;
         if (winApplication != null) winApplication.HandleException();
         Application.LoggedOff += Application_LoggedOff;
         Application.Disposed += Application_Disposed;
     }
 }

        public override void Setup(ApplicationModulesManager moduleManager) {
            base.Setup(moduleManager);
            if (Application == null)
                return;
            if (RuntimeMode) {
                AddToAdditionalExportedTypes("Xpand.Persistent.BaseImpl.JobScheduler");
                Application.LoggedOn += ApplicationOnLoggedOn;
            }

        }

 public override void Setup(ApplicationModulesManager moduleManager) {
     base.Setup(moduleManager);
     if (Application != null) {
         Application.LoggingOn += (sender, args) => {
             if (ModelsLoaded.HasValue)
                 LoadModels(!ModelsLoaded.Value);
             ModelsLoaded = true;
         };
     }
 }

 public override void Setup(ApplicationModulesManager moduleManager) {
     base.Setup(moduleManager);
     var modelDifferenceBaseModule = (ModelDifferenceBaseModule)moduleManager.Modules.FirstOrDefault(mbase => mbase is ModelDifferenceBaseModule);
     if (modelDifferenceBaseModule != null)
         modelDifferenceBaseModule.CreateCustomModelDifferenceStore += ModelDifferenceBaseModuleOnCreateCustomModelDifferenceStore;
     var exceptionHandlingWinModule =
         (ExceptionHandlingWinModule)moduleManager.Modules.FindModule(typeof(ExceptionHandlingWinModule));
     if (exceptionHandlingWinModule != null)
         exceptionHandlingWinModule.CustomHandleException += ExceptionHandlingWinModuleOnCustomHandleException;
 }

        public override void Setup(ApplicationModulesManager moduleManager) {
            base.Setup(moduleManager);
            AdditionalExportedTypes.AddRange(ModuleHelper.CollectExportedTypesFromAssembly(Assembly.GetAssembly(typeof(Analysis)), IsExportedType));
            AdditionalExportedTypes.AddRange(ModuleHelper.CollectExportedTypesFromAssembly(Assembly.GetAssembly(typeof(SequenceObject)), IsExportedType));
            AdditionalExportedTypes.AddRange(ModuleHelper.CollectExportedTypesFromAssembly(Assembly.GetAssembly(typeof(ThresholdSeverity)), IsExportedType));
            AdditionalExportedTypes.AddRange(ModuleHelper.CollectExportedTypesFromAssembly(Assembly.GetAssembly(typeof(Customer)), IsExportedType));

            var modelDifferenceBaseModule = (ModelDifferenceBaseModule)moduleManager.Modules.SingleOrDefault(mbase => mbase is ModelDifferenceBaseModule);
            if (modelDifferenceBaseModule != null)
                modelDifferenceBaseModule.CreateCustomModelDifferenceStore += ModelDifferenceBaseModuleOnCreateCustomModelDifferenceStore;
        }

 public void AddDynamicModules(ApplicationModulesManager moduleManager, UnitOfWork unitOfWork){
     Type assemblyInfoType = TypesInfo.Instance.PersistentAssemblyInfoType;
     List<IPersistentAssemblyInfo> persistentAssemblyInfos =
         new XPCollection(unitOfWork, assemblyInfoType).Cast<IPersistentAssemblyInfo>().Where(info => !info.DoNotCompile &&
             moduleManager.Modules.Where(@base => @base.Name == "Dynamic" + info.Name + "Module").FirstOrDefault() ==null).ToList();
     _definedModules = new CompileEngine().CompileModules(persistentAssemblyInfos,GetPath());
     foreach (var definedModule in _definedModules){
         moduleManager.AddModule(definedModule);
     }
     unitOfWork.CommitChanges();
 }

        /// <summary>
        /// Для модулей
        /// </summary>
        public override void Setup(ApplicationModulesManager moduleManager)
        {
            base.Setup(moduleManager);
            // Убираем My Details(информация о текущем пользователе) из панели меню
            DevExpress.ExpressApp.Security.MyDetailsController.CanGenerateMyDetailsNavigationItem = false;

            fileAttachmentsModule = moduleManager.Modules.FindModule<FileAttachmentsWindowsFormsModule>();

            if (fileAttachmentsModule != null)
                fileAttachmentsModule.CustomOpenFileWithDefaultProgram += fileAttachmentsModule_CustomOpenWithDefaultProgram;
        }

        public override void Setup(ApplicationModulesManager moduleManager) {
            base.Setup(moduleManager);
            AddToAdditionalExportedTypes("Xpand.Persistent.BaseImpl.PivotChart");
            try {
                var assembly = Assembly.Load("DevExpress.Persistent.BaseImpl" + XafAssemblyInfo.VersionSuffix);
                TypesInfo.LoadTypes(assembly);
            } catch (FileNotFoundException) {
                throw new TypeLoadException("Please make sure DevExpress.Persistent.BaseImpl is referenced from your application project and has its Copy Local==true");
            }
            var typeInfo = TypesInfo.FindTypeInfo("DevExpress.Persistent.BaseImpl.Analysis").Type;
            AdditionalExportedTypes.Add(typeInfo);

        }