Exemplo n.º 1
0
        private Object ExtractCurrentVersionValue(IReadOnlyEntity entity, IColumn versionColumn, Type type
                                                  , ITransaction tx)
        {
            Object versionValue = null;

            ITypeFieldValueList keyFieldValueList = OperationUtils.ExtractEntityTypeKeyValues(entity, type);
            IDbCommand          cmd    = null;
            IDataReader         reader = null;

            try
            {
                cmd    = CreateRetrievalPreparedStatement(keyFieldValueList, tx);
                reader = cmd.ExecuteReader();
                if (reader.Read())
                {
                    versionValue = DbLayer.DataManipulate().ReadFromResultSet(reader, versionColumn);
                }
            }
            catch (Exception ex)
            {
                String message = String.Format("SQL Exception while trying retrieve version information from {0}"
                                               , entity.GetType().FullName);
                throw new StatementExecutionException(message, ex);
            }
            finally
            {
                DbMgtUtility.Close(reader);
                DbMgtUtility.Close(cmd);
            }
            return(versionValue);
        }
Exemplo n.º 2
0
 public void CopyReferenceStoreFrom(IReadOnlyEntity entity)
 {
     if (entity.Context != null)
     {
         _referenceStore = entity.Context.ReferenceStore;
     }
 }
Exemplo n.º 3
0
        private ICollection <EntityFieldValue> GetModifiedFieldValues(IReadOnlyEntity entity, Type type)
        {
            EntityInfo                     entityInfo      = CacheManager.GetEntityInfo(type);
            ICollection <IColumn>          typeColumns     = entityInfo.Columns;
            ITypeFieldValueList            currentValues   = OperationUtils.ExtractEntityTypeFieldValues(entity, type);
            ICollection <EntityFieldValue> modifiedColumns = new  List <EntityFieldValue>();

            foreach (IColumn typeColumn in typeColumns)
            {
                if (typeColumn.Key)
                {
                    continue;
                }

                EntityFieldValue classFieldValue    = currentValues.GetFieldValue(typeColumn.AttributeName);
                EntityFieldValue originalFieldValue = entity.Context != null?entity.Context.ChangeTracker.GetFieldValue(typeColumn.AttributeName) : null;

                bool matches = originalFieldValue != null && classFieldValue != null && classFieldValue.Value == originalFieldValue.Value ||
                               (originalFieldValue != null && classFieldValue != null && classFieldValue.Value != null && classFieldValue.Value.Equals(originalFieldValue.Value));
                if (!matches)
                {
                    modifiedColumns.Add(classFieldValue);
                }
            }
            return(modifiedColumns);
        }
Exemplo n.º 4
0
        public static ICollection <IEntity> GetRelationEntities(IReadOnlyEntity rootEntity, IRelation relation)
        {
            EntityInfo   entityInfo = CacheManager.GetEntityInfo(rootEntity);
            PropertyInfo property   = entityInfo.GetProperty(relation.AttributeName);
            object       value      = ReflectionUtils.GetValue(property, rootEntity);

            ICollection <IEntity> treeEntities = new List <IEntity>();

            if (value is ICollection)
            {
                ICollection collection = (ICollection)value;
                foreach (object o in collection)
                {
                    if (o is IEntity &&
                        ReflectionUtils.IsSubClassOf(o.GetType(), relation.RelatedObjectType))
                    {
                        treeEntities.Add((IEntity)o);
                    }
                }
            }
            else if (value is IEntity &&
                     ReflectionUtils.IsSubClassOf(value.GetType(), relation.RelatedObjectType))
            {
                treeEntities.Add((IEntity)value);
            }
            return(treeEntities);
        }
