当生产规模较小时，您就不会特别热心，并且在方法中做到这一切都是正确的。逐渐地，服务构造函数开始变得越来越庞大，以用于BL和端到端功能的实现的传入服务越来越多。这是ILogger，IAuditService，INotifySerice。
我不认识你，但我不喜欢同时进行许多动作的大量注射和大型方法。
您可以在代码上结束任何AOP实现。在.NET堆栈中，此类实现会在正确的位置插入到您的应用程序中，看起来像80级魔术，并且经常会出现键入和调试问题。
我试图找到一个中间立场。如果这些问题还没有解决，欢迎您的光临。
剧透 实际上，我能够解决的问题比上面描述的要多。例如，我可以将BL开发交给一个开发人员，同时将端到端功能甚至挂起的传入数据验证挂接到另一个开发人员。
装饰人员和DI插件帮助我实现了这一点。有人会进一步说这是代理，我将很乐意在评论中对此进行讨论。
那么，作为开发人员我想要什么？
- 实施BL时，请勿被左侧功能分散注意力。
- 只能在单元测试中测试BL。而且我不喜欢做100,500个模拟来禁用所有辅助功能。2-3-好的，但是我不想。
- 了解额头没有7个跨度的情况。:)
- 能够分别管理服务及其每个包装的生命周期！
作为设计师和团队负责人我想要什么？
- 为了能够以最佳的方式和最小的一致性分解任务，以便同时有可能让尽可能多的开发人员参与不同的任务，同时使他们花费尽可能少的时间进行研究（如果开发人员需要开发BL，并同时考虑如何以及如何确保安全性，他将花费更多的时间进行研究。因此，对于每个BL而言，获取审核记录并将其记录在整个项目中要容易得多。
- 保持代码执行与开发分开的顺序。
这个界面将帮助我。
/// <summary>
/// .
/// </summary>
/// <typeparam name="T"> . </typeparam>
public interface IDecorator<T>
{
/// <summary>
/// .
/// </summary>
Func<T> NextDelegate { get; set; }
}
你可以用这样的东西
interface IService
{
Response Method(Request request);
}
class Service : IService
{
public Response Method(Request request)
{
// BL
}
}
class Wrapper : IDecorator<IService>, IService
{
public Func<IService> NextDelegate { get; set; }
public Response Method(Request request)
{
// code before
var result = NextDelegate().Method(request);
// code after
return result;
}
}因此，我们的行动将更加深入。
wrapper1
wrapper2
service
end wrapper2
end wrapper1等一下 这已经在OOP中，称为继承。：D
class Service {}
class Wrapper1: Service {}
class Wrapper2: Wrapper1 {}正如我想象的那样，会出现其他端到端功能，这些功能必须在整个应用程序的中间实现，或者交换现有功能，我的头发反而立于不败之地。
但是我的懒惰并不是一个很好的理由。很好的理由是，在单元测试Wrapper1和Wrapper2类中的功能时会遇到很大的问题，而在我的示例中，可以简单地模拟NextDelegate。此外，服务和每个包装器都有注入到构造函数中的自己的一组工具，而对于继承而言，最后的包装器必须具有不必要的工具才能将其传递给父级。
因此，该方法已被接受，剩下的工作就是弄清楚在何处，如何以及何时分配NextDelegate。
我决定，最合理的解决方案是在注册服务的地方进行此操作。（默认为Startup.sc）。
这是基本版本中的外观。
services.AddScoped<Service>();
services.AddTransient<Wrapper1>();
services.AddSingleton<Wrapper2>();
services.AddSingleton<IService>(sp =>
{
var wrapper2 = sp.GetService<Wrapper2>();
wrapper2.NextDelegate = () =>
{
var wrapper1 = sp.GetService<Wrapper1>();
wrapper1.NextDelegate = () =>
{
return sp.GetService<Service>();
};
return wrapper1;
};
return wrapper2;
});通常，所有要求都得到满足，但是出现了另一个问题-嵌套。
这个问题可以通过蛮力或递归来解决。但是在幕后。从表面上看，一切都应该看起来简单易懂。
这是我设法实现的
services.AddDecoratedScoped<IService, Service>(builder =>
{
builder.AddSingletonDecorator<Wrapper1>();
builder.AddTransientDecorator<Wrapper2>();
builder.AddScopedDecorator<Wrapper3>();
});这些扩展方法帮助了我。
这些扩展方法和景观构建器帮助了我。
/// <summary>
/// .
/// </summary>
public static class DecorationExtensions
{
/// <summary>
/// .
/// </summary>
/// <typeparam name="TDefinition"> . </typeparam>
/// <typeparam name="TImplementation"> . </typeparam>
/// <param name="lifeTime"></param>
/// <param name="serviceCollection"> . </param>
/// <param name="decorationBuilder"> . </param>
/// <returns> . </returns>
public static IServiceCollection AddDecorated<TDefinition, TImplementation>(
this IServiceCollection serviceCollection, ServiceLifetime lifeTime,
Action<DecorationBuilder<TDefinition>> decorationBuilder)
where TImplementation : TDefinition
{
var builder = new DecorationBuilder<TDefinition>();
decorationBuilder(builder);
var types = builder.ServiceDescriptors.Select(k => k.ImplementationType).ToArray();
var serviceDescriptor = new ServiceDescriptor(typeof(TImplementation), typeof(TImplementation), lifeTime);
serviceCollection.Add(serviceDescriptor);
foreach (var descriptor in builder.ServiceDescriptors)
{
serviceCollection.Add(descriptor);
}
var resultDescriptor = new ServiceDescriptor(typeof(TDefinition),
ConstructServiceFactory<TDefinition>(typeof(TImplementation), types), ServiceLifetime.Transient);
serviceCollection.Add(resultDescriptor);
return serviceCollection;
}
/// <summary>
/// Scoped.
/// </summary>
/// <typeparam name="TDefinition"> . </typeparam>
/// <typeparam name="TImplementation"> . </typeparam>
/// <param name="serviceCollection"> . </param>
/// <param name="decorationBuilder"> . </param>
/// <returns> . </returns>
public static IServiceCollection AddDecoratedScoped<TDefinition, TImplementation>(
this IServiceCollection serviceCollection,
Action<DecorationBuilder<TDefinition>> decorationBuilder)
where TImplementation : TDefinition
{
return serviceCollection.AddDecorated<TDefinition, TImplementation>(ServiceLifetime.Scoped,
decorationBuilder);
}
/// <summary>
/// Singleton.
/// </summary>
/// <typeparam name="TDefinition"> . </typeparam>
/// <typeparam name="TImplementation"> . </typeparam>
/// <param name="serviceCollection"> . </param>
/// <param name="decorationBuilder"> . </param>
/// <returns> . </returns>
public static IServiceCollection AddDecoratedSingleton<TDefinition, TImplementation>(
this IServiceCollection serviceCollection,
Action<DecorationBuilder<TDefinition>> decorationBuilder)
where TImplementation : TDefinition
{
return serviceCollection.AddDecorated<TDefinition, TImplementation>(ServiceLifetime.Singleton,
decorationBuilder);
}
/// <summary>
/// Transient.
/// </summary>
/// <typeparam name="TDefinition"> . </typeparam>
/// <typeparam name="TImplementation"> . </typeparam>
/// <param name="serviceCollection"> . </param>
/// <param name="decorationBuilder"> . </param>
/// <returns> . </returns>
public static IServiceCollection AddDecoratedTransient<TDefinition, TImplementation>(
this IServiceCollection serviceCollection,
Action<DecorationBuilder<TDefinition>> decorationBuilder)
where TImplementation : TDefinition
{
return serviceCollection.AddDecorated<TDefinition, TImplementation>(ServiceLifetime.Transient,
decorationBuilder);
}
/// <summary>
///
/// </summary>
/// <typeparam name="TService"></typeparam>
/// <param name="implType"></param>
/// <param name="next"></param>
/// <returns></returns>
private static Func<IServiceProvider, TService> ConstructDecorationActivation<TService>(Type implType,
Func<IServiceProvider, TService> next)
{
return x =>
{
var service = (TService) x.GetService(implType);
if (service is IDecorator<TService> decorator)
decorator.NextDelegate = () => next(x);
else
throw new InvalidOperationException(" ");
return service;
};
}
/// <summary>
/// .
/// </summary>
/// <typeparam name="TDefinition"> . </typeparam>
/// <param name="serviceType"> . </param>
/// <param name="decoratorTypes"> . </param>
/// <returns> DI. </returns>
private static Func<IServiceProvider, object> ConstructServiceFactory<TDefinition>(Type serviceType,
Type[] decoratorTypes)
{
return sp =>
{
Func<IServiceProvider, TDefinition> currentFunc = x =>
(TDefinition) x.GetService(serviceType);
foreach (var decorator in decoratorTypes)
{
currentFunc = ConstructDecorationActivation(decorator, currentFunc);
}
return currentFunc(sp);
};
}
} /// <summary>
/// .
/// </summary>
/// <typeparam name="TService"> . </typeparam>
public class DecorationBuilder<TService>
{
private readonly List<ServiceDescriptor> _serviceDescriptors = new List<ServiceDescriptor>();
/// <summary>
/// .
/// </summary>
public IReadOnlyCollection<ServiceDescriptor> ServiceDescriptors => _serviceDescriptors;
/// <summary>
/// .
/// </summary>
/// <typeparam name="TDecorator"> . </typeparam>
/// <param name="lifeTime"> . </param>
public void AddDecorator<TDecorator>(ServiceLifetime lifeTime) where TDecorator : TService, IDecorator<TService>
{
var container = new ServiceDescriptor(typeof(TDecorator), typeof(TDecorator), lifeTime);
_serviceDescriptors.Add(container);
}
/// <summary>
/// Scoped.
/// </summary>
/// <typeparam name="TDecorator"> . </typeparam>
public void AddScopedDecorator<TDecorator>() where TDecorator : TService, IDecorator<TService>
{
AddDecorator<TDecorator>(ServiceLifetime.Scoped);
}
/// <summary>
/// Singleton.
/// </summary>
/// <typeparam name="TDecorator"> . </typeparam>
public void AddSingletonDecorator<TDecorator>() where TDecorator : TService, IDecorator<TService>
{
AddDecorator<TDecorator>(ServiceLifetime.Singleton);
}
/// <summary>
/// Transient.
/// </summary>
/// <typeparam name="TDecorator"> . </typeparam>
public void AddTransientDecorator<TDecorator>() where TDecorator : TService, IDecorator<TService>
{
AddDecorator<TDecorator>(ServiceLifetime.Transient);
}
}现在给功能主义者一些糖
现在给功能主义者一些糖
, , ,
, :
/// <summary>
/// .
/// </summary>
/// <typeparam name="T"> . </typeparam>
public class DecoratorBase<T> : IDecorator<T>
{
/// <summary>
/// .
/// </summary>
public Func<T> NextDelegate { get; set; }
/// <summary>
/// .
/// </summary>
/// <typeparam name="TResult"> . </typeparam>
/// <param name="lambda"> . </param>
/// <returns></returns>
protected Task<TResult> ExecuteAsync<TResult>(Func<T, Task<TResult>> lambda)
{
return lambda(NextDelegate());
}
/// <summary>
/// .
/// </summary>
/// <param name="lambda"> . </param>
/// <returns></returns>
protected Task ExecuteAsync(Func<T, Task> lambda)
{
return lambda(NextDelegate());
}
}, , ,
public Task<Response> MethodAsync(Request request)
{
return ExecuteAsync(async next =>
{
// code before
var result = await next.MethodAsync(request);
// code after
return result;
});
}, :
public Task<Response> MethodAsync(Request request)
{
return ExecuteAsync(next => next.MethodAsync(request));
}仍然有一点魔力。即，NextDelegate属性的目的。目前尚不清楚它是什么以及如何使用它，但是有经验的程序员会找到它，但是没有经验的人需要解释一次。就像DbContext中的DbSets。
我没有把它放在git hub上。没有太多代码，它已经被泛化了，因此您可以从这里开始。
最后，我不想说什么。