void AddTableNames(XPClassInfo xpClassInfo, string key) {
     List<string> list = _tables[key];
     list.Add(xpClassInfo.TableName);
     foreach (var tableName in GetIntermediateTableNames(xpClassInfo).Where(tableName => !list.Contains(tableName))) {
         list.Add(tableName);
     }
 }

 public ReflectionDictionary GetDictionary(XPClassInfo xpClassInfo) {
     string key = GetKey(xpClassInfo);
     var reflectionDictionary = GetDictionary(key);
     if (xpClassInfo.IsPersistent)
         AddTableNames(xpClassInfo, key);
     return reflectionDictionary;
 }

 //        private void createObjectTypeColumn(XPClassInfo xpClassInfo, UnitOfWork unitOfWork)
 //        {
 //            unitOfWork.CreateObjectTypeRecords(xpClassInfo);
 //            var newObject = xpClassInfo.CreateNewObject(unitOfWork);
 //            unitOfWork.CommitChanges();
 //            unitOfWork.Delete(newObject);
 //            unitOfWork.CommitChanges();
 //        }
 private void updateObjectType(UnitOfWork unitOfWork, XPClassInfo xpClassInfo, XPClassInfo mergedXPClassInfo, IDbCommand command)
 {
     var propertyName = XPObject.Fields.ObjectType.PropertyName;
     command.CommandText = "UPDATE [" + getTableName(mergedXPClassInfo) + "] SET " + propertyName + "=" + unitOfWork.GetObjectType(xpClassInfo).Oid +
                           " WHERE " + propertyName + " IS NULL OR " + propertyName + "=" +unitOfWork.GetObjectType(mergedXPClassInfo).Oid;
     command.ExecuteNonQuery();
 }

 IEnumerable<DCPropertyInfo> DCPropertyInfos(XPClassInfo classInfo) {
     if (classInfo != null){
         var xpandCalcMemberInfos = classInfo.OwnMembers.OfType<XpandCustomMemberInfo>();
         return xpandCalcMemberInfos.Select(info => DcPropertyInfo(classInfo, info));
     }
     return Enumerable.Empty<DCPropertyInfo>();
 }

 string getTableName(XPClassInfo mergedXPClassInfo) {
     string tableName = mergedXPClassInfo.TableName;
     while (mergedXPClassInfo.BaseClass != null && mergedXPClassInfo.BaseClass.IsPersistent) {
         mergedXPClassInfo = mergedXPClassInfo.BaseClass;
         tableName = mergedXPClassInfo.TableName;
     }
     return tableName;
 }

 protected virtual void Synchonize(object persistentPivotOption, Type type, XPClassInfo classInfo) {
     var gridOptionInstances = GetGridOptionInstance(type);
     foreach (var gridOptionInstance in gridOptionInstances) {
         var propertyInfos = gridOptionInstance.GetType().GetProperties().Where(propertyInfo => propertyInfo.GetSetMethod() != null);
         foreach (var propertyInfo in propertyInfos) {
             classInfo.GetMember(propertyInfo.Name).SetValue(persistentPivotOption, propertyInfo.GetValue(gridOptionInstance, null));
         }
     }
 }

 public DCPropertyInfo(string name, Type propertyType, XPClassInfo declaringType, bool canRead, bool canWrite, XpandCustomMemberInfo xpandCustomMemberInfo) {
     _nameCore = name;
     _propertyTypeCore = propertyType;
     _declaringTypeCore = declaringType;
     _canReadCore = canRead;
     _canWriteCore = canWrite;
     _xpandCustomMemberInfo = xpandCustomMemberInfo;
     _attributesCore.AddRange(xpandCustomMemberInfo.Attributes);
 }

 long GetNextSequence(XPClassInfo classInfo, string preFix) {
     if (classInfo == null)
         throw new ArgumentNullException("classInfo");
     var objectByKey = _explicitUnitOfWork.GetObjectByKey(_sequenceObjectType, preFix + classInfo.FullName, true);
     _sequence = objectByKey != null ? (ISequenceObject)objectByKey : CreateSequenceObject(preFix + classInfo.FullName, _explicitUnitOfWork);
     long nextId = _sequence.NextSequence;
     _sequence.NextSequence++;
     _explicitUnitOfWork.FlushChanges();
     return nextId;
 }

 static XpandCustomMemberInfo GetMemberInfo(IModelRuntimeMember modelMember, XPClassInfo xpClassInfo) {
     if (modelMember is IModelRuntimeCalculatedMember)
         return xpClassInfo.CreateCalculabeMember(modelMember.Name, modelMember.Type,
                                               new Attribute[] { new PersistentAliasAttribute(((IModelRuntimeCalculatedMember)modelMember).AliasExpression) });
     if (modelMember is IModelRuntimeOrphanedColection) {
         var modelRuntimeOrphanedColection = ((IModelRuntimeOrphanedColection)modelMember);
         return xpClassInfo.CreateCollection(modelMember.Name, modelRuntimeOrphanedColection.CollectionType.TypeInfo.Type,
                                             modelRuntimeOrphanedColection.Criteria);
     }
     return xpClassInfo.CreateCustomMember(modelMember.Name, modelMember.Type, modelMember is IModelRuntimeNonPersistentMember);
 }

 static XpandCustomMemberInfo GetMemberInfo(IModelRuntimeMember modelMember, XPClassInfo xpClassInfo) {
     var calculatedMember = modelMember as IModelRuntimeCalculatedMember;
     if (calculatedMember != null)
         return xpClassInfo.CreateCalculabeMember(calculatedMember.Name, calculatedMember.Type, calculatedMember.AliasExpression);
     var member = modelMember as IModelRuntimeOrphanedColection;
     if (member != null) {
         var modelRuntimeOrphanedColection = member;
         return xpClassInfo.CreateCollection(member.Name, modelRuntimeOrphanedColection.CollectionType.TypeInfo.Type,
                                             modelRuntimeOrphanedColection.Criteria);
     }
     return xpClassInfo.CreateCustomMember(modelMember.Name, modelMember.Type, modelMember is IModelRuntimeNonPersistentMember);
 }

 /// <contentfrom cref="ISecurityRule.GetSelectFilterCriteria" />
 public bool GetSelectFilterCriteria(DevExpress.Xpo.SecurityContext context, XPClassInfo classInfo, out CriteriaOperator criteria)
 {
     List<CriteriaOperator> subList = new List<CriteriaOperator>();
     CriteriaOperator subCriteria;
     foreach (ISecurityRule rule in rules)
         if (rule.GetSelectFilterCriteria(context, classInfo, out subCriteria))
             subList.Add(subCriteria);
     if (subList.Count == 0)
         criteria = null;
     else if (subList.Count == 1)
         criteria = subList[0];
     else
         criteria = new GroupOperator(GroupOperatorType.And, subList.ToArray());
     return subList.Count > 0;
 }

 /// <contentfrom cref="ISecurityRule.GetSelectMemberExpression" />
 public bool GetSelectMemberExpression(DevExpress.Xpo.SecurityContext context, XPClassInfo classInfo, XPMemberInfo memberInfo, out CriteriaOperator expression)
 {
     CriteriaOperator subExpression;
     expression = null;
     foreach (ISecurityRule rule in rules)
         if (rule.GetSelectMemberExpression(context, classInfo, memberInfo, out subExpression))
         {
             if (ReferenceEquals(expression, null))
                 expression = subExpression;
             else if (!CriteriaOperator.CriterionEquals(expression, subExpression))
             {
                 expression = new OperandValue(null);
                 return true;
             }
         }
     return !ReferenceEquals(expression, null);
 }

 void MapManyToMany(XPDictionary outputDictionary, XPDictionary inputDictionary, XPClassInfo classInfo) {
     foreach (var memberInfo in ManyToManyMemberInfos(classInfo)) {
         var initialDataAttribute = (InitialDataAttribute)memberInfo.FindAttributeInfo(typeof(InitialDataAttribute));
         var className = initialDataAttribute.DataProviderTableName;
         if (initialDataAttribute.DataProvider && inputDictionary.QueryClassInfo(null, className) == null) {
             CreateIntermediateClassInfo(outputDictionary, inputDictionary, className, initialDataAttribute, memberInfo);
         }
     }
 }

        public InputObjectClassInfo(XPDictionary dictionary, string className, XPClassInfo outputClassInfo)
            : base(dictionary, null, className, GetAttributes()) {
            Guard.ArgumentNotNull(outputClassInfo, "outputClassInfo");
            _outputClassInfo = outputClassInfo;

        }

 void CreateAllOwnMembers(XPClassInfo outputClassInfo, XPClassInfo inputClassInfo) {
     foreach (var memberInfo in MemberInfos(outputClassInfo)) {
         if (memberInfo.HasAttribute(typeof(InitialDataAttribute))) {
             CreateMemberFromAttribute(inputClassInfo, memberInfo);
         } else {
             CreateMemberCore(inputClassInfo, memberInfo.Name, memberInfo);
         }
     }
 }

 bool AllOwnMembers(XPClassInfo classInfo) {
     return ((InitialDataAttribute)classInfo.FindAttributeInfo(typeof(InitialDataAttribute))).AllOwnMembers;
 }

 void CreateMemberFromAttribute(XPClassInfo classInfo, XPMemberInfo memberInfo) {
     var initialDataAttribute = (InitialDataAttribute)memberInfo.FindAttributeInfo(typeof(InitialDataAttribute));
     if (initialDataAttribute != null) {
         CreateMemberCore(classInfo, initialDataAttribute.Name ?? memberInfo.Name, memberInfo);
     }
 }

        bool HasKey(XPClassInfo classInfo) {
            XPMemberInfo xpMemberInfo;
            try {
#pragma warning disable 168
                xpMemberInfo = classInfo.KeyProperty;
#pragma warning restore 168
            } catch (KeyPropertyAbsentException) {
                return false;
            }
            return xpMemberInfo != null;
        }

 public InputMemberInfo(XPClassInfo owner, string propertyName, XPClassInfo referenceType, bool nonPersistent, XPMemberInfo outputMemberInfo, params Attribute[] attributes)
     : base(owner, propertyName, referenceType.ClassType, referenceType, nonPersistent, false) {
     Guard.ArgumentNotNull(outputMemberInfo, "outputMemberInfo");
     _outputMemberInfo = outputMemberInfo;
     AddAttributes(attributes);
 }

 Dictionary<string, XPMemberInfo> BaseMemberInfos(XPClassInfo outputClassInfo) {
     var members = ((InitialDataAttribute)outputClassInfo.FindAttributeInfo(typeof(InitialDataAttribute))).BaseMembers;
     var xpMemberInfos = new Dictionary<string, XPMemberInfo>();
     if (members != null) {
         var baseMembers = members.Split(',');
         foreach (var baseMember in baseMembers) {
             var strings = baseMember.Split('|');
             var xpMemberInfo = outputClassInfo.FindMember(strings[0]);
             xpMemberInfos.Add(strings[strings.Length - 1], xpMemberInfo);
         }
     }
     return xpMemberInfos;
 }