Exemplo n.º 5
0
        public override bool Filter(IReadOnlyEntity entity, QueryParameter param)
        {
            var fileInfo = entity.GetComponent(FileInfo.TypeCode);

            if (fileInfo == null)
            {
                return(true);
            }

            if (param.Template == Parameters.FileName)
            {
                return(param.FilterOperatorString(fileInfo.FileName));
            }
            else if (param.Template == Parameters.HashMD5)
            {
                return(param.FilterOperatorString(fileInfo.HashMD5));
            }
            else if (param.Template == Parameters.HashSHA1OfMD5)
            {
                return(param.FilterOperatorString(fileInfo.HashSHA1OfMD5));
            }
            else
            {
                return(true);
            }
        }
Exemplo n.º 6
0
        private void CreateProxy(IReadOnlyEntity parentRoEntity, Type type, ITransaction tx, IRelation relation,
                                 object value, PropertyInfo property)
        {
            Type proxyType = value == null ? property.PropertyType : value.GetType();

            if (proxyType.IsGenericType)
            {
                Type generic = proxyType.GetGenericArguments()[0];
                if (proxyType.IsInterface)
                {
                    proxyType = typeof(List <>).MakeGenericType(new Type[] { generic });
                }
            }
            if (value == null)
            {
                value = Activator.CreateInstance(proxyType);
            }

            Object proxy = null;

            if (ReflectionUtils.IsImplementInterface(property.PropertyType, typeof(ICollection <>)))
            {
                Type generic     = proxyType.GetGenericArguments()[0];
                Type genericType = typeof(ICollection <>).MakeGenericType(new Type[] { generic });
                proxy = _proxyGenerator.CreateInterfaceProxyWithTarget(genericType, value,
                                                                       new ChildLoadInterceptor(this, parentRoEntity, type, tx,
                                                                                                relation));
            }
            else
            {
                proxy = _proxyGenerator.CreateClassProxy(proxyType, new object[] {},
                                                         new ChildLoadInterceptor(this, parentRoEntity, type, tx, relation));
            }
            ReflectionUtils.SetValue(property, parentRoEntity, proxy);
        }
 private void RemoveEntity(IReadOnlyEntity entity)
 {
     if (_contents.Remove(entity))
     {
         Removed?.Invoke(this, entity);
     }
 }
Exemplo n.º 8
0
        private ITypeFieldValueList ExtractCurrentRowValues(IReadOnlyEntity entity, Type type, ITransaction tx)
        {
            ITypeFieldValueList fieldValueList = null;

            ITypeFieldValueList keyFieldValueList = OperationUtils.ExtractEntityTypeKeyValues(entity, type);
            IDbCommand          cmd    = null;
            IDataReader         reader = null;

            try
            {
                cmd    = CreateRetrievalPreparedStatement(keyFieldValueList, tx);
                reader = cmd.ExecuteReader();
                if (reader.Read())
                {
                    fieldValueList = ReadValues(type, reader);
                }
            }
            catch (Exception ex)
            {
                string message = String.Format("SQL Exception while trying retrieve current data row from {0}"
                                               , entity.GetType().FullName);
                throw new StatementExecutionException(message, ex);
            }
            finally
            {
                DbMgtUtility.Close(reader);
                DbMgtUtility.Close(cmd);
            }
            return(fieldValueList);
        }
Exemplo n.º 9
0
        private static void SetParentRelationFieldsForNonIdentifyingRelations(IEntity parentEntity
                                                                              , IEnumerable <IEntity> childObjects, RelationColumnMapping mapping)
        {
            IReadOnlyEntity       firstObject     = null;
            IEnumerator <IEntity> childEnumerator = childObjects.GetEnumerator();

            if (childEnumerator.MoveNext())
            {
                firstObject = childEnumerator.Current;
            }
            if (firstObject == null)
            {
                return;
            }
            EntityInfo parentInfo = CacheManager.GetEntityInfo(parentEntity);
            EntityInfo childInfo  = CacheManager.GetEntityInfo(firstObject);

            PropertyInfo setter    = null;
            bool         foundOnce = false;

            while (parentInfo != null)
            {
                IColumn parentMatchedColumn = parentInfo.FindColumnByAttribute(mapping.FromField);
                if (parentMatchedColumn != null)
                {
                    foundOnce = true;
                    setter    = parentInfo.GetProperty(parentMatchedColumn);
                }
                parentInfo = parentInfo.SuperEntityInfo;
            }
            if (!foundOnce)
            {
                string message = String.Format("The field {0} does not have a matching field in the object {1}", mapping.ToField, firstObject.GetType().FullName);
                throw new NoMatchingColumnFoundException(message);
            }

            foundOnce = false;
            while (childInfo != null)
            {
                IColumn childMatchedColumn = childInfo.FindColumnByAttribute(mapping.ToField);

                if (childMatchedColumn != null)
                {
                    foundOnce = true;
                    foreach (IReadOnlyEntity dbObject in childObjects)
                    {
                        ITypeFieldValueList fieldValueList  = OperationUtils.ExtractEntityTypeFieldValues(dbObject, childInfo.EntityType);
                        EntityFieldValue    childFieldValue = fieldValueList.GetFieldValue(childMatchedColumn.AttributeName);
                        setter.SetValue(parentEntity, childFieldValue.Value, null);
                    }
                }
                childInfo = childInfo.SuperEntityInfo;
            }
            if (!foundOnce)
            {
                string message = String.Format("The field {0} does not have a matching field in the object {1}", mapping.ToField, firstObject.GetType().FullName);
                throw new NoMatchingColumnFoundException(message);
            }
        }
Exemplo n.º 10
0
 public bool Filter(IReadOnlyEntity entity, QueryHandler queryHandler)
 {
     if (queryHandler == null)
     {
         throw new ArgumentNullException(nameof(queryHandler));
     }
     return(Parameters.All(parameter => parameter.Filter(entity, queryHandler)));
 }
Exemplo n.º 11
0
 public static IReadOnlyEntity AsReadOnly(this IReadOnlyEntity self)
 {
     if (self == null)
     {
         throw new ArgumentNullException(nameof(self));
     }
     return(new ReadOnlyEntity(self));
 }
Exemplo n.º 12
0
 public ReadOnlyEntity(IReadOnlyEntity source)
 {
     if (source == null)
     {
         throw new ArgumentNullException(nameof(source));
     }
     Source = source;
 }
Exemplo n.º 13
0
        public void AddToCurrentObjectGraphIndex(IReadOnlyEntity refEntity)
        {
            IEntityFieldValueList refKeyList = OperationUtils.ExtractEntityKeyValues(refEntity);

            if (!AlreadyInCurrentObjectGraph(refKeyList))
            {
                _entityFieldValueList.Add(refKeyList);
            }
        }
Exemplo n.º 14
0
 public ChildLoadInterceptor(RetrievalOperationLayer dataRetrievalOperationLayer, IReadOnlyEntity parentRoEntity
                             , Type applicableParentType, ITransaction transaction, IRelation relation)
 {
     _dataRetrievalOperationLayer = dataRetrievalOperationLayer;
     _parentRoEntity       = parentRoEntity;
     _applicableParentType = applicableParentType;
     _transaction          = transaction;
     _transactionFactory   = transaction.Factory;
     _relation             = relation;
 }
Exemplo n.º 15
0
 public static IReadOnlyEntity AsReadOnly(this IReadOnlyEntity self, IReadOnlyComponentFilter componentFilter)
 {
     if (self == null)
     {
         throw new ArgumentNullException(nameof(self));
     }
     if (componentFilter == null)
     {
         throw new ArgumentNullException(nameof(componentFilter));
     }
     return(new FilteredEntity(self, componentFilter));
 }
Exemplo n.º 16
0
 public FilteredEntity(IReadOnlyEntity entity, IReadOnlyComponentFilter componentFilter)
 {
     if (entity == null)
     {
         throw new ArgumentNullException(nameof(entity));
     }
     if (componentFilter == null)
     {
         throw new ArgumentNullException(nameof(componentFilter));
     }
     Entity          = entity;
     ComponentFilter = componentFilter;
 }
