public CriteriaObjectReplacer(ITypesInfo typesInfo)
        {
            if (typesInfo == null)
                throw new ArgumentNullException("typesInfo");

            this.typesInfo = typesInfo;
        }

 public NHObjectSpaceProvider(ITypesInfo typesInfo, IPersistenceManager persistenceManager)
 {
     Guard.ArgumentNotNull(typesInfo, "typesInfo");
     Guard.ArgumentNotNull(persistenceManager, "persistenceManager");
     this.typesInfo = typesInfo;
     this.persistenceManager = persistenceManager;
 }

        internal NHNestedObjectSpace(ITypesInfo typesInfo, IEntityStore entityStore, IPersistenceManager persistenceManager, 
            Dictionary<object, ObjectSpaceInstanceInfo> instances,  NHObjectSpace parentObjectSpace) : 
            base(typesInfo, entityStore, persistenceManager, instances, null)
        {

            this.parentObjectSpace = parentObjectSpace;
        }

 public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
     base.CustomizeTypesInfo(typesInfo);
     if (!RuntimeMode) {
         CreateDesignTimeCollection(typesInfo, typeof(UserModelDifferenceObject), "Users");
         CreateDesignTimeCollection(typesInfo, typeof(RoleModelDifferenceObject), "Roles");
     }
 }

 public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
     base.CustomizeTypesInfo(typesInfo);
     if (!RuntimeMode) {
         CreateDesignTimeCollection(typesInfo, typeof(SendEmailJobDetailDataMap), "Users");
         CreateDesignTimeCollection(typesInfo, typeof(SendEmailJobDetailDataMap), "Roles");
     }
 }

 void UpdateLayoutManager(ITypesInfo typesInfo) {
     if (!(LayoutManager is ILayoutManager)) {
         var typeInfo = ReflectionHelper.FindTypeDescendants(typesInfo.FindTypeInfo(typeof(ILayoutManager))).FirstOrDefault();
         if (typeInfo != null)
             this.SetPropertyInfoBackingFieldValue(view => view.LayoutManager, this, ReflectionHelper.CreateObject(typeInfo.Type));
     }
 }

 void CreateMembers(ITypesInfo typesInfo, Type optionsType, Type persistentType) {
     ITypeInfo typeInfo = typesInfo.FindTypeInfo(ReflectionHelper.GetType(persistentType.Name));
     IEnumerable<PropertyInfo> propertyInfos = optionsType.GetProperties().Where(info => info.GetSetMethod() != null).Where(propertyInfo => typeInfo.FindMember(propertyInfo.Name) == null);
     foreach (PropertyInfo propertyInfo in propertyInfos) {
         OnCreateMember(typeInfo, propertyInfo.Name, propertyInfo.PropertyType);
     }
 }

 public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
     base.CustomizeTypesInfo(typesInfo);
     var memberInfos = typesInfo.PersistentTypes.SelectMany(info => info.OwnMembers);
     foreach (var memberInfo in memberInfos) {
         HandleCustomAttribute(memberInfo, typesInfo);
     }
 }

 public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
     base.CustomizeTypesInfo(typesInfo);
     new FullTextContainsFunction().Register();
     if (Application != null && Application.Security != null) {
         CreatePessimisticLockingField(typesInfo);
     }
 }

        ApplicationModulesManager CreateModulesManager(XafApplication application, string configFileName, string assembliesPath, ITypesInfo typesInfo) {
            if (!string.IsNullOrEmpty(configFileName)) {
                bool isWebApplicationModel = string.Compare(Path.GetFileNameWithoutExtension(configFileName), "web", true) == 0;
                if (string.IsNullOrEmpty(assembliesPath)) {
                    assembliesPath = Path.GetDirectoryName(configFileName);
                    if (isWebApplicationModel) {
                        assembliesPath = Path.Combine(assembliesPath + "", "Bin");
                    }
                }
            }
            ReflectionHelper.AddResolvePath(assembliesPath);
            try {
                var result = new ApplicationModulesManager(new ControllersManager(), assembliesPath);
                if (application != null) {
                    foreach (ModuleBase module in application.Modules) {
                        result.AddModule(module);
                    }
                    result.Security = application.Security;
                }
                if (!string.IsNullOrEmpty(configFileName)) {
                    result.AddModuleFromAssemblies(GetModulesFromConfig(application));
                }
                if (typesInfo is TypesInfo)
                    XpandModuleBase.Dictiorary = ((TypesInfo)typesInfo).Source.XPDictionary;

                result.Load(typesInfo);
                return result;
            } finally {
                XpandModuleBase.Dictiorary = XafTypesInfo.XpoTypeInfoSource.XPDictionary;
                ReflectionHelper.RemoveResolvePath(assembliesPath);
            }

        }

 protected void CreateDesignTimeCollection(ITypesInfo typesInfo, Type classType, string propertyName) {
     XPClassInfo info = XafTypesInfo.XpoTypeInfoSource.XPDictionary.GetClassInfo(classType);
     if (info.FindMember(propertyName) == null) {
         info.CreateMember(propertyName, typeof(XPCollection), true);
         typesInfo.RefreshInfo(classType);
     }
 }

 void CreateMember(ITypesInfo typesInfo, IRoleTypeProvider roleTypeProvider, SecurityOperationsAttribute attribute) {
     var roleTypeInfo = typesInfo.FindTypeInfo(roleTypeProvider.RoleType);
     if (roleTypeInfo.FindMember(attribute.OperationProviderProperty) == null) {
         var memberInfo = roleTypeInfo.CreateMember(attribute.OperationProviderProperty, typeof(SecurityOperationsEnum));
         memberInfo.AddAttribute(new RuleRequiredFieldAttribute());
     }
 }

 public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
     base.CustomizeTypesInfo(typesInfo);
     if (Application != null) {
         typesInfo.FindTypeInfo(typeof(ShowInAnalysisPermission)).FindMember("ControllerType").AddAttribute(new VisibleInDetailViewAttribute(false));
         typesInfo.FindTypeInfo(typeof(PivotSettingsPermission)).FindMember("ControllerType").AddAttribute(new VisibleInDetailViewAttribute(false));
     }
 }

 protected override IObjectSpace CreateObjectSpaceCore(UnitOfWork unitOfWork, ITypesInfo typesInfo) {
     var objectSpace = new XpandObjectSpace(new XpandUnitOfWork(unitOfWork.DataLayer), typesInfo) {
         AsyncServerModeSourceResolveSession = AsyncServerModeSourceResolveSession,
         AsyncServerModeSourceDismissSession = AsyncServerModeSourceDismissSession
     };
     return objectSpace;
 }

 public ApplicationModulesManager CreateApplicationModulesManager(XafApplication application, string configFileName, string assembliesPath, ITypesInfo typesInfo) {
     if (!string.IsNullOrEmpty(configFileName)) {
         bool isWebApplicationModel =
             String.Compare(Path.GetFileNameWithoutExtension(configFileName), "web", StringComparison.OrdinalIgnoreCase) == 0;
         if (string.IsNullOrEmpty(assembliesPath)) {
             assembliesPath = Path.GetDirectoryName(configFileName);
             if (isWebApplicationModel) {
                 assembliesPath = Path.Combine(assembliesPath + "", "Bin");
             }
         }
     }
     ReflectionHelper.AddResolvePath(assembliesPath);
     try {
         var result = new ApplicationModulesManager(new ControllersManager(), assembliesPath);
         foreach (ModuleBase module in application.Modules) {
             result.AddModule(module);
         }
         result.Security = application.Security;
         if (GetModulesFromConfig(application) != null) {
             result.AddModuleFromAssemblies(GetModulesFromConfig(application));
         }
         return result;
     } finally {
         ReflectionHelper.RemoveResolvePath(assembliesPath);
     }
 }

        private XPCustomMemberInfo CreateMemberInfo(ITypesInfo typesInfo, IMemberInfo memberInfo, ProvidedAssociationAttribute providedAssociationAttribute, AssociationAttribute associationAttribute) {
            var typeToCreateOn = getTypeToCreateOn(memberInfo, associationAttribute);
            if (typeToCreateOn == null)
                throw new NotImplementedException();
            XPCustomMemberInfo xpCustomMemberInfo;
            if (!(memberInfo.IsList) || (memberInfo.IsList && providedAssociationAttribute.RelationType == RelationType.ManyToMany)) {
                xpCustomMemberInfo = typesInfo.CreateCollection(
                    typeToCreateOn,
                    memberInfo.Owner.Type,
                    associationAttribute.Name,
                    XpandModuleBase.Dictiorary,
                    providedAssociationAttribute.ProvidedPropertyName ?? memberInfo.Owner.Type.Name + "s", false);
            } else {
                xpCustomMemberInfo = typesInfo.CreateMember(
                    typeToCreateOn,
                    memberInfo.Owner.Type,
                    associationAttribute.Name,
                    XpandModuleBase.Dictiorary,
                    providedAssociationAttribute.ProvidedPropertyName ?? memberInfo.Owner.Type.Name, false);
            }

            if (!string.IsNullOrEmpty(providedAssociationAttribute.AssociationName) && memberInfo.FindAttribute<AssociationAttribute>() == null)
                memberInfo.AddAttribute(new AssociationAttribute(providedAssociationAttribute.AssociationName));

            typesInfo.RefreshInfo(typeToCreateOn);

            return xpCustomMemberInfo;
        }

 public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
     base.CustomizeTypesInfo(typesInfo);
     InitializeInstanceXafApplicationManager();
     var type = (BaseInfo)typesInfo.FindTypeInfo(typeof(IModelMember)).FindMember("Type");
     var attribute = type.FindAttribute<ReadOnlyAttribute>();
     if (attribute != null)
         type.RemoveAttribute(attribute);
 }

 private void SetAdditionalExportedTypesProperties(ITypesInfo typesInfo)
 {
     foreach (var type in AdditionalExportedTypes)
     {
         var typeInfo = (TypeInfo)typesInfo.FindTypeInfo(type);
         typeInfo.IsDomainComponent = true;
     }
 }

 void CreateMembers(ITypesInfo typesInfo) {
     foreach (FilterProviderBase provider in FilterProviderManager.Providers) {
         FilterProviderBase provider1 = provider;
         foreach (ITypeInfo typeInfo in typesInfo.PersistentTypes.Where(typeInfo => TypeMatch(typeInfo, provider1))) {
             CreateMember(typeInfo, provider);
         }
     }
 }

 public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
     base.CustomizeTypesInfo(typesInfo);
     var memberInfos = typesInfo.PersistentTypes.SelectMany(info => info.OwnMembers);
     foreach (var memberInfo in memberInfos) {
         HandleNumericFormatAttribute(memberInfo);
         HandleSequencePropertyAttribute(memberInfo);
     }
 }