Should repository services know about transaction information?

Question

I'm using NHibernate in conjunction with Repository Design Pattern. In current task, I need to update an entity and also delete another entity in the same transaction. I though about declare ISession.BeginTransaction() in Repository's Services layter and pass it to Repository's method as following:

public class SomeEntity
{
    //entity's properties
}

public class EntityRepository : IEntityRepository
{
    public void update(ISession session, Entity entity)
    {
        session.Update(entity);
    }

    public void delete(ISession session, Entity entity)
    {
        session.Delete(entity);
    }
}

public class EntityService
{
    private IEntityRepository repository;

    public EntityService(IEntityRepository repository)
    {
        //I'm using Ninject for DI here
        this.repository = repository;
    }

    public void DoTask(Entity _updateEntity, Entity _deleteEntity)
    { 
        ISession session = NHibernateHelper.OpenSession();
        using(ITransaction transaction = session.BeginTransaction())
        {
            this.repositoy.update(session, _updateEntity);
            this.repositoy.delete(session, _deleteEntity);

            transaction.Commit();
        }
    }
}

What I want to ask are

1. Is it a good idea to let Repository's Service layer manage ISession as well as ITransaction and pass it around Associate Repository?
2. If it's not a good idea, how should I change my design in order to perform those task in a same transaction without letting Repository's Service layer know about that transaction but still make Repository layer as lightweight as possible?

EDIT

For clarify, my EntityService is a business logic layer which depends on Repository to perform business logic then pass the result to presentation layer (a winform in my case). So that I thought that letting EntityService manage ISession and ITransaction will lead to tight coupling which I want to avoid in the first place.

EDIT 2

According to ptk93, I made some change to design as follow:

public class SomeEntity
{
    //entity's properties
}

public class EntityRepository : IEntityRepository
{
    private ISession session;

    private ITrasaction trasaction;

    public EntityRepository()
    {
        this.session = NHibernateHelper.OpenSession();
    }

    public void BeginTransaction()
    {
        if(this.transaction != null && this.transaciont.isActive)
        {
            throw new Exception();
        }

        this.transaction = this.session.BeginTransaction();
    }

    public void CommitTransaction()
    {
        if(this.transaction == null || this.transaction.isActive = false)
        {
            throw new Exception();
        }

        this.transaction.Commit();
        this.transaction.Dispose();
    }

    public void update(ISession session, Entity entity)
    {
        if(this.transaction == null || this.transaction.isActive = false)
        {
            throw new Exception();
        }

        session.Update(entity);
    }

    public void delete(ISession session, Entity entity)
    {
        if(this.transaction == null || this.transaction.isActive = false)
        {
            throw new Exception();
        }

        session.Delete(entity);
    }
}

public class EntityService
{
    private IEntityRepository repository;

    public EntityService(IEntityRepository repository)
    {
        //I'm using Ninject for DI here
        this.repository = repository;
    }

    public void DoTask(Entity _updateEntity, Entity _deleteEntity)
    { 
        this.repository.BeginTransaction()

        this.repositoy.update(session, _updateEntity);
        this.repositoy.delete(session, _deleteEntity);

        this.repository.CommitTransaction();            
    }
}

Does this design enough for de-coupling Repository and Repository Service?

Answer 1

You could separate your services in boundary and control services. Boundaries are visible to the client, webpage, etc and controls are only visible to the boundary services. Are your repositories visible to the client? It seems that in your usecase the repositories are only used by other services not the clients themselves, so they are controls. Controls should be marked with MANDATORY so they will throw an exception if they are called with no already startend transaction and from the beginning to the end of a method in your boundaries a transaction must be startend.

In the case you are creating a User with three Addresses using the controls/repositories UserRepository and AddressRepository all will be in the same transaction startend at the beginning of the boundary RegistrationService's register method.
If you are deleting all contact information the controls AddressRepository and MailRepository are necessary to be used inside another boundary called ContactService with different transaction boundaries.

Such decisions depend on your use case, but in my opinion the Entity-Control-Boundary pattern could fit your needs.

Answer 2

I personally prefer to have transaction control in the service, because sometimes you want to access multiple repositories in the same transaction, otherwise a repository could throw an exception and not be able to rollback changes associated with a previous transaction.

Having said that we also have helpers in our repository base to manage transactions so that the repository is easier to use in those cases where you only update one repository.