C# 供应商整合的适当方法

在我现在从事的项目中，我们通过40多家不同供应商的web服务收集了一些数据，然后将它们汇总在一起，然后展示给我们的客户。
每个供应商都提供不同类型的服务（我们发送的一些请求是SOAP调用，一些是通过POST或GET的简单查询字符串，还有一些…。
目前系统有点混乱，我们有一个基类，它有一个名为GetSupplierData（Request-Request）的抽象方法，每个供应商类都会覆盖该方法。问题是，每个供应商类在该方法中执行完全不同的操作，在请求的不同部分设置超时等。我的任务是在所有供应商之间实现一个通用的业务逻辑/计时/日志记录，因此我认为应该更改此方法。
根据业务逻辑，整个流程可分为4个不同阶段：

• 生成特定于供应商的请求
• 发送该请求并等待响应
• 将响应映射到公共格式（称该类为CommonResponse）
• 对CommonResponse进行后期处理（这里的逻辑对所有供应商都是通用的，因此在基类中实现）

根据这一逻辑，我决定实现一个模板方法设计模式，我在基类中创建了一个业务逻辑方法和3个抽象方法，代表上述业务逻辑的前3个步骤：

public class SupplierBase
{
    protected abstract XDocument generateRequest(Request request);
    protected abstract XDocument sendRequest(XDocument request);
    protected abstract CommonResponse mapResponse(XDocument response);

    public CommonResponse process(Request request)
    {
        return mapResponse(sendRequest(generateRequest(request)));
    }
}

但我不喜欢的是我们操作XDocument（因此我们使用Linq到XML创建供应商请求），而不是某种代理对象。另一方面，如果我们在函数中传入和传出这么多完全不同的代理对象，我不知道如何实现模板模式。我知道在某些情况下，每个请求都可以（甚至在某些情况下必须）用XML表示，而且我知道每个供应商的退货都是XML，因此我决定使用XDocument，而不是映射供应商特定的对象来表示该XML（并序列化/反序列化）。
然而，我有一种奇怪的感觉，这可以做得更好。

---

你们中有人在过去做过类似的事情吗？你是怎么做的？我会为任何指点而努力。

我正在从事一个类似的项目。这听起来和你正在做的非常相似

---

因为我需要供应商响应的历史记录，所以我让各个供应商类将响应写入数据库（在解析响应的相关部分之后），然后从主线程访问它

我在做一个类似的项目。这听起来和你正在做的非常相似

---

因为我需要供应商响应的历史记录，所以我让各个供应商类将响应写入数据库（在解析响应的相关部分之后），然后从主线程访问它

您不能使用泛型并使用代理对象吗？差不多

public abstract class SupplierBase<TRequest, TResponse>
    {
        protected abstract TRequest generateRequest();
        protected abstract TResponse sendRequest (TRequest request);
        protected abstract CommonResponse mapResponse (TResponse request);

        public CommonResponse process(TRequest request)
        {
            return mapResponse(sendRequest(generateRequest()));
        }
    }

    // an implementing class...
    public class SupplierA:SupplierBase<RequestA, ResponseA>
    {
        protected override RequestA generateRequest()
        {
            return new RequestA();
        }

        protected override ResponseA sendRequest(RequestA request)
        {
            // call with the request and return the specific response
        }

        protected override CommonResponse mapResponse(ResponseA request)
        {
            // map the specific response to the common response
        }
    }

公共抽象类SupplierBase
{
受保护的抽象TRequest generateRequest（）；
受保护的抽象响应sendRequest（TRequest请求）；
受保护的抽象CommonResponse映射响应（响应请求）；
公共公共响应过程（TRequest请求）
{
返回mapResponse（sendRequest（generateRequest（））；
}
}
//一个实现类。。。
公共类SupplierA:SupplierBase
{
受保护的覆盖请求A generateRequest（）
{
返回新的RequestA（）；
}
受保护的覆盖响应A sendRequest（请求A请求）
{
//调用请求并返回特定响应
}
受保护的覆盖CommonResponse映射响应（ResponseA请求）
{
//将特定响应映射到公共响应
}
}

您不能使用泛型并使用代理对象吗？差不多

public abstract class SupplierBase<TRequest, TResponse>
    {
        protected abstract TRequest generateRequest();
        protected abstract TResponse sendRequest (TRequest request);
        protected abstract CommonResponse mapResponse (TResponse request);

        public CommonResponse process(TRequest request)
        {
            return mapResponse(sendRequest(generateRequest()));
        }
    }

    // an implementing class...
    public class SupplierA:SupplierBase<RequestA, ResponseA>
    {
        protected override RequestA generateRequest()
        {
            return new RequestA();
        }

        protected override ResponseA sendRequest(RequestA request)
        {
            // call with the request and return the specific response
        }

        protected override CommonResponse mapResponse(ResponseA request)
        {
            // map the specific response to the common response
        }
    }

公共抽象类SupplierBase
{
受保护的抽象TRequest generateRequest（）；
受保护的抽象响应sendRequest（TRequest请求）；
受保护的抽象CommonResponse映射响应（响应请求）；
公共公共响应过程（TRequest请求）
{
返回mapResponse（sendRequest（generateRequest（））；
}
}
//一个实现类。。。
公共类SupplierA:SupplierBase
{
受保护的覆盖请求A generateRequest（）
{
返回新的RequestA（）；
}
受保护的覆盖响应A sendRequest（请求A请求）
{
//调用请求并返回特定响应
}
受保护的覆盖CommonResponse映射响应（ResponseA请求）
{
//将特定响应映射到公共响应
}
}

这很有道理！我会检查这个：）谢谢！这很有道理！我会检查这个：）谢谢！