c# - 通用委托(delegate)变量

我伤了我的大脑。
一些背景：
我有一个多层应用程序的多重服务。有些是短生命的（应该用using来消费），而有些不是（所以我只是将它们注入到任何我想要的类中并直接使用）。我的客户端代码有不同的数据接口和随机的关键字。
出于某些原因（主要是科学原因），我决定对它进行一点重构。我已经创建了一个universalusing类，它应该为我使用的每个服务关闭，这个universal类封装了客户端的逻辑。
DataServiceAdapter<>如下所示（简短的工作示例here on dotnetfiddle）

public class DataServiceAdapter<TService> : IDataService
    where TService : IDataService, new()
{
    private readonly TService _service;
    private readonly Func<Func<TService, dynamic>, dynamic> _run;

    public DataServiceAdapter()
    {
        if (typeof(IDisposable).IsAssignableFrom(typeof(TService)))
        {
            _run = RunWithUsing;
        }
        else
        {
            _service = new TService();
            _run = RunWithoutUsing;
        }
    }

    public bool Foo()
    {
        return _run(x => x.Foo());
    }

    public int Bar(string arg)
    {
        return _run(x => x.Bar(arg));
    }

    private dynamic RunWithUsing(Func<TService, dynamic> func)
    {
        using (var service = (IDisposable) new TService())
        {
            return func((TService)service);
        }
    }

    private dynamic RunWithoutUsing(Func<TService, dynamic> func)
    {
        return func(_service);
    }
}

public interface IDataService
{
    bool Foo();
    int Bar(string arg);
}

客户应该这样处理：

//class variable. Get this from IoC container
private readonly IDataService _service;
//somewhere in methods
var resultData = _service.Foo(); //full static type checking

但因为我现实生活中的using包含了很多方法，所以我像这样重写了DataServiceAdapter（只是改变，dotnetfiddle link）：

public class DataServiceAdapter<TService> : IDataServiceAdapter<TService>
    where TService : IDataService, new()
{
    public dynamic Run(Func<TService, dynamic> func)
    {
        return _serviceUsing(func);
    }
}

public interface IDataServiceAdapter<out TService>
    where TService : IDataService
{
    dynamic Run(Func<TService, dynamic> func);
}

客户端现在以这种方式处理IDataService的版本：

//class variable. Get this from IoC container
private readonly IDataServiceAdapter<IDataService> _service;
//somewhere in methods
var resultData = _service.Run(s => s.Foo());

由于DataServiceAdapter
所以（我们几乎有问题了）我决定再次重写它（为了科学）并返回静态安全性，但不必在适配器类中包装所有DataServiceAdapter方法。
首先我写了这篇文章：

private delegate TRes RunDelegate<TResult>(Func<TService, TResult> func);

但我只是不能创建这样的委托的变量，并通过一些我希望使用的方法，就像我在上面所做的。
问题：
有什么方法可以实现我的设计思想吗（通用服务提供者调用的是带有dynamic的方法还是没有它的方法，并且具有类型安全性）？

最佳答案

您可以将运行逻辑委托给实现irunner接口的runner类。如果你觉得有必要的话，你可以选择注射。
这样地：
使用系统；

public class Program
{
    public static void Main()
    {
        //Dependency register logic here. Choose either

        //var service = new DataServiceAdapter<SpecificNotDisposableDataService>();
        var service = new DataServiceAdapter<SpecificDisposableDataService>();

        var client = new Client(service);
        client.ClientMethod();
        Console.ReadLine();
    }
}

public class Client
{
    private readonly IDataServiceAdapter<IDataService> _service;
    public Client(IDataServiceAdapter<IDataService> service)
    {
        _service = service;
    }

    public void ClientMethod()
    {
        Console.WriteLine(_service.Run(s => s.Foo()));
        Console.WriteLine(_service.Run(s => s.Bar("Hello")));
    }
}

public class DataServiceAdapter<TService> : IDataServiceAdapter<TService>
    where TService : IDataService, new()
{
    private interface IRunner
    {
        T Run<T>(Func<TService, T> func);
    }
    private class WithUsing : IRunner
    {
        public T Run<T>(Func<TService, T> func)
        {
            using (var service = (IDisposable) new TService())
            {
                return func((TService)service);
            }
        }
    }
    private class WithoutUsing : IRunner
    {
        private readonly TService _service = new TService();
        public T Run<T>(Func<TService, T> func)
        {
            return func(_service);
        }
    }
    private readonly IRunner _runner;

    public DataServiceAdapter()
    {
        if (typeof(IDisposable).IsAssignableFrom(typeof(TService)))
        {
            _runner = new WithUsing();
        }
        else
        {
            _runner = new WithoutUsing();
        }
    }

    public T Run<T>(Func<TService, T> func)
    {
        return _runner.Run<T>(func);
    }
}

public class SpecificDisposableDataService : IDataService, IDisposable
{
    public bool Foo()
    {
        return true;
    }

    public int Bar(string arg)
    {
        return arg.Length;
    }

    public void Dispose()
    {
        //Dispose logic here
    }
}

public class SpecificNotDisposableDataService : IDataService
{
    public bool Foo()
    {
        return false;
    }

    public int Bar(string arg)
    {
        return arg.Length*2;
    }
}

public interface IDataServiceAdapter<out TService>
    where TService : IDataService
{
    T Run<T>(Func<TService, T> func);
}

public interface IDataService
{
    bool Foo();
    int Bar(string arg);
}

这是上面的一个工作点：https://dotnetfiddle.net/FmNpju
下面是另一个运行这两种服务的：
https://dotnetfiddle.net/KxEGRB