0
votes

I am building an mvc4 n layer application using the following frameworks

1.nhibernate

2.ninject

3.mvc4/Console(For testing)

The layers are(All are class library projects)

1.Presentation(Calling BLL layer)

2.BLL(Calling my DAO layer)

3.Domain(POCOS)

4.Nhibernate(Implementation of DAO)

5.Core

BLL Layer Coding

public interface IUserService
{
   IList<User> GetAllActiveUsers();

   User GetUserDetailsByUsername(string usernameOrEmail);
}

public class UserService :IUserService { private readonly IUserRepository userRepository;

   public UserService(IUserRepository userRepository)
   {
       this.userRepository = userRepository;
   }

   public IList<User> GetAllActiveUsers()
   {
       var activeUserList = from user in userRepository.All()
                            where user.ACTIVE_STATUS == true
                            select user;
       return activeUserList.ToList<User>();
   }




   public User GetUserDetailsByUsername(string usernameOrEmail)
   {
       var registerUser = from user in userRepository.All()
                          where user.USER_NAME == usernameOrEmail
                          select user;
       return (User)registerUser;
   }
}

DAO layer Code

 public interface IRepository<TKey, TEntity> where TEntity : class
{
    IQueryable<TEntity> All();
    TEntity FindBy(Expression<Func<TEntity, bool>> expression);
    IQueryable<TEntity> FilterBy(Expression<Func<TEntity, bool>> expression);
    TEntity FindBy(TKey id);
    bool Add(TEntity entity);
    bool Add(IEnumerable<TEntity> items);
    bool Update(TEntity entity);
    bool Delete(TEntity entity);
    bool Delete(IEnumerable<TEntity> entities);
}



public interface IUowDAO:IDisposable
    {

        void Commit();
        void Rollback();

    }


public interface IUserRepository:IRepository<long,User>
    {
    }

DAO.Nhibernate Layer

public class IURMSNhibernateRepository<TKey, T> : IRepository<TKey, T> where T : class
    {
        private readonly ISession _session;

        public IURMSNhibernateRepository(ISession session)
        {
            _session = session;
        }


        public bool Add(T entity)
        {
            _session.Save(entity);
            return true;
        }

        public bool Add(IEnumerable<T> items)
        {
            foreach (T item in items)
            {

                _session.Save(item);
            }
            return true;
        }

        public bool Update(T entity)
        {
            _session.SaveOrUpdate(entity);
            return true;
        }

        public bool Delete(T entity)
        {
            _session.Delete(entity);
            return true;
        }

        public bool Delete(IEnumerable<T> entities)
        {
            foreach (T entity in entities)
            {
                _session.Delete(entity);

            }
            return true;
        }

        public System.Linq.IQueryable<T> All()
        {
            return _session.Query<T>();
        }

        public T FindBy(System.Linq.Expressions.Expression<Func<T, bool>> expression)
        {
            return FilterBy(expression).SingleOrDefault();
        }

        public System.Linq.IQueryable<T> FilterBy(System.Linq.Expressions.Expression<Func<T, bool>> expression)
        {
            return All().Where(expression).AsQueryable();
        }

        public T FindBy(TKey id)
        {
            return _session.Get<T>(id);
        }
    }




public class IURMSUnitOfWork:IUowDAO
    {

        private readonly ISessionFactory _sessionFactory;
        private readonly ITransaction _transaction;
        public ISession Session { get; private set; }




        public IURMSUnitOfWork(ISessionFactory sessionFactory)
        {
            _sessionFactory = sessionFactory;
            Session = _sessionFactory.OpenSession();
            Session.FlushMode = FlushMode.Auto;
            _transaction = Session.BeginTransaction(IsolationLevel.ReadCommitted);
        }




        public void Commit()
        {
            if (!_transaction.IsActive)
            {
                throw new InvalidOperationException("Oops! We don't have an active transaction");
            }
            _transaction.Commit();
        }

        public void Rollback()
        {
            if (_transaction.IsActive)
            {
                _transaction.Rollback();
            }
        }

        public void Dispose()
        {
            if (Session.IsOpen)
            {
                Session.Close();
            }
        }
    }

public class UserRepository:IURMSNhibernateRepository<long,User>,IUserRepository
    {
       public UserRepository(ISession session)
           : base(session)
       {
       }
    }

CORE Layer

public class BuisnessLogicModule:NinjectModule
    {
        public override void Load()
        {
            Bind<IUserService>().To<UserService>();
        }
    }
public  class DataAccessLogicModule:NinjectModule
    {

        public override void Load()
        {

            Bind<IUowDAO>().To<IURMSUnitOfWork>().InTransientScope();

            Bind(typeof(IRepository<,>)).To(typeof(IURMSNhibernateRepository<,>));

            Bind<IUserRepository>().To<UserRepository>();
        }
    }

Console layerCoding

public interface IConsole
    {
       IList<User> GetAllUsers();
    }

public class ConsoleUser:IConsole
    {
       private readonly IUserService _userService;
       public ConsoleUser(IUserService UserService)
       {
           this._userService = UserService;
       }
        public IList<IURMSPOC.DOMAIN.User> GetAllUsers()
        {
            var user = _userService.GetAllActiveUsers();
            return user;
        }
    }



public  class TopModule:NinjectModule
    {
        public override void Load()
        {
            Bind<IConsole>().To<ConsoleUser>();
        }
    }
public class Program
    {
        static void Main(string[] args)
        {
            IKernel kernel = new StandardKernel(new TopModule());

            var modules = new List<INinjectModule>
            {
                new IURMSPOC.CORE.Dependency.BuisnessLogicModule(),
                new IURMSPOC.CORE.Dependency.DataAccessLogicModule(),
            };
            kernel.Load(modules);

            var topClass = kernel.Get<IConsole>();
            var message = topClass.GetAllUsers();
            System.Console.WriteLine(message);

            System.Console.WriteLine("Press enter to continue...");
            System.Console.ReadLine();
        }
    }

But when i am running the application the error shows Error activating ISession No matching bindings are available, and the type is not self-bindable.

I am new to ninject and nhibernate .Please give me the solution .I understand the problem but can not find any solution.

1

1 Answers

0
votes

That's not an issue of Nhibernate, I guess the error comes from the ctor of

   public UserRepository(ISession session)
       : base(session)
   {
   }

Where you require an ISession.

You construct the session in IURMSUnitOfWork so there is no way for the UserRepository to determine the session or for the injection to figure out where ISession is coming from...

Instead I'd suggest to refactor your code and inject your unit of work instance to where it is needed, or refactor the repository to care about unit of work.

Easiest would be to extend IUowDAO with something like GetSession() and change

   public UserRepository(IUowDAO dao)
       : base(dao.GetSession())
   {
   }

or something like that...

Your implementation is a little bit strange. Your data access object has the signature of a transaction etc... maybe read this article for a basic unit of work implementation with nhibernate. What your are missing is basically the session factory.