前言

简单介绍一下实体模型的设计。

正文

前文提及了我们的应用分为:

  1. 共享层

  2. 基础设施层

  3. 领域层

  4. 应用层

今天来介绍领域模型层。

前文提及到领域模型在共享层有一个领域模型抽象类库。

里面有这些类:

先分别介绍一下这些类是做什么的。

IEntity 类,是我们实体的接口:

/// <summary>
/// 实体接口(包含多个主键的实体接口)
/// </summary>
public interface IEntity
{
object[] GetKeys();
} /// <summary>
/// 实体接口(包含唯一主键Id的实体接口)
/// </summary>
/// <typeparam name="TKey">主键ID类型</typeparam>
public interface IEntity<TKey> : IEntity
{
TKey Id { get; }
}

实现抽象类Entity:

/// <summary>
/// 实体抽象类(包含多个主键的实体接口)
/// </summary>
public abstract class Entity : IEntity
{
public abstract object[] GetKeys(); public override string ToString()
{
return $"[Entity:{GetType().Name}] Keys = {string.Join(",", GetKeys())}";
} #region 领域事件定义处理 DomainEvents /// <summary>
/// 领域事件集合
/// </summary>
private List<IDomainEvent> _domainEvents; /// <summary>
/// 获取当前实体对象领域事件集合(只读)
/// </summary>
public IReadOnlyCollection<IDomainEvent> DomainEvents => _domainEvents?.AsReadOnly(); /// <summary>
/// 添加领域事件至当前实体对象领域事件结合中
/// </summary>
/// <param name="eventItem"></param>
public void AddDomainEvent(IDomainEvent eventItem)
{
_domainEvents = _domainEvents ?? new List<IDomainEvent>();
_domainEvents.Add(eventItem);
} /// <summary>
/// 移除指定领域事件
/// </summary>
/// <param name="eventItem"></param>
public void RemoveDomainEvent(IDomainEvent eventItem)
{
_domainEvents?.Remove(eventItem);
} /// <summary>
/// 清空所有领域事件
/// </summary>
public void ClearDomainEvents()
{
_domainEvents?.Clear();
} #endregion
} /// <summary>
/// 实体抽象类(包含唯一主键Id的实体接口)
/// </summary>
/// <typeparam name="TKey">主键ID类型</typeparam>
public abstract class Entity<TKey> : Entity, IEntity<TKey>
{
int? _requestedHasCode;
public virtual TKey Id { get; protected set; }
public override object[] GetKeys()
{
return new object[] { Id };
} /// <summary>
/// 对象是否想等
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public override bool Equals(object obj)
{
if (obj == null || !(obj is Entity<TKey>))
{
return false;
} if (Object.ReferenceEquals(this, obj))
{
return true;
} Entity<TKey> item = (Entity<TKey>)obj; if (item.IsTransient() || this.IsTransient())
{
return false;
}
else
{
return item.Id.Equals(this.Id);
}
} public override int GetHashCode()
{
if (!IsTransient())
{
if (!_requestedHasCode.HasValue)
{
_requestedHasCode = this.Id.GetHashCode() ^ 31; // TODO
}
return _requestedHasCode.Value;
}
else
{
return base.GetHashCode();
}
} /// <summary>
/// 对象是否为全新创建的,未持久化的
/// </summary>
/// <returns></returns>
public bool IsTransient()
{
return EqualityComparer<TKey>.Default.Equals(Id, default);
}
public override string ToString()
{
return $"[Entity:{GetType().Name}] Id = {Id}";
} /// <summary>
/// == 操作符重载
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns></returns>
public static bool operator ==(Entity<TKey> left,Entity<TKey> right)
{
if (Object.Equals(left,null))
{
return (Object.Equals(right, null)) ? true : false;
}
else
{
return left.Equals(right);
}
} /// <summary>
/// != 操作符重载
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns></returns>
public static bool operator !=(Entity<TKey> left, Entity<TKey> right)
{
return !(left == right);
}
}

聚合根接口IAggregateRoot.cs:

/// <summary>
/// 聚合根接口
/// 作用是我们在实现仓储层的时候,让我们的一个仓储对应一个聚合根
/// </summary>
public interface IAggregateRoot
{
}

领域事件IDomainEvent :

/// <summary>
/// 领域事件接口
/// 用来标记我们某一个对象是否是领域事件
/// </summary>
public interface IDomainEvent : INotification
{
}

领域事件的处理接口IDomainEventHandler:

/// <summary>
/// 领域事件处理器接口
/// </summary>
public interface IDomainEventHandler<TDomainEvent> : INotificationHandler<TDomainEvent> where TDomainEvent : IDomainEvent
{
//这里我们使用了INotificationHandler的Handle方法来作为处理方法的定义,所以无需重新定义
//Task Handle(TDomainEvent domainEvent, CancellationToken cancellationToken);
}

值对象 ValueObject:

