业务逻辑层

  • 业务逻辑层是应用程序的大脑:
  1. 负责处理系统的业务逻辑,
  2. 负责对用户定义的流程进行建模,
  3. 负责数据访问层和展示层的通讯,
  4. 负责将错误信息返回给展示层。

业务逻辑层,不能因为数据库的变换而变化,也不能因为终端的变换而变化。

业务逻辑层在此架构中包含IBLL,BLL,WFActivitys和WFDesigner四个项目。

1. BLL——业务逻辑

业务逻辑的操作,包括业务处理,调用数据访问,事务等。

2. IBLL——业务接口

业务逻辑层的方法对外暴露的接口和服务契约

3. WFActivitys——工作流活动层

定义了工作流中使用的活动

4. WFDesigner——工作流设计器

在此将工作流活动安装一定的业务规则组织在一起,设计工作流的业务流程 

 

  • 接口

 

View Code
using System;
using System.Collections.Generic;
using System.Linq;

using Common;
using Langben.DAL;
using System.ServiceModel;

namespace Langben.IBLL
{
    /// <summary>
    /// 异常处理 接口
    /// </summary>
    [ServiceContract(Namespace = "www.langben.com")]
    public interface ISysExceptionBLL
    {
        /// <summary>
        /// 查询的数据
        /// </summary>
        /// <param name="id">额外的参数</param>
        /// <param name="page">页码</param>
        /// <param name="rows">每页显示的行数</param>
        /// <param name="order">排序字段</param>
        /// <param name="sort">升序asc(默认)还是降序desc</param>
        /// <param name="search">查询条件</param>
        /// <param name="total">结果集的总数</param>
        /// <returns>结果集</returns>
        [OperationContract]
        IQueryable<SysException> GetByParam(string id, int page, int rows, string order, string sort, string search, ref int total);
        /// <summary>
        /// 获取所有
        /// </summary>
        /// <returns></returns>
        [OperationContract]
        System.Collections.Generic.List<SysException> GetAll();
        
        
        /// <summary>
        /// 根据主键,查看详细信息
        /// </summary>
        /// <param name="id">根据主键</param>
        /// <returns></returns>
        [OperationContract]
        SysException GetById(string id);    
        /// <summary>
        /// 创建一个对象
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="entity">一个对象</param>
        /// <returns></returns>
        [OperationContract]
         bool Create(ref Common.ValidationErrors validationErrors, DAL.SysException entity); 
        /// <summary>
        ///  创建对象集合
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="entitys">对象集合</param>
        /// <returns></returns>
        [OperationContract]
        bool CreateCollection(ref Common.ValidationErrors validationErrors, System.Linq.IQueryable<DAL.SysException> entitys);
        /// <summary>
        /// 删除一个对象
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="id">一条数据的主键</param>
        /// <returns></returns>  
        [OperationContract]
        bool Delete(ref Common.ValidationErrors validationErrors, string id);
        /// <summary>
        /// 删除对象集合
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="deleteCollection">主键的集合</param>
        /// <returns></returns>       
        [OperationContract]
        bool DeleteCollection(ref Common.ValidationErrors validationErrors, string[] deleteCollection);
        /// <summary>
        /// 编辑一个对象
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="entity">一个对象</param>
        /// <returns></returns>
        [OperationContract]
        bool Edit(ref Common.ValidationErrors validationErrors, DAL.SysException entity); 
        /// <summary>
        ///  创建对象集合
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="entitys">对象集合</param>
        /// <returns></returns>
        [OperationContract]
        bool EditCollection(ref Common.ValidationErrors validationErrors, System.Linq.IQueryable<DAL.SysException> entitys);
    }
}

 

  • 实现

 

View Code
using System;
using System.Collections.Generic;
using System.Linq;
using System.Transactions;
using Langben.DAL;
using Common;

