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();
}
