C# DDD、CQRS和Mediatr查询过滤

我正在从事一个遵循CQRS和Mediatr模式的项目

我有一个这样的实体

    public class Order
{
    public Guid OrderId { get; set; }

    public Guid CreatedByUserId { get; set; }

    public Guid? AcceptedByUserId { get; set; }

    public string Registration { get; set; }

    public string Description { get; set; }

    public User CreatedByUser { get; set; }
    public User AcceptedByUser { get; set; }
}

当我编写两个查询getAllorderCreatedByUser和getAllorderAcceptedByUser时，所有代码实际上都是相同的

唯一的例外是创建的查询my where在CreatedByUserId上，而我的已接受查询where在AcceptedByUserId上

GetAllordersAcceptedByser:-

        public async Task<OrderAcceptedByUserListViewModel> Handle(GetAllOrdersAcceptedByUserQuery request, CancellationToken cancellationToken)
    {
        var model = new OrderAcceptedByUserListViewModel
        {
            Orders = await _context.Order
            .Where(x => x.AcceptedByUserId == request.UserId)
            .Select(OrderDto.Projection)
            .OrderBy(o => o.Registration)
            .ToListAsync(cancellationToken)
        };

        return model;
    }

        public async Task<OrderCreatedByUserListViewModel> Handle(GetAllOrdersCreatedByUserQuery request, CancellationToken cancellationToken)
    {
        var model = new OrderCreatedByUserListViewModel
        {
            Orders = await _context.Order
            .Where(x => x.CreatedByUserId == request.UserId)
            .Select(OrderDto.Projection)
            .OrderBy(o => o.Registration)
            .ToListAsync(cancellationToken)
        };

        return model;
    }

公共异步任务句柄（GetAllOrdersAcceptedByUserQuery请求，CancellationToken CancellationToken）
{
var model=new OrderAcceptedByUserListViewModel
{
订单=等待_context.Order
.Where（x=>x.AcceptedByUserId==request.UserId）
.Select（OrderDto.Projection）
.OrderBy（o=>o.Registration）
.ToListSync（取消令牌）
};
收益模型；
}

GetAllOrdersCreatedByUser:-

        public async Task<OrderAcceptedByUserListViewModel> Handle(GetAllOrdersAcceptedByUserQuery request, CancellationToken cancellationToken)
    {
        var model = new OrderAcceptedByUserListViewModel
        {
            Orders = await _context.Order
            .Where(x => x.AcceptedByUserId == request.UserId)
            .Select(OrderDto.Projection)
            .OrderBy(o => o.Registration)
            .ToListAsync(cancellationToken)
        };

        return model;
    }

        public async Task<OrderCreatedByUserListViewModel> Handle(GetAllOrdersCreatedByUserQuery request, CancellationToken cancellationToken)
    {
        var model = new OrderCreatedByUserListViewModel
        {
            Orders = await _context.Order
            .Where(x => x.CreatedByUserId == request.UserId)
            .Select(OrderDto.Projection)
            .OrderBy(o => o.Registration)
            .ToListAsync(cancellationToken)
        };

        return model;
    }

公共异步任务句柄（GetAllorderCreatedByUserQuery请求，CancellationToken CancellationToken）
{
var model=new OrderCreatedByUserListViewModel
{
订单=等待_context.Order
.Where（x=>x.CreatedByUserId==request.UserId）
.Select（OrderDto.Projection）
.OrderBy（o=>o.Registration）
.ToListSync（取消令牌）
};
收益模型；
}

这是正确的实现还是客观上最好有一个查询，根据控制器调用它的方式，它可以同时执行这两个任务

---

编辑：添加更好的标记

查询可以保持独立（因此它们紧随其后），并且可以通过其他方式避免代码重复。可以尝试提取查询的重复部分，以获取订单，而不必先使用

虚拟
方法中的
where
进行过滤，然后在相应的查询中进行过滤。
查询可以保持独立（因此它们紧随其后），并且可以通过其他方式避免代码重复。可以尝试提取查询的重复部分，以获取订单，而不首先使用
虚拟
方法中的
where
进行过滤，然后在相应的查询中进行过滤。
首先，合并类
GetAllOrdersCreatedByUserQuery
和
GetAllOrdersAcceptedByUserQuery

参考请参见以下类别：

public class GetAllOrdersByUserQuery :  : IRequest<OrdeListViewModel>
{
    // if OrderAcceptedByUser is true else OrderCreatedByUser = false
    public bool AcceptedOrCreatedBit { get; set; } 
    public string UserId { get; set; }
}