/// <summary>
/// 值对象
/// TODO 领域驱动中比较关键的类
/// </summary>
public abstract class ValueObject
{
protected static bool EqualOperator(ValueObject left, ValueObject right)
{
if (ReferenceEquals(left, null) ^ ReferenceEquals(right, null))
{
return false;
}
return ReferenceEquals(left, null) || left.Equals(right);
} protected static bool NotEqualQperator(ValueObject left, ValueObject right)
{
return !(EqualOperator(left, right));
} /// <summary>
/// 获取值对象原子值(字段值)
/// 将我们值对象的字段输出出来,作为唯一标识来判断我们两个对象是否想等
/// </summary>
/// <returns></returns>
protected abstract IEnumerable<object> GetAtomicValues(); public override bool Equals(object obj)
{
if (obj == null || obj.GetType() != GetType())
{
return false;
}
ValueObject other = (ValueObject)obj;
IEnumerator<object> thisValues = GetAtomicValues().GetEnumerator();
IEnumerator<object> otherValues = other.GetAtomicValues().GetEnumerator();
while (thisValues.MoveNext() && otherValues.MoveNext())
{
if (ReferenceEquals(thisValues.Current, null) ^ ReferenceEquals(otherValues.Current, null))
{
return false;
}
if (thisValues.Current != null && !thisValues.Current.Equals(otherValues.Current))
{
return false;
}
}
return !thisValues.MoveNext() && !otherValues.MoveNext();
} public override int GetHashCode()
{
return GetAtomicValues()
.Select(x => x != null ? x.GetHashCode() : 0)
.Aggregate((x, y) => x ^ y);
}
}

那么来看一下领域模型的具体实现:

先来看一下Aggregate 的具体实现:

/// <summary>
/// 订单实体
/// </summary>
public class Order : Entity<long>, IAggregateRoot
{
// 实体内字段的 set 方法都是 private 的
// 实体类型相关的数据操作,都应该是由我们实体来负责,而不是被外部的对象去操作
// 这样的好处是让我们的领域模型符合封闭开放的原则 public string UserId { get; private set; }
public string UserName { get; private set; }
public Address Address { get; private set; }
public int ItemCount { get; set; } protected Order()
{
} public Order(string userId, string userName, int itemCount, Address address)
{
this.UserId = userId;
this.UserName = userName;
this.ItemCount = itemCount;
this.Address = address; // 构造新的Order对象的时候,添加一个创建Order领域事件
this.AddDomainEvent(new OrderCreatedDomainEvent(this));
} /// <summary>
/// 修改收货地址
/// </summary>
/// <param name="address"></param>
public void ChangeAddress(Address address)
{
this.Address = address; // 同样的,在修改地址操作时,也该定义一个类似的修改地址领域事件
//this.AddDomainEvent(new OrderAddressChangedDomainEvent(this));
}
}

这里面实现了Entity,同时实现了IAggregateRoot,这个接口里面没有任何东西,表示这是定义接口,表示将这个Order 定义为一个聚合根。

看一下Address:

/// <summary>
/// 地址实体
/// 定义为值对象
/// </summary>
public class Address : ValueObject
{
public string Street { get; private set; }
public string City { get; private set; }
public string ZipCode { get; private set; }
public Address()
{ }
public Address(string street, string city, string zipCode)
{
this.Street = street;
this.City = city;
this.ZipCode = zipCode;
} /// <summary>
/// 重载获取原子值的方法
/// 这里特殊的是,我们使用了 yield return 的方式
/// </summary>
/// <returns></returns>
protected override IEnumerable<object> GetAtomicValues()
{
yield return Street;
yield return City;
yield return ZipCode;
}
}

将这个Address 定义为值对象。

梳理

这里如果不了解领域设计,会有点蒙。

那么这里只需要知道这里Order 定义为了aggregateRoot,也就是聚合根。

把Address 定义为了值对象即可。随着后面系列的他们之间的调用会越来越清晰的。

总结

  1. 将领域模型字段的修改设置为私有的。

  2. 使用构造函数表示对象的创建

  3. 使用具有业务的动作来操作模型字段

  4. 领域模型复制堆自己数据的处理

  5. 领域模型负责对自己数据的处理

  6. 领域服务或命令处理者扶着调用领域模型业务动作

下一节 领域模型之工作单元模式

