使用Dictionary泛型集合封装业务逻辑判断 z

C#2.0 提供了Dictionary 泛型类，它提供了从一组键到一组值的映射。字典中的每个添加项都由一个值及其相关联的键组成。通过键来检索值的速度是非常快的，接近于 O(1)，这是因为 Dictionary 类是作为一个哈希表来实现的。本文主要介绍如何通过它来封装一些业务逻辑处理。在客户端可以非常方便的调用。

     例子是从我在项目中的一个小的模块重构得来，场景说明:“系统刷单的时候可能要经过很多验证，如操作员权限检查、仓库检查、客户资金检查”等，而且项目中单据类型很多，有发货单、退货单、调拨单等都需要或多或少经过这几步检查，如果不重构的话，将会出现大量的重复代码，而且

逻辑稍微发生修改，对维护也将是一个非常大的噩耗。

客户端代码 ——————>永远不要提供底层不是很关心的数据
客户端只需要这么简单的代码就完成了以前多个if语句的判断,下面是我改善后的代码：
protected override bool HandleRecords(List<ReceiptRecord> res)
{
    if (res.Count <= 0) return false;
    ReceiptRecord record = res[0];
    var productBrand = record.BrandID;
    var branchId = selectBranch1.txtBranchId.Text.Trim();
    var stockId = cmbStockId.SelectedValue.ToString();
    //初始化验证器类（封装的一个底层类型）
    SaoDanValid valid = new SaoDanValid(stockId, productBrand, branchId);
    //添加对仓库的验证
     valid.SetValidObject(new VerifyEntity { VerifyType = SaoDanValidType.Stock, ErrorText = "仓库对应的品牌与扫单所对应的品牌不一致" });
    //添加对操作员的验证
     valid.SetValidObject(new VerifyEntity { VerifyType = SaoDanValidType.User, ErrorText = "没有操作该品牌的权限" });
     //添加对产品的验证
     valid.SetValidObject(new VerifyEntity { VerifyType = SaoDanValidType.Product, ErrorText = "一张单据不能出现多个品牌" });
     //添加对客户资金的验证
     valid.SetValidObject(new VerifyEntity { VerifyType = SaoDanValidType.Customer, ErrorText = "客户没有经营此品牌的权限" });
    //执行逻辑处理
    return valid.Vaild() == true ? true : false;
}
      上面的设计客户端只需要发送必要的数据给底层类型，然后通过枚举指定每个步骤主要是干什么的，具体怎么去做完全是由底层去实现，客户端唯一要做的事情就是传递必要的数据给底层类型，最后每个步骤都添加到Dictionary集合，然后统一调用Vaild方法执行逻辑判断，这样的设计改进,客户端就可以随时随地的添加或删除业务逻辑，同样修改也将十分的方便，从面向对象的的角度去看，更体现了封装的魅力。

业务单元支持的枚举类型
public enum SaoDanValidType
 {
        Stock,       //仓库效验
        User,         //操作员效验
        Customer, //客户效验
        Product     //货品效验
}
      这个枚举就是提供刷单时的效验单元,供客户端使用,当然也可以不用枚举而使用字符串，不过那样不好，因为对系统不是很熟悉的时候很容易写错，
而枚举却似乎带有强硬的选择限制，这样客户端就不会调用出错。

客户端发送数据的类型
public class VerifyEntity
{
        //效验类型
        public SaoDanValidType VerifyType { get; private set; }
        public string ErrorText { get; private set; }
 }
      当然如果这里设计成抽象类型会更好，这样客户端可以对不同的逻辑提供不同的数据。


底层设计
    /  针对扫单时各单据验证不一致的情况,提取的一个公共类
    ///  主要通过不同的具体类来封装if语句
    public class SaoDanValid
    {
       //提供逻辑封装的一个Dictionary容器, ValidBase表示所有逻辑的抽象基类型
        rivate Dictionary<string, ValidBase> dictionary = new Dictionary<string, ValidBase>();
       // 装客户端对每个逻辑效验时发送的数据,（私有供内部使用）
        ivate List<VerifyEntity> verifyList = new List<VerifyEntity>();
        // 构造器 重载+3
        public SaoDanValid(string productBrand) : this(productBrand, "") { }
        public SaoDanValid(string productBrand, string branchId) : this("", productBrand, branchId) { }
        public SaoDanValid(string stockId, string productBrand, string branchId)
        {
            //初始化Dictionary容器，这里的key和上面的枚举元素对应,value则表示对应要效验的抽象子类
            dictionary.Add("Stock", new StockValid(stockId, productBrand));
            dictionary.Add("User", new UserValid(productBrand));
            dictionary.Add("Customer", new CustomerValid(branchId, productBrand));
            dictionary.Add("Product", new ProductValid(productBrand));
        }
       /提供客户端添加数据
        public void SetValidObject(VerifyEntity obj)
        {
            verifyList.Add(obj);
        }
        //提供客户端效验方法
        public bool Vaild()
        {
            foreach (VerifyEntity entity in verifyList)
            {
                if (dictionary[entity.VerifyType.ToString()].Valid() == false)
                {
                    MessageBox.Show(entity.ErrorText,"提示");
                    return false;
                }
            }
            return true;  //效验通过返回True
        }
    }

效验部分的设计
    public bastract class ValidBase //抽象类
    {
        public abstract bool Valid(); //抽象方法
    }
    public class StockValid : ValidBase
    {
        private string stockID;
        private string productBrand;
        public StockValid(string stockID, string productBrand)
        {
            this.productBrand = productBrand;
            this.stockID = stockID;
        }
        public override bool Valid()
        {
            if (!SaoDanUtil.IsHaveBrandForStock(stockID, productBrand))
            {
                return false;
            }
            return true;
        }
    }
    public class UserValid : ValidBase
    {
        private string productBrand;
        public UserValid(string productBrand)
        {
            this.productBrand = productBrand;
        }
        public override bool Valid()
        {
            //操作员是否有操作该品牌的权限!";
            if (!SaoDanUtil.IsHaveBrandForUser(productBrand))
            {
                return false;
            }
            return true;
        }
    }
    public class CustomerValid : ValidBase
    {
        private string branchId;
        private string currentBrand;
        public CustomerValid(string branchId, string currentBrand)
        {
            this.branchId = branchId;
            this.currentBrand = currentBrand;
        }
        public override bool Valid()
        {
            //客户是否有当前操作品牌的权限
            if (!SaoDanUtil.IsHaveBrandForCustomer(branchId, currentBrand))
            {
                return false;
            }
            return true;
        }
    }
    public class ProductValid : ValidBase
    {
        private string productBrand;
        public ProductValid(string productBrand)
        {
            this.productBrand = productBrand;
        }
        public override bool Valid()
        {
            //一张单据不能出现多个品牌
            return Globals.CurrentUser.CurrentBrand.ToUpper() == productBrand.ToUpper();
        }
    }
}