TinyFrame升级之三：逻辑访问部分

在上一篇，我们打造了自己的数据访问部分，这篇，我们准备讲解如何打造逻辑访问部分。

在上一篇中，我们利用Repository模式构建了基于泛型的操作合集。由于这些操作的合集都是原子性的操作，也就是针对单表的操作，我们有必要为每个单表做增删改查操作，所以这里我们最好将泛型包装一下：

这里是IBook接口部分，它继承自IRepository接口，并承载了Book实体类

using TinyFrame.Data.DataRepository;
using TinyFrame.Data.DomainModel;

namespace TinyFrame.Repository
{
    public interface IBook:IRepository<Book>
    {
    }
}

这里是BookRepository实现部分，它继承自Repository<Book>和IBook接口：

using TinyFrame.Data.DataRepository;
using TinyFrame.Data.DataContext;
using TinyFrame.Data.DomainModel;

namespace TinyFrame.Repository
{
    public class BookRepository:Repository<Book>,IBook
    {
        public BookRepository(IDbContext context)
            : base(context)
        {
            this.context = context;
        }

        private IDbContext context;
    }
}

这样包装之后，在TinyFrame.Services中，我们就可以实现自己的业务逻辑了。

比如，对于存储的书籍来说，我们需要对其进行增删改查：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;
using TinyFrame.Data.DomainModel;

namespace TinyFrame.Services
{
    public interface IBookService
    {
        IList<BookPlace> GetAllPlaces();
        BookPlace GetPlacesByBookID(int bookid);

        IList<BookType> GetAllTypes();
        BookType GetTypesByBookID(int bookid);

        Book GetBook(int bookid);
        IList<Book> GetAllBooks();
        IList<Book> GetBooks(Expression<Func<Book,bool>> where);

        bool AddBook(Book book);
        bool UpdateBook(Book book);
        bool DeleteBook(Book book);
    }
}

它的实现部分如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using TinyFrame.Data.DataUnitOfWork;
using TinyFrame.Repository;
using System.Linq.Expressions;
using TinyFrame.Data.DomainModel;

namespace TinyFrame.Services
{
    public class BookService:IBookService
    {
        public BookService(IUnitOfWork unitOfWork
            , IBook bookRepository
            , IBookType bookTypeRepository
            , IBookPlace bookPlaceRepository
            )
        {
            this.unitOfWork = unitOfWork;
            this.bookRepository = bookRepository;
            this.bookTypeRepository = bookTypeRepository;
            this.bookPlaceRepository = bookPlaceRepository;
        }

        private readonly IUnitOfWork unitOfWork;
        private readonly IBook bookRepository;
        private readonly IBookType bookTypeRepository;
        private readonly IBookPlace bookPlaceRepository;

        public IList<BookPlace> GetAllPlaces()
        {
            return bookPlaceRepository.GetMany(m => m.ID >= 0).ToList();
        }

        public BookPlace GetPlacesByBookID(int bookid)
        {
            int bookPlaceID = bookRepository.Get(m => m.ID == bookid).BookPlaceID;
            return bookPlaceRepository.Get(m => m.ID == bookPlaceID);
        }

        public IList<BookType> GetAllTypes()
        {
            return bookTypeRepository.GetMany(m => m.ID >= 0).ToList();
        }

        public BookType GetTypesByBookID(int bookid)
        {
            int bookTypeID = bookRepository.Get(m => m.ID == bookid).BookTypeID;
            return bookTypeRepository.Get(m => m.ID == bookTypeID);
        }

        public Book GetBook(int bookid)
        {
            return bookRepository.Get(m=>m.ID==bookid);
        }

        public IList<Book> GetAllBooks()
        {
            return bookRepository.GetMany(m => m.ID >= 0).ToList();
        }

        public IList<Book> GetBooks(Expression<Func<Book, bool>> where)
        {
            return bookRepository.GetMany(where).ToList();
        }


        public bool AddBook(Book book)
        {
            try
            {
                bookRepository.Insert(book);
                unitOfWork.Commit();
                return true;
            }
            catch { return false; }
        }

        public bool UpdateBook(Book book)
        {
            try
            {
                bookRepository.Update(book);
                unitOfWork.Commit();
                return true;
            }
            catch { return false; }
        }

        public bool DeleteBook(Book book)
        {
            try
            {
                bookRepository.Delete(book);
                unitOfWork.Commit();
                return true;
            }
            catch { return false; }
        }
    }
}

通过上面的代码，我们就能够有效地控制逻辑部分，同时融合cache和log的话，基本上就可以随心所欲的控制了。