Exemplo n.º 17
0
        protected static void SetValues(IReadOnlyEntity roEntity, ITypeFieldValueList values)
        {
            EntityInfo entityInfo = CacheManager.GetEntityInfo(roEntity);

            foreach (EntityFieldValue fieldValue in values.FieldValues)
            {
                if (entityInfo.FindRelationColumnInfo(fieldValue.Column.AttributeName) == null)
                {
                    PropertyInfo setter = entityInfo.GetProperty(fieldValue.Column.AttributeName);
                    ReflectionUtils.SetValue(setter, roEntity, fieldValue.Value);
                }
            }
        }
Exemplo n.º 18
0
        public override void GetQueryFormat(IReadOnlyEntity entity, QueryFormat format)
        {
            var fileInfo = entity.GetComponent(FileInfo.TypeCode);

            if (fileInfo == null)
            {
                return;
            }

            format.AddParameter(Parameters.FileName);
            format.AddParameter(Parameters.HashMD5);
            format.AddParameter(Parameters.HashSHA1OfMD5);
        }
Exemplo n.º 19
0
        private ICollection <IReadOnlyEntity> ExecuteAndReadFromPreparedStatement(IReadOnlyEntity entity, ITransaction tx, IDbCommand cmd
                                                                                  , Type childType)
        {
            EntityInfo                    entityInfo = CacheManager.GetEntityInfo(childType);
            ICollection <IColumn>         childKeys  = null;
            ICollection <IReadOnlyEntity> data       = new List <IReadOnlyEntity>();

            IDataReader reader = null;

            try
            {
                reader = cmd.ExecuteReader();
                while (reader.Read())
                {
                    if (childKeys == null)
                    {
                        childKeys = entityInfo.GetKeys();
                    }
                    ITypeFieldValueList childTypeKeyList = new EntityTypeFieldValueList(childType);
                    foreach (IColumn childKey in childKeys)
                    {
                        Object value = DbLayer.DataManipulate().ReadFromResultSet(reader, childKey);
                        childTypeKeyList.FieldValues.Add(new EntityFieldValue(value, childKey));
                    }
                    if (entity.Context.AlreadyInCurrentObjectGraph(childTypeKeyList))
                    {
                        data.Add(entity.Context.GetFromCurrentObjectGraph(childTypeKeyList));
                        continue;
                    }

                    IReadOnlyEntity rodbClass = (IReadOnlyEntity)Activator.CreateInstance(childType);
                    rodbClass.Context.CopyReferenceStoreFrom(entity);
                    rodbClass.Retrieve(reader, tx);
                    data.Add(rodbClass);

                    entity.Context.AddToCurrentObjectGraphIndex(rodbClass);
                }
            }
            catch (Exception ex)
            {
                string message = String.Format("SQL Exception while trying to read type {0} from result set", childType.FullName);
                throw new ReadFromResultSetException(message, ex);
            }
            finally
            {
                DbMgtUtility.Close(reader);
                DbMgtUtility.Close(cmd);
            }

            return(data);
        }
Exemplo n.º 20
0
        public static ITypeFieldValueList ExtractEntityTypeKeyValues(IReadOnlyEntity entity, Type type)
        {
            EntityTypeFieldValueList valueList = null;

            if (entity is IEntity)
            {
                valueList = new EntityTypeFieldValueList(type);
                IEntity entityDbClass = (IEntity)entity;
                ICollection <EntityFieldValue> extractedValues = ExtractValues(entityDbClass, true, type);
                foreach (EntityFieldValue entityFieldValue in extractedValues)
                {
                    valueList.FieldValues.Add(entityFieldValue);
                }
            }
            return(valueList);
        }
