一、领域逻辑

1、领域模型

单个实体内部的领域逻辑，不进行持久化，持久化交给上层处理，如领域服务，应用服务。

public class Product : AuditedAggregateRoot<Guid>
    {
        [NotNull]
        public string Code { get; private set; }

        [NotNull]
        public string Name { get; private set; }

        public float Price { get; private set; }

        public int StockCount { get; private set; }

        public string ImageName { get; private set; }

        private Product()
        {
            //Default constructor is needed for ORMs.
        }

        internal Product(
            Guid id,
            [NotNull] string code, 
            [NotNull] string name, 
            float price = 0.0f, 
            int stockCount = 0,
            string imageName = null)
        {
            Check.NotNullOrWhiteSpace(code, nameof(code));

            if (code.Length >= ProductConsts.MaxCodeLength)
            {
                throw new ArgumentException($"Product code can not be longer than {ProductConsts.MaxCodeLength}");
            }

            Id = id;
            Code = code;
            SetName(Check.NotNullOrWhiteSpace(name, nameof(name)));
            SetPrice(price);
            SetImageName(imageName);
            SetStockCountInternal(stockCount, triggerEvent: false);
        }

        public Product SetName([NotNull] string name)
        {
            Check.NotNullOrWhiteSpace(name, nameof(name));

            if (name.Length >= ProductConsts.MaxNameLength)
            {
                throw new ArgumentException($"Product name can not be longer than {ProductConsts.MaxNameLength}");
            }

            Name = name;
            return this;
        }
          ...
      }

2、领域服务

涉及一个或多个完整实体的领域逻辑。实现 DomainService

public class ProductManager : DomainService
{
    private readonly IRepository<Product, Guid> _productRepository;

    public ProductManager(IRepository<Product, Guid> productRepository)
    {
        _productRepository = productRepository;
    }

    public async Task<Product> CreateAsync(
        [NotNull] string code,
        [NotNull] string name,
        float price = 0.0f,
        int stockCount = 0)
    {
        var existingProduct = 
            await _productRepository.FirstOrDefaultAsync(p => p.Code == code);
            
        if (existingProduct != null)
        {
            throw new ProductCodeAlreadyExistsException(code);
        }

        return await _productRepository.InsertAsync(
            new Product(
                GuidGenerator.Create(),
                code,
                name,
                price,
                stockCount
            )
        );
    }
}

3、领域事件

通过事件的发布订阅来处理领域逻辑，对复杂的流程业务进行解耦，实现事务的最终一致性。领域事件可以分为本地事件和分布式事件。

public class Product : AuditedAggregateRoot<Guid>
    {
        ...

        public Product SetStockCount(int stockCount)
        {
            return SetStockCountInternal(stockCount);
        }

        private Product SetStockCountInternal(int stockCount, bool triggerEvent = true)
        {
            if (StockCount < 0)
            {
                throw new ArgumentException($"{nameof(stockCount)} can not be less than 0!");
            }

            if (StockCount == stockCount)
            {
                return this;
            }

            if (triggerEvent)
            {
                AddDistributedEvent(
                    new ProductStockCountChangedEto(
                        Id,
                        StockCount,
                        stockCount
                    )
                );
            }

            StockCount = stockCount;
            return this;
        }
     }

二、非领域逻辑

仓储

仓储用于保存和获取聚合对象。仓储分为两种，一种是基于集合的，一种是基于持久化的。Abp 的 IRespository 实现了常用的CRUD方法。
如果不够用（极少情况），可以自定义仓储实现IRespository。所有不含业务逻辑的CRUD都写在这里。代码实现写在基础架构层，接口定义在Domian层。

应用服务

负责调用领域逻辑增改和处理非领域逻辑的查删，并持久化。实现 ApplicationService。

[Authorize(ProductManagementPermissions.Products.Default)]
public class ProductAppService : ApplicationService, IProductAppService
{
	private readonly ProductManager _productManager;
	private readonly IRepository<Product, Guid> _productRepository;

	public ProductAppService(ProductManager productManager, IRepository<Product, Guid> productRepository)
	{
		_productManager = productManager;
		_productRepository = productRepository;
	}

	public async Task<PagedResultDto<ProductDto>> GetListPagedAsync(PagedAndSortedResultRequestDto input)
	{
		await NormalizeMaxResultCountAsync(input);

		var products = await _productRepository
			.OrderBy(input.Sorting ?? "Name")
			.Skip(input.SkipCount)
			.Take(input.MaxResultCount)
			.ToListAsync();

		var totalCount = await _productRepository.GetCountAsync();

		var dtos = ObjectMapper.Map<List<Product>, List<ProductDto>>(products);

		return new PagedResultDto<ProductDto>(totalCount, dtos);
	}

	public async Task<ListResultDto<ProductDto>> GetListAsync() //TODO: Why there are two GetList. GetListPagedAsync would be enough (rename it to GetList)!
	{
		var products = await _productRepository.GetListAsync();

		var productList =  ObjectMapper.Map<List<Product>, List<ProductDto>>(products);

		return new ListResultDto<ProductDto>(productList);
	}

	public async Task<ProductDto> GetAsync(Guid id)
	{
		var product = await _productRepository.GetAsync(id);

		return ObjectMapper.Map<Product, ProductDto>(product);
	}

	[Authorize(ProductManagementPermissions.Products.Create)]
	public async Task<ProductDto> CreateAsync(CreateProductDto input)
	{
		var product = await _productManager.CreateAsync(
			input.Code,
			input.Name,
			input.Price,
			input.StockCount,
			input.ImageName
		);

		return ObjectMapper.Map<Product, ProductDto>(product);
	}

	[Authorize(ProductManagementPermissions.Products.Update)]
	public async Task<ProductDto> UpdateAsync(Guid id, UpdateProductDto input)
	{
		var product = await _productRepository.GetAsync(id);

		product.SetName(input.Name);
		product.SetPrice(input.Price);
		product.SetStockCount(input.StockCount);
		product.SetImageName(input.ImageName);

		return ObjectMapper.Map<Product, ProductDto>(product);
	}

	[Authorize(ProductManagementPermissions.Products.Delete)]
	public async Task DeleteAsync(Guid id)
	{
		await _productRepository.DeleteAsync(id);
	}

	private async Task NormalizeMaxResultCountAsync(PagedAndSortedResultRequestDto input)
	{
		var maxPageSize = (await SettingProvider.GetOrNullAsync(ProductManagementSettings.MaxPageSize))?.To<int>();
		if (maxPageSize.HasValue && input.MaxResultCount > maxPageSize.Value)
		{
			input.MaxResultCount = maxPageSize.Value;
		}
	}
}