protected IEnumerable<ModelApplicationBase> GetAllLayers(IEnumerable<ModelDifferenceObject> differenceObjects, ModelApplicationBase master) {
     if (GetttingNonAppModels(differenceObjects))
         differenceObjects = differenceObjects.Where(o => o.CombineOrder < CombineOrder);
     var modelApplicationBases = differenceObjects.Distinct().Select(differenceObject => differenceObject.GetModel(master));
     modelApplicationBases = modelApplicationBases.Concat(new List<ModelApplicationBase> { GetModel(master) });
     return modelApplicationBases;
 }

        protected override void ReplaceLayer(ModelApplicationBase model, ModelApplicationBase layer, bool isCurrentUserModel, ShowViewParameters showViewParameters){
            
            var showViewStrategyBase = (WinShowViewStrategyBase)Application.ShowViewStrategy;
            var modelApplicationBase = ((ModelApplicationBase)Application.Model);
            var lastLayer = modelApplicationBase.LastLayer;
            modelApplicationBase.RemoveLayer(lastLayer.Id);

            var dummyLayer = modelApplicationBase.CreatorInstance.CreateModelApplication();
            dummyLayer.Id = lastLayer.Id;
            ModelApplicationHelper.AddLayer(modelApplicationBase, dummyLayer);
            var keyValue = ObjectSpace.GetKeyValue(View.CurrentObject);
            var objectType = View.ObjectTypeInfo.Type;
            var modelDetailView = View.Model;
            showViewStrategyBase.CloseAllWindows();

            base.ReplaceLayer(model, layer, isCurrentUserModel,showViewParameters);
            showViewStrategyBase.ShowStartupWindow();

            var xafApplication = ApplicationHelper.Instance.Application;
            var objectSpace = xafApplication.CreateObjectSpace();
            var objectByKey = objectSpace.GetObjectByKey(objectType,keyValue);
            showViewStrategyBase = (WinShowViewStrategyBase)xafApplication.ShowViewStrategy;
            
            showViewParameters.CreatedView = xafApplication.CreateDetailView(objectSpace, modelDetailView, true, objectByKey);
            showViewStrategyBase.ShowView(showViewParameters, new ShowViewSource(null,null));

        }

 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 static void AddLayerBeforeLast(this ModelApplicationBase application, ModelApplicationBase layer) {
     ModelApplicationBase lastLayer = application.LastLayer;
     if (lastLayer.Id != "After Setup" && lastLayer.Id != "UserDiff")
         throw new ArgumentException("LastLayer.Id", lastLayer.Id);
     ModelApplicationHelper.RemoveLayer(application);
     ModelApplicationHelper.AddLayer(application, layer);
     ModelApplicationHelper.AddLayer(application, lastLayer);
 }

 protected internal override void OnDifferenceObjectSaving(ModelDifferenceObject userModelDifferenceObject, ModelApplicationBase model) {
     var userStoreObject = ((UserModelDifferenceObject)userModelDifferenceObject);
     if (!userStoreObject.NonPersistent) {
         userModelDifferenceObject.CreateAspectsCore(model);
         base.OnDifferenceObjectSaving(userModelDifferenceObject, model);
     }
     CombineModelFromPermission(model);
 }

 IEnumerable<ModelApplicationBase> RemoveLayers(ModelApplicationBase modelApplicationBase, IEnumerable<string> strings) {
     var modelApplicationBases = new List<ModelApplicationBase>();
     while (modelApplicationBase.LastLayer.Id != "Unchanged Master Part") {
         if (!(strings.Contains(modelApplicationBase.LastLayer.Id)))
             modelApplicationBases.Add(modelApplicationBase.LastLayer);
         ModelApplicationHelper.RemoveLayer(modelApplicationBase.LastLayer);
     }
     return modelApplicationBases;
 }

 Dictionary<string, ModelDifferenceObjectInfo> GetLoadedModelDifferenceObjectInfos(ModelApplicationBase model) {
     Dictionary<string, ModelDifferenceObjectInfo> loadedModelDifferenceObjectInfos = GetLoadedModelApplications(model);
     if (!loadedModelDifferenceObjectInfos.Any())
         if (ObjectSpace.IsServerSide() || !(Application is ServerApplication))
             return CreateNew(model);
         else
             return loadedModelDifferenceObjectInfos;
     return loadedModelDifferenceObjectInfos;
 }

 public static void ReadFromModel(this ModelXmlReader modelXmlReader, ModelApplicationBase modelNode,
                                   ModelApplicationBase readFrom, Func<string, bool> aspectNamePredicate) {
     for (int i = 0; i < readFrom.AspectCount; i++) {
         string aspect = readFrom.GetAspect(i);
         string xml = new ModelXmlWriter().WriteToString(readFrom, i);
         if (!(string.IsNullOrEmpty(xml)))
             new ModelXmlReader().ReadFromString(modelNode, aspect, xml);
     }
 }

 void LoadApplicationModels(bool loadResources, ModelApplicationBase model) {
     var userDiffLayer = model.LastLayer;
     ModelApplicationHelper.RemoveLayer(model);
     var customModelDifferenceStoreEventArgs = new CreateCustomModelDifferenceStoreEventArgs();
     OnCreateCustomModelDifferenceStore(customModelDifferenceStoreEventArgs);
     if (!customModelDifferenceStoreEventArgs.Handled)
         new XpoModelDictionaryDifferenceStore(Application, GetPath(), customModelDifferenceStoreEventArgs.ExtraDiffStores, loadResources).Load(model);
     ModelApplicationHelper.AddLayer((ModelApplicationBase)Application.Model, userDiffLayer);
     RuntimeMemberBuilder.CreateRuntimeMembers(Application.Model);
 }

 void CombineWithActiveDifferenceObjects(ModelApplicationBase model, IEnumerable<ModelDifferenceObject> modelDifferenceObjects) {
     var reader = new ModelXmlReader();
     foreach (var modelDifferenceObject in modelDifferenceObjects) {
         foreach (var aspectObject in modelDifferenceObject.AspectObjects) {
             var xml = aspectObject.Xml;
             if (!string.IsNullOrEmpty(xml))
                 reader.ReadFromString(model, modelDifferenceObject.GetAspectName(aspectObject), xml);
         }
     }
 }

        public override void SaveDifference(ModelApplicationBase model) {
            if (model != null) {
                _objectSpace = _application.CreateObjectSpace() as ObjectSpace;
                ModelDifferenceObject modelDifferenceObject =
                    GetActiveDifferenceObject(model.Id) ??
                    GetNewDifferenceObject(_objectSpace)
                    .InitializeMembers(model.Id == "Application" ? Application.Title : model.Id, Application.Title, Application.GetType().FullName);

                OnDifferenceObjectSaving(modelDifferenceObject, model);
            }
        }

        public override void Load(ModelApplicationBase model) {
            base.Load(model);

            var modelDifferenceObjects = GetActiveDifferenceObjects().ToList();
            if (modelDifferenceObjects.Count() == 0) {
                SaveDifference(model);
                return;
            }

            CombineWithActiveDifferenceObjects(model, modelDifferenceObjects);
        }

 public void AddLayers(string modelApplicationPrefix, Dictionary<string, ModelDifferenceObjectInfo> loadedModelDifferenceObjectInfos, ModelApplicationBase model) {
     var modelXmlReader = new ModelXmlReader();
     var assemblies = _xafApplication.Modules.Select(module => module.GetType().Assembly);
     var resourceModelCollector = new ResourceModelCollector();
     foreach (var keyValuePair in resourceModelCollector.Collect(assemblies, modelApplicationPrefix)) {
         var modelDifferenceObjectInfo = GetModelDifferenceObjectInfo(modelApplicationPrefix, loadedModelDifferenceObjectInfos, keyValuePair.Key, model);
         foreach (var aspectInfo in keyValuePair.Value.AspectInfos) {
             modelXmlReader.ReadFromString(modelDifferenceObjectInfo.Model, aspectInfo.AspectName, aspectInfo.Xml);
         }
         modelDifferenceObjectInfo.ModelDifferenceObject.CreateAspects(modelDifferenceObjectInfo.Model);
     }
 }

 void AddLayersCore(IEnumerable<KeyValuePair<string, ResourceInfo>> layers, ModelApplicationBase modelApplication) {
     IEnumerable<KeyValuePair<string, ResourceInfo>> keyValuePairs = layers;
     foreach (var pair in keyValuePairs) {
         ModelApplicationBase layer = modelApplication.CreatorInstance.CreateModelApplication();
         layer.Id = pair.Key;
         modelApplication.AddLayer(layer);
         var modelXmlReader = new ModelXmlReader();
         foreach (var aspectInfo in pair.Value.AspectInfos) {
             modelXmlReader.ReadFromString(layer, aspectInfo.AspectName, aspectInfo.Xml);
         }
     }
 }

 void CombineModelFromPermission(ModelApplicationBase model) {
     if (SecuritySystem.Instance is ISecurityComplex && IsGranted()) {
         var space = Application.CreateObjectSpace();
         ModelDifferenceObject difference = GetDifferenceFromPermission((XPObjectSpace)space);
         var master = new ModelLoader(difference.PersistentApplication.ExecutableName).GetMasterModel(true);
         var diffsModel = difference.GetModel(master);
         new ModelXmlReader().ReadFromModel(diffsModel, model);
         difference.CreateAspectsCore(diffsModel);
         space.SetModified(difference);
         space.CommitChanges();
     }
 }

 ModelDifferenceObjectInfo GetModelDifferenceObjectInfo(string prefix, Dictionary<string, ModelDifferenceObjectInfo> loadedModelDifferenceObjectInfos, string resourceName, ModelApplicationBase model) {
     ModelDifferenceObject activeDifferenceObject;
     ModelApplicationBase modelApplicationBase;
     if (!loadedModelDifferenceObjectInfos.ContainsKey(resourceName)) {
         activeDifferenceObject = FindDifferenceObject(resourceName, prefix) ??
                                  CreateDifferenceObject(resourceName, prefix);
         modelApplicationBase = activeDifferenceObject.GetModel(model);
     } else {
         var loadedModelDifferenceObjectInfo = loadedModelDifferenceObjectInfos[resourceName];
         activeDifferenceObject = loadedModelDifferenceObjectInfo.ModelDifferenceObject;
         modelApplicationBase = loadedModelDifferenceObjectInfo.Model;
     }
     return new ModelDifferenceObjectInfo(activeDifferenceObject, modelApplicationBase);
 }

        public override void Load(ModelApplicationBase model) {
            base.Load(model);

            foreach (var roleModel in this.GetActiveRoleDifferenceObjects())
                roleModel.GetModel(base.Application.Model as ModelApplicationBase);

            var modelDifferenceObjects = GetActiveDifferenceObjects().ToList();
            if (modelDifferenceObjects.Count() == 0) {
                SaveDifference(model);
                return;
            }

            CombineWithActiveDifferenceObjects(model, modelDifferenceObjects);
        }

        Dictionary<string, ModelDifferenceObjectInfo> GetLoadedModelDifferenceObjectInfos(ModelApplicationBase model) {
            Dictionary<string, ModelDifferenceObjectInfo> loadedModelDifferenceObjectInfos = GetLoadedModelApplications(model);

            if (loadedModelDifferenceObjectInfos.Count() == 0) {
                var modelDifferenceObjectInfos = new Dictionary<string, ModelDifferenceObjectInfo>();
                var application = model.CreatorInstance.CreateModelApplication();
                application.Id = XpandModuleBase.Application.Title;
                model.AddLayerBeforeLast(application);
                var modelDifferenceObject = ObjectSpace.CreateObject<ModelDifferenceObject>().InitializeMembers(application.Id);
                modelDifferenceObjectInfos.Add(application.Id, new ModelDifferenceObjectInfo(modelDifferenceObject, application));
                loadedModelDifferenceObjectInfos = modelDifferenceObjectInfos;
            }
            return loadedModelDifferenceObjectInfos;
        }

 public override void Load(ModelApplicationBase model) {
     var extraDiffStoresLayerBuilder = new ExtraDiffStoresLayerBuilder();
     var language = model.Application.PreferredLanguage;
     if (UseModelFromPath()) {
         return;
     }
     var loadedModelDifferenceObjectInfos = GetLoadedModelDifferenceObjectInfos(model);
     extraDiffStoresLayerBuilder.AddLayers(loadedModelDifferenceObjectInfos, _extraDiffStores);
     if (_loadResources)
         CreateResourceModels(model, loadedModelDifferenceObjectInfos);
     if (model.Application.PreferredLanguage != language) {
         Application.SetLanguage(model.Application.PreferredLanguage);
     }
     ObjectSpace.CommitChanges();
 }

 void CombineModelFromPermission(ModelApplicationBase model) {
     if (SecuritySystem.Instance is ISecurityComplex && IsGranted()) {
         var space = Application.CreateObjectSpace(typeof(ModelDifferenceObject));
         ModelDifferenceObject difference = GetDifferenceFromPermission((XPObjectSpace)space);
         if (difference != null) {
             InterfaceBuilder.SkipAssemblyCleanup = true;
             var master = new ModelLoader(difference.PersistentApplication.ExecutableName, XafTypesInfo.Instance).GetMasterModel(true,info => info.AssignAsInstance());
             InterfaceBuilder.SkipAssemblyCleanup = false;
             var diffsModel = difference.GetModel(master);
             new ModelXmlReader().ReadFromModel(diffsModel, model);
             difference.CreateAspectsCore(diffsModel);
             space.SetModified(difference);
             space.CommitChanges();
         }
     }
 }