Question

我在这里伤害了我的大脑。

一些背景知识：

我在多层应用程序中有多个服务。其中一些是短寿命（应该与using一起使用），其中一些不是（所以我只是将它们注入我想要的任何类并直接使用）。我的客户端代码具有不同的数据接口和随机using关键字。

出于某些原因（主要是科学）我决定稍微重构一下。我已经创建了一个通用的DataServiceAdapter<>类，应该为我使用的每个服务关闭它，这个通用类从客户端封装using逻辑。

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

但是因为IDataService的真实版本包含了几十种方法，所以我重写了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);
}

客户端现在以这种方式使用该版本的DataServiceAdapter：

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

由于dynamic

，它无需静态检查

所以（我们接近于问题）我决定再次重写它（对于SCIENCE）并返回静态安全性，但是没有必要在我的适配器类中包装所有IDataService方法。

首先我写了这个delegate：

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

但是我不能创建这样的委托的变量并传递一些我希望使用的方法，就像我上面那样。

问题：有没有办法在那里实现我的设计思想（通用服务提供商调用是否使用using方法或没有它的方法并且具有类型安全性？）

Answer 1

您可以将运行逻辑委托给实现IRunner接口的运行程序类。如果您觉得有必要，可以选择注入。

像这样：

使用System;

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);
}

以上是上面的工作dotnetfiddle：https://dotnetfiddle.net/FmNpju

这是另一个运行两个服务： https://dotnetfiddle.net/KxEGRB

Answer 2

这可以通过简单的扩展方法来处理：

public static TResult Run<TService, TResult>(this IDataService<TService> @this, 
                                             Func<TService, TResult> func)
{
  if (typeof(IDisposable).IsAssignableFrom(typeof(TService)))
  {
    using (var service = (@this.GetInstance() as IDisposable))
    {
      return func(@this);
    }
  }
  else
  {
    return func(@this.GetInstance());
  }
}

只需实施GetInstance方法即可返回新服务（IDisposable时）或“单身”（非IDisposable时）。

你会发现在使用功能范例时（比如本例中的lambda / delegates），一路走来都是值得的，而不是试图强制使用一些功能/继承导向的混合。

当然，如果你之前已经尝试过功能性编程，那么即使这段代码已经在唠叨你了 - 这也是可疑的。为什么要限制自己这种操作呢？

您可以使用相同的方法将逻辑移动到您的服务提供商。关键是你保持执行方法通用，这允许你保持强类型。只需让方法处理执行而不是尝试在某处存储委托。

如果确实想要进一步委托，您可以使用额外的界面：

interface IExecutor<TService>
{
  TResult Execute<TResult>(Func<TService, TResult> func);
}

请注意，该界面仅在TService上是通用的 - 它是Execute方法，可再次为类型安全添加TResult。这意味着您可以轻松地将任一实现存储在同一个字段中 - 您只在实际请求TResult操作时传递Execute，然后您就知道TResult应该是什么。

通用委托变量

2 个答案: