业务逻辑层_业务逻辑是什么

业务逻辑层是应用程序的大脑：

负责处理系统的业务逻辑，
负责对用户定义的流程进行建模，
负责数据访问层和展示层的通讯，
负责将错误信息返回给展示层。

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

业务逻辑层在此架构中包含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

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

今天的文章业务逻辑层_业务逻辑是什么分享到此就结束了，感谢您的阅读，如果确实帮到您，您可以动动手指转发给其他人。

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至举报，一经查实，本站将立刻删除。
如需转载请保留出处：https://bianchenghao.cn/45680.html

业务逻辑层_业务逻辑是什么

相关推荐

发表回复