重新整理 .net core 实践篇—————Entity的定义[二十五]的更多相关文章

  1. 重新整理 .net core 实践篇—————日志系统之战地记者[十五]

    前言 本节开始整理日志相关的东西.先整理一下日志的基本原理. 正文 首先介绍一下包: Microsoft.Extengsion.Logging.Abstrations 这个是接口包. Microsof ...

  2. 重新整理 .net core 实践篇—————工作单元模式[二十六]

    前言 简单整理一下工作单元模式. 正文 工作单元模式有3个特性,也算是其功能: 使用同一上下文 跟踪实体的状态 保障事务一致性 工作单元模式 主要关注事务,所以重点在事务上. 在共享层的基础建设类库中 ...

  3. 重新整理 .net core 实践篇————依赖注入应用[二]

    前言 这里介绍一下.net core的依赖注入框架,其中其代码原理在我的另一个整理<<重新整理 1400篇>>中已经写了,故而专门整理应用这一块. 以下只是个人整理,如有问题, ...

  4. 重新整理 .net core 实践篇—————服务与配置之间[十一二]

    前言 前面基本介绍了,官方对于asp .net core 设计配置和设计服务的框架的一些思路.看下服务和配置之间是如何联系的吧. 正文 服务: public interface ISelfServic ...

  5. 重新整理 .net core 实践篇————polly失败重试[三十四]

    前言 简单整理一下polly 重试. 正文 在开发程序中一般都有一个重试帮助类,那么polly同样有这个功能. polly 组件包: polly 功能包 polly.Extensions.Http 专 ...

  6. 重新整理 .net core 实践篇—————3种配置验证[十四]

    前言 简单整理一些配置的验证. 正文 配置的验证大概分为3类: 直接注册验证函数 实现IValidteOptions 使用Microsoft.Extensions.Options.DataAnnota ...

  7. 重新整理 .net core 实践篇—————路由和终结点[二十三]

    前言 简单整理一下路由和终节点. 正文 路由方式主要有两种: 1.路由模板方式 2.RouteAttribute 方式 路由约束: 1.类型约束 2.范围约束 3.正则表达式 4.是否必选 5.自定义 ...

  8. 重新整理 .net core 实践篇————配置应用[一]

    前言 本来想整理到<<重新整理.net core 计1400篇>>里面去,但是后来一想,整理 .net core 实践篇 是偏于实践,故而分开. 因为是重新整理,那么就从配置开 ...

  9. .NET Core实战项目之CMS 第十五章 各层联动工作实现增删改查业务

    连着两天更新叙述性的文章大家可别以为我转行了!哈哈!今天就继续讲讲我们的.NET Core实战项目之CMS系统的教程吧!这个系列教程拖得太久了,所以今天我就以菜单部分的增删改查为例来讲述下我的项目分层 ...

  10. abp(net core)+easyui+efcore实现仓储管理系统——EasyUI之货物管理七(二十五)

    abp(net core)+easyui+efcore实现仓储管理系统目录 abp(net core)+easyui+efcore实现仓储管理系统——ABP总体介绍(一) abp(net core)+ ...

随机推荐

  1. python 字典列表,元组列表 列表嵌套字典 列表嵌套元组 字典嵌套列表

    列表嵌套字典 l=[] for i in alist: kk = {} names.append(i.string) a_url.append(i.get('href')) kk['章节名']=i.s ...

  2. Server-side template injection 模板注入问题总结

    概念: 服务器模板注入(Server-side template injection) 攻击者能够使用本地的模板语法去注入一个恶意的payload,然后在服务器端执行该攻击,当与欧股直接输入数据到模板 ...

  3. Fiddler修改响应体

    方法1 将请求从左侧列表中,拖入AutoResponder中. 然后右键规则,点击编辑 修改后点击save 方法2 在AutoResponder中选择Create New Response也可类似方式 ...

  4. C#泛型的类型参数约束

    常用约束 约束告知编译器类型参数必须具备的功能. 在没有任何约束的情况下,类型参数可以是任何类型. 编译器只能假定 System.Object 的成员,它是任何 .NET 类型的最终基类. 如果客户端 ...

  5. esp8266 I2C 实例解析及源码分析

    一  前言 作为一个方案商兼芯片开发者,研究芯片和功能实现除了基本的工作需要,还有一层就是也变成了一种职业习惯.从芯片到方案,发现很多方案公司的人水平都比较堪忧,只会调用api,根本不会看底层的代码实 ...

  6. dbvisualizer之编辑区中文乱码问题

    !在SQL Commander中,sql语句中如果有中文,显示是'口口口'. 解决办法如下: 在Tools->tool Properties->General->Appearance ...

  7. AOSP编译成功后关闭终端emulator命令找不到

    当我们编译好AOSP系统源码后,可以通过emulator命令打开模拟器,但是当我们关闭终端后,在次打开终端输入emulator命令,提示未找到命令: 此时我们需要重新执行下面语句 source bui ...

  8. 移植openssh-7.5p1(包括openssl-1.0.2l、zlib-1.2.11)到HISI3520d(编译篇)

    PS:要转载请注明出处,本人版权所有. PS: 这个只是基于<我自己>的理解, 如果和你的原则及想法相冲突,请谅解,勿喷. 前置说明   本文作为本人csdn blog的主站的备份.(Bl ...

  9. [503. 下一个更大元素 II] 单调栈

    import java.util.ArrayDeque; import java.util.Deque; class Solution { public static void main(String ...

  10. 什么是3D可视化,为什么要使用3D可视化

    虽然许多设计师听说过为什么设计的可视化在他们的审批过程中是有益的,但并不是每个人都知道3D可视化到底是什么. 3D可视化与3D图形.3D渲染.计算机生成图像和其他术语同义使用.3D可视化是指使用计算机 ...