Exemplo n.º 21
0
        public static ITypeFieldValueList ExtractRelationKeyValues(IReadOnlyEntity child, IRelation relation)
        {
            EntityRelationFieldValueList valueList = null;

            if (child is IEntity)
            {
                valueList = new EntityRelationFieldValueList(relation);
                IEntity childDbClass = (IEntity)child;
                ICollection <EntityFieldValue> extractedValues = ExtractValues(childDbClass, true, null);
                foreach (EntityFieldValue entityFieldValue in extractedValues)
                {
                    valueList.FieldValues.Add(entityFieldValue);
                }
            }
            return(valueList);
        }
Exemplo n.º 22
0
        public override void GetQueryFormat(IReadOnlyEntity entity, QueryFormat format)
        {
            if (entity == null)
            {
                throw new ArgumentNullException(nameof(entity));
            }
            if (format == null)
            {
                throw new ArgumentNullException(nameof(format));
            }

            foreach (var handler in Handlers)
            {
                handler.GetQueryFormat(entity, format);
            }
        }
Exemplo n.º 23
0
        private void LoadFromDb(IReadOnlyEntity roEntity, IDataReader reader, ITransaction tx)
        {
            EntityInfo entityInfo = CacheManager.GetEntityInfo(roEntity);

            while (entityInfo != null)
            {
                string tableName = entityInfo.TableInfo.TableName;
                if (entityInfo.EntityType == roEntity.GetType() || tableName == null) //if i==0 that means it's base class and can use existing result set
                {
                    LoadForType(roEntity, entityInfo.EntityType, reader, tx);
                }
                else
                {
                    IDbCommand  superCmd    = null;
                    IDataReader superReader = null;
                    try
                    {
                        ITypeFieldValueList keyValueList = OperationUtils.ExtractEntityTypeKeyValues(roEntity, entityInfo.EntityType);
                        superCmd    = CreateRetrievalPreparedStatement(keyValueList, tx);
                        superReader = superCmd.ExecuteReader();
                        if (superReader.Read())
                        {
                            LoadForType(roEntity, entityInfo.EntityType, superReader, tx);
                        }
                        else
                        {
                            string message =
                                String.Format(
                                    "Super class {0} does not contains a matching record for the base class {1}",
                                    entityInfo.EntityType.FullName, roEntity.GetType().FullName);
                            throw new NoMatchingRecordFoundForSuperClassException(message);
                        }
                    }
                    catch (Exception ex)
                    {
                        String message = String.Format("SQL Exception while trying to read from table {0}", tableName);
                        throw new ReadFromResultSetException(message, ex);
                    }
                    finally
                    {
                        DbMgtUtility.Close(superReader);
                        DbMgtUtility.Close(superCmd);
                    }
                }
                entityInfo = entityInfo.SuperEntityInfo;
            }
        }
Exemplo n.º 24
0
        private bool VersionValidated(IReadOnlyEntity entity, Type type, ITransaction tx)
        {
            EntityInfo            entityInfo  = CacheManager.GetEntityInfo(type);
            ICollection <IColumn> typeColumns = entityInfo.Columns;

            foreach (IColumn typeColumn in typeColumns)
            {
                if (typeColumn.ColumnType == ColumnType.Version)
                {
                    Object           classValue         = ExtractCurrentVersionValue(entity, typeColumn, type, tx);
                    EntityFieldValue originalFieldValue = entity.Context.ChangeTracker.GetFieldValue(typeColumn.AttributeName);
                    return(originalFieldValue != null && classValue == originalFieldValue.Value ||
                           (originalFieldValue != null && classValue != null && classValue.Equals(originalFieldValue.Value)));
                }
            }

            if (entityInfo.TableInfo.UpdateStrategy == UpdateStrategy.ChangedColumns)
            {
                ICollection <EntityFieldValue> modified = GetModifiedFieldValues(entity, type);
                typeColumns = new List <IColumn>();
                foreach (EntityFieldValue fieldValue in modified)
                {
                    typeColumns.Add(fieldValue.Column);
                }
            }

            ITypeFieldValueList fieldValueList = ExtractCurrentRowValues(entity, type, tx);

            if (fieldValueList == null)
            {
                return(false);
            }
            foreach (IColumn typeColumn in typeColumns)
            {
                EntityFieldValue classFieldValue    = fieldValueList.GetFieldValue(typeColumn.AttributeName);
                EntityFieldValue originalFieldValue = entity.Context != null?entity.Context.ChangeTracker.GetFieldValue(typeColumn.AttributeName) : null;

                bool matches = originalFieldValue != null && classFieldValue != null && classFieldValue.Value == originalFieldValue.Value ||
                               (originalFieldValue != null && classFieldValue != null && classFieldValue.Value != null && classFieldValue.Value.Equals(originalFieldValue.Value));
                if (!matches)
                {
                    return(false);
                }
            }
            return(true);
        }