最后，您的MediatR句柄方法应该如下所示：

public async Task<OrdeListViewModel> Handle(GetAllOrdersByUserQuery request, CancellationToken cancellationToken)
{
    OrdeListViewModel model = new OrdeListViewModel();
    if (request.AcceptedOrCreatedBit) // true for OrderAcceptedByUser
    {

            model.Orders = await _context.Order
            .Where(x => x.AcceptedByUserId == request.UserId)
            .Select(OrderDto.Projection)
            .OrderBy(o => o.Registration)
            .ToListAsync(cancellationToken)

    }
    else // false for OrderCreatedByUser
    {

            model.Orders = await _context.Order
            .Where(x => x.CreatedByUserId == request.UserId)
            .Select(OrderDto.Projection)
            .OrderBy(o => o.Registration)
            .ToListAsync(cancellationToken)

    }

    return model;
}

公共异步任务句柄（GetAllorderByUserQuery请求，CancellationToken CancellationToken）
{
OrdeListViewModel模型=新的OrdeListViewModel（）；
if（request.AcceptedOrCreatedBit）//对于OrderAcceptedByUser为true
{
model.Orders=wait\u context.Order
.Where（x=>x.AcceptedByUserId==request.UserId）
.Select（OrderDto.Projection）
.OrderBy（o=>o.Registration）
.ToListSync（取消令牌）
}
对于OrderCreatedByUser，else//false
{
model.Orders=wait\u context.Order
.Where（x=>x.CreatedByUserId==request.UserId）
.Select（OrderDto.Projection）
.OrderBy（o=>o.Registration）
.ToListSync（取消令牌）
}
收益模型；
}
首先，合并类
GetAllOrdersCreatedByUserQuery
和
GetAllOrdersAcceptedByUserQuery

参考请参见以下类别：

public class GetAllOrdersByUserQuery :  : IRequest<OrdeListViewModel>
{
    // if OrderAcceptedByUser is true else OrderCreatedByUser = false
    public bool AcceptedOrCreatedBit { get; set; } 
    public string UserId { get; set; }
}

最后，您的MediatR句柄方法应该如下所示：

public async Task<OrdeListViewModel> Handle(GetAllOrdersByUserQuery request, CancellationToken cancellationToken)
{
    OrdeListViewModel model = new OrdeListViewModel();
    if (request.AcceptedOrCreatedBit) // true for OrderAcceptedByUser
    {

            model.Orders = await _context.Order
            .Where(x => x.AcceptedByUserId == request.UserId)
            .Select(OrderDto.Projection)
            .OrderBy(o => o.Registration)
            .ToListAsync(cancellationToken)

    }
    else // false for OrderCreatedByUser
    {

            model.Orders = await _context.Order
            .Where(x => x.CreatedByUserId == request.UserId)
            .Select(OrderDto.Projection)
            .OrderBy(o => o.Registration)
            .ToListAsync(cancellationToken)

    }

    return model;
}

公共异步任务句柄（GetAllorderByUserQuery请求，CancellationToken CancellationToken）
{
OrdeListViewModel模型=新的OrdeListViewModel（）；
if（request.AcceptedOrCreatedBit）//对于OrderAcceptedByUser为true
{
model.Orders=wait\u context.Order
.Where（x=>x.AcceptedByUserId==request.UserId）
.Select（OrderDto.Projection）
.OrderBy（o=>o.Registration）
.ToListSync（取消令牌）
}
对于OrderCreatedByUser，else//false
{
model.Orders=wait\u context.Order
.Where（x=>x.CreatedByUserId==request.UserId）
.Select（OrderDto.Projection）
.OrderBy（o=>o.Registration）
.ToListSync（取消令牌）
}
收益模型；
}
您可以将规范模式应用于查询，即一个以谓词作为参数的查询

但是DDD提倡使用一种普遍存在的语言，如果您的用户不使用谓词，而是使用具体的方法名称，我将向用户提供2个查询，然后如果您不想重复代码，两个查询都将使用谓词调用通用查询。
您可以将规范模式应用于查询，即。，一个以谓词作为参数的查询

但是DDD提倡使用一种普遍存在的语言，如果您的用户不使用谓词，而是使用具体的方法名称，我将向用户提供2个查询，然后如果您不想重复代码，两个查询都将使用谓词调用通用查询。
这些方法的类是什么？这些方法的类是什么？