public virtual void Context() { Entity = new TestEntity(); Session = Mock<ISession>(); var unitOfWork = CreateUnitOfWorkWithStartedTransaction(); Repository = new NhibernateRepository<TestEntity>(unitOfWork); }
public Item SelectById(int id) { using (ISession session = NhibernateRepository.OpenSessionSQL()) { return(session.Get <Item>(id)); } }
protected void SaveGeneric <TAggregateRoot, TId>(TAggregateRoot entity) where TAggregateRoot : IAggregateRoot { var repository = new NhibernateRepository <TAggregateRoot, TId>(UnitOfWork); repository.Save(entity); Flush(); }
public async Task CreateNewShip(CoreDddSampleNhibernateConfigurator nhibernateConfigurator) { using (var unitOfWork = new NhibernateUnitOfWork(nhibernateConfigurator)) { unitOfWork.BeginTransaction(); var shipRepository = new NhibernateRepository <Ship>(unitOfWork); try { var createNewShipCommand = new CreateNewShipCommand { ShipName = "lady", Tonnage = 10m }; var createNewShipCommandHandler = new CreateNewShipCommandHandler(shipRepository); var generatedShipId = 0; createNewShipCommandHandler.CommandExecuted += args => generatedShipId = (int)args.Args; await createNewShipCommandHandler.ExecuteAsync(createNewShipCommand); Console.WriteLine($"Create new ship command was executed. Generated ship id: {generatedShipId}"); await unitOfWork.CommitAsync(); } catch { await unitOfWork.RollbackAsync(); throw; } } }
public IList <Item> SelectAll() { using (ISession session = NhibernateRepository.OpenSessionSQL()) { return(session.Query <Item>().ToList()); } }
/// <summary> /// Loads an aggregate root domain entity proxy using NhibernateRepository. /// </summary> /// <typeparam name="TAggregateRoot">An aggregate root domain entity type</typeparam> /// <typeparam name="TId">Entity Id type</typeparam> /// <param name="unitOfWork">NHibernate unit of work</param> /// <param name="id">An aggregate root domain entity id</param> /// <returns>An aggregate root domain entity proxy</returns> public static TAggregateRoot Load <TAggregateRoot, TId>(this NhibernateUnitOfWork unitOfWork, TId id) where TAggregateRoot : Entity <TId>, IAggregateRoot { var repository = new NhibernateRepository <TAggregateRoot, TId>(unitOfWork); return(repository.Load(id)); }
/// <summary> /// Fetches an aggregate root domain entity from the database using NhibernateRepository. /// </summary> /// <typeparam name="TAggregateRoot">An aggregate root domain entity type</typeparam> /// <param name="unitOfWork">NHibernate unit of work</param> /// <param name="id">An aggregate root domain entity id</param> /// <returns>An aggregate root domain entity, or null when not found</returns> public static TAggregateRoot Get <TAggregateRoot>(this NhibernateUnitOfWork unitOfWork, int id) where TAggregateRoot : Entity, IAggregateRoot { var repository = new NhibernateRepository <TAggregateRoot>(unitOfWork); return(repository.Get(id)); }
public async Task QueryShipsByName(CoreDddSampleNhibernateConfigurator nhibernateConfigurator) { using (var unitOfWork = new NhibernateUnitOfWork(nhibernateConfigurator)) { unitOfWork.BeginTransaction(); var shipRepository = new NhibernateRepository <Ship>(unitOfWork); try { var ship = new Ship("lady starlight", tonnage: 10m); await shipRepository.SaveAsync(ship); unitOfWork.Flush(); var getShipByNameQuery = new GetShipsByNameQuery { ShipName = "lady" }; var getShipByNameQueryHandler = new GetShipsByNameQueryHandler(unitOfWork); var shipDtos = await getShipByNameQueryHandler.ExecuteAsync <ShipDto>(getShipByNameQuery); Console.WriteLine($"Ship by name query was executed. Number of ships queried: {shipDtos.Count()}"); await unitOfWork.CommitAsync(); } catch { await unitOfWork.RollbackAsync(); throw; } } }
public async Task PersistNewEntity(CoreDddSampleNhibernateConfigurator nhibernateConfigurator) { using (var unitOfWork = new NhibernateUnitOfWork(nhibernateConfigurator)) { unitOfWork.BeginTransaction(); var shipRepository = new NhibernateRepository <Ship>(unitOfWork); try { var ship = new Ship("ship name", tonnage: 10m); await shipRepository.SaveAsync(ship); await unitOfWork.CommitAsync(); Console.WriteLine("Ship entity was persisted."); } catch { await unitOfWork.RollbackAsync(); throw; } } }
/// <summary> /// Saves an aggregate root domain entity using NhibernateRepository. /// </summary> /// <typeparam name="TAggregateRoot">An aggregate root domain entity type</typeparam> /// <typeparam name="TId">Entity Id type</typeparam> /// <param name="unitOfWork">NHibernate unit of work</param> /// <param name="aggregateRoot">An instance of aggregate root domain entity</param> public static void Save <TAggregateRoot, TId>(this NhibernateUnitOfWork unitOfWork, TAggregateRoot aggregateRoot) where TAggregateRoot : Entity <TId>, IAggregateRoot { var repository = new NhibernateRepository <TAggregateRoot, TId>(unitOfWork); repository.Save(aggregateRoot); unitOfWork.Flush(); }
protected static IRepository GetRepository() { var openSession = MSpecAssemblyContext.NhibernateFluent <CallSessionContext>().BuildSessionFactory().OpenSession(); var nhibernateRepository = new NhibernateRepository(/*Pleasure.MockStrictAsObject<INhibernateSessionFactory>(mock => mock.Setup(r => r.GetCurrent()).Returns(openSession))*/); nhibernateRepository.SetProvider(new Lazy <ISession>(() => openSession)); return(nhibernateRepository); }
/// <summary> /// Deletes an aggregate root domain entity using NhibernateRepository. /// </summary> /// <typeparam name="TAggregateRoot">An aggregate root domain entity type</typeparam> /// <param name="unitOfWork">NHibernate unit of work</param> /// <param name="aggregateRoot">An instance of aggregate root domain entity</param> public static void Delete <TAggregateRoot>(this NhibernateUnitOfWork unitOfWork, TAggregateRoot aggregateRoot) where TAggregateRoot : Entity, IAggregateRoot { var repository = new NhibernateRepository <TAggregateRoot>(unitOfWork); repository.Delete(aggregateRoot); unitOfWork.Flush(); }
public void Save(Item item) { using (ISession session = NhibernateRepository.OpenSessionSQL()) { using (ITransaction transaction = session.BeginTransaction()) { session.Save(item); transaction.Commit(); } } }
public void Context() { _unitOfWork = IoC.Resolve <NhibernateUnitOfWork>(); _unitOfWork.BeginTransaction(IsolationLevel.Serializable); _testEntityRepository = new NhibernateRepository <TestEntity>(_unitOfWork); _testEntity = new TestEntity(); _testEntityRepository.Save(_testEntity); _unitOfWork.Commit(); }
public async Task Context() { _unitOfWork = IoC.Resolve <NhibernateUnitOfWork>(); _unitOfWork.BeginTransaction(); _testEntityRepository = new NhibernateRepository <TestEntity>(_unitOfWork); _testEntity = new TestEntity(); _testEntityRepository.Save(_testEntity); await _unitOfWork.RollbackAsync(); }
public void Delete(int id) { using (ISession session = NhibernateRepository.OpenSessionSQL()) { var itemDelete = session.Get <Item>(id); using (ITransaction transaction = session.BeginTransaction()) { session.Delete(itemDelete); transaction.Commit(); } } }
public void Context() { var specification = new TCommittingUnitOfWorkSpecification(); _unitOfWork = IoC.Resolve <NhibernateUnitOfWork>(); _unitOfWork.BeginTransaction(); _testEntityRepository = new NhibernateRepository <TestEntity>(_unitOfWork); _testEntity = new TestEntity(); _testEntityRepository.Save(_testEntity); specification.CommitAct(_unitOfWork); }
public void entity_is_persisted_and_retrieved() { var testEntityRepository = new NhibernateRepository <TestEntity>(UnitOfWork); var testEntity = new TestEntity(); testEntityRepository.Save(testEntity); UnitOfWork.Flush(); UnitOfWork.Clear(); testEntity = testEntityRepository.Get(testEntity.Id, LockMode.Upgrade); testEntity.ShouldNotBeNull(); }
public void Update(Item item) { using (ISession session = NhibernateRepository.OpenSessionSQL()) { var itemUpdate = session.Get <Item>(item.Id); itemUpdate.Titulo = item.Titulo; itemUpdate.Descricao = item.Descricao; using (ITransaction transaction = session.BeginTransaction()) { session.Save(itemUpdate); transaction.Commit(); } } }
public void entity_is_loaded_from_database() { var entityRepository = new NhibernateRepository<EntityWithText>(UnitOfWork); var entity = new EntityWithText("hello"); entityRepository.Save(entity); UnitOfWork.Flush(); UnitOfWork.Clear(); entity = entityRepository.Load(entity.Id, LockMode.Upgrade); entity.ShouldNotBeNull(); entity.Text.ShouldBe("hello"); }
public async Task entity_is_persisted_and_retrieved() { var testEntityRepository = new NhibernateRepository <TestEntity>(UnitOfWork); var testEntity = new TestEntity(); testEntityRepository.Save(testEntity); UnitOfWork.Flush(); UnitOfWork.Clear(); testEntity = await testEntityRepository.GetAsync(testEntity.Id); testEntity.ShouldNotBeNull(); }
public async Task entity_is_loaded_from_database() { var entityRepository = new NhibernateRepository <EntityWithText>(UnitOfWork); var entity = new EntityWithText("hello"); await entityRepository.SaveAsync(entity); UnitOfWork.Flush(); UnitOfWork.Clear(); entity = await entityRepository.LoadAsync(entity.Id); entity.ShouldNotBeNull(); entity.Text.ShouldBe("hello"); }
public void Context() { _unitOfWork = IoC.Resolve <NhibernateUnitOfWork>(); _unitOfWork.BeginTransaction(); _testEntityRepository = new NhibernateRepository <TestEntity>(_unitOfWork); _testEntity = new TestEntity(); _testEntityRepository.Save(_testEntity); _makeTransactionDisconnected(); void _makeTransactionDisconnected() { _unitOfWork.Session.Transaction.Dispose(); } }
public static IRepository BuildNhibernateRepository() { try { var nhibernateRepository = new NhibernateRepository(); nhibernateRepository.SetProvider(new Lazy <ISession>(() => SessionFactory.Open(null))); nhibernateRepository.GetProvider <ISession>().CacheMode = CacheMode.Ignore; return(nhibernateRepository);//Pleasure.MockStrictAsObject<INhibernateSessionFactory>(mock => mock.Setup(r => r.GetCurrent()).Returns(new SessionSource(instanceBuilderConfiguration).CreateSession()))); } ////ncrunch: no coverage start catch (Exception e) { Clipboard.SetText("Exception in build configuration {0}".F(e)); return(null); } ////ncrunch: no coverage end }
public async Task QueryShipsByName() { var ioCContainer = new WindsorContainer(); _RegisterComponents(ioCContainer); var unitOfWork = ioCContainer.Resolve <NhibernateUnitOfWork>(); var shipRepository = new NhibernateRepository <Ship>(unitOfWork); try { unitOfWork.BeginTransaction(); try { var ship = new Ship("lady starlight", tonnage: 10m); await shipRepository.SaveAsync(ship); unitOfWork.Flush(); var queryExecutor = ioCContainer.Resolve <IQueryExecutor>(); var getShipByNameQuery = new GetShipsByNameQuery { ShipName = "lady" }; var shipDtos = await queryExecutor.ExecuteAsync <GetShipsByNameQuery, ShipDto>(getShipByNameQuery); Console.WriteLine($"Ship by name query was executed by query executor resolved from IoC container. Number of ships queried: {shipDtos.Count()}"); await unitOfWork.CommitAsync(); } catch { await unitOfWork.RollbackAsync(); throw; } } finally { ioCContainer.Release(unitOfWork); } ioCContainer.Dispose(); }
public void entity_is_deleted() { var testEntityRepository = new NhibernateRepository <TestEntity>(UnitOfWork); var testEntity = new TestEntity(); testEntityRepository.Save(testEntity); UnitOfWork.Flush(); UnitOfWork.Clear(); testEntityRepository.Delete(testEntity); UnitOfWork.Flush(); UnitOfWork.Clear(); testEntity = testEntityRepository.Get(testEntity.Id); testEntity.ShouldBeNull(); }
public void Context() { var specification = new TRollingBackUnitOfWorkInTransactionScopeSpecification(); using (var transactionScope = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted })) { _unitOfWork = IoC.Resolve <NhibernateUnitOfWork>(); _unitOfWork.BeginTransaction(); _testEntityRepository = new NhibernateRepository <TestEntity>(_unitOfWork); _testEntity = new TestEntity(); _testEntityRepository.Save(_testEntity); specification.RollbackAct(_unitOfWork); } }
public async Task entity_is_deleted() { var testEntityRepository = new NhibernateRepository <TestEntity>(UnitOfWork); var testEntity = new TestEntity(); await testEntityRepository.SaveAsync(testEntity); UnitOfWork.Flush(); UnitOfWork.Clear(); await testEntityRepository.DeleteAsync(testEntity); UnitOfWork.Flush(); UnitOfWork.Clear(); testEntity = await testEntityRepository.GetAsync(testEntity.Id); testEntity.ShouldBeNull(); }
public void entities_are_not_persisted() { var unitOfWork = IoC.Resolve <NhibernateUnitOfWork>(); unitOfWork.BeginTransaction(); var testEntityRepository = new NhibernateRepository <TestEntity>(unitOfWork); var testEntity = new TestEntity(); testEntityRepository.Save(testEntity); unitOfWork.Clear(); testEntity = testEntityRepository.Get(testEntity.Id); testEntity.ShouldBeNull(); unitOfWork.Rollback(); }
public async Task entities_are_persisted() { var unitOfWork = IoC.Resolve <NhibernateUnitOfWork>(); unitOfWork.BeginTransaction(); var testEntityRepository = new NhibernateRepository <TestEntity>(unitOfWork); var testEntity = new TestEntity(); testEntityRepository.Save(testEntity); await unitOfWork.FlushAsync(); unitOfWork.Clear(); testEntity = testEntityRepository.Get(testEntity.Id); testEntity.ShouldNotBeNull(); unitOfWork.Rollback(); }
public void Context() { using (var transactionScope = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted })) { _unitOfWork = IoC.Resolve <NhibernateUnitOfWork>(); _unitOfWork.BeginTransaction(); _testEntityRepository = new NhibernateRepository <TestEntity>(_unitOfWork); _testEntity = new TestEntity(); _testEntityRepository.Save(_testEntity); _unitOfWork.Commit(); transactionScope.Complete(); } _unitOfWork.Rollback(); }