Exemplo n.º 25
0
 public void Load(IReadOnlyEntity roEntity, IDataReader reader, ITransaction tx)
 {
     if (roEntity is IEntity)
     {
         IEntity entity = (IEntity)roEntity;
         entity.Status = EntityStatus.Unmodified;
     }
     try
     {
         LoadFromDb(roEntity, reader, tx);
         roEntity.Context.DestroyReferenceStore();
     }
     catch (Exception e)
     {
         Logger.GetLogger(Config.LoggerName).Fatal(e.Message, e);
         throw new RetrievalException(e.Message, e);
     }
 }
Exemplo n.º 26
0
        private void LoadForType(IReadOnlyEntity entity, Type type, IDataReader reader, ITransaction tx)
        {
            EntityInfo          entityInfo    = CacheManager.GetEntityInfo(type);
            IEntityContext      entityContext = entity.Context;
            ITypeFieldValueList valueTypeList = ReadValues(type, reader);

            SetValues(entity, valueTypeList);
            entity.Context.AddToCurrentObjectGraphIndex(entity);

            if (entityContext != null)
            {
                entityContext.ChangeTracker.AddFields(valueTypeList.FieldValues);
            }

            ICollection <IRelation> dbRelations = entityInfo.Relations;

            foreach (IRelation relation in dbRelations)
            {
                LoadChildrenFromRelation(entity, type, tx, relation, false);
            }
        }
Exemplo n.º 27
0
        /// <summary>
        /// Compare equality through ID
        /// </summary>
        /// <param name="other">Entity to compare.</param>
        /// <returns>true if are equals</returns>
        /// <remarks>
        /// Two entities are equals if they are of the same hierarchy tree/sub-tree
        /// and has same id.
        /// </remarks>
        public virtual bool Equals(IReadOnlyEntity <IdT> other)
        {
            if (null == other || (!GetType().IsInstanceOfType(other) && !other.GetType().IsInstanceOfType(this)))
            {
                return(false);
            }
            if (ReferenceEquals(this, other))
            {
                return(true);
            }

            bool otherIsTransient = Equals(other.ID, default(IdT));
            bool thisIsTransient  = IsTransient();

            if (otherIsTransient && thisIsTransient)
            {
                return(ReferenceEquals(other, this));
            }

            return(other.ID.Equals(ID));
        }
        public override void GetQueryFormat(IReadOnlyEntity entity, QueryFormat format)
        {
            var card = entity.GetComponent(KoikatuCharacterCard.TypeCode);

            if (card == null)
            {
                return;
            }

            format.AddParameter(Parameters.Name);
            format.AddSelectableValue(Parameters.Sex, card.Sex);
            format.AddSelectableValue(Parameters.Personality, card.Personality);
            format.AddSelectableValue(Parameters.ClubActivities, card.ClubActivity);
            format.AddSelectableValue(Parameters.BloodType, card.BloodType);

            format.AddSelectableValue(Parameters.TeethType, card.TeethType);

            format.AddSelectableValue(Parameters.HeightType, card.HeightType);
            format.AddSelectableValue(Parameters.BustSizeType, card.BustSizeType);
            format.AddSelectableValue(Parameters.SkinType, card.SkinType);
            foreach (var adjective in Palettes.Skin.GetAdjectives(card.SkinColor))
            {
                format.AddSelectableValue(Parameters.SkinColorType, adjective);
#if DEBUG
                format.AddSelectableValue(Parameters.InverseSkinColorType, adjective);
#endif
            }

            format.AddSelectableValue(Parameters.HairStyle, card.HairStyle);
            foreach (var adjective in card.HairColors.Select(i => Palettes.Hair.GetAdjectives(i)).SelectMany(i => i))
            {
                format.AddSelectableValue(Parameters.HairColorType, adjective);
#if DEBUG
                format.AddSelectableValue(Parameters.InverseHairColorType, adjective);
#endif
            }
        }
