public void ShouldIgnoreMembersIfConfiguredInEntityConfig() { var entityA = new EntityA {One = "one", Two = "two"}; var entityB = new EntityB {One = "one", Two = "two"}; dynamic documentA = serializer.ConvertToJson( entityA, MockEntityConfig( mock => mock.Setup(ec => ec.IgnoredMembers).Returns(typeof (EntityA).GetMember("One")), documentType: "entityA", entityType: typeof(EntityA) ), true); dynamic documentB = serializer.ConvertToJson( entityB, MockEntityConfig( mock => mock.Setup(ec => ec.IgnoredMembers).Returns(typeof (EntityA).GetMember("Two")), documentType: "entityB", entityType: typeof(EntityB) ), true); Assert.Null(documentA.one); Assert.Equal("two", documentA.two); Assert.Equal("one", documentB.one); Assert.Null(documentB.two); }
/// <summary> /// Función para crear una entidad dentro de la factoría a partir /// de los argumentos especificados. /// </summary> /// <remarks> /// Crea una entidad de tipo <see cref="ICategoria"/> /// </remarks> /// <param name="nombre"> /// /// </param> /// <returns> /// Devuelve una entidad de tipo <see cref="ICategoriaFactory"/> /// </returns> public static EntityB Create(string nombre) { // El Id viene dado cuando se inserte en la BBDD... de momento tiene uno temporal. // Creamos la nueva entidad. EntityB entityB = new EntityB(nombre); //devolvemos la entidad recien creada return entityB; }
public void Test() { using (var store = NewDocumentStore()) { EntityA a = new EntityA { Id = Guid.NewGuid() }; EntityB b = new EntityB { Id = a.Id }; EntityC c = new EntityC { Id = Guid.NewGuid(), EntityAId = a.Id, EntityBId = b.Id }; using (var session = store.OpenSession()) { session.Store(a); session.Store(b); session.Store(c); session.SaveChanges(); Assert.AreEqual(store.DatabaseCommands.GetStatistics().CountOfDocuments, 3); } using (var session = store.OpenSession()) { var resultA = session.Load<EntityA>(c.EntityAId); var resultB = session.Load<EntityB>(c.EntityBId); var resultC = session.Load<EntityC>(c.Id); Assert.NotNull(resultA, "resultA"); Assert.NotNull(resultB, "resultB - Load"); Assert.NotNull(resultC, "resultC"); Assert.AreEqual(session.Advanced.NumberOfRequests, 3); } using (var session = store.OpenSession()) { var resultC = session .Include<EntityC, EntityA>(x => x.EntityAId) .Include<EntityB>(x => x.EntityBId) .Load<EntityC>(c.Id); var resultA = session.Load<EntityA>(a.Id); var resultB = session.Load<EntityB>(b.Id); Assert.AreEqual(1, session.Advanced.NumberOfRequests); Assert.NotNull(resultC, "resultC"); Assert.NotNull(resultA, "resultA"); Assert.NotNull(resultB, "resultB - Include"); } } }
static void Main() { IoC.IoC ioc = new IoC.IoC(); ioc.Register(); var mediator = ioc.Container.GetInstance <IMediator>(); Console.WriteLine("--- Communicating from context A to context B. ---"); EntityA entityA = new EntityA(mediator); Console.WriteLine(entityA.MethodA().Result); Console.WriteLine(); Console.WriteLine("--- Communicating from context B to context A. ---"); EntityB entityB = new EntityB(mediator); Console.WriteLine(entityB.MethodB().Result); Console.ReadKey(); }
public bool UpdateEntity(IEntityB entityB) { EntityB original = (EntityB)RepositoryDbContext.EntitiesB.Find(entityB.Id); try { if (original != null) { original.Username = entityB.Username; original.Email = entityB.Email; return(true); } } catch (Exception exception) { throw new DbUpdateException(GetType().FullName + " - " + MethodBase.GetCurrentMethod().Name, exception); } return(false); }
static EntityB() { Encoder.Register( 101, typeof(EntityB), (serializer, any) => { var e = (EntityB)any; serializer.WriteObject(e.A); serializer.WriteObject(e.B); serializer.WriteObject(e.C); }, (deserializer) => { var eb = new EntityB(); deserializer.ReadObject <EntityA>(value => { eb.A = value; }); deserializer.ReadObject <EntityA>(value => { eb.B = value; }); deserializer.ReadObject <EntityA>(value => { eb.C = value; }); return(eb); }); }
private EntityA Create_EntityA_EntityB_And_Many_To_Many_Relation() { using (IUnitOfWork unitOfWork = UnitOfWork.Start()) { var a = new EntityA(); a.Name = "A"; var b = new EntityB(); b.Name = "B"; a.AddB(b); var repoA = this.unityContainer.Resolve <IEntityARepository>(); var repoB = this.unityContainer.Resolve <IEntityBRepository>(); repoB.Add(b); repoA.Add(a); unitOfWork.Commit(); return(a); } }
//bool Delete(Int32 Entity1Id, UserContextDto userContextDto);// invocacion con identificación de usuario public bool Delete(Int32 EntityBId) { #region Preconditions // Comprobar el DTO de entrada. if (EntityBId == default(int)) { return(false); } #endregion IEntityBRepository repo = this.unityContainer.Resolve <IEntityBRepository>(); IEnumerable <EntityB> results = repo.GetFilteredElements(u => u.Id == EntityBId); EntityB entityB2Delete = results.First(); if (!entityB2Delete.CanBeDeleted()) { return(false); } repo.Remove(entityB2Delete); this.Commit(); return(true); }
public override void Seed() { for (int i = 1; i <= 5; i++) { EntityASet.Add(new EntityA { ID = i, Children = new List <EntityAChild> { new EntityAChild { ID = i } } }); var entityB = new EntityB { ID = i }; if (i <= 2) { entityB.Children = new List <EntityBChild>() { new EntityBChild { ID = i * 10 + 1 } } } ; EntityBSet.Add(entityB); EntityCSet.Add(new EntityC { ID = i, Children = new List <EntityCChild>() { new EntityCChild { ID = i } } }); EntityESet.Add(new EntityE { ID = i, Children = new List <EntityEChild>() { new EntityEChild { ID = i } } }); } EntityDSet.Add(new EntityD { ID = 1, Children = new List <EntityDChild> { new EntityDChild { ID = 1, ChildValue = 1 }, new EntityDChild { ID = 2, ChildValue = 2 }, new EntityDChild { ID = 3, ChildValue = 1 }, new EntityDChild { ID = 4, ChildValue = 3 }, new EntityDChild { ID = 5, ChildValue = 4 }, } }); EntityDSet.Add(new EntityD { ID = 2, Children = new List <EntityDChild> { new EntityDChild { ID = 6, ChildValue = 1 }, new EntityDChild { ID = 7, ChildValue = 3 }, new EntityDChild { ID = 8, ChildValue = 1 }, } }); EntityFSet.Add(new EntityF { ID = 1, Children = new List <EntityFChild> { new EntityFChild { ID = 1, ChildValue = 1 }, new EntityFChild { ID = 2, ChildValue = 1 }, new EntityFChild { ID = 3, ChildValue = 3 }, new EntityFChild { ID = 4, ChildValue = 4 }, } }); EntityFSet.Add(new EntityF { ID = 2, Children = new List <EntityFChild> { new EntityFChild { ID = 5, ChildValue = 1 }, new EntityFChild { ID = 6, ChildValue = 2 }, new EntityFChild { ID = 7, ChildValue = 3 }, } }); EntityGSet.Add(new EntityG { ID = 1, IsDeleted = false, HEntities = new HashSet <EntityH> { new EntityH { ID = 1, IsDeleted = false }, new EntityH { ID = 2, IsDeleted = true }, } }); EntityGSet.Add(new EntityG { ID = 2, IsDeleted = true, HEntities = new HashSet <EntityH> { new EntityH { ID = 3, IsDeleted = false }, new EntityH { ID = 4, IsDeleted = true }, } }); SaveChanges(); } }
public void PersistBehaviors() { { var ea1 = new EntityA(); TestBase.TestSerialization(ea1); var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB { A = ea1 }; TestBase.TestSerialization(eb2); using (var em = Emf.CreateEntityManager()) { em.Persist(ea1); em.Persist(eb1); em.Persist(eb2); } using (var em = Emf.CreateEntityManager()) { Assert.AreEqual(1, em.Fetch<EntityA>().Count()); Assert.AreEqual(2, em.Fetch<EntityB>().Count()); var _ea1 = em.Find<EntityA>(ea1.RowKey); Assert.AreEqual(ea1, _ea1); var _eb1 = em.Find<EntityB>(eb1.Key); Assert.AreEqual(eb1, _eb1); var _eb2 = em.Find<EntityB>(eb2.Key); Assert.AreEqual(eb2, _eb2); var _ea2 = em.Find<EntityA>(eb2.A.RowKey); Assert.AreEqual(ea1, _ea2); } TestBase.ClearNamespace(); using (var em = Emf.CreateEntityManager()) { em.Persist(ea1); } using (var em = Emf.CreateEntityManager()) { em.Persist(eb1); em.Persist(eb2); } using (var em = Emf.CreateEntityManager()) { Assert.AreEqual(2, em.Fetch<EntityA>().Count()); Assert.AreEqual(2, em.Fetch<EntityB>().Count()); var _ea1 = em.Find<EntityA>(ea1.RowKey); Assert.AreEqual(ea1, _ea1); var _eb1 = em.Find<EntityB>(eb1.Key); Assert.AreEqual(eb1, _eb1); var _eb2 = em.Find<EntityB>(eb2.Key); Assert.AreEqual(eb2, _eb2); var _ea2 = em.Find<EntityA>(eb2.A.RowKey); Assert.AreEqual(eb2.A, _ea2); } TestBase.ClearNamespace(); using (var em = Emf.CreateEntityManager()) { var ida = new HashSet<string>(); var idb = new HashSet<string>(); em.Persist(ea1, Behaviors.CreateLazy); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateLazy); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateLazy); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); em.Persist(ea1, Behaviors.CreateLazy); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateLazy); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateLazy); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); Assert.AreEqual(1, ida.Count); Assert.AreEqual(2, idb.Count); em.Flush(); Assert.AreEqual(1, em.Fetch<EntityA>().Count()); Assert.AreEqual(2, em.Fetch<EntityB>().Count()); } TestBase.ClearNamespace(); using (var em = Emf.CreateEntityManager()) { var ida = new HashSet<string>(); var idb = new HashSet<string>(); em.Persist(ea1, Behaviors.CreateAlways); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateAlways); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateAlways); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); em.Persist(ea1, Behaviors.CreateAlways); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateAlways); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateAlways); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); Assert.AreEqual(4, ida.Count); Assert.AreEqual(4, idb.Count); em.Flush(); Assert.AreEqual(4, em.Fetch<EntityA>().Count()); Assert.AreEqual(4, em.Fetch<EntityB>().Count()); } TestBase.ClearNamespace(); using (var em = Emf.CreateEntityManager()) { var ida = new HashSet<string>(); var idb = new HashSet<string>(); em.Persist(ea1, Behaviors.CreateNew); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateNew); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateNew); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); em.Persist(ea1, Behaviors.CreateNew); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateNew); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateNew); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); Assert.AreEqual(1, ida.Count); Assert.AreEqual(2, idb.Count); em.Flush(); Assert.AreEqual(1, em.Fetch<EntityA>().Count()); Assert.AreEqual(2, em.Fetch<EntityB>().Count()); } } TestBase.ClearNamespace(); { var ea1 = new EntityA(); TestBase.TestSerialization(ea1); var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB { A = ea1 }; TestBase.TestSerialization(eb2); using (var em = Emf.CreateEntityManager()) { var ida = new HashSet<string>(); var idb = new HashSet<string>(); em.Persist(ea1, Behaviors.CreateLazy); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateLazy); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateLazy); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); em.Persist(ea1, Behaviors.CreateLazy); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateLazy); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateLazy); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); Assert.AreEqual(1, ida.Count); Assert.AreEqual(2, idb.Count); em.Flush(); Assert.AreEqual(1, em.Fetch<EntityA>().Count()); Assert.AreEqual(2, em.Fetch<EntityB>().Count()); } } TestBase.ClearNamespace(); { var ea1 = new EntityA(); TestBase.TestSerialization(ea1); var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB { A = ea1 }; TestBase.TestSerialization(eb2); using (var em = Emf.CreateEntityManager()) { var ida = new HashSet<string>(); var idb = new HashSet<string>(); em.Persist(ea1, Behaviors.CreateAlways); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateAlways); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateAlways); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); em.Persist(ea1, Behaviors.CreateAlways); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateAlways); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateAlways); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); Assert.AreEqual(4, ida.Count); Assert.AreEqual(4, idb.Count); em.Flush(); Assert.AreEqual(4, em.Fetch<EntityA>().Count()); Assert.AreEqual(4, em.Fetch<EntityB>().Count()); } } TestBase.ClearNamespace(); { var ea1 = new EntityA(); TestBase.TestSerialization(ea1); var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB { A = ea1 }; TestBase.TestSerialization(eb2); using (var em = Emf.CreateEntityManager()) { var ida = new HashSet<string>(); var idb = new HashSet<string>(); em.Persist(ea1, Behaviors.CreateNew); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateNew); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateNew); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); em.Persist(ea1, Behaviors.CreateNew); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateNew); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateNew); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); Assert.AreEqual(1, ida.Count); Assert.AreEqual(2, idb.Count); em.Flush(); Assert.AreEqual(1, em.Fetch<EntityA>().Count()); Assert.AreEqual(2, em.Fetch<EntityB>().Count()); } } }
public void PersistAndFind() { var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB { A = new EntityA() }; TestBase.TestSerialization(eb2); using (var em = Emf.CreateEntityManager()) { em.Persist(eb1); Assert.IsNotNull(eb1.Key); Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.Row)); Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.ColumnFamily)); Assert.IsTrue(string.IsNullOrEmpty(eb1.Key.ColumnQualifier)); em.Persist(eb2); Assert.IsNotNull(eb2.Key); Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.Row)); Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.ColumnFamily)); Assert.IsTrue(string.IsNullOrEmpty(eb2.Key.ColumnQualifier)); Assert.IsFalse(string.IsNullOrEmpty(eb2.A.RowKey)); } using (var em = Emf.CreateEntityManager()) { var _eb1 = em.Find<EntityB>(eb1.Key); Assert.AreEqual(eb1, _eb1); var _ea2 = em.Find<EntityA>(eb2.A.RowKey); Assert.AreEqual(eb2.A, _ea2); var _eb2 = em.Find<EntityB>(eb2.Key); Assert.AreEqual(eb2, _eb2); } var ec1 = new EntityC1(); var ec2 = new EntityC2 { C1 = new EntityC1() }; using (var em = Emf.CreateEntityManager()) { em.Persist(ec1); Assert.IsNotNull(ec1.Key); Assert.IsFalse(string.IsNullOrEmpty(ec1.Key.Row)); Assert.IsFalse(string.IsNullOrEmpty(ec1.Key.ColumnFamily)); Assert.IsFalse(string.IsNullOrEmpty(ec1.Key.ColumnQualifier)); em.Persist(ec2); Assert.IsNotNull(ec2.Key); Assert.IsFalse(string.IsNullOrEmpty(ec2.Key.Row)); Assert.IsFalse(string.IsNullOrEmpty(ec2.Key.ColumnFamily)); Assert.IsFalse(string.IsNullOrEmpty(ec2.Key.ColumnQualifier)); Assert.IsNotNull(ec2.C1); Assert.IsFalse(string.IsNullOrEmpty(ec2.C1.Key.Row)); Assert.IsFalse(string.IsNullOrEmpty(ec2.C1.Key.ColumnFamily)); Assert.IsFalse(string.IsNullOrEmpty(ec2.C1.Key.ColumnQualifier)); } using (var em = Emf.CreateEntityManager()) { var _ec1 = em.Find<EntityC1>(ec1.Key); Assert.AreEqual(ec1, _ec1); var _ec12 = em.Find<EntityC1>(ec2.C1.Key); Assert.AreEqual(ec2.C1, _ec12); var _ec2 = em.Find<EntityC2>(ec2.Key); Assert.AreEqual(ec2, _ec2); } }
public void PersistBehaviors() { { var ea1 = new EntityA(); TestBase.TestSerialization(ea1); var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB { A = ea1 }; TestBase.TestSerialization(eb2); using (var em = Emf.CreateEntityManager()) { em.Persist(ea1); em.Persist(eb1); em.Persist(eb2); } using (var em = Emf.CreateEntityManager()) { Assert.AreEqual(1, em.Fetch <EntityA>().Count()); Assert.AreEqual(2, em.Fetch <EntityB>().Count()); var _ea1 = em.Find <EntityA>(ea1.RowKey); Assert.AreEqual(ea1, _ea1); var _eb1 = em.Find <EntityB>(eb1.Key); Assert.AreEqual(eb1, _eb1); var _eb2 = em.Find <EntityB>(eb2.Key); Assert.AreEqual(eb2, _eb2); var _ea2 = em.Find <EntityA>(eb2.A.RowKey); Assert.AreEqual(ea1, _ea2); } TestBase.ClearNamespace(); using (var em = Emf.CreateEntityManager()) { em.Persist(ea1); } using (var em = Emf.CreateEntityManager()) { em.Persist(eb1); em.Persist(eb2); } using (var em = Emf.CreateEntityManager()) { Assert.AreEqual(2, em.Fetch <EntityA>().Count()); Assert.AreEqual(2, em.Fetch <EntityB>().Count()); var _ea1 = em.Find <EntityA>(ea1.RowKey); Assert.AreEqual(ea1, _ea1); var _eb1 = em.Find <EntityB>(eb1.Key); Assert.AreEqual(eb1, _eb1); var _eb2 = em.Find <EntityB>(eb2.Key); Assert.AreEqual(eb2, _eb2); var _ea2 = em.Find <EntityA>(eb2.A.RowKey); Assert.AreEqual(eb2.A, _ea2); } TestBase.ClearNamespace(); using (var em = Emf.CreateEntityManager()) { var ida = new HashSet <string>(); var idb = new HashSet <string>(); em.Persist(ea1, Behaviors.CreateLazy); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateLazy); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateLazy); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); em.Persist(ea1, Behaviors.CreateLazy); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateLazy); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateLazy); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); Assert.AreEqual(1, ida.Count); Assert.AreEqual(2, idb.Count); em.Flush(); Assert.AreEqual(1, em.Fetch <EntityA>().Count()); Assert.AreEqual(2, em.Fetch <EntityB>().Count()); } TestBase.ClearNamespace(); using (var em = Emf.CreateEntityManager()) { var ida = new HashSet <string>(); var idb = new HashSet <string>(); em.Persist(ea1, Behaviors.CreateAlways); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateAlways); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateAlways); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); em.Persist(ea1, Behaviors.CreateAlways); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateAlways); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateAlways); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); Assert.AreEqual(4, ida.Count); Assert.AreEqual(4, idb.Count); em.Flush(); Assert.AreEqual(4, em.Fetch <EntityA>().Count()); Assert.AreEqual(4, em.Fetch <EntityB>().Count()); } TestBase.ClearNamespace(); using (var em = Emf.CreateEntityManager()) { var ida = new HashSet <string>(); var idb = new HashSet <string>(); em.Persist(ea1, Behaviors.CreateNew); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateNew); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateNew); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); em.Persist(ea1, Behaviors.CreateNew); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateNew); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateNew); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); Assert.AreEqual(1, ida.Count); Assert.AreEqual(2, idb.Count); em.Flush(); Assert.AreEqual(1, em.Fetch <EntityA>().Count()); Assert.AreEqual(2, em.Fetch <EntityB>().Count()); } } TestBase.ClearNamespace(); { var ea1 = new EntityA(); TestBase.TestSerialization(ea1); var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB { A = ea1 }; TestBase.TestSerialization(eb2); using (var em = Emf.CreateEntityManager()) { var ida = new HashSet <string>(); var idb = new HashSet <string>(); em.Persist(ea1, Behaviors.CreateLazy); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateLazy); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateLazy); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); em.Persist(ea1, Behaviors.CreateLazy); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateLazy); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateLazy); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); Assert.AreEqual(1, ida.Count); Assert.AreEqual(2, idb.Count); em.Flush(); Assert.AreEqual(1, em.Fetch <EntityA>().Count()); Assert.AreEqual(2, em.Fetch <EntityB>().Count()); } } TestBase.ClearNamespace(); { var ea1 = new EntityA(); TestBase.TestSerialization(ea1); var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB { A = ea1 }; TestBase.TestSerialization(eb2); using (var em = Emf.CreateEntityManager()) { var ida = new HashSet <string>(); var idb = new HashSet <string>(); em.Persist(ea1, Behaviors.CreateAlways); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateAlways); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateAlways); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); em.Persist(ea1, Behaviors.CreateAlways); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateAlways); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateAlways); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); Assert.AreEqual(4, ida.Count); Assert.AreEqual(4, idb.Count); em.Flush(); Assert.AreEqual(4, em.Fetch <EntityA>().Count()); Assert.AreEqual(4, em.Fetch <EntityB>().Count()); } } TestBase.ClearNamespace(); { var ea1 = new EntityA(); TestBase.TestSerialization(ea1); var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB { A = ea1 }; TestBase.TestSerialization(eb2); using (var em = Emf.CreateEntityManager()) { var ida = new HashSet <string>(); var idb = new HashSet <string>(); em.Persist(ea1, Behaviors.CreateNew); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateNew); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateNew); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); em.Persist(ea1, Behaviors.CreateNew); ida.Add(ea1.RowKey); em.Persist(eb1, Behaviors.CreateNew); idb.Add(eb1.Key.Row); em.Persist(eb2, Behaviors.CreateNew); idb.Add(eb2.Key.Row); ida.Add(eb2.A.RowKey); Assert.AreEqual(1, ida.Count); Assert.AreEqual(2, idb.Count); em.Flush(); Assert.AreEqual(1, em.Fetch <EntityA>().Count()); Assert.AreEqual(2, em.Fetch <EntityB>().Count()); } } }
public void PersistAndFind() { var bindings = Emf.Configuration.Binding; Assert.IsTrue(bindings.RegisterKeyBinding(typeof(EntityA), new KeyBindingEntityA())); Assert.IsFalse(bindings.RegisterKeyBinding(typeof(EntityA), new KeyBindingEntityA())); Assert.IsTrue(bindings.RegisterKeyBinding(typeof(EntityB), new KeyBindingEntityB())); { var cb = new ColumnBinding("e"); Assert.IsTrue(bindings.RegisterColumnBinding(typeof(EntityC), cb)); Assert.IsTrue(bindings.RegisterKeyBinding(typeof(EntityC), new KeyBinding<EntityC>(e => e.Name))); } var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB { A = new EntityA() }; TestBase.TestSerialization(eb2); using (var em = Emf.CreateEntityManager()) { em.Persist(eb1); Assert.IsNotNull(eb1.Key); Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.Row)); Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.ColumnFamily)); Assert.IsTrue(string.IsNullOrEmpty(eb1.Key.ColumnQualifier)); Assert.IsTrue(eb1.Key.Row.StartsWith(typeof(EntityB).Name)); em.Persist(eb2); Assert.IsNotNull(eb2.Key); Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.Row)); Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.ColumnFamily)); Assert.IsTrue(string.IsNullOrEmpty(eb2.Key.ColumnQualifier)); Assert.IsTrue(eb2.Key.Row.StartsWith(typeof(EntityB).Name)); Assert.IsTrue(eb2.A.Name.StartsWith(typeof(EntityA).Name)); } using (var em = Emf.CreateEntityManager()) { var _eb1 = em.Find<EntityB>(eb1.Key); Assert.AreEqual(eb1, _eb1); Assert.IsTrue(_eb1.Key.Row.StartsWith(_eb1.GetType().Name)); var _ea2 = em.Find<EntityA>(eb2.A.Name); // EntityA key binding uses the Name property as row key Assert.AreEqual(eb2.A, _ea2); var _eb2 = em.Find<EntityB>(eb2.Key); Assert.AreEqual(eb2, _eb2); Assert.IsTrue(_eb2.Key.Row.StartsWith(typeof(EntityB).Name)); Assert.AreEqual(eb2.A.Name, _eb2.A.Name); Assert.IsTrue(eb2.A.Name.StartsWith(typeof(EntityA).Name)); } var ec1 = new EntityC { Name = "11", A = new EntityA() }; TestBase.TestSerialization(ec1); var ec2 = new EntityC { Name = "222", A = new EntityA(), B = new EntityB() }; TestBase.TestSerialization(ec2); using (var em = Emf.CreateEntityManager()) { em.Persist(ec1); Assert.AreEqual(ec1.Id, ec1.Name); em.Persist(ec2); Assert.AreEqual(ec2.Id, ec2.Name); } using (var em = Emf.CreateEntityManager()) { var _ec1 = em.Find<EntityC>("11"); Assert.AreEqual(ec1, _ec1); var _ec2 = em.Find<EntityC>(ec2); Assert.AreEqual(ec2, _ec2); } bindings.UnregisterBinding(typeof(EntityA)); bindings.UnregisterBinding(typeof(EntityB)); bindings.UnregisterBinding(typeof(EntityC)); }
static EntityB() { Encoder.Register( 101, typeof(EntityB), (serializer, any) => { var e = (EntityB)any; serializer.WriteObject(e.A); serializer.WriteObject(e.B); serializer.WriteObject(e.C); }, (deserializer) => { var eb = new EntityB(); deserializer.ReadObject<EntityA>(value => { eb.A = value; }); deserializer.ReadObject<EntityA>(value => { eb.B = value; }); deserializer.ReadObject<EntityA>(value => { eb.C = value; }); return eb; }); }
private EntityA Create_EntityA_EntityB_And_Many_To_Many_Relation() { using (IUnitOfWork unitOfWork = UnitOfWork.Start()) { var a = new EntityA(); a.Name = "A"; var b = new EntityB(); b.Name = "B"; a.AddB(b); var repoA = this.unityContainer.Resolve<IEntityARepository>(); var repoB = this.unityContainer.Resolve<IEntityBRepository>(); repoB.Add(b); repoA.Add(a); unitOfWork.Commit(); return a; } }
public EntityA(EntityB owner) { this.OwnerB = owner; this.Name = Guid.NewGuid().ToString(); }
public void PersistAndFind() { { var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB(); eb2.A = new EntityA(eb2); TestBase.TestSerialization(eb2); using (var em = Emf.CreateEntityManager()) { em.Persist(eb1); Assert.IsFalse(string.IsNullOrEmpty(eb1.Id)); em.Persist(eb2); Assert.IsFalse(string.IsNullOrEmpty(eb2.Id)); } using (var em = Emf.CreateEntityManager()) { var _eb1 = em.Find<EntityB>(eb1.Id); Assert.AreEqual(eb1, _eb1); var _ea2 = em.Find<EntityA>(eb2.A.Id); Assert.AreEqual(eb2.A, _ea2); Assert.AreEqual(eb2, _ea2.OwnerB); Assert.AreSame(_ea2, _ea2.OwnerB.A); var _eb2 = em.Find<EntityB>(eb2.Id); Assert.AreEqual(eb2, _eb2); Assert.AreSame(_eb2, _eb2.A.OwnerB); } } { var ec1 = new EntityC(); TestBase.TestSerialization(ec1); var ec2 = new EntityC(); ec2.I.A = new EntityA(ec2); TestBase.TestSerialization(ec2); var ec3 = new EntityC { I = { A = new EntityA(ec1) } }; TestBase.TestSerialization(ec3); using (var em = Emf.CreateEntityManager()) { em.Persist(ec1); Assert.IsFalse(string.IsNullOrEmpty(ec1.Id)); em.Persist(ec2); Assert.IsFalse(string.IsNullOrEmpty(ec2.Id)); em.Persist(ec3); Assert.IsFalse(string.IsNullOrEmpty(ec3.Id)); } using (var em = Emf.CreateEntityManager()) { var _ec1 = em.Find<EntityC>(ec1.Id); Assert.AreEqual(ec1, _ec1); var _ea2 = em.Find<EntityA>(ec2.I.A.Id); Assert.AreEqual(ec2.I.A, _ea2); Assert.AreEqual(ec2, _ea2.OwnerC); Assert.AreSame(_ea2, _ea2.OwnerC.I.A); var _ec2 = em.Find<EntityC>(ec2.Id); Assert.AreEqual(ec2, _ec2); Assert.AreSame(_ec2, _ec2.I.A.OwnerC); var _ea3 = em.Find<EntityA>(ec3.I.A.Id); Assert.AreEqual(ec3.I.A, _ea3); Assert.AreEqual(ec1, _ea3.OwnerC); Assert.IsNull(_ea3.OwnerC.I.A); var _ec3 = em.Find<EntityC>(ec3.Id); Assert.AreEqual(ec3, _ec3); Assert.AreEqual(_ec1, _ec3.I.A.OwnerC); } } { var ed1 = new EntityD(); TestBase.TestSerialization(ed1); var ed2 = new EntityD(); ed2.I1.A = new EntityA(ed2); TestBase.TestSerialization(ed2); var ed3 = new EntityD { I2 = { A = new EntityA(ed1) } }; TestBase.TestSerialization(ed3); using (var em = Emf.CreateEntityManager()) { em.Persist(ed1); Assert.IsFalse(string.IsNullOrEmpty(ed1.Id)); em.Persist(ed2); Assert.IsFalse(string.IsNullOrEmpty(ed2.Id)); em.Persist(ed3); Assert.IsFalse(string.IsNullOrEmpty(ed3.Id)); } using (var em = Emf.CreateEntityManager()) { var _ed1 = em.Find<EntityD>(ed1.Id); Assert.AreEqual(ed1, _ed1); Assert.AreSame(_ed1.I1, _ed1.I2); var _ea2 = em.Find<EntityA>(ed2.I1.A.Id); Assert.AreEqual(ed2.I1.A, _ea2); Assert.AreEqual(ed2, _ea2.OwnerD); Assert.AreSame(_ea2.OwnerD.I2, _ea2.OwnerD.I2); Assert.AreSame(_ea2, _ea2.OwnerD.I1.A); var _ed2 = em.Find<EntityD>(ed2.Id); Assert.AreEqual(ed2, _ed2); Assert.AreSame(_ed2, _ed2.I1.A.OwnerD); Assert.AreSame(_ed2.I1, _ed2.I2); var _ea3 = em.Find<EntityA>(ed3.I1.A.Id); Assert.AreEqual(ed3.I1.A, _ea3); Assert.AreEqual(ed1, _ea3.OwnerD); Assert.IsNull(_ea3.OwnerD.I1.A); Assert.AreSame(_ea3.OwnerD.I1, _ea3.OwnerD.I2); var _ed3 = em.Find<EntityD>(ed3.Id); Assert.AreEqual(ed3, _ed3); Assert.AreEqual(_ed1, _ed3.I1.A.OwnerD); Assert.AreSame(_ed1.I1, _ed1.I2); } } }
public void PersistAndFind() { var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB { A = new EntityA() }; TestBase.TestSerialization(eb2); var ec1 = new EntityC { A = new EntityA() }; TestBase.TestSerialization(ec1); var dateTime = DateTime.UtcNow - TimeSpan.FromMilliseconds(250); using (var em = Emf.CreateEntityManager()) { em.Persist(eb1); Assert.IsFalse(string.IsNullOrEmpty(eb1.Id)); Assert.AreEqual(0, eb1.LastModified.Ticks); em.Persist(eb2); Assert.IsFalse(string.IsNullOrEmpty(eb2.Id)); Assert.IsFalse(eb2.A.Id.Equals(Guid.Empty)); Assert.AreEqual(0, eb2.LastModified.Ticks); Assert.AreEqual(0, eb2.A.LastModified.Ticks); em.Persist(ec1); Assert.IsFalse(string.IsNullOrEmpty(ec1.Id)); Assert.IsFalse(ec1.A.Id.Equals(Guid.Empty)); Assert.AreEqual(0, ec1.LastModified.Ticks); Assert.AreEqual(0, ec1.A.LastModified.Ticks); } using (var em = Emf.CreateEntityManager()) { var _eb1 = em.Find <EntityB>(eb1.Id); Assert.AreEqual(eb1, _eb1); Assert.IsTrue(_eb1.LastModified > dateTime); var _ea2 = em.Find <EntityA>(eb2.A.Id); Assert.AreEqual(eb2.A, _ea2); Assert.IsTrue(_ea2.LastModified > dateTime); var _eb2 = em.Find <EntityB>(eb2.Id); Assert.AreEqual(eb2, _eb2); Assert.IsTrue(_eb2.LastModified > dateTime); Assert.IsTrue(_eb2.A.LastModified > dateTime); } using (var em = Emf.CreateEntityManager()) { var _ec1 = em.Find <EntityC>(ec1.Id); Assert.AreEqual(ec1, _ec1); Assert.IsTrue(_ec1.LastModified > dateTime); Assert.IsTrue(_ec1.A.LastModified > dateTime); var _ea2 = em.Find <EntityA>(ec1.A.Id); Assert.AreEqual(ec1.A, _ea2); Assert.IsTrue(_ec1.A.LastModified > dateTime); } }
public void PersistAndFind() { var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB { A = new EntityA() }; TestBase.TestSerialization(eb2); var ec1 = new EntityC { A = new EntityA() }; TestBase.TestSerialization(ec1); var dateTime = DateTime.UtcNow - TimeSpan.FromMilliseconds(250); using (var em = Emf.CreateEntityManager()) { em.Persist(eb1); Assert.IsFalse(string.IsNullOrEmpty(eb1.Id)); Assert.AreEqual(0, eb1.LastModified.Ticks); em.Persist(eb2); Assert.IsFalse(string.IsNullOrEmpty(eb2.Id)); Assert.IsFalse(eb2.A.Id.Equals(Guid.Empty)); Assert.AreEqual(0, eb2.LastModified.Ticks); Assert.AreEqual(0, eb2.A.LastModified.Ticks); em.Persist(ec1); Assert.IsFalse(string.IsNullOrEmpty(ec1.Id)); Assert.IsFalse(ec1.A.Id.Equals(Guid.Empty)); Assert.AreEqual(0, ec1.LastModified.Ticks); Assert.AreEqual(0, ec1.A.LastModified.Ticks); } using (var em = Emf.CreateEntityManager()) { var _eb1 = em.Find<EntityB>(eb1.Id); Assert.AreEqual(eb1, _eb1); Assert.IsTrue(_eb1.LastModified > dateTime); var _ea2 = em.Find<EntityA>(eb2.A.Id); Assert.AreEqual(eb2.A, _ea2); Assert.IsTrue(_ea2.LastModified > dateTime); var _eb2 = em.Find<EntityB>(eb2.Id); Assert.AreEqual(eb2, _eb2); Assert.IsTrue(_eb2.LastModified > dateTime); Assert.IsTrue(_eb2.A.LastModified > dateTime); } using (var em = Emf.CreateEntityManager()) { var _ec1 = em.Find<EntityC>(ec1.Id); Assert.AreEqual(ec1, _ec1); Assert.IsTrue(_ec1.LastModified > dateTime); Assert.IsTrue(_ec1.A.LastModified > dateTime); var _ea2 = em.Find<EntityA>(ec1.A.Id); Assert.AreEqual(ec1.A, _ea2); Assert.IsTrue(_ec1.A.LastModified > dateTime); } }
public void PersistAndFind() { var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB { A = new EntityA() }; TestBase.TestSerialization(eb2); using (var em = Emf.CreateEntityManager()) { em.Persist(eb1); Assert.IsFalse(string.IsNullOrEmpty(eb1.RowKey)); em.Persist(eb2); Assert.IsFalse(string.IsNullOrEmpty(eb2.RowKey)); Assert.IsFalse(string.IsNullOrEmpty(eb2.A.Id)); } using (var em = Emf.CreateEntityManager()) { var _eb1 = em.Find<EntityB>(eb1.RowKey); Assert.AreEqual(eb1, _eb1); var _ea2 = em.Find<EntityA>(eb2.A.Id); Assert.AreEqual(eb2.A, _ea2); var _eb2 = em.Find<EntityB>(eb2.RowKey); Assert.AreEqual(eb2, _eb2); } }
public void PersistAndFind() { var bindingContext = new BindingContext(); Assert.IsFalse(bindingContext.StrictExplicitColumnBinding); Assert.IsFalse(bindingContext.StrictExplicitKeyBinding); Assert.IsFalse(bindingContext.StrictExplicitTableBinding); bindingContext.StrictExplicitColumnBinding = true; Assert.IsTrue(bindingContext.RegisterColumnBinding(typeof(EntityA), new ColumnBindingEntityA())); Assert.IsFalse(bindingContext.RegisterColumnBinding(typeof(EntityA), new ColumnBindingEntityA())); Assert.IsTrue(bindingContext.RegisterColumnBinding(typeof(EntityB), new ColumnBinding("b", "qb"))); Assert.IsTrue(bindingContext.RegisterColumnBinding(typeof(EntityC1), new ColumnBinding("c", "1"))); Assert.IsTrue(bindingContext.RegisterColumnBinding(typeof(EntityC2), new ColumnBinding("c", "2"))); var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB { A = new EntityA() }; TestBase.TestSerialization(eb2); var ec1 = new EntityC1 { A = new EntityA() }; TestBase.TestSerialization(ec1); var ec2 = new EntityC2 { A = new EntityA() }; TestBase.TestSerialization(ec2); using (var em = Emf.CreateEntityManager(bindingContext)) { Assert.IsTrue(em.IsTypeDeclared <EntityA>()); Assert.IsTrue(em.IsTypeDeclared <EntityB>()); Assert.IsTrue(em.IsTypeDeclared <EntityC1>()); Assert.IsTrue(em.IsTypeDeclared <EntityC2>()); em.Configuration.Binding.StrictExplicitColumnBinding = true; em.Persist(eb1); Assert.IsNotNull(eb1.Key); Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.Row)); Assert.AreEqual("b", eb1.Key.ColumnFamily); Assert.AreEqual("qb", eb1.Key.ColumnQualifier); em.Persist(eb2); Assert.IsNotNull(eb2.Key); Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.Row)); Assert.AreEqual("b", eb2.Key.ColumnFamily); Assert.AreEqual("qb", eb2.Key.ColumnQualifier); Assert.IsNotNull(eb2.A.Key); Assert.IsFalse(string.IsNullOrEmpty(eb2.A.Key.Row)); Assert.AreEqual("a", eb2.A.Key.ColumnFamily); Assert.AreEqual("qa", eb2.A.Key.ColumnQualifier); em.Persist(ec1); Assert.IsNotNull(ec1.Key); Assert.IsFalse(string.IsNullOrEmpty(ec1.Key.Row)); Assert.AreEqual("c", ec1.Key.ColumnFamily); Assert.AreEqual("1", ec1.Key.ColumnQualifier); em.Persist(ec2); Assert.IsNotNull(ec2.Key); Assert.IsFalse(string.IsNullOrEmpty(ec2.Key.Row)); Assert.AreEqual("c", ec2.Key.ColumnFamily); Assert.AreEqual("2", ec2.Key.ColumnQualifier); } using (var em = Emf.CreateEntityManager(bindingContext)) { var _eb1 = em.Find <EntityB>(eb1.Key); Assert.AreEqual(eb1, _eb1); var _ea2 = em.Find <EntityA>(eb2.A.Key); Assert.AreEqual(eb2.A, _ea2); var _eb2 = em.Find <EntityB>(eb2.Key); Assert.AreEqual(eb2, _eb2); var _ec1 = em.Find <EntityC1>(ec1.Key); Assert.AreEqual(ec1, _ec1); var _ec2 = em.Find <EntityC2>(ec2.Key); Assert.AreEqual(ec2, _ec2); var ecl = em.Fetch <EntityC>().ToList(); Assert.AreEqual(2, ecl.Count); Assert.IsTrue(ecl.Contains(_ec1)); Assert.IsTrue(ecl.Contains(_ec2)); } Assert.IsTrue(bindingContext.UnregisterColumnBinding(typeof(EntityA))); Assert.IsFalse(bindingContext.UnregisterColumnBinding(typeof(EntityA))); Assert.IsTrue(bindingContext.UnregisterColumnBinding(typeof(EntityB))); Assert.IsTrue(bindingContext.UnregisterColumnBinding(typeof(EntityC1))); Assert.IsTrue(bindingContext.UnregisterColumnBinding(typeof(EntityC2))); }
public void PersistAndFind() { var bindingContext = new BindingContext(); Assert.IsFalse(bindingContext.StrictExplicitColumnBinding); Assert.IsFalse(bindingContext.StrictExplicitKeyBinding); Assert.IsFalse(bindingContext.StrictExplicitTableBinding); bindingContext.StrictExplicitColumnBinding = true; Assert.IsTrue(bindingContext.RegisterColumnBinding(typeof(EntityA), new ColumnBindingEntityA())); Assert.IsFalse(bindingContext.RegisterColumnBinding(typeof(EntityA), new ColumnBindingEntityA())); Assert.IsTrue(bindingContext.RegisterColumnBinding(typeof(EntityB), new ColumnBinding("b", "qb"))); Assert.IsTrue(bindingContext.RegisterColumnBinding(typeof(EntityC1), new ColumnBinding("c", "1"))); Assert.IsTrue(bindingContext.RegisterColumnBinding(typeof(EntityC2), new ColumnBinding("c", "2"))); var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB { A = new EntityA() }; TestBase.TestSerialization(eb2); var ec1 = new EntityC1 { A = new EntityA() }; TestBase.TestSerialization(ec1); var ec2 = new EntityC2 { A = new EntityA() }; TestBase.TestSerialization(ec2); using (var em = Emf.CreateEntityManager(bindingContext)) { Assert.IsTrue(em.IsTypeDeclared<EntityA>()); Assert.IsTrue(em.IsTypeDeclared<EntityB>()); Assert.IsTrue(em.IsTypeDeclared<EntityC1>()); Assert.IsTrue(em.IsTypeDeclared<EntityC2>()); em.Configuration.Binding.StrictExplicitColumnBinding = true; em.Persist(eb1); Assert.IsNotNull(eb1.Key); Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.Row)); Assert.AreEqual("b", eb1.Key.ColumnFamily); Assert.AreEqual("qb", eb1.Key.ColumnQualifier); em.Persist(eb2); Assert.IsNotNull(eb2.Key); Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.Row)); Assert.AreEqual("b", eb2.Key.ColumnFamily); Assert.AreEqual("qb", eb2.Key.ColumnQualifier); Assert.IsNotNull(eb2.A.Key); Assert.IsFalse(string.IsNullOrEmpty(eb2.A.Key.Row)); Assert.AreEqual("a", eb2.A.Key.ColumnFamily); Assert.AreEqual("qa", eb2.A.Key.ColumnQualifier); em.Persist(ec1); Assert.IsNotNull(ec1.Key); Assert.IsFalse(string.IsNullOrEmpty(ec1.Key.Row)); Assert.AreEqual("c", ec1.Key.ColumnFamily); Assert.AreEqual("1", ec1.Key.ColumnQualifier); em.Persist(ec2); Assert.IsNotNull(ec2.Key); Assert.IsFalse(string.IsNullOrEmpty(ec2.Key.Row)); Assert.AreEqual("c", ec2.Key.ColumnFamily); Assert.AreEqual("2", ec2.Key.ColumnQualifier); } using (var em = Emf.CreateEntityManager(bindingContext)) { var _eb1 = em.Find<EntityB>(eb1.Key); Assert.AreEqual(eb1, _eb1); var _ea2 = em.Find<EntityA>(eb2.A.Key); Assert.AreEqual(eb2.A, _ea2); var _eb2 = em.Find<EntityB>(eb2.Key); Assert.AreEqual(eb2, _eb2); var _ec1 = em.Find<EntityC1>(ec1.Key); Assert.AreEqual(ec1, _ec1); var _ec2 = em.Find<EntityC2>(ec2.Key); Assert.AreEqual(ec2, _ec2); var ecl = em.Fetch<EntityC>().ToList(); Assert.AreEqual(2, ecl.Count); Assert.IsTrue(ecl.Contains(_ec1)); Assert.IsTrue(ecl.Contains(_ec2)); } Assert.IsTrue(bindingContext.UnregisterColumnBinding(typeof(EntityA))); Assert.IsFalse(bindingContext.UnregisterColumnBinding(typeof(EntityA))); Assert.IsTrue(bindingContext.UnregisterColumnBinding(typeof(EntityB))); Assert.IsTrue(bindingContext.UnregisterColumnBinding(typeof(EntityC1))); Assert.IsTrue(bindingContext.UnregisterColumnBinding(typeof(EntityC2))); }
public void PersistAndFind() { { var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB(); eb2.A = new EntityA(eb2); TestBase.TestSerialization(eb2); using (var em = Emf.CreateEntityManager()) { em.Persist(eb1); Assert.IsFalse(string.IsNullOrEmpty(eb1.Id)); em.Persist(eb2); Assert.IsFalse(string.IsNullOrEmpty(eb2.Id)); } using (var em = Emf.CreateEntityManager()) { var _eb1 = em.Find <EntityB>(eb1.Id); Assert.AreEqual(eb1, _eb1); var _ea2 = em.Find <EntityA>(eb2.A.Id); Assert.AreEqual(eb2.A, _ea2); Assert.AreEqual(eb2, _ea2.OwnerB); Assert.AreSame(_ea2, _ea2.OwnerB.A); var _eb2 = em.Find <EntityB>(eb2.Id); Assert.AreEqual(eb2, _eb2); Assert.AreSame(_eb2, _eb2.A.OwnerB); } } { var ec1 = new EntityC(); TestBase.TestSerialization(ec1); var ec2 = new EntityC(); ec2.I.A = new EntityA(ec2); TestBase.TestSerialization(ec2); var ec3 = new EntityC { I = { A = new EntityA(ec1) } }; TestBase.TestSerialization(ec3); using (var em = Emf.CreateEntityManager()) { em.Persist(ec1); Assert.IsFalse(string.IsNullOrEmpty(ec1.Id)); em.Persist(ec2); Assert.IsFalse(string.IsNullOrEmpty(ec2.Id)); em.Persist(ec3); Assert.IsFalse(string.IsNullOrEmpty(ec3.Id)); } using (var em = Emf.CreateEntityManager()) { var _ec1 = em.Find <EntityC>(ec1.Id); Assert.AreEqual(ec1, _ec1); var _ea2 = em.Find <EntityA>(ec2.I.A.Id); Assert.AreEqual(ec2.I.A, _ea2); Assert.AreEqual(ec2, _ea2.OwnerC); Assert.AreSame(_ea2, _ea2.OwnerC.I.A); var _ec2 = em.Find <EntityC>(ec2.Id); Assert.AreEqual(ec2, _ec2); Assert.AreSame(_ec2, _ec2.I.A.OwnerC); var _ea3 = em.Find <EntityA>(ec3.I.A.Id); Assert.AreEqual(ec3.I.A, _ea3); Assert.AreEqual(ec1, _ea3.OwnerC); Assert.IsNull(_ea3.OwnerC.I.A); var _ec3 = em.Find <EntityC>(ec3.Id); Assert.AreEqual(ec3, _ec3); Assert.AreEqual(_ec1, _ec3.I.A.OwnerC); } } { var ed1 = new EntityD(); TestBase.TestSerialization(ed1); var ed2 = new EntityD(); ed2.I1.A = new EntityA(ed2); TestBase.TestSerialization(ed2); var ed3 = new EntityD { I2 = { A = new EntityA(ed1) } }; TestBase.TestSerialization(ed3); using (var em = Emf.CreateEntityManager()) { em.Persist(ed1); Assert.IsFalse(string.IsNullOrEmpty(ed1.Id)); em.Persist(ed2); Assert.IsFalse(string.IsNullOrEmpty(ed2.Id)); em.Persist(ed3); Assert.IsFalse(string.IsNullOrEmpty(ed3.Id)); } using (var em = Emf.CreateEntityManager()) { var _ed1 = em.Find <EntityD>(ed1.Id); Assert.AreEqual(ed1, _ed1); Assert.AreSame(_ed1.I1, _ed1.I2); var _ea2 = em.Find <EntityA>(ed2.I1.A.Id); Assert.AreEqual(ed2.I1.A, _ea2); Assert.AreEqual(ed2, _ea2.OwnerD); Assert.AreSame(_ea2.OwnerD.I2, _ea2.OwnerD.I2); Assert.AreSame(_ea2, _ea2.OwnerD.I1.A); var _ed2 = em.Find <EntityD>(ed2.Id); Assert.AreEqual(ed2, _ed2); Assert.AreSame(_ed2, _ed2.I1.A.OwnerD); Assert.AreSame(_ed2.I1, _ed2.I2); var _ea3 = em.Find <EntityA>(ed3.I1.A.Id); Assert.AreEqual(ed3.I1.A, _ea3); Assert.AreEqual(ed1, _ea3.OwnerD); Assert.IsNull(_ea3.OwnerD.I1.A); Assert.AreSame(_ea3.OwnerD.I1, _ea3.OwnerD.I2); var _ed3 = em.Find <EntityD>(ed3.Id); Assert.AreEqual(ed3, _ed3); Assert.AreEqual(_ed1, _ed3.I1.A.OwnerD); Assert.AreSame(_ed1.I1, _ed1.I2); } } }
public EntityHandlerA(EntityB eb, TaskEntityB teb) { _entityB = ea; _taskEntityB = teb; }
public void PersistAndFind() { var bindings = Emf.Configuration.Binding; Assert.IsFalse(bindings.StrictExplicitColumnBinding); Assert.IsFalse(bindings.StrictExplicitKeyBinding); Assert.IsFalse(bindings.StrictExplicitTableBinding); Assert.IsTrue(bindings.RegisterTableBinding(typeof(EntityA), new TableBindingEntityA())); Assert.IsFalse(bindings.RegisterTableBinding(typeof(EntityA), new TableBindingEntityA())); Assert.IsTrue(bindings.RegisterTableBinding(typeof(EntityB), new TableBindingEntityB())); var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB { A = new EntityA() }; TestBase.TestSerialization(eb2); using (var em = Emf.CreateEntityManager()) { Assert.IsTrue(em.IsTypeDeclared <EntityA>()); Assert.IsTrue(em.IsTypeDeclared <EntityB>()); em.Configuration.Binding.StrictExplicitTableBinding = true; em.Persist(eb1); Assert.IsNotNull(eb1.Key); Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.Row)); Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.ColumnFamily)); Assert.IsTrue(string.IsNullOrEmpty(eb1.Key.ColumnQualifier)); em.Persist(eb2); Assert.IsNotNull(eb2.Key); Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.Row)); Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.ColumnFamily)); Assert.IsTrue(string.IsNullOrEmpty(eb2.Key.ColumnQualifier)); Assert.IsNotNull(eb2.A.Key); Assert.IsFalse(string.IsNullOrEmpty(eb2.A.Key.Row)); Assert.IsFalse(string.IsNullOrEmpty(eb2.A.Key.ColumnFamily)); Assert.IsTrue(string.IsNullOrEmpty(eb2.A.Key.ColumnQualifier)); } using (var em = Emf.CreateEntityManager()) { var _eb1 = em.Find <EntityB>(eb1.Key); Assert.AreEqual(eb1, _eb1); var _ea2 = em.Find <EntityA>(eb2.A.Key); Assert.AreEqual(eb2.A, _ea2); var _eb2 = em.Find <EntityB>(eb2.Key); Assert.AreEqual(eb2, _eb2); } Assert.IsTrue(bindings.UnregisterTableBinding(typeof(EntityA))); Assert.IsFalse(bindings.UnregisterTableBinding(typeof(EntityA))); Assert.IsTrue(bindings.UnregisterTableBinding(typeof(EntityB))); }
public void PersistAndFind() { var ea1 = new EntityA { X = 1, Y = 2, Z = 3 }; TestBase.TestSerialization(ea1); var ea2 = new EntityA { X = 4, Y = 5, Z = 6 }; TestBase.TestSerialization(ea2); var eb1 = new EntityB { A = ea1, B = ea2 }; TestBase.TestSerialization(eb1); using (var em = Emf.CreateEntityManager()) { em.Persist(eb1); Assert.IsFalse(string.IsNullOrEmpty(eb1.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.A.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.B.Id)); } using (var em = Emf.CreateEntityManager()) { var _eb1 = em.Find<EntityB>(eb1.Id); Assert.AreEqual(eb1, _eb1); } eb1 = new EntityB { A = ea1, B = ea2, C = ea1 }; TestBase.TestSerialization(eb1); using (var em = Emf.CreateEntityManager()) { em.Persist(eb1); Assert.IsFalse(string.IsNullOrEmpty(eb1.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.A.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.B.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.C.Id)); } using (var em = Emf.CreateEntityManager()) { var _eb1 = em.Find<EntityB>(eb1.Id); Assert.AreEqual(eb1, _eb1); } eb1 = new EntityB { A = ea1, B = ea1, C = ea2 }; TestBase.TestSerialization(eb1); using (var em = Emf.CreateEntityManager()) { em.Persist(eb1); Assert.IsFalse(string.IsNullOrEmpty(eb1.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.A.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.B.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.C.Id)); } using (var em = Emf.CreateEntityManager()) { var _eb1 = em.Find<EntityB>(eb1.Id); Assert.AreEqual(eb1, _eb1); } eb1 = new EntityB { A = ea1, B = ea1, C = ea1 }; TestBase.TestSerialization(eb1); using (var em = Emf.CreateEntityManager()) { em.Persist(eb1); Assert.IsFalse(string.IsNullOrEmpty(eb1.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.A.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.B.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.C.Id)); } using (var em = Emf.CreateEntityManager()) { var _eb1 = em.Find<EntityB>(eb1.Id); Assert.AreEqual(eb1, _eb1); } }
public void PersistAndFind() { var bindings = Emf.Configuration.Binding; Assert.IsTrue(bindings.RegisterKeyBinding(typeof(EntityA), new KeyBindingEntityA())); Assert.IsFalse(bindings.RegisterKeyBinding(typeof(EntityA), new KeyBindingEntityA())); Assert.IsTrue(bindings.RegisterKeyBinding(typeof(EntityB), new KeyBindingEntityB())); { var cb = new ColumnBinding("e"); Assert.IsTrue(bindings.RegisterColumnBinding(typeof(EntityC), cb)); Assert.IsTrue(bindings.RegisterKeyBinding(typeof(EntityC), new KeyBinding <EntityC>(e => e.Name))); } var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB { A = new EntityA() }; TestBase.TestSerialization(eb2); using (var em = Emf.CreateEntityManager()) { em.Persist(eb1); Assert.IsNotNull(eb1.Key); Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.Row)); Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.ColumnFamily)); Assert.IsTrue(string.IsNullOrEmpty(eb1.Key.ColumnQualifier)); Assert.IsTrue(eb1.Key.Row.StartsWith(typeof(EntityB).Name)); em.Persist(eb2); Assert.IsNotNull(eb2.Key); Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.Row)); Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.ColumnFamily)); Assert.IsTrue(string.IsNullOrEmpty(eb2.Key.ColumnQualifier)); Assert.IsTrue(eb2.Key.Row.StartsWith(typeof(EntityB).Name)); Assert.IsTrue(eb2.A.Name.StartsWith(typeof(EntityA).Name)); } using (var em = Emf.CreateEntityManager()) { var _eb1 = em.Find <EntityB>(eb1.Key); Assert.AreEqual(eb1, _eb1); Assert.IsTrue(_eb1.Key.Row.StartsWith(_eb1.GetType().Name)); var _ea2 = em.Find <EntityA>(eb2.A.Name); // EntityA key binding uses the Name property as row key Assert.AreEqual(eb2.A, _ea2); var _eb2 = em.Find <EntityB>(eb2.Key); Assert.AreEqual(eb2, _eb2); Assert.IsTrue(_eb2.Key.Row.StartsWith(typeof(EntityB).Name)); Assert.AreEqual(eb2.A.Name, _eb2.A.Name); Assert.IsTrue(eb2.A.Name.StartsWith(typeof(EntityA).Name)); } var ec1 = new EntityC { Name = "11", A = new EntityA() }; TestBase.TestSerialization(ec1); var ec2 = new EntityC { Name = "222", A = new EntityA(), B = new EntityB() }; TestBase.TestSerialization(ec2); using (var em = Emf.CreateEntityManager()) { em.Persist(ec1); Assert.AreEqual(ec1.Id, ec1.Name); em.Persist(ec2); Assert.AreEqual(ec2.Id, ec2.Name); } using (var em = Emf.CreateEntityManager()) { var _ec1 = em.Find <EntityC>("11"); Assert.AreEqual(ec1, _ec1); var _ec2 = em.Find <EntityC>(ec2); Assert.AreEqual(ec2, _ec2); } bindings.UnregisterBinding(typeof(EntityA)); bindings.UnregisterBinding(typeof(EntityB)); bindings.UnregisterBinding(typeof(EntityC)); }
public void PersistAndFind() { var ea1 = new EntityA { X = 1, Y = 2, Z = 3 }; TestBase.TestSerialization(ea1); var ea2 = new EntityA { X = 4, Y = 5, Z = 6 }; TestBase.TestSerialization(ea2); var eb1 = new EntityB { A = ea1, B = ea2 }; TestBase.TestSerialization(eb1); using (var em = Emf.CreateEntityManager()) { em.Persist(eb1); Assert.IsFalse(string.IsNullOrEmpty(eb1.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.A.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.B.Id)); } using (var em = Emf.CreateEntityManager()) { var _eb1 = em.Find <EntityB>(eb1.Id); Assert.AreEqual(eb1, _eb1); } eb1 = new EntityB { A = ea1, B = ea2, C = ea1 }; TestBase.TestSerialization(eb1); using (var em = Emf.CreateEntityManager()) { em.Persist(eb1); Assert.IsFalse(string.IsNullOrEmpty(eb1.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.A.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.B.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.C.Id)); } using (var em = Emf.CreateEntityManager()) { var _eb1 = em.Find <EntityB>(eb1.Id); Assert.AreEqual(eb1, _eb1); } eb1 = new EntityB { A = ea1, B = ea1, C = ea2 }; TestBase.TestSerialization(eb1); using (var em = Emf.CreateEntityManager()) { em.Persist(eb1); Assert.IsFalse(string.IsNullOrEmpty(eb1.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.A.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.B.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.C.Id)); } using (var em = Emf.CreateEntityManager()) { var _eb1 = em.Find <EntityB>(eb1.Id); Assert.AreEqual(eb1, _eb1); } eb1 = new EntityB { A = ea1, B = ea1, C = ea1 }; TestBase.TestSerialization(eb1); using (var em = Emf.CreateEntityManager()) { em.Persist(eb1); Assert.IsFalse(string.IsNullOrEmpty(eb1.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.A.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.B.Id)); Assert.IsFalse(string.IsNullOrEmpty(eb1.C.Id)); } using (var em = Emf.CreateEntityManager()) { var _eb1 = em.Find <EntityB>(eb1.Id); Assert.AreEqual(eb1, _eb1); } }
public void PersistAndFind() { var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB { A = new EntityA() }; TestBase.TestSerialization(eb2); using (var em = Emf.CreateEntityManager()) { em.Persist(eb1); Assert.IsNotNull(eb1.Key); Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.Row)); Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.ColumnFamily)); Assert.IsTrue(string.IsNullOrEmpty(eb1.Key.ColumnQualifier)); em.Persist(eb2); Assert.IsNotNull(eb2.Key); Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.Row)); Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.ColumnFamily)); Assert.IsTrue(string.IsNullOrEmpty(eb2.Key.ColumnQualifier)); Assert.IsFalse(string.IsNullOrEmpty(eb2.A.RowKey)); } using (var em = Emf.CreateEntityManager()) { var _eb1 = em.Find <EntityB>(eb1.Key); Assert.AreEqual(eb1, _eb1); var _ea2 = em.Find <EntityA>(eb2.A.RowKey); Assert.AreEqual(eb2.A, _ea2); var _eb2 = em.Find <EntityB>(eb2.Key); Assert.AreEqual(eb2, _eb2); } var ec1 = new EntityC1(); var ec2 = new EntityC2 { C1 = new EntityC1() }; using (var em = Emf.CreateEntityManager()) { em.Persist(ec1); Assert.IsNotNull(ec1.Key); Assert.IsFalse(string.IsNullOrEmpty(ec1.Key.Row)); Assert.IsFalse(string.IsNullOrEmpty(ec1.Key.ColumnFamily)); Assert.IsFalse(string.IsNullOrEmpty(ec1.Key.ColumnQualifier)); em.Persist(ec2); Assert.IsNotNull(ec2.Key); Assert.IsFalse(string.IsNullOrEmpty(ec2.Key.Row)); Assert.IsFalse(string.IsNullOrEmpty(ec2.Key.ColumnFamily)); Assert.IsFalse(string.IsNullOrEmpty(ec2.Key.ColumnQualifier)); Assert.IsNotNull(ec2.C1); Assert.IsFalse(string.IsNullOrEmpty(ec2.C1.Key.Row)); Assert.IsFalse(string.IsNullOrEmpty(ec2.C1.Key.ColumnFamily)); Assert.IsFalse(string.IsNullOrEmpty(ec2.C1.Key.ColumnQualifier)); } using (var em = Emf.CreateEntityManager()) { var _ec1 = em.Find <EntityC1>(ec1.Key); Assert.AreEqual(ec1, _ec1); var _ec12 = em.Find <EntityC1>(ec2.C1.Key); Assert.AreEqual(ec2.C1, _ec12); var _ec2 = em.Find <EntityC2>(ec2.Key); Assert.AreEqual(ec2, _ec2); } }
public void PersistAndFind() { var bindings = Emf.Configuration.Binding; Assert.IsFalse(bindings.StrictExplicitColumnBinding); Assert.IsFalse(bindings.StrictExplicitKeyBinding); Assert.IsFalse(bindings.StrictExplicitTableBinding); Assert.IsTrue(bindings.RegisterTableBinding(typeof(EntityA), new TableBindingEntityA())); Assert.IsFalse(bindings.RegisterTableBinding(typeof(EntityA), new TableBindingEntityA())); Assert.IsTrue(bindings.RegisterTableBinding(typeof(EntityB), new TableBindingEntityB())); var eb1 = new EntityB(); TestBase.TestSerialization(eb1); var eb2 = new EntityB { A = new EntityA() }; TestBase.TestSerialization(eb2); using (var em = Emf.CreateEntityManager()) { Assert.IsTrue(em.IsTypeDeclared<EntityA>()); Assert.IsTrue(em.IsTypeDeclared<EntityB>()); em.Configuration.Binding.StrictExplicitTableBinding = true; em.Persist(eb1); Assert.IsNotNull(eb1.Key); Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.Row)); Assert.IsFalse(string.IsNullOrEmpty(eb1.Key.ColumnFamily)); Assert.IsTrue(string.IsNullOrEmpty(eb1.Key.ColumnQualifier)); em.Persist(eb2); Assert.IsNotNull(eb2.Key); Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.Row)); Assert.IsFalse(string.IsNullOrEmpty(eb2.Key.ColumnFamily)); Assert.IsTrue(string.IsNullOrEmpty(eb2.Key.ColumnQualifier)); Assert.IsNotNull(eb2.A.Key); Assert.IsFalse(string.IsNullOrEmpty(eb2.A.Key.Row)); Assert.IsFalse(string.IsNullOrEmpty(eb2.A.Key.ColumnFamily)); Assert.IsTrue(string.IsNullOrEmpty(eb2.A.Key.ColumnQualifier)); } using (var em = Emf.CreateEntityManager()) { var _eb1 = em.Find<EntityB>(eb1.Key); Assert.AreEqual(eb1, _eb1); var _ea2 = em.Find<EntityA>(eb2.A.Key); Assert.AreEqual(eb2.A, _ea2); var _eb2 = em.Find<EntityB>(eb2.Key); Assert.AreEqual(eb2, _eb2); } Assert.IsTrue(bindings.UnregisterTableBinding(typeof(EntityA))); Assert.IsFalse(bindings.UnregisterTableBinding(typeof(EntityA))); Assert.IsTrue(bindings.UnregisterTableBinding(typeof(EntityB))); }
private EntityA _Create_EntityA_EntityB_And_Many_To_Many_Relation() { var a = new EntityA(); a.Name = "A"; var b = new EntityB(); b.Name = "B"; a.AddB(b); using (IUnitOfWork uow = UnitOfWorkScope.Start()) { var repoA = ServiceLocator.GetInstance<IEntityARepository>(); var repoB = ServiceLocator.GetInstance<IEntityBRepository>(); repoB.Add(b); repoA.Add(a); uow.Commit(); } return a; }
public void starter() { this.unityContainer = new UnityContainer(); ServiceLocator.Initialize( (x, y) => this.unityContainer.RegisterType(x, y), (x, y) => this.unityContainer.RegisterInstance(x, y), (x) => { return unityContainer.Resolve(x); }, (x) => { return unityContainer.ResolveAll(x); }); NHibernateUnitOfWorkFactory<int> ctxFactory = this.CreateNHContextFactory(); if (!ctxFactory.DatabaseExists()) { ctxFactory.CreateDatabase(); } ctxFactory.ValidateDatabaseSchema(); NHibernate.ISessionFactory sessionFactory = ctxFactory.Create(); this.unityContainer.RegisterInstance<NHibernate.ISessionFactory>(sessionFactory); this.unityContainer.RegisterInstance<IDatabaseManager>(ctxFactory); this.unityContainer.RegisterType<ISession, ISession>(this.sessionPerTestLifeTimeManager, new InjectionFactory((c) => { ISession session = sessionFactory.OpenSession(); session.Transaction.Begin(); return session; })); this.unityContainer.RegisterType<IUnitOfWork, NHibernateUnitOfWork>(this.unitOfWorkPerTestLifeTimeManager); // Repositories this.unityContainer.RegisterType<IEntityARepository, EntityANHRepository>(new PerResolveLifetimeManager()); this.unityContainer.RegisterType<IEntityBRepository, EntityBNHRepository>(new PerResolveLifetimeManager()); ApplicationContext.User = new CorePrincipal(new CoreIdentity("cmendible", "hexa.auth", "*****@*****.**"), new string[] { }); // comienzan las operaciones // añadimos una entidad var entityA = new EntityA(); entityA.Name = "Martin4"; var repo = this.unityContainer.Resolve<IEntityARepository>(); repo.Add(entityA); //this.Commit(); // al contrario que en ef aqui no tenemos commint // añadimos 2 entidades y su relación var a = new EntityA(); a.Name = "willi4"; var b = new EntityB(); b.Name = "matematicas"; a.AddB(b); var repoA = this.unityContainer.Resolve<IEntityARepository>(); var repoB = this.unityContainer.Resolve<IEntityBRepository>(); repoB.Add(b); repoA.Add(a); this.RollBack(); ///////////////////////////////////////////////////////////////////////////////////////////// IUnitOfWork unitOfWork = this.unityContainer.Resolve<IUnitOfWork>(); unitOfWork.Dispose(); this.unitOfWorkPerTestLifeTimeManager.RemoveValue(); this.sessionPerTestLifeTimeManager.RemoveValue(); }