namespace Langben.BLL
{
    /// <summary>
    /// 异常处理 
    /// </summary>
    public class SysExceptionBLL : BaseBLL, Langben.IBLL.ISysExceptionBLL
    {
        /// <summary>
        /// 私有的数据访问上下文
        /// </summary>
        protected SysEntities db;
        /// <summary>
        /// 异常处理的数据库访问对象
        /// </summary>
        SysExceptionRepository repository = null;
        /// <summary>
        /// 构造函数,默认加载数据访问上下文
        /// </summary>
        public SysExceptionBLL()
        {
            db = new SysEntities();
            repository = new SysExceptionRepository();
        }
        /// <summary>
        /// 已有数据访问上下文的方法中调用
        /// </summary>
        /// <param name="entities">数据访问上下文</param>
        public SysExceptionBLL(SysEntities entities)
        {
            db = entities;
            repository = new SysExceptionRepository();
        }
        /// <summary>
        /// 查询的数据
        /// </summary>
        /// <param name="id">额外的参数</param>
        /// <param name="page">页码</param>
        /// <param name="rows">每页显示的行数</param>
        /// <param name="order">排序字段</param>
        /// <param name="sort">升序asc(默认)还是降序desc</param>
        /// <param name="search">查询条件</param>
        /// <param name="total">结果集的总数</param>
        /// <returns>结果集</returns>
        public IQueryable<SysException> GetByParam(string id, int page, int rows, string order, string sort, string search, ref int total)
        {
            IQueryable<SysException> queryData = repository.DaoChuData(db, order, sort, search);
            total = queryData.Count();
            if (total > 0)
            {
                if (page <= 1)
                {
                    queryData = queryData.Take(rows);
                }
                else
                {
                    queryData = queryData.Skip((page - 1) * rows).Take(rows);
                }

            }
            return queryData;
        }
        /// <summary>
        /// 创建一个异常处理
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="db">数据库上下文</param>
        /// <param name="entity">一个异常处理</param>
        /// <returns></returns>
        public bool Create(ref ValidationErrors validationErrors, SysException entity)
        {
            try
            {
                return repository.Create(entity) == 1;
            }
            catch (Exception ex)
            {
                validationErrors.Add(ex.Message);
                ExceptionsHander.WriteExceptions(ex);
            }
            return false;
        }
        /// <summary>
        ///  创建异常处理集合
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="entitys">异常处理集合</param>
        /// <returns></returns>
        public bool CreateCollection(ref ValidationErrors validationErrors, IQueryable<SysException> entitys)
        {
            try
            {
                if (entitys != null)
                {
                    int count = entitys.Count();
                    if (count == 1)
                    {
                        return this.Create(ref validationErrors, entitys.FirstOrDefault());
                    }
                    else if (count > 1)
                    {
                        using (TransactionScope transactionScope = new TransactionScope())
                        {
                            repository.Create(db, entitys);
                            if (count == repository.Save(db))
                            {
                                transactionScope.Complete();
                                return true;
                            }
                            else
                            {
                                Transaction.Current.Rollback();
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                validationErrors.Add(ex.Message);
                ExceptionsHander.WriteExceptions(ex);
            }
            return false;
        }
        /// <summary>
        /// 删除一个异常处理
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="id">一异常处理的主键</param>
        /// <returns></returns>  
        public bool Delete(ref ValidationErrors validationErrors, string id)
        {
            try
            {
                return repository.Delete(id) == 1;
            }
            catch (Exception ex)
            {
                validationErrors.Add(ex.Message);
                ExceptionsHander.WriteExceptions(ex);
            }
            return false;
        }
        /// <summary>
        /// 删除异常处理集合
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="deleteCollection">异常处理的集合</param>
        /// <returns></returns>    
        public bool DeleteCollection(ref ValidationErrors validationErrors, string[] deleteCollection)
        {
            try
            {
                if (deleteCollection != null)
                {
                    using (TransactionScope transactionScope = new TransactionScope())
                    {
                        repository.Delete(db, deleteCollection);
                        if (deleteCollection.Length == repository.Save(db))
                        {
                            transactionScope.Complete();
                            return true;
                        }
                        else
                        {
                            Transaction.Current.Rollback();
                        }
                    }
                }

            }
            catch (Exception ex)
            {
                validationErrors.Add(ex.Message);
                ExceptionsHander.WriteExceptions(ex);
            }
            return false;
        }
        /// <summary>
        ///  创建异常处理集合
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="entitys">异常处理集合</param>
        /// <returns></returns>
        public bool EditCollection(ref ValidationErrors validationErrors, IQueryable<SysException> entitys)
        {
            try
            {
                if (entitys != null)
                {
                    int count = entitys.Count();
                    if (count == 1)
                    {
                        return this.Edit(ref validationErrors, entitys.FirstOrDefault());
                    }
                    else if (count > 1)
                    {
                        using (TransactionScope transactionScope = new TransactionScope())
                        {
                            repository.Edit(db, entitys);
                            if (count == repository.Save(db))
                            {
                                transactionScope.Complete();
                                return true;
                            }
                            else
                            {
                                Transaction.Current.Rollback();
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                validationErrors.Add(ex.Message);
                ExceptionsHander.WriteExceptions(ex);
            }
            return false;
        }
        /// <summary>
        /// 编辑一个异常处理
        /// </summary>
        /// <param name="validationErrors">返回的错误信息</param>
        /// <param name="entity">一个异常处理</param>
        /// <returns></returns>
        public bool Edit(ref ValidationErrors validationErrors, SysException entity)
        {
            try
            {
                repository.Edit(db, entity);
                return repository.Save(db) == 1;
            }
            catch (Exception ex)
            {
                validationErrors.Add(ex.Message);
                ExceptionsHander.WriteExceptions(ex);
            }
            return false;
        }

        public List<SysException> GetAll()
        {
            return repository.GetAll(db).ToList();
        }

        /// <summary>
        /// 根据主键获取一个异常处理
        /// </summary>
        /// <param name="id">异常处理的主键</param>
        /// <returns>一个异常处理</returns>
        public SysException GetById(string id)
        {
            return repository.GetById(db, id);
        }


    }
}

 

 

 

在业务逻辑层使用事务和处理异常信息,因为服务层和展示层都会调用,保证此层是业务的最小逻辑单元,所以在此层做事务和异常的处理,TransactionScope类是一个分布式事务类,ExceptionsHander类是处理异常的类。 

更新的时候会面临一个难点,如果用户在屏幕上调出一条记录,看了两分钟,然后进行修改,最后保存到数据库,系统应该只对用户最开始所看到的那条记录进行更新。如果在第一个客户看的两分钟中,其他的客户成功的对该数据进行了修改,则第一个客户保存到数据库不应该成功。解决此问题,可以在该数据表中增加一个TimeStamp字段。 

  • 我们约定:

1.将系统需要的基础类放在"Framework"文件夹中

2.每个业务逻辑层的方法都有两个构造函数,SysExceptionBLL(SysEntities entities)是在其他业务逻辑层方法调用的时候使用,保证一个业务单元使用一个上下文。 

此架构的代码实现,请参考 https://files.cnblogs.com/langben/www.langben.com.zip

 

以上我们完成了数据访问层的设计,下一章我们实现展示层的代码

 

posted @ 2012-07-20 17:38  腾飞刘  阅读(6170)  评论(4编辑  收藏  举报