Exemplo n.º 29
0
 public void Load(IReadOnlyEntity readOnlyEntity, IDataReader reader, ITransaction tx)
 {
     _persistRetrievalLayer.Load(readOnlyEntity, reader, tx);
 }
Exemplo n.º 30
0
        public void LoadChildrenFromRelation(IReadOnlyEntity parentRoEntity, Type entityType, ITransaction tx
                                             , IRelation relation, bool lazy)
        {
            EntityInfo     entityInfo    = CacheManager.GetEntityInfo(entityType);
            IEntityContext entityContext = parentRoEntity.Context;

            PropertyInfo property = entityInfo.GetProperty(relation.AttributeName);
            Object       value    = ReflectionUtils.GetValue(property, parentRoEntity);

            if (!lazy && relation.FetchStrategy == FetchStrategy.Lazy)
            {
                CreateProxy(parentRoEntity, entityType, tx, relation, value, property);
                return;
            }

            ICollection <IReadOnlyEntity> children = ReadRelationChildrenFromDb(parentRoEntity, entityType, tx, relation);

            if (entityContext != null &&
                !relation.ReverseRelationship)
            {
                foreach (IReadOnlyEntity childEntity in children)
                {
                    ITypeFieldValueList valueTypeList = OperationUtils.ExtractRelationKeyValues(childEntity, relation);
                    if (valueTypeList != null)
                    {
                        entityContext.ChangeTracker.AddChildEntityKey(valueTypeList);
                    }
                }
            }

            if ((value == null || ProxyUtil.IsProxyType(value.GetType())) &&
                ReflectionUtils.IsImplementInterface(property.PropertyType, typeof(ICollection <>)))
            {
                Type propertyType = property.PropertyType;
                if (propertyType.IsInterface)
                {
                    Type generic = propertyType.GetGenericArguments()[0];
                    propertyType = typeof(List <>).MakeGenericType(new Type[] { generic });
                }
                value = Activator.CreateInstance(propertyType);

                IList genCollection = (IList)value;
                foreach (IReadOnlyEntity serverRoDbClass in children)
                {
                    genCollection.Add(serverRoDbClass);
                }
                ReflectionUtils.SetValue(property, parentRoEntity, genCollection);
            }
            else if (value != null &&
                     ReflectionUtils.IsImplementInterface(property.PropertyType, typeof(ICollection <>)))
            {
                IList genCollection = (IList)value;
                foreach (IReadOnlyEntity serverRoDbClass in children)
                {
                    genCollection.Add(serverRoDbClass);
                }
            }
            else
            {
                IEnumerator <IReadOnlyEntity> childEnumarator = children.GetEnumerator();
                if (childEnumarator.MoveNext())
                {
                    IReadOnlyEntity singleRoDbClass = childEnumarator.Current;
                    if (property.PropertyType.IsAssignableFrom(singleRoDbClass.GetType()))
                    {
                        ReflectionUtils.SetValue(property, parentRoEntity, singleRoDbClass);
                    }
                    else
                    {
                        string message = singleRoDbClass.GetType().FullName + " is not matching the getter " + property.Name;
                        Logger.GetLogger(Config.LoggerName).Fatal(message);
                        throw new NoSetterFoundToSetChildObjectListException(message);
                    }
                }
            }
        }