public void DeepLoadEntityManyToManyTest() { var usersTable = CreateAndPopulateMockTable("User"); var groupsTable = CreateAndPopulateMockTable("Group"); var groupUserTable = CreateAndPopulateMockTable("GroupUser"); var memProvider = new MemoryDataProvider(); memProvider.AddTable(usersTable); memProvider.AddTable(groupsTable); memProvider.AddTable(groupUserTable); var query = new DataModelQuery <DataModel <Group> >(); var egroups = memProvider.DeepLoadModels(query); var groups = new DataModelCollection <DataModel <Group> >(egroups); Assert.IsTrue(groups.Count == 2, "Groups did not load"); Assert.IsNotNull(groups[0].Entity, "Group 0 Entity was not set"); Assert.IsNotNull(groups[0].Entity.Users, "Group 0 Users were not set"); Assert.IsTrue(groups[0].Entity.Users.Count == 2, "Users count (group 0 of 0,1) is not 2"); Assert.IsNotNull(groups[1].Entity, "Group 1 Entity was not set"); Assert.IsNotNull(groups[0].Entity.Users, "Group 1 Users were not set"); Assert.IsTrue(groups[1].Entity.Users.Count == 2, "Users count (group 1 of 0,1) is not 2"); Assert.IsTrue(groups[0].Entity.Users[0].ID != groups[1].Entity.Users[0].ID, "Same user loaded between groups"); Assert.IsTrue(groups[0].Entity.Users[0].ID != groups[1].Entity.Users[1].ID, "Same user loaded between groups"); Assert.IsTrue(groups[1].Entity.Users[0].ID != groups[0].Entity.Users[0].ID, "Same user loaded between groups"); }
public SampleViewModel() { Data = new DataModelCollection { new DataModel { NodeName = "Node 11", Children = new DataModelCollection { new DataModel { NodeName = "Node 113" }, new DataModel { NodeName = "Node 123" }, new DataModel { NodeName = "Node 133" }, } }, new DataModel { NodeName = "Node 22", Children = new DataModelCollection { new DataModel { NodeName = "Node 213" }, new DataModel { NodeName = "Node 223" }, } }, new DataModel { NodeName = "Node 33", Children = new DataModelCollection { new DataModel { NodeName = "Node 313" }, } }, }; }
/// <summary> /// Saves the changes that were made to each of the /// specified <paramref name="dataEntities"/>, within the specified /// database <paramref name="transactionContext"/>. /// <remarks> /// The specified entities must have the Deleted property set to true, /// IsDirty evaluated as true, or IsNew evaluated as true, or else /// the entity will not be saved. /// </remarks> /// </summary> /// <param name="dataEntities"></param> /// <param name="transactionContext"></param> public override void SaveModels <TModel>(DataModelCollection <TModel> dataEntities, DbTransaction transactionContext) { DbConnection tmpConn = null; if (transactionContext == null) { tmpConn = CreateAndOpenConnection(); transactionContext = tmpConn.BeginTransaction(); } try { foreach (TModel entity in dataEntities) { SaveModel(entity, transactionContext); } } finally { if (tmpConn != null) { transactionContext.Commit(); tmpConn.Close(); } } }
/// <summary> /// Loads the full object graph for the /// <see cref="DataModel"/> objects that are returned from the specified /// <paramref name="query"/>, within the specified database /// <paramref name="transactionContext"/>. /// </summary> /// <param name="query"></param> /// <param name="transactionContext"></param> /// <param name="depth"></param> /// <param name="loadedModels"> /// Used for keeping recursive loading from resulting /// in infinite loops. Evaluate each loaded item from /// a database result set against this collection; if /// there is a match, use the collection item, /// otherwise use the database loaded item, deep-load /// it, and add it to this collection. /// </param> /// <returns></returns> public virtual DataModelCollection <TModel> DeepLoadModels <TModel>( DataModelQuery <TModel> query, int?depth, DbTransaction transactionContext, List <DataModel> loadedModels) where TModel : DataModel { DataModelCollection <TModel> entities = LoadModels(query); DataModel e; bool hasForeignKey = false; if (entities.Count > 0) { e = entities[0]; foreach (var field_kvp in e.EntityMappings.FieldMappings) { DataModelColumnAttribute field = field_kvp.Value; if (field.IsForeignKey) { hasForeignKey = true; break; } } if (!hasForeignKey && (e.EntityMappings.ForeignModelMappings == null || e.EntityMappings.ForeignModelMappings.Count == 0)) { return(entities); } } for (int i = 0; i < entities.Count; i++) { if (depth == null || depth > 0) { TModel entity = entities[i]; if (hasForeignKey && !loadedModels.Contains(entity)) { foreach (var field_kvp in entity.EntityMappings.FieldMappings) { DataModelColumnAttribute field = field_kvp.Value; if (field.IsForeignKey && field.ForeignKeyMapping.AssignToMember != null) { LoadMember(entity, field, field_kvp.Key, transactionContext, loadedModels); loadedModels.Add(entity); } } } if (entity.EntityMappings.ForeignModelMappings != null && entity.EntityMappings.ForeignModelMappings.Count > 0 ) { DataModelQuery <TModel> query2 = EntityToIdentifyingQuery(entity); entity = (depth == null) ? DeepLoadModel(query2, transactionContext, loadedModels) : DeepLoadModel(query2, depth - 1, transactionContext, loadedModels); //loadedModels.Add(entity); entities[i] = entity; } } } return(entities); }
/// <summary> /// Saves the entire object graph of the specified /// <see cref="DataModel"/> objects, within the specified /// database <paramref name="transactionContext"/>, /// where any of their properties /// are also <see cref="DataModel"/> objects with /// IsDirty, Deleted, or IsNew change state. /// </summary> /// <typeparam name="TModel"></typeparam> /// <param name="col"></param> /// <param name="transactionContext"></param> public void DeepSaveModels <TModel>( DataModelCollection <TModel> col, DbTransaction transactionContext) where TModel : DataModel { var savedModels = new List <DataModel>(); DeepSaveModels(col, transactionContext, savedModels); }
/// <summary> /// Applies the appropriate changes to the database with respect to /// any in-memory <see cref="DataTable"/> records associated with /// the specified <paramref name="dataEntities"/>. /// The <paramref name="transactionContext"/> parameter is not supported /// and must be null. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="dataEntities"></param> /// <param name="transactionContext"></param> public override void SaveModels <T>( DataModelCollection <T> dataEntities, DbTransaction transactionContext) { if (transactionContext != null) { throw new NotImplementedException("MemoryDataProvider does not support DbTransactions"); } foreach (var dataModel in dataEntities) { SaveModel(dataModel, transactionContext); } }
/// <summary> /// Saves the entire object graph of the specified /// <see cref="DataModel"/> objects, within the specified /// database <paramref name="transactionContext"/>, /// where any of their properties /// are also <see cref="DataModel"/> objects with /// IsDirty, Deleted, or IsNew change state. /// </summary> /// <typeparam name="TModel"></typeparam> /// <param name="col"></param> /// <param name="transactionContext"></param> /// <param name="savedModels"></param> public virtual void DeepSaveModels <TModel>( DataModelCollection <TModel> col, DbTransaction transactionContext, List <DataModel> savedModels) where TModel : DataModel { foreach (TModel entity in col) { if (savedModels.Contains(entity)) { continue; } entity.SynchronizeFields(SyncTo.FieldMappedData); DeepSaveModel(entity, transactionContext); savedModels.Add(entity); } }
/// <summary> /// Returns a collection of loaded instances of the specified type using the specified /// <paramref name="query"/> and <paramref name="transactionContext"/>. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="query"></param> /// <param name="transactionContext"></param> /// <returns></returns> public override DataModelCollection <T> LoadModels <T>(DataModelQuery <T> query, DbTransaction transactionContext) { if (transactionContext != null) { throw new NotImplementedException("MemoryDataProvider does not support DbTransactions"); } var map = DataModel.GetMapping <T>(); var table = Tables[map.TableMapping.Table]; var rows = table.Select(QueryToExpression(query), QueryToSortExpression(query)); var retcol = new DataModelCollection <T>(); if (rows.Length == 0) { return(retcol); } var t = DataModel.GetUnwrappedType(typeof(T)); foreach (DataRow row in rows) { T ret; while (t.IsGenericType && t.IsOrInherits(typeof(IEnumerable))) { t = t.GetGenericArguments().Last(); } if (t != typeof(T)) { var subret = Activator.CreateInstance(t); var retT = typeof(DataModel <>).MakeGenericType(t); ret = (T)Activator.CreateInstance(retT, new[] { subret }); ret.Load(row); ret.DataProvider = this; } else { ret = (T)Activator.CreateInstance(typeof(T)); ret.Load(row); ret.DataProvider = this; } retcol.Add(ret); } retcol.DataProvider = this; return(retcol); }
public void DeepLoadEntitiesTest() { DataProviderBase mockRepos = new MemoryDataProvider(); var table = ((MemoryDataProvider)mockRepos).AddTable("mock_table"); PopulateMockTable(table); var table2 = ((MemoryDataProvider)mockRepos).AddTable("mock_table2"); PopulateMockTable(table2); var query = DataModel <DataModelRelationshipMetadataTest.MockPocoChild> .NewQuery(); DataModelCollection <DataModel <DataModelRelationshipMetadataTest.MockPocoChild> > entities = mockRepos.DeepLoadModels(query); Assert.IsNotNull(entities); Assert.IsTrue(entities.Count == 4); Assert.IsTrue(entities[0].Entity.MockPoco != null); Assert.IsTrue(entities[3].Entity.MockPoco != null); Assert.IsTrue(entities[2].Entity.MockPoco.MockDecimalValue .Equals(entities[2].Entity.MockDecimalValue)); }
public DataModel() { Children = new DataModelCollection(); }
/// <summary> /// Loads a set of <see cref="DataModel"/> objects /// using the specified <paramref name="query"/> within the /// specified database <paramref name="transactionContext"/>. /// </summary> /// <typeparam name="TModel"></typeparam> /// <param name="query"></param> /// <param name="transactionContext"></param> /// <returns></returns> public override DataModelCollection <TModel> LoadModels <TModel>( DataModelQuery <TModel> query, DbTransaction transactionContext) { DataModelMap demap = DataModel.GetMapping <TModel>(); DbConnection tmpConn = null; if (transactionContext == null) { tmpConn = CreateAndOpenConnection(); transactionContext = tmpConn.BeginTransaction(ProviderDefaults.IsolationLevel); } DbConnection conn = transactionContext.Connection; try { DbDataProviderCommandBuilder <TModel> cmdBuilder = CreateCommandBuilder(query); using (DbCommand cmd = cmdBuilder.CreateDbCommand(transactionContext)) { cmd.Transaction = transactionContext; using (DbDataReader dr = cmd.ExecuteReader(cmdBuilder.ExecuteBehavior ?? CommandBehavior.Default)) { var ret = new DataModelCollection <TModel> { DataProvider = this }; if (query.Pagination == null || query.Pagination.ItemsPerPage == int.MaxValue || query.Pagination.ItemsPerPage == 0 || cmdBuilder.PaginationIsHandled) { while (dr.Read()) { var obj = (TModel)Activator.CreateInstance(typeof(TModel)); obj.DataProvider = this; obj.Load(dr); ret.Add(obj); } } else { int start = query.Pagination.Page * query.Pagination.ItemsPerPage - query.Pagination.ItemsPerPage; bool eof = false; for (int i = 0; i < start; i++) { if (!dr.Read()) { eof = true; break; } } for (int i = 0; i < query.Pagination.ItemsPerPage && !eof; i++) { if (!dr.Read()) { eof = true; break; } var obj = (TModel)Activator.CreateInstance(typeof(TModel)); obj.DataProvider = this; obj.Load(dr); ret.Add(obj); } } if (!string.IsNullOrEmpty(demap.TableMapping.SelectManyProcedure) && query.OrderBy.Count > 0) { // exec sort from last sort field to first to get correct end result for (int i = query.OrderBy.Count - 1; i >= 0; i--) { string fld = query.OrderBy[i].GetFieldMapping(typeof(TModel)).TargetMember.Name; switch (query.OrderBy[i].SortDirection) { case Sort.Ascending: TModel[] asc = (from item in ret orderby item[fld] ascending select item).ToArray(); ret = new DataModelCollection <TModel>(asc); break; case Sort.Descending: TModel[] desc = (from item in ret orderby item[fld] descending select item).ToArray(); ret = new DataModelCollection <TModel>(desc); break; } } } return(ret); } } } finally { if (tmpConn != null) { transactionContext.Commit(); tmpConn.Close(); } } }
public void DeepSaveEntitiesTest() { var companyTable = CreateAndPopulateMockTable("Company"); var contactTable = CreateAndPopulateMockTable("Contact"); var memProvider = new MemoryDataProvider(); memProvider.AddTable(companyTable); memProvider.AddTable(contactTable); var query = new DataModelQuery <DataModel <Company> >() .WhereProperty["ID"].IsEqualTo(1); var decompany = memProvider.DeepLoadModel(query); var company = decompany.Entity; company.CompanyName += "_"; foreach (var c in company.Contacts) { c.Name += "_"; } var query2 = new DataModelQuery <DataModel <Company> >() .WhereProperty["ID"].IsEqualTo(2); var decompany2 = memProvider.DeepLoadModel(query2); var company2 = decompany2.Entity; company2.CompanyName = "_" + company2.CompanyName; foreach (var c in company2.Contacts) { c.Name = "_" + c.Name; } var col = new DataModelCollection <DataModel <Company> >(); col.Add(decompany); col.Add(decompany2); col.DataProvider = memProvider; col.Save(true); query = new DataModelQuery <DataModel <Company> >() .WhereProperty["ID"].IsEqualTo(1); decompany = memProvider.DeepLoadModel(query); company = decompany.Entity; Assert.IsTrue(company.CompanyName.Length > 1 && company.CompanyName.EndsWith("_")); Assert.IsTrue(company.Contacts[0] .Name.Length > 1 && company.Contacts[0] .Name.EndsWith("_")); Assert.IsTrue(company.Contacts[company.Contacts.Count - 1] .Name.Length > 1 && company.Contacts[company.Contacts.Count - 1] .Name.EndsWith("_")); query = new DataModelQuery <DataModel <Company> >() .WhereProperty["ID"].IsEqualTo(2); decompany = memProvider.DeepLoadModel(query); company = decompany.Entity; Assert.IsTrue(company.CompanyName.Length > 1 && company.CompanyName.StartsWith("_")); Assert.IsTrue(company.Contacts[0] .Name.Length > 1 && company.Contacts[0] .Name.StartsWith("_")); Assert.IsTrue(company.Contacts[company.Contacts.Count - 1] .Name.Length > 1 && company.Contacts[company.Contacts.Count - 1] .Name.StartsWith("_")); }
public static void Unserialize( this XElement element , DataModelContext context , IUnserializeErrorReporter reporter , ref DataModelCollection<string> instance ) { instance = new DataModelCollection<string> (context); if (element == null) { return; } foreach (var subElement in element.Elements (NodeName)) { instance.Add (subElement.Value); } }
/// <summary> /// When implemented, saves the changes that were made to each of the /// specified <paramref name="dataModels"/>, within the specified /// database <paramref name="transactionContext"/>. /// <remarks> /// The specified <paramref name="dataModels"/> must have the Deleted /// property set to true, IsDirty evaluated as true, or IsNew /// evaluated as true, or else the model will not be saved. /// </remarks> /// </summary> /// <param name="dataModels"></param> /// <param name="transactionContext"></param> public abstract void SaveModels <TModel>(DataModelCollection <TModel> dataModels, DbTransaction transactionContext) where TModel : DataModel;
public void DeepSaveEntitiesTest() { try { var sqlFactory = SqlClientFactory.Instance; var dbProvider = new DbDataProvider(sqlFactory, TestSqlConnection); var query = new DataModelQuery <DataModel <Company> >() .WhereProperty["ID"] == 1; var decompany = dbProvider.DeepLoadModel(query); var company = decompany.Entity; company.CompanyName += "_"; foreach (var c in company.Contacts) { c.Name += "_"; } var query2 = new DataModelQuery <DataModel <Company> >() .WhereProperty["ID"] == 2; var decompany2 = dbProvider.DeepLoadModel(query2); var company2 = decompany2.Entity; company2.CompanyName = "_" + company2.CompanyName; foreach (var c in company2.Contacts) { c.Name = "_" + c.Name; } var col = new DataModelCollection <DataModel <Company> >(); col.Add(decompany); col.Add(decompany2); col.DataProvider = dbProvider; col.Save(true); query = new DataModelQuery <DataModel <Company> >() .WhereProperty["ID"] == 1; decompany = dbProvider.DeepLoadModel(query); company = decompany.Entity; Assert.IsTrue(company.CompanyName.Length > 1 && company.CompanyName.EndsWith("_")); Assert.IsTrue(company.Contacts[0] .Name.Length > 1 && company.Contacts[0] .Name.EndsWith("_")); Assert.IsTrue(company.Contacts[company.Contacts.Count - 1] .Name.Length > 1 && company.Contacts[company.Contacts.Count - 1] .Name.EndsWith("_")); query = new DataModelQuery <DataModel <Company> >() .WhereProperty["ID"] == 2; decompany = dbProvider.DeepLoadModel(query); company = decompany.Entity; Assert.IsTrue(company.CompanyName.Length > 1 && company.CompanyName.StartsWith("_")); Assert.IsTrue(company.Contacts[0] .Name.Length > 1 && company.Contacts[0] .Name.StartsWith("_")); Assert.IsTrue(company.Contacts[company.Contacts.Count - 1] .Name.Length > 1 && company.Contacts[company.Contacts.Count - 1] .Name.StartsWith("_")); } finally { ReloadData_CompanyContact(); // clean-up } }
public void Setup() { _model = new DataModelCollection <TestClass>(); }
/// <summary> /// When implemented, saves the changes that were made to each of the /// specified <paramref name="dataModels"/>. /// </summary> /// <typeparam name="TModel"></typeparam> /// <param name="dataModels"></param> public void SaveModels <TModel>(DataModelCollection <TModel> dataModels) where TModel : DataModel { SaveModels(dataModels, null); }
/// <summary> /// When implemented, loads the full object graph for the first /// <see cref="DataModel"/> that is returned from the specified /// <paramref name="query"/>, within the specified database /// <paramref name="transactionContext"/>. /// </summary> /// <param name="query"></param> /// <param name="transactionContext"></param> /// <param name="depth"></param> /// <param name="loadedModels"> /// Used for keeping recursive loading from resulting /// in infinite loops. Evaluate each loaded item from /// a database result set against this collection; if /// there is a match, use the collection item, /// otherwise use the database loaded item, deep-load /// it, and add it to this collection. /// </param> /// <returns></returns> public virtual TModel DeepLoadModel <TModel>( DataModelQuery <TModel> query, int?depth, DbTransaction transactionContext, List <DataModel> loadedModels ) where TModel : DataModel { TModel e = LoadModel(query, transactionContext); if (e == null) { return(e); } if (loadedModels == null) { loadedModels = new List <DataModel>(); } if (loadedModels.Contains(e)) { return((TModel)loadedModels[loadedModels.IndexOf(e)]); } foreach (DataModel previouslyLoadedModel in loadedModels) { if (query.GetType().IsGenericType) { Type qt = query.GetType().GetGenericArguments()[0]; if (previouslyLoadedModel.GetType().IsOrInherits(qt) && previouslyLoadedModel.Equals(e) && previouslyLoadedModel is TModel) { return((TModel)previouslyLoadedModel); } } } if (!loadedModels.Contains(e)) { loadedModels.Add(e); } foreach (var fe_kvp in e.EntityMappings.ForeignModelMappings) { if (depth == null || depth > 0) { ForeignDataModelAttribute fe = fe_kvp.Value; Type targetEntityType = fe.TargetMemberType; while (targetEntityType.IsGenericType && targetEntityType.IsOrInherits(typeof(IEnumerable))) { targetEntityType = targetEntityType.GetGenericArguments().Last(); } if (!targetEntityType.IsDataModel()) { targetEntityType = typeof(DataModel <>).MakeGenericType(targetEntityType); } Type subQueryType = typeof(DataModelQuery <>).MakeGenericType(targetEntityType); Relationship relationship = fe.Relationship; if (relationship == Relationship.ManyToMany && string.IsNullOrEmpty(fe.MappingTable)) { relationship = Relationship.OneToMany; } switch (relationship) { case Relationship.OneToOne: case Relationship.ManyToOne: IDataModelQuery subQuery = ((IDataModelQuery)Activator.CreateInstance(subQueryType)) .WhereColumn[fe.RelatedTableColumn].IsEqualTo( e.ColumnMappedValue[fe.LocalColumn]); DataModel e2 = DeepLoadModel(targetEntityType, subQuery, depth == null ? null : depth - 1, transactionContext, loadedModels); object e2o = e2; if (!fe.TargetMemberType.IsDataModel()) { e2o = (e2).Entity; } if (fe.TargetMember.MemberType == MemberTypes.Field) { ((FieldInfo)fe.TargetMember).SetValue(e.Entity, e2o); } else if (fe.TargetMember.MemberType == MemberTypes.Property) { ((PropertyInfo)fe.TargetMember).SetValue(e.Entity, e2o, new object[] {}); } break; case Relationship.OneToMany: IDataModelQuery subQuery2 = ((IDataModelQuery)Activator.CreateInstance(subQueryType)) .WhereColumn[fe.RelatedTableColumn].IsEqualTo( e.ColumnMappedValue[fe.LocalColumn]); IDataModelCollection e2c = DeepLoadModels(targetEntityType, subQuery2, depth, transactionContext, loadedModels); object e2ct = Activator.CreateInstance(fe.TargetMemberType); if (e2ct is IList) { bool de = fe.TargetMemberType.IsGenericType && fe.TargetMemberType.GetGenericArguments().Last().IsDataModel(); foreach (object e2cx in e2c) { if (de) { ((IList)e2ct).Add(e2cx); } else { object e2cx2 = ((DataModel)e2cx).Entity; ((IList)e2ct).Add(e2cx2); } } } else { e2ct = ((IList)e2c)[0]; } if (fe.TargetMember.MemberType == MemberTypes.Field) { ((FieldInfo)fe.TargetMember).SetValue(e.Entity, e2ct); } else if (fe.TargetMember.MemberType == MemberTypes.Property) { ((PropertyInfo)fe.TargetMember).SetValue(e.Entity, e2ct, new object[] {}); } break; case Relationship.ManyToMany: if (!fe.TargetMemberType.IsOrInherits(typeof(IList))) { throw new InvalidCastException( "Cannot apply ManyToMany binding to a non-IList property."); } Type tleft = fe.DeclaringType; Type tleftEntity = tleft; while (tleftEntity.IsDataModelWrapper(true)) { if (tleftEntity.BaseType != (typeof(DataModel <>)).BaseType) { tleftEntity = tleftEntity.BaseType; } else { tleftEntity = tleftEntity.GetGenericArguments()[0]; } } Type tright = (fe.TargetMemberType.IsGenericType && !fe.TargetMemberType.IsDataModel() && fe.TargetMemberType.IsOrInherits(typeof(IList))) ? fe.TargetMemberType.GetGenericArguments()[0] : fe.TargetMemberType; Type trightEntity = tright; if (!tright.IsDataModel()) { tright = typeof(DataModel <>).MakeGenericType(tright); } Type mapType = typeof(DataModelMap.RuntimeMappingTable <,>) .MakeGenericType( // left side of mapping table fe.TargetMember.DeclaringType, // right side tright); var mapObj = (DataModel)Activator.CreateInstance(mapType); mapObj.EntityMappings.TableMapping.Schema = fe.MappingTableSchema ?? ProviderDefaults.DefaultSchema; mapObj.EntityMappings.TableMapping.Table = fe.MappingTable ?? (string.Compare(trightEntity.Name, tleftEntity.Name) == -1 ? trightEntity.Name + tleftEntity.Name : tleftEntity.Name + trightEntity.Name); DataModelColumnAttribute mapLeftCol = mapObj.EntityMappings.FieldMappings["LeftColumn"]; mapLeftCol.ColumnName = fe.LocalColumn; mapLeftCol.DbType = e.EntityMappings .GetFieldMappingByDbColumnName(fe.LocalColumn).DbType; mapLeftCol.TargetMemberType = e.EntityMappings .GetFieldMappingByDbColumnName(fe.LocalColumn).TargetMemberType; Type mapQueryType = typeof(DataModelQuery <>).MakeGenericType(new[] { mapType }); var mapQuery = (IDataModelQuery)Activator.CreateInstance(mapQueryType); mapQuery.WhereColumn[fe.LocalColumn].IsEqualTo( e.ColumnMappedValue[fe.LocalColumn]); IDataModelCollection mapdes = LoadModels(mapType, mapQuery, transactionContext); var mappedDEs = new DataModelCollection <DataModel>(); foreach (DataModel de in mapdes) // de is a MappingTable<L,R> { var mappedDEQuery = (IDataModelQuery) Activator.CreateInstance(typeof(DataModelQuery <>) .MakeGenericType(targetEntityType)); mappedDEQuery.WhereColumn[fe.RelatedTableColumn] .IsEqualTo(de.ColumnMappedValue[fe.RelatedTableColumn]); DataModel mappedDE = DeepLoadModel(targetEntityType, mappedDEQuery, depth == null ? null : depth - 1, transactionContext, loadedModels); if (mappedDE != null) { mappedDEs.Add(mappedDE); } } Type mmtargtype = fe.TargetMemberType; var mmtargcol = (IList)Activator.CreateInstance(fe.TargetMemberType); Type mapdeType = null; foreach (DataModel mapde in mappedDEs) { if (mapdeType == null) { mapdeType = mapde.GetType(); } object deinst = mapde; if (mmtargtype.IsGenericType && !mmtargtype.GetGenericArguments()[0].IsDataModel()) { deinst = mapde.Entity; } mmtargcol.Add(deinst); } if (fe.TargetMember is FieldInfo) { ((FieldInfo)fe.TargetMember).SetValue(e, mmtargcol); } else if (fe.TargetMember is PropertyInfo) { ((PropertyInfo)fe.TargetMember).SetValue( e.Entity, mmtargcol, new object[] {}); } break; } } } foreach (var field_kvp in e.EntityMappings.FieldMappings) { DataModelColumnAttribute field = field_kvp.Value; if (field.IsForeignKey && field.ForeignKeyMapping.AssignToMember != null) { LoadMember(e, field, field_kvp.Key, transactionContext, loadedModels); } } return(e); }
/// <summary> /// Saves the entire object graph of the specified /// <see cref="DataModel"/> objects, /// where any of their properties /// are also <see cref="DataModel"/> objects with /// IsDirty, Deleted, or IsNew change state. /// </summary> /// <typeparam name="TModel"></typeparam> /// <param name="col"></param> public void DeepSaveModels <TModel>(DataModelCollection <TModel> col) where TModel : DataModel { DeepSaveModels(col, null); }