Рефакторинг шаблона команд

Это ближе к тому, что я хочу, и проще. Модифицировано из здесь.

Однако он по-прежнему не возвращает правильный тип во время сборки — мне нужен DeleteOrderResponse вместо IResponse. Клиенту раздражает то, что ему приходится выполнять это самому.

И мне также не нужен дополнительный шаг по созданию DeleteOrderCommand для клиента. SDK должен позаботиться об этом.

public class TestItOut
{
    public static void Test()
    {
        Sdk sdk = new Sdk();

        Request request = new Request { OrderNum = "1234" };
        AbstractCommand command = new DeleteOrderCommand(request);

        var response = (DeleteOrderResponse)sdk.ExecuteSdkCommand(command);
    }
}

public abstract class AbstractCommand
{
    protected Request request;

    // Constructor

    public AbstractCommand(Request request)
    {
        this.request = request;
    }

    public abstract IResponse Execute();
}

public interface IResponse { }
public class DeleteOrderResponse : IResponse
{
}

public class CreateOrderResponse : IResponse
{
}

/// <summary>
/// The 'ConcreteCommand' class
/// </summary>
public class DeleteOrderCommand : AbstractCommand
{
    public DeleteOrderCommand(Request request) : base(request)
    {
    }

    public override DeleteOrderResponse Execute()
    {
        string orderNum = request.OrderNum;
        // do logic here
        return new DeleteOrderResponse();
    }
}
public class CreateOrderCommand : AbstractCommand
{
    public CreateOrderCommand(Request request) : base(request)
    {
    }

    public override CreateOrderResponse Execute()
    {
        string orderNum = request.OrderNum;
        // do logic here
        return new CreateOrderResponse();
    }
}

public class Request
{
    public string OrderNum { get; set; }
}

public class Sdk
{
    public IResponse ExecuteSdkCommand(AbstractCommand command)
    {
        return command.Execute();
    }
}

Я обдумал это и нашел решение, которое работает так, как я хочу.

Несколько ключевых моментов:

• Тип ответа заключен в интерфейсе запроса. Таким образом, клиенту не нужно приводить ответ из интерфейса к конкретному типу, когда он получает его обратно.
• Требования заключались в том, что я не хотел, чтобы клиент мог сам выполнить команду. Для этого объекты запроса не могут содержать никаких ссылок на класс команды, поскольку объектом запроса является public. Поэтому я использовал internal class для команд и перегрузил широко известный метод входным аргументом типов запроса. Может быть есть другие способы сделать это, которые лучше? Было бы неплохо не использовать dynamic, чтобы IRequest<TOut> распознавал либо DeleteOrderRequest, либо CreateOrderRequest. В любом случае, это работает.

    using Microsoft.VisualStudio.TestTools.UnitTesting;
    
    namespace Hack6;
    
    [TestClass]
    public class Tests
    {
        private Sdk sdk;
        public Tests()
        {
            this.sdk = new Sdk();
        }
    
        [TestMethod]
        public void CanCreateOrder()
        {
            var createOrderRequest = new CreateOrderRequest();
            var createOrderResponse = this.sdk.ExecuteSdk(createOrderRequest);
            Assert.IsInstanceOfType(createOrderResponse, typeof(CreateOrderResponse));
            Assert.AreEqual(createOrderResponse.OrderId, "1234");
            Assert.AreEqual(createOrderResponse.Status, "success");
        }
        [TestMethod]
        public void CanDeleteOrder()
        {
            var sdk = new Sdk();
            var deleteOrderRequest = new DeleteOrderRequest { OrderNum = "1234" };
            var deleteOrderResponse = this.sdk.ExecuteSdk(deleteOrderRequest);
            Assert.IsInstanceOfType(deleteOrderResponse, typeof(DeleteOrderResponse));
            Assert.AreEqual(deleteOrderResponse.Status, "deleted");
        }
    }
    
    public interface IResponse { }
    
    public class DeleteOrderResponse : IResponse
    {
        public string Status { get; set; }
    }
    
    public class CreateOrderResponse : IResponse
    {
        public string OrderId { get; set; }
        public string Status { get; set; }
    }
    
    public interface IRequest<TOut> where TOut : IResponse
    {
    }
    
    public class DeleteOrderRequest : IRequest<DeleteOrderResponse>
    {
        public string OrderNum { get; set; }
    }
    
    public class CreateOrderRequest : IRequest<CreateOrderResponse>
    {
    }
    
    public class Sdk
    {
        public TOut ExecuteSdk<TOut>(IRequest<TOut> request)
            where TOut : IResponse
        {
            var commands = new Commands();
            var response = commands.ExecuteCommand((dynamic)request);
            return response;
        }
    }
    
    internal class Commands
    {
        public DeleteOrderResponse ExecuteCommand(DeleteOrderRequest request)
        {
            // logic goes here
            return new DeleteOrderResponse { Status = "deleted" };
        }
    
        public CreateOrderResponse ExecuteCommand(CreateOrderRequest request)
        {
            // logic goes here
            return new CreateOrderResponse
            {
                OrderId = "1234",
                Status = "success"
            };
        }
    }

