充血模型续

前言

大概20天以前水了一篇文章,主要讲了我封装一个小控件的经历,今天QA那边提了一个小bug,我在修改bug的同时重新思考了这个需求,顺便重构了一下代码,算是对上次水文的补充,我也会把全部代码都放出来。

该控件的主要作用就是展示仓库货架物品信息,并提供位置选择功能。

对象建模

选仓库,展示货架,货架按货架编号排序,货架中显示出货品,货品按种子编号和坐标排序,该控件就是一个聚合,三个层次,货架列表控件,包含货架控件,货架控件包含货品控件。 实体:货架列表 货架 货品 值对象:坐标 颜色(我为了简单只用了字符串)货品属性

控件截图

全部代码

 public delegate void ChooseGoodsEventHanler(ChooseShelfEvevtArgs args);

    /// <summary>
    ///     货架物品
    /// </summary>
    public partial class ShelfGoods : UserControl
    {
        private readonly List<GoodsProperty> _goodsProperties = new List<GoodsProperty>();
        private readonly Point3D _point3D;
        private string _goodsNo;

        public ShelfGoods(Point3D point)
        {
            InitializeComponent();
            _point3D = point;
        }
        public IEnumerable<GoodsProperty> GoodsProperties
        {
            get { return _goodsProperties; }
        }
        public Point3D Point3D
        {
            get { return _point3D; }
        }
        public string GoodsNo
        {
            get { return _goodsNo; }
        }
        public ChooseGoodsEventHanler ChoosedGoodsEventHanler = null;

        public void AddProperty(GoodsProperty goodsProperty)
        {
            if (_goodsProperties.Any(s => s.IsEquals(goodsProperty))) return;
            _goodsProperties.Add(goodsProperty);
        }

        public void AddProperties(IEnumerable<GoodsProperty> goodsProperties)
        {
            _goodsProperties.AddRange(goodsProperties);
        }

        public void SetGoodsNo(string goodsNo)
        {
            _goodsNo = goodsNo;
            TextGoodsNo.Text = goodsNo;
        }

        public void SetTip()
        {
            foreach (GoodsProperty property in GoodsProperties)
            {
                string tip = string.Format("{0}:{1}", property.PropertyName, property.PropertyValue);
                var label = new Label {Content = tip};
                ToolPanel.Children.Add(label);
            }
        }

        public void ChangeBgColor(string color)
        {
            var solidColorBrush = new SolidColorBrush {Color = GetColors(color)};
            BoxGrid.Background = solidColorBrush;
        }

        private Color GetColors(string color)
        {
            switch (color)
            {
                case "红色":
                    return Colors.Red;
                case "橙色":
                    return Colors.Orange;
                case "黄色":
                    return Colors.Yellow;
                case "绿色":
                    return Colors.Green;
                case "蓝色":
                    return Colors.Blue;
                case "浅蓝色":
                    return Colors.LightBlue;
                case "黑色":
                    return Colors.Black;
                case "灰色":
                    return Colors.Gray;
                default:
                    return Colors.White;
            }
        }

        public override string ToString()
        {
            if (string.IsNullOrEmpty(GoodsNo))
                return string.Format("x={0},y={1},z={2}", Point3D.PointX, Point3D.PointY, Point3D.PointZ);
            return string.Format("物品编号:{0},x={1},y={2},z={3}", GoodsNo, Point3D.PointX, Point3D.PointY, Point3D.PointZ);
        }

        private void BoxGrid_OnMouseDown(object sender, MouseButtonEventArgs e)
        {
            if (ChoosedGoodsEventHanler != null)
            {
                ChoosedGoodsEventHanler(new ChooseShelfEvevtArgs {GoodsNo = GoodsNo, GoodsPoint3D = Point3D});
            }
        }
    }

    public class ChooseShelfEvevtArgs : EventArgs
    {
        public Point3D GoodsPoint3D { get; set; }
        public string GoodsNo { get; set; }
        public bool IsOnlySaveWarehouse { get; set; }
        public decimal WarehouseId { get; set; }
        public string WareHouseName { get; set; }

    }

    /// <summary>
    ///     货架物品坐标
    /// </summary>
    public class Point3D
    {
        public Point3D(int x, int y, int z)
        {
            PointX = x;
            PointY = y;
            PointZ = z;
        }

        public int PointX { get; private set; }
        public int PointY { get; private set; }
        public int PointZ { get; private set; }

        public bool IsEquals(Point3D point)
        {
            if (point == null)
                return false;
            return PointX == point.PointX &&
                   PointY == point.PointY && PointZ == point.PointZ;
        }
    }

货品控件

 /// <summary>
    ///     货架
    /// </summary>
    public partial class ShelfLine : UserControl
    {
        private readonly int _colCount;
        private readonly int _layIndex;
        private readonly int _rowIndex;
        private readonly WarehouseBLL _warehouseBll = new WarehouseBLL();
        private List<ShelfGoods> _goodses = new List<ShelfGoods>();
        public ChooseGoodsEventHanler ChoosedGoodsEventHanler = null;

        public int ColCount
        {
            get { return _colCount; }
        }
        public int LayIndex
        {
            get { return _layIndex; }
        }
        public int RowIndex
        {
            get { return _rowIndex; }
        }

        public ShelfLine(int rowIndex, int colCount, int layIndex = 0)
        {
            InitializeComponent();
            _rowIndex = rowIndex;
            _colCount = colCount;
            _layIndex = layIndex;
            for (int i = 0; i < colCount; i++)
            {
                _goodses.Add(new ShelfGoods(new Point3D(rowIndex, i + 1, layIndex)));
            }
        }

        public void Sort()
        {
            _goodses = _goodses.OrderBy(s => s.GoodsNo).ToList();
        }

        public void Draw()
        {
            foreach (ShelfGoods goods in _goodses)
            {
                if (ChoosedGoodsEventHanler != null)
                {
                    goods.ChoosedGoodsEventHanler += ChoosedGoodsEventHanler;
                }
                LinePanel.Children.Add(goods);
            }
        }

        public ShelfGoods Find(Point3D point)
        {
            return _goodses.FirstOrDefault(s => s.Point3D.IsEquals(point));
        }

        public void Put(List<ShelfGoods> shelfGoodses)
        {
            foreach (ShelfGoods goods in shelfGoodses)
            {
                ShelfGoods query = Find(goods.Point3D);
                if (query == null) continue;
                query.SetGoodsNo(goods.GoodsNo);
                query.AddProperties(goods.GoodsProperties);
                query.SetTip();
                string color = _warehouseBll.GetColor(goods.GoodsNo);
                if (!string.IsNullOrEmpty(color))
                {
                    query.ChangeBgColor(color);
                }
                break;
            }
        }
    }

货架

 /// <summary>
    ///     Interaction logic for ShelfLayer.xaml
    /// </summary>
    public partial class ShelfLayer : UserControl
    {
        private int _colCount;
        private int _layIndex;
        private int _rowCount;
        private List<ShelfLine> _shelfLines ;
        public ChooseGoodsEventHanler ChoosedGoodsEventHanler = null;

        public ShelfLayer()
        {
            InitializeComponent();
        }

        public int ColCount
        {
            get { return _colCount; }
        }

        public int LayIndex
        {
            get { return _layIndex; }
        }

        public int RowCount
        {
            get { return _rowCount; }
        }

        public void Init(int rowCount, int colCount, int layIndex = 0)
        {
            _rowCount = rowCount;
            _colCount = colCount;
            _layIndex = layIndex;
            _shelfLines = new List<ShelfLine>();

            for (int i = 0; i < rowCount; i++)
            {
                var line = new ShelfLine(i+1, colCount, layIndex);
                if (ChoosedGoodsEventHanler != null)
                {
                    line.ChoosedGoodsEventHanler += ChoosedGoodsEventHanler;
                }
                _shelfLines.Add(line);
            }
        }

        public void Sort()
        {
            _shelfLines = _shelfLines.OrderBy(s => s.RowIndex).ToList();
        }

        public void Draw()
        {
            Clear();
            foreach (ShelfLine  line in _shelfLines)
            {
                line.Draw();
                LayerPanel.Children.Add(line);
            }
        }

        public void Clear()
        {
            LayerPanel.Children.Clear();
        }

        public ShelfGoods Find(Point3D point)
        {
            return _shelfLines.Select(line => line.Find(point)).FirstOrDefault(query => query != null);
        }

        public void Put(List<ShelfGoods> shelfGoodses)
        {
            foreach (ShelfLine line in _shelfLines)
            {
                List<ShelfGoods> query = shelfGoodses.Where(s => s.Point3D.PointX == line.RowIndex).ToList();
                line.Put(query);
            }
        }
    }

货架列表

  this.WareHouseControl.HiddenConfig(true);
            WareHouseControl.ChoosedGoodsEventHanler  += args =>
            {
                if (args == null)
                    return;
                if (args.IsOnlySaveWarehouse)
                {
                    if (MessageBoxEx.Show("您确定选择选择仓库:" + args.WareHouseName + "?", "提示", MessageBoxExButtons.YesNo, MessageBoxExIcon.Question) == true)
                    {
                        _chooseWarehouseId = args.WarehouseId;
                        _chooseWarehouseName = args.WareHouseName;
                        DialogResult = true;
                    }
                    return;
                }
                if (!string.IsNullOrEmpty(args.GoodsNo))
                {
                    string msg = string.Format("该位置({0},{1},{2})已经存储货物!", args.GoodsPoint3D.PointX, args.GoodsPoint3D.PointY,
                        args.GoodsPoint3D.PointZ);
                    MessageBoxEx.Show(msg, "提示", MessageBoxExButtons.OK, MessageBoxExIcon.Information);
                    return;
                }
                _choosedPoint = args.GoodsPoint3D;
                _shelfNo = WareHouseControl.ShelfNo;
                _chooseWarehouseId = WareHouseControl.WarehouseId;
                _chooseWarehouseName = WareHouseControl.WarehouseName;

                if (_chooseWarehouseId < 0 || string.IsNullOrEmpty(_shelfNo))
                    return;
                string message = string.Format("您确定选择选择货架编号:{0},位置:({1},{2},{3})?", _shelfNo, args.GoodsPoint3D.PointX,
                    args.GoodsPoint3D.PointY, args.GoodsPoint3D.PointZ);
                if (MessageBoxEx.Show(message, "提示", MessageBoxExButtons.YesNo, MessageBoxExIcon.Question) == true)
                {
                    DialogResult = true;
                }
            };

控件调用

作者:Dynamic-xia

博客地址:http://www.cnblogs.com/dynamic-xia

声明:本博客以学习、研究和分享为主,欢迎转载,但必须在文章页面明显位置给出原文连接。

时间: 2024-11-05 19:35:21

充血模型续的相关文章

贫血模型和充血模型

贫血模型:领域对象里只有get和set方法,或者包含少量的CRUD方法,而不包含有业务逻辑的处理,把"行为"和"状态"分离到不同的对象里,只有状态的对象被称为"贫血对象"(VO),而只有"行为"的对象一般被用作服务对象,就像spring的server一样,都是无状态对象,本身并不存储数据,只处理逻辑. 充血模型:业务逻辑和持久化都放在对象中,Business Logic(业务逻辑层)只负责简单封装部分业务逻辑以及控制事务.权限

失血模型,充血模型

一.失血模型 失血模型简单来说,就是domain object只有属性的getter/setter方法的纯数据类. 简单来说,就是domain ojbect包含了不依赖于持久化的领域逻辑,而那些依赖持久化的领域逻辑被分离到Service层. Service(业务逻辑,事务封装) --> DAO ---> domain object 这种模型的优点: 1.各层单向依赖,结构清楚,易于实现和维护 2.设计简单易行,底层模型非常稳定 这种模型的缺点: 1.domain object的部分比较紧密依赖

5Python全栈之路系列之Django模型续

Python全栈之路系列之Django模型续 连表操作一对一 在app的models.py文件内添加以下内容用户创建一对多关系的表: from django.db import models # Create your models here. class UserType(models.Model):     nid = models.AutoField(primary_key=True)     caption = models.CharField(max_length=32)      c

领域模型(domain model)&amp;贫血模型(anaemic domain model)&amp;充血模型(rich domain model)

领域模型是领域内的概念类或现实世界中对象的可视化表示,又称为概念模型或分析对象模型,它专注于分析问题领域本身,发掘重要的业务领域概念,并建立业务领域概念之间的关系. 贫血模型是指使用的领域对象中只有setter和getter方法(POJO),所有的业务逻辑都不包含在领域对象中而是放在业务逻辑层.有人将我们这里说的贫血模型进一步划分成失血模型(领域对象完全没有业务逻辑)和贫血模型(领域对象有少量的业务逻辑),就不对此加以区分了. 充血模型将大多数业务逻辑和持久化放在领域对象中,业务逻辑(业务门面)

贫血,充血模型的解释以及一些经验

为了补大家的遗憾,在此总结下ROBBIN的领域模型的一些观点和大家的补充,在网站和演讲中,robbin将领域模型初步分为4大类: 1,失血模型 2,贫血模型 3,充血模型 4,胀血模型 那么让我们看看究竟有这些领域模型的具体内容,以及他们的优缺点: 一.失血模型 失血模型简单来说,就是domain object只有属性的getter/setter方法的纯数据类,所有的业务逻辑完全由business object来完成(又称Transaction Script),这种模型下的domain obje

什么是领域模型(domain model)?贫血模型(anaemic domain model) 和充血模型(rich domain model)有什么区别

http://blog.csdn.net/helloboat/article/details/51208128 领域模型是领域内的概念类或现实世界中对象的可视化表示,又称为概念模型或分析对象模型,它专注于分析问题领域本身,发掘重要的业务领域概念,并建立业务领域概念之间的关系.贫血模型是指使用的领域对象中只有setter和getter方法(POJO),所有的业务逻辑都不包含在领域对象中而是放在业务逻辑层.有人将我们这里说的贫血模型进一步划分成失血模型(领域对象完全没有业务逻辑)和贫血模型(领域对象

贫血模型跟充血模型-摘录

贫血模型:是指领域对象里只有get和set方法,或者包含少量的CRUD方法,所有的业务逻辑都不包含在内而是放在Business Logic层. 优点是系统的层次结构清楚,各层之间单向依赖,Client->(Business Facade)->Business Logic->Data Access(ADO.NET).当然Business Logic是依赖Domain Object的.似乎现在流行的架构就是这样,当然层次还可以细分. 该模型的缺点是不够面向对象,领域对象只是作为保存状态或者传

领域模型、贫血模型、充血模型概念总结

领域模型 领域模型是对领域内的概念类或现实世界中对象的可视化表示.又称概念模型.领域对象模型.分析对象模型.它专注于分析问题领域本身,发掘重要的业务领域概念,并建立业务领域概念之间的关系. 业务对象模型(也叫领域模型 domain model)是描述业务用例实现的对象模型.它是对业务角色和业务实体之间应该如何联系和协作以执行业务的一种抽象.业务对象模型从业务角色内部的观点定义了业务用例.该模型为产生预期效果确定了业务人员以及他们处理和使用的对象(“业务类和对象”)之间应该具有的静态和动态关系.它

从经典架构项目中透析微服务架构的核心概念和充血模型

微服务架构和SOA区别 微服务现在辣么火,业界流行的对比的却都是所谓的Monolithic单体应用,而大量的系统在十几年前都是已经是分布式系统了,那么微服务作为新的理念和原来的分布式系统,或者说SOA(面向服务架构)是什么区别呢? 我们先看相同点: 需要Registry,实现动态的服务注册发现机制:需要考虑分布式下面的事务一致性,CAP原则下,两段式提交不能保证性能,事务补偿机制需要考虑:同步调用还是异步消息传递,如何保证消息可靠性?SOA由ESB来集成所有的消息:都需要统一的Gateway来汇