通过另类的泛型约束将两个输入输出参数不同的方法合并成一个方法的实现

 其实我也不知道如何定义这个标题，词乏，姑且先这样定义吧。

看了本文章的朋友，如果有更好标题，请告诉我，谢谢。

有个项目使用SDK时遇到这样一个情况。

该SDK有个BtPrinterManager类，拥有两个方法：ServerPrint和ClientPrint，这两个方法有一部分参数是一样的，一部分参数不一样。

现在我们要对这个类进行封装，把这两个方法合并成一个方法，并且使其拥有相同的输入参数和输出参数。

比较粗糙的做法是，把这两个方法的输入参数合并成一个输入模型类，把两个方法的输出参数也合并成一个输出模型类。

通过增加一个参数或(判断某个方法专属参数是否有值)在方法内部决定应该调用ServerPrint还是ClientPrint，以及应该从输入模型类里取哪些参数，应该赋哪些值给输出模型类。

如果不按照上面的做法写，还有什么办法可以做到呢？

答案是有的，泛型约束+方法内对泛型实际类型判断。

以下是实现代码：

using System;

namespace Test
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            Run();
            
            Console.ReadKey();
        }

        private static void Run()
        {
            PrinterManager clientManager = new ClientPrinterManager();
            ClientInputModel clientInputModel = new ClientInputModel();
            //clientInputModel对象赋值....
            Action<ClientOutputModel> clientAction = info => { Console.WriteLine(info.PrinterName + info.ClientName); };
            clientManager.Print(clientInputModel, clientAction);

            PrinterManager serverManager = new ServerPrinterManager();
            ClientInputModel serverInputModel = new ClientInputModel();
            //serverInputModel对象赋值....
            Action<ServerOutputModel> serverAction = info => { Console.WriteLine(info.PrinterName + info.ServerName); };
            serverManager.Print(serverInputModel, serverAction);
        }
    }

    /// <summary>
    /// 打印管理类
    /// </summary>
    public abstract class PrinterManager
    {
        /// <summary>
        /// 打印文件
        /// </summary>
        /// <typeparam name="TInputModel"></typeparam>
        /// <typeparam name="TOutputModel"></typeparam>
        /// <param name="model"></param>
        /// <param name="action"></param>
        /// <returns></returns>
        public abstract string Print<TInputModel, TOutputModel>(TInputModel model, Action<TOutputModel> action) where TInputModel : InputModelBase, new() where TOutputModel : OutputModelBase, new();
    }

    /// <summary>
    /// 客户端打印管理类
    /// </summary>
    public class ClientPrinterManager : PrinterManager
    {
        public override string Print<TInputModel, TOutputModel>(TInputModel model, Action<TOutputModel> action)
        {
            string message = string.Empty;

            #region 泛型类型校验
            if (typeof(TInputModel) != typeof(ClientInputModel))
            {
                throw new ArgumentException($"{nameof(TInputModel)} generic types must be of type {nameof(ClientInputModel)}", nameof(ClientInputModel));
            }

            if (typeof(TOutputModel) != typeof(ClientOutputModel))
            {
                throw new ArgumentException($"{nameof(TOutputModel)} generic types must be of type {nameof(ClientOutputModel)}", nameof(ClientOutputModel));
            }
            #endregion

            #region 这里假装是调用某SDK方法获取的结果

            //BtPrinter printer = new BtPrinter();
            //string message;
            //var info = printer.ClientPrint(model.Param1, model.Param2, model.Param1, model.ClientParam1, out message);

            var info = new ClientOutputModel
            {
                PrinterName = "Test Printer",
                ClientName = "Test Client"
            };
            message = "ClientPrint Success";

            #endregion

            TOutputModel result = (TOutputModel)Convert.ChangeType(info, typeof(TOutputModel));
            action(result);

            return message;
        }
    }

    /// <summary>
    /// 服务器端打印管理类
    /// </summary>
    public class ServerPrinterManager : PrinterManager
    {
        public override string Print<TInputModel, TOutputModel>(TInputModel model, Action<TOutputModel> action)
        {
            string message = string.Empty;

            #region 泛型类型校验
            if (typeof(TInputModel) != typeof(ServerInputModel))
            {
                throw new ArgumentException($"{nameof(TInputModel)} generic types must be of type {nameof(ServerInputModel)}", nameof(ServerInputModel));
            }

            if (typeof(TOutputModel) != typeof(ServerOutputModel))
            {
                throw new ArgumentException($"{nameof(TOutputModel)} generic types must be of type {nameof(ServerOutputModel)}", nameof(ServerOutputModel));
            }
            #endregion

            #region 这里假装是调用某SDK方法获取的结果

            //BtPrinter printer = new BtPrinter();
            //string message;
            //var info = printer.ServerPrint(model.Param1, model.Param2, model.ServerParam1, model.ServerParam2, out message);

            var info = new ServerOutputModel
            {
                PrinterName = "Test Printer",
                ServerName = "Test Server"
            };
            message = "ServerPrint Success";

            #endregion

            TOutputModel result = (TOutputModel)Convert.ChangeType(info, typeof(TOutputModel));
            action(result);

            return message;
        }
    }

    #region 输入模型类
    public class InputModelBase
    {
        public string Param1 { get; set; }

        public string Param2 { get; set; }
    }

    public class ClientInputModel : InputModelBase
    {
        public string ClientParam1 { get; set; }
    }

    public class ServerInputModel : InputModelBase
    {
        public string ServerParam1 { get; set; }

        public string ServerParam2 { get; set; }
    }
    #endregion

    #region 输出模型类
    public class OutputModelBase
    {
        public string PrinterName { get; set; }
    }

    public class ClientOutputModel : OutputModelBase
    {
        public string ClientName { get; set; }
    }

    public class ServerOutputModel : OutputModelBase
    {
        public string ServerName { get; set; }
    }
    #endregion
}

如果有更好的方法实现，求指教，谢谢。