В конце концов решение оказалось довольно простым — просто сделайте команды членами двух интерфейсов — одного публичного, не содержащего метода ExecuteCommand(), и одного внутреннего, содержащего метод ExecuteCommand(). Затем SDK примет общедоступный интерфейс в своем методе ExecuteSdk() и немедленно преобразует этот объект во внутренний интерфейс для внутреннего использования метода ExecuteCommand().

Сборка 1 — клиент:

    [TestClass]
    public class Tests
    {
        [TestMethod]
        public async Task CanCreateOrder()
        {
            var sdk = new Sdk();
            var createOrderRequest = new CreateOrderRequest();
    
            // note: createOrderRequest.Execute() does not exist in this assembly - good
            // this means the client cannot bypass sdk.ExecuteSdk()
            // createOrderRequest.Execute();
    
            // but sdk.ExecuteSdk does exist in this assembly - exactly as I want
            var createOrderResponse = await sdk.ExecuteSdk(createOrderRequest);
    
            Assert.IsInstanceOfType(createOrderResponse, typeof(CreateOrderResponse));
            Assert.AreEqual(createOrderResponse.OrderId, 1234);
            Assert.AreEqual(createOrderResponse.Status, "success");
        }
    }

Сборка 2 – SDK:

public class Sdk
{
    public async Task<TOut> ExecuteSdk<TOut>(ICommandRequest<TOut> commandRequest)
        where TOut : ICommandResponse
    {
        // validation logic and other logic goes here
        return await ((IInternalCommandRequest<TOut>)commandRequest).ExecuteCommand(this);
    }
}

public interface IResponse { }
public interface ICommandResponse : IResponse { }

public interface ICommandRequest<TOut>
    where TOut : ICommandResponse
{
    // note: do not expose the ExecuteCommand() method here, otherwise it will be public
    // and can be called directly by users of this SDK, bypassing the validations in the
    // Sdk.ExecuteSdk() methods
}

internal interface IInternalCommandRequest<TOut>
    where TOut : ICommandResponse
{
    // note: do define the ExecuteCommand() method here, only to be used internally by
    // the SDK
    Task<TOut> ExecuteCommand(Sdk sdk);
}

public class CreateOrderResponse : ICommandResponse
{
    public int OrderId { get; set; }
    public string Status { get; set; }
}

// there are many request objects. this one is for creating orders.
public class CreateOrderRequest : IInternalCommandRequest<CreateOrderResponse>, ICommandRequest<CreateOrderResponse>
{
    async Task<CreateOrderResponse> IInternalCommandRequest<CreateOrderResponse>.ExecuteCommand(Sdk sdk)
    {
        // logic goes here
        var createOrderResponse = new CreateOrderResponse
        {
            OrderId = 1234,
            Status = "success"
        };
        return await Task.FromResult(createOrderResponse); // example response
    }
}

public class DeleteOrderResponse : ICommandResponse
{
    public string Status { get; set; }
}

public class DeleteOrderRequest : IInternalCommandRequest<DeleteOrderResponse>, ICommandRequest<DeleteOrderResponse>
{
    async Task<DeleteOrderResponse> IInternalCommandRequest<DeleteOrderResponse>.ExecuteCommand(Sdk sdk)
    {
        // logic goes here
        return await Task.FromResult(new DeleteOrderResponse { Status = "failed"}); // example response
    }
}