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);
}
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);
}
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);
}
private void FillChangeTrackerValues(IEntity entity, ITransaction tx, IEntityContext entityContext)
{
if (entity.Status == EntityStatus.New ||
entity.Status == EntityStatus.Deleted)
{
return;
}
EntityInfo entityInfo = CacheManager.GetEntityInfo(entity);
while (entityInfo != null)
{
ITypeFieldValueList values = ExtractCurrentRowValues(entity, entityInfo.EntityType, tx);
entityContext.ChangeTracker.AddFields(values.FieldValues);
ICollection <IRelation> dbRelations = entityInfo.Relations;
foreach (IRelation relation in dbRelations)
{
ICollection <IReadOnlyEntity> children = ReadRelationChildrenFromDb(entity, entityInfo.EntityType, tx, relation);
foreach (IReadOnlyEntity childEntity in children)
{
ITypeFieldValueList valueTypeList = OperationUtils.ExtractRelationKeyValues(childEntity, relation);
if (valueTypeList != null)
{
entityContext.ChangeTracker.AddChildEntityKey(valueTypeList);
}
}
}
entityInfo = entityInfo.SuperEntityInfo;
}
}
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);
}
}
private void SaveForType(IEntity entity, Type type, ITransaction tx)
{
EntityInfo entityInfo = CacheManager.GetEntityInfo(type);
if (entityInfo == null)
{
return;
}
ProcessNonIdentifyingRelations(entity, entityInfo);
ITypeFieldValueList fieldValues = OperationUtils.ExtractEntityTypeFieldValues(entity, type);
if (entity.Status == EntityStatus.Unmodified)
{
//do nothing
}
else if (entity.Status == EntityStatus.New)
{
Insert(entity, fieldValues, type, tx);
}
else if (entity.Status == EntityStatus.Modified)
{
if (entityInfo.TableInfo.VerifyOnWriteStrategy == VerifyOnWriteStrategy.Verify)
{
if (!VersionValidated(entity, type, tx))
{
throw new DataUpdatedFromAnotherSourceException(String.Format("The type {0} updated from another transaction", type));
}
OperationUtils.IncrementVersion(fieldValues);
SetValues(entity, fieldValues);
}
Update(entity, fieldValues, type, tx);
}
else if (entity.Status == EntityStatus.Deleted)
{
Delete(fieldValues, type, tx);
}
else
{
string message = String.Format("In-corret status for class {0}", type.FullName);
throw new IncorrectStatusException(message);
}
fieldValues = OperationUtils.ExtractEntityTypeFieldValues(entity, type);
IEntityContext entityContext = entity.Context;
if (entityContext != null)
{
entityContext.ChangeTracker.AddFields(fieldValues.FieldValues);
}
entity.Context.AddToCurrentObjectGraphIndex(entity);
ProcessIdentifyingRelations(entity, type, tx, entityInfo, fieldValues);
}
public void AddChildEntityKey(ITypeFieldValueList list)
{
lock (this)
{
var tmpList = new List <ITypeFieldValueList>();
tmpList.AddRange(_childEntityRelationKeys);
tmpList.Add(list);
_childEntityRelationKeys = new ReadOnlyCollection <ITypeFieldValueList>(tmpList);
}
}
public IReadOnlyEntity GetFromCurrentObjectGraph(ITypeFieldValueList keys)
{
foreach (IEntityFieldValueList existingEntity in _entityFieldValueList)
{
if (OperationUtils.IsTypeKeyEquals(keys, existingEntity))
{
return(existingEntity.Entity);
}
}
return(null);
}
private void Insert(IEntity entity, ITypeFieldValueList valueTypeList, Type entityType, ITransaction tx)
{
EntityInfo entityInfo = CacheManager.GetEntityInfo(entityType);
StringBuilder logSb = new StringBuilder();
string query = entityInfo.GetInsertQuery(DbLayer);
IDbCommand cmd = tx.CreateCommand();
cmd.CommandText = query;
bool showQuery = Config.ShowQueries;
if (showQuery)
{
logSb.Append(query);
}
int i = 0;
foreach (EntityFieldValue fieldValue in valueTypeList.FieldValues)
{
IColumn column = fieldValue.Column;
Object columnValue;
if (column.ReadFromSequence &&
column.SequenceGenerator != null)
{
columnValue = column.SequenceGenerator.GetNextSequenceValue(tx);
PropertyInfo setter = entityType.GetProperty(column.AttributeName);
ReflectionUtils.SetValue(setter, entity, columnValue);
}
else
{
columnValue = fieldValue.Value;
}
if (showQuery)
{
logSb.Append(" ,").Append(column.ColumnName).Append("=").Append(columnValue);
}
DbLayer.DataManipulate().SetToPreparedStatement(cmd, columnValue, i + 1, column);
i++;
}
if (showQuery)
{
Logger.GetLogger(Config.LoggerName).Debug(logSb.ToString());
}
if (Config.EnableStatistics)
{
Statistics.RegisterInsert(entityType);
}
cmd.ExecuteNonQuery();
DbMgtUtility.Close(cmd);
}
public static void IncrementVersion(ITypeFieldValueList fieldValues)
{
foreach (EntityFieldValue fieldValue in fieldValues.FieldValues)
{
if (fieldValue.Column.ColumnType == ColumnType.Version)
{
int version = int.Parse(fieldValue.Value.ToString());
version++;
fieldValue.Value = version;
break;
}
}
}
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);
}
}
}
protected IDbCommand CreateRetrievalPreparedStatement(ITypeFieldValueList keyValueList, ITransaction tx)
{
Type targetType = keyValueList.Type;
EntityInfo entityInfo = CacheManager.GetEntityInfo(targetType);
string query = entityInfo.GetLoadQuery(DbLayer);
IDbCommand cmd;
try
{
cmd = tx.CreateCommand();
cmd.CommandText = query;
}
catch (Exception ex)
{
string message = String.Format("SQL Exception while trying create command for sql {0}", query);
throw new CommandCreationException(message, ex);
}
ICollection <IColumn> keys = entityInfo.GetKeys();
StringBuilder logSb = new StringBuilder();
bool showQuery = Config.ShowQueries;
if (showQuery)
{
logSb.Append(query);
}
int i = 0;
foreach (IColumn key in keys)
{
Object fieldValue = keyValueList.GetFieldValue(key.AttributeName).Value;
if (showQuery)
{
logSb.Append(" ,").Append(key.ColumnName).Append("=").Append(fieldValue);
}
DbLayer.DataManipulate().SetToPreparedStatement(cmd, fieldValue, ++i, key);
}
if (showQuery)
{
Logger.GetLogger(Config.LoggerName).Debug(logSb.ToString());
}
if (Config.EnableStatistics)
{
Statistics.RegisterSelect(targetType);
}
return(cmd);
}
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;
}
}
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);
}
private void Delete(ITypeFieldValueList valueTypeList, Type type, ITransaction tx)
{
EntityInfo entityInfo = CacheManager.GetEntityInfo(type);
StringBuilder logSb = new StringBuilder();
string query = entityInfo.GetDeleteQuery(DbLayer);
IList <EntityFieldValue> keys = new List <EntityFieldValue>();
foreach (EntityFieldValue fieldValue in valueTypeList.FieldValues)
{
if (fieldValue.Column.Key)
{
keys.Add(fieldValue);
}
}
bool showQuery = Config.ShowQueries;
if (showQuery)
{
logSb.Append(query);
}
IDbCommand ps = tx.CreateCommand();
ps.CommandText = query;
for (int i = 0; i < keys.Count; i++)
{
EntityFieldValue fieldValue = keys[i];
if (showQuery)
{
logSb.Append(" ,").Append(fieldValue.Column.ColumnName).Append("=").Append(fieldValue.Value);
}
DbLayer.DataManipulate().SetToPreparedStatement(ps, fieldValue.Value, i + 1, fieldValue.Column);
}
if (showQuery)
{
Logger.GetLogger(Config.LoggerName).Debug(logSb.ToString());
}
if (Config.EnableStatistics)
{
Statistics.RegisterDelete(type);
}
ps.ExecuteNonQuery();
DbMgtUtility.Close(ps);
}
protected static ICollection <ITypeFieldValueList> GetChildEntityValueList(IEntity parentEntity, bool takeDeleted)
{
EntityInfo entityInfo = CacheManager.GetEntityInfo(parentEntity);
ICollection <ITypeFieldValueList> existingEntityChildRelations = new List <ITypeFieldValueList>();
while (entityInfo != null)
{
ICollection <IRelation> typeRelations = entityInfo.Relations;
foreach (IRelation typeRelation in typeRelations)
{
if (typeRelation.ReverseRelationship)
{
continue;
}
if (IsProxyObject(parentEntity, typeRelation))
{
continue;
}
ICollection <IEntity> childEntities = OperationUtils.GetRelationEntities(parentEntity, typeRelation);
foreach (IEntity childEntity in childEntities)
{
if (parentEntity.Status == EntityStatus.Deleted &&
typeRelation.DeleteRule == ReferentialRuleType.Cascade)
{
childEntity.Status = EntityStatus.Deleted;
}
if (childEntity.Status == EntityStatus.Deleted && !takeDeleted)
{
continue;
}
ITypeFieldValueList childKeyValueList = OperationUtils.ExtractRelationKeyValues(childEntity, typeRelation);
if (childKeyValueList != null)
{
existingEntityChildRelations.Add(childKeyValueList);
}
}
}
entityInfo = entityInfo.SuperEntityInfo;
}
return(existingEntityChildRelations);
}
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);
}
}
private static void SetRelationObjectKeyValues(ITypeFieldValueList valueTypeList, Type entityType, Type childEntityType
, IEnumerable <IEntity> childObjects, IRelation relation)
{
EntityInfo entityInfo = CacheManager.GetEntityInfo(entityType);
ICollection <IColumn> columns = entityInfo.Columns;
foreach (RelationColumnMapping mapping in relation.TableColumnMappings)
{
IColumn matchColumn = entityInfo.FindColumnByAttribute(mapping.FromField);
EntityFieldValue fieldValue = valueTypeList.GetFieldValue(matchColumn.AttributeName);
if (fieldValue != null)
{
SetChildPrimaryKeys(fieldValue, childEntityType, childObjects, mapping);
}
else
{
string message = String.Format("The column {0} does not have a matching column in the object {1}", matchColumn.ColumnName, valueTypeList.Type.FullName);
throw new NoMatchingColumnFoundException(message);
}
}
}
private static void ProcessIdentifyingRelations(IEntity entity, Type type, ITransaction tx
, EntityInfo entityInfo, ITypeFieldValueList fieldValues)
{
ICollection <IRelation> dbRelations = entityInfo.Relations;
foreach (IRelation relation in dbRelations)
{
if (relation.ReverseRelationship ||
relation.NonIdentifyingRelation)
{
continue;
}
if (IsProxyObject(entity, relation))
{
continue;
}
ICollection <IEntity> childObjects = OperationUtils.GetRelationEntities(entity, relation);
if (childObjects != null)
{
SetRelationObjectKeyValues(fieldValues, type, relation.RelatedObjectType, childObjects, relation);
foreach (IEntity fieldObject in childObjects)
{
IEntityFieldValueList childEntityKeyList = OperationUtils.ExtractEntityKeyValues(fieldObject);
if (entity.Context.AlreadyInCurrentObjectGraph(childEntityKeyList))
{
continue;
}
fieldObject.Context.CopyReferenceStoreFrom(entity);
if (fieldObject.Status != EntityStatus.Deleted) //deleted items are already deleted
{
fieldObject.Persist(tx);
entity.Context.AddToCurrentObjectGraphIndex(fieldObject);
}
}
}
}
}
private void Update(IEntity entity, ITypeFieldValueList valueTypeList, Type type, ITransaction tx)
{
EntityInfo entityInfo = CacheManager.GetEntityInfo(type);
ICollection <EntityFieldValue> keys = new List <EntityFieldValue>();
ICollection <EntityFieldValue> values = new List <EntityFieldValue>();
StringBuilder logSb = new StringBuilder();
string query;
if (entityInfo.TableInfo.UpdateStrategy == UpdateStrategy.ChangedColumns)
{
values = GetModifiedFieldValues(entity, type);
if (values.Count == 0)
{
return;
}
keys = OperationUtils.ExtractEntityKeyValues(entity).FieldValues;
ICollection <IColumn> keysAndModified = new List <IColumn>();
foreach (EntityFieldValue fieldValue in values)
{
keysAndModified.Add(fieldValue.Column);
}
foreach (EntityFieldValue fieldValue in keys)
{
keysAndModified.Add(fieldValue.Column);
}
query = DbLayer.DataManipulate().CreateUpdateQuery(entityInfo.TableInfo.TableName, keysAndModified);
}
else
{
query = entityInfo.GetUpdateQuery(DbLayer);
foreach (EntityFieldValue fieldValue in valueTypeList.FieldValues)
{
if (fieldValue.Column.Key)
{
keys.Add(fieldValue);
}
else
{
values.Add(fieldValue);
}
}
}
bool showQuery = Config.ShowQueries;
if (showQuery)
{
logSb.Append(query);
}
IDbCommand cmd = tx.CreateCommand();
cmd.CommandText = query;
int count = 0;
foreach (EntityFieldValue fieldValue in values)
{
if (showQuery)
{
logSb.Append(" ,").Append(fieldValue.Column.ColumnName).Append("=").Append(fieldValue.Value);
}
DbLayer.DataManipulate().SetToPreparedStatement(cmd, fieldValue.Value, ++count, fieldValue.Column);
}
foreach (EntityFieldValue fieldValue in keys)
{
if (showQuery)
{
logSb.Append(" ,").Append(fieldValue.Column.ColumnName).Append("=").Append(fieldValue.Value);
}
DbLayer.DataManipulate().SetToPreparedStatement(cmd, fieldValue.Value, ++count, fieldValue.Column);
}
if (showQuery)
{
Logger.GetLogger(Config.LoggerName).Debug(logSb.ToString());
}
if (Config.EnableStatistics)
{
Statistics.RegisterUpdate(type);
}
cmd.ExecuteNonQuery();
DbMgtUtility.Close(cmd);
}
public bool AlreadyInCurrentObjectGraph(ITypeFieldValueList keys)
{
return(GetFromCurrentObjectGraph(keys) != null);
}
public IReadOnlyEntity GetFromCurrentObjectGraph(ITypeFieldValueList keys)
{
InitReferenceStore();
return(_referenceStore.GetFromCurrentObjectGraph(keys));
}
public bool AlreadyInCurrentObjectGraph(ITypeFieldValueList keys)
{
InitReferenceStore();
return(_referenceStore.AlreadyInCurrentObjectGraph(keys));
}
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);
}
}
}
}
public static bool IsTypeKeyEquals(ITypeFieldValueList item1, ITypeFieldValueList item2)
{
return(item1.Type == item2.Type && IsValueKeyEquals(item1, item2));
}
