Question

编写一些处理响应和请求的代码。两者都可以是XML的形式，并且都可以是通过转换和序列化创建的C＃对象的形式。（这是.NET 2.0）

响应和请求是较大消息类型的基本实现。现在我有GetEligibility和FindCandidates。

下面使用的Model.MessageModel类的示例：

public partial class GetEligibilityResponseMessage : ResponseMessage

public partial class ResponseMessage : Message

因为我不想复制我的映射功能，所以我决定使用泛型来简化这个过程，并且效果很好：

基类代码

    public virtual Model.MessageModel.Message MapToModel<T>(XmlDocument xml)
    {
        V3Mapper mapper = new V3Mapper();
        Model.MessageModel.Message message = mapper.MapToDomainModel<T>(xml, Environment) as Model.MessageModel.Message;
        return message;
    }

    public virtual XmlDocument MapToXml<T>(Model.MessageModel.Message message)
    {
        V3Mapper mapper = new V3Mapper();
        XmlDocument xml= mapper.MapToV3Message<T>(message, Environment);
        return xml;
    }

首次调用我的代码时，它有一个XML文档。我知道这个文档将被映射为一个请求，所以我调用一个被覆盖的虚方法（我觉得它很难看）。将映射代码保留在基础中的原因是不重复代码，但我发现我正在做的事情我想避免以下内容：

GetEligibility：BaseClass

   public override Model.MessageModel.Message MapToModel<T>(XmlDocument xml)
    {   
        if(typeof(T).IsAssignableFrom(typeof(GetEligibilityResponseMessage)))
        {
            return base.MapToModel<GetEligibilityResponseMessage>(xml);
        }
        else if (typeof(T).IsAssignableFrom(typeof(GetEligibilityRequestMessage))) 
        {
            return base.MapToModel<GetEligibilityRequestMessage>(xml);
        }
        return null;//because this is a quick code snippet
    }

有更优雅的方式吗？我总是知道我是否正在处理响应或请求。我希望将功能保持打开状态，以便它不会过于紧密耦合，但同时又具有功能性和快速性。

这将由许多不同的消息类型实现，我真的很讨厌复制/粘贴编码风格，所以优雅的解决方案会很棒，但我不确定是否有。（.NET 2.0）

Answer 1

您可以使用MethodInfo.MakeGenericMethod Method来避免在调用泛型方法之前检查类型。以下是一个快速使用示例：

class Program
{
    public static void Generic<T>(T toDisplay)
    {
        Console.WriteLine("\r\nHere it is: {0}", toDisplay);
    }

    static void Main(string[] args)
    {
        MethodInfo mi = typeof(Program).GetMethod("Generic");
        MethodInfo miConstructed = mi.MakeGenericMethod(typeof(DateTime));

        DateTime now = DateTime.Now;
        miConstructed.Invoke(null, new object[] { now });
    }
}

请注意，我使用了 typeof（DateTime），但在您的情况下，您可以通过 typeof（T）替换它，以实现所需的松散耦合解决方案。

Answer 2

如果您只想验证请求和响应类型，可以让您的基类知道：

public class BaseClass
{
    private readonly Type _requestType;
    private readonly Type _responseType;

    protected BaseClass(Type requestType, Type responseType)
    {
        _requestType = requestType;
        _responseType = responseType;
    }

    public T MapToModel<T>(XmlDocument xml)
    {
        if (typeof(T) != _requestType && typeof(T) != _responseType)
            throw new InvalidOperationException("Invalid type");

        var mapper = new V3Mapper();
        return mapper.MapToDomainModel<T>(xml, Environment);
    }
}

public GetEligibility : BaseClass
{
    public GetEligibility() 
        : base(typeof(GetEligibilityRequestMessage), typeof(GetEligibilityResponseMessage))
    {}
}

您甚至可以更进一步，使用BaseClass和MapToRequest专用MapToResponse和public class BaseClass<TRequest, TResponse> where TRequest:RequestMessage, TResponse:ResponseMessage { public TRequest MapToRequest(XmlDocument xml) { return MapToModel<TRequest>(xml); } public TResponse MapToResponse(XmlDocument xml) { return MapToModel<TResponse>(xml); } private T MapToModel<T>(XmlDocument xml) { var mapper = new V3Mapper(); return mapper.MapToDomainModel<T>(xml, Environment); } } public GetEligibility : BaseClass<GetEligibilityRequestMessage, GetEligibilityResponseMessage> {}方法，使{{1}}通用，并知道要返回的内容：

{{1}}

任何更好的方法来确定基于T和子类的类型

2 个答案: