Add non-lazy registration mutator supporting.

Author: hypercodeplace

LazyProxy.Autofac.Tests/AutofacExtensionTests.cs

@@ -4,7 +4,10 @@
 using System.Linq;
 using System.Runtime.CompilerServices;
 using Autofac;
+using Autofac.Builder;
 using Autofac.Core;
+using Autofac.Extras.DynamicProxy;
+using Castle.DynamicProxy;
 using Xunit;
 
 [assembly: InternalsVisibleTo("LazyProxy.DynamicTypes")]
@@ -350,6 +353,36 @@ public void OpenGenericServiceMustBeResolved(string name)
  }
  }
 
+ [Theory]
+ [InlineData(null)]
+ [InlineData("name")]
+ public void NonLazyRegistrationMutatorMustBeApplied(string name)
+ {
+ const string arg1 = nameof(arg1);
+ const string arg2 = nameof(arg2);
+
+ var containerBuilder = new ContainerBuilder();
+ var mutator = new FooMutator();
+
+ containerBuilder.RegisterType<FooInterceptor>().AsSelf();
+ containerBuilder.RegisterLazy(typeof(IService1), typeof(Service1), name, mutator);
+ containerBuilder.RegisterType<Service2>().As<IService2>();
+
+ using (var container = containerBuilder.Build())
+ {
+ var service = name == null
+ ? container.Resolve<IService1>()
+ : container.ResolveNamed<IService1>(name);
+
+ var result = service.Method(s => s.Method(arg1), arg2);
+
+ Assert.Equal(
+ $"{Service1MethodValue}{Service2MethodValue}{arg1}{arg2}" +
+ $"{FooInterceptor.InterceptionSuffix}",
+ result);
+ }
+ }
+
  #region Lifetime tests
 
  [Theory]
@@ -557,6 +590,29 @@ private static void AssertAllInstancesAreDifferent(params Guid[] keys) =>
 
  #endregion
 
+ #region Private members for mutator testing
+
+ private class FooMutator : IRegistrationMutator
+ {
+ public IRegistrationBuilder<TLimit, TActivatorData, TRegistrationStyle>
+ Mutate<TLimit, TActivatorData, TRegistrationStyle>(
+ IRegistrationBuilder<TLimit, TActivatorData, TRegistrationStyle> registration) =>
+ registration.EnableInterfaceInterceptors().InterceptedBy(typeof(FooInterceptor));
+ }
+
+ private class FooInterceptor : IInterceptor
+ {
+ public const string InterceptionSuffix = "Intercepted";
+
+ public void Intercept(IInvocation invocation)
+ {
+ invocation.Proceed();
+ invocation.ReturnValue = (string) invocation.ReturnValue + InterceptionSuffix;
+ }
+ }
+
+ #endregion
+
  #region Test classes
 
  public interface IHasId

LazyProxy.Autofac.Tests/LazyProxy.Autofac.Tests.csproj

@@ -6,6 +6,7 @@
  </PropertyGroup>
 
  <ItemGroup>
+ <PackageReference Include="Autofac.Extras.DynamicProxy" Version="4.5.0" />
  <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.6.0" />
  <PackageReference Include="Moq" Version="4.9.0" />
  <PackageReference Include="xunit" Version="2.3.1" />

LazyProxy.Autofac/AutofacExtensions.cs

@@ -59,9 +59,11 @@ public static IRegistrationBuilder<object, SimpleActivatorData, SingleRegistrati
  /// <param name="typeTo">The linked class.</param>
  /// <param name="builder">The instance of the Autofac container builder.</param>
  /// <param name="name">The registration name. Null if named registration is not required.</param>
+ /// <param name="nonLazyRegistrationMutator">A mutator allowing to change the non-lazy registration.</param>
  /// <returns>The instance of the Autofac registration builder.</returns>
  public static IRegistrationBuilder<object, SimpleActivatorData, SingleRegistrationStyle>
- RegisterLazy(this ContainerBuilder builder, Type typeFrom, Type typeTo, string name)
+ RegisterLazy(this ContainerBuilder builder, Type typeFrom, Type typeTo, string name,
+ IRegistrationMutator nonLazyRegistrationMutator = null)
  {
  // There is no way to constraint it on the compilation step.
  if (!typeFrom.IsInterface)
@@ -75,11 +77,13 @@ public static IRegistrationBuilder<object, SimpleActivatorData, SingleRegistrati
 
  if (typeTo.IsGenericTypeDefinition)
  {
- builder.RegisterGeneric(typeTo).Named(registrationName, typeFrom);
+ var nonLazyRegistration = builder.RegisterGeneric(typeTo).Named(registrationName, typeFrom);
+ nonLazyRegistrationMutator?.Mutate(nonLazyRegistration);
  }
  else
  {
- builder.RegisterType(typeTo).Named(registrationName, typeFrom);
+ var nonLazyRegistration = builder.RegisterType(typeTo).Named(registrationName, typeFrom);
+ nonLazyRegistrationMutator?.Mutate(nonLazyRegistration);
  }
 
  var registration = builder.Register((c, p) =>

LazyProxy.Autofac/IRegistrationMutator.cs

@@ -0,0 +1,23 @@
+using Autofac.Builder;
+
+namespace LazyProxy.Autofac
+{
+ /// <summary>
+ /// A mutator allowing to change a registration.
+ /// </summary>
+ public interface IRegistrationMutator
+ {
+ /// <summary>
+ /// Changes or adjusts the registration status.
+ /// </summary>
+ /// <param name="registration">A container registration.</param>
+ /// <typeparam name="TLimit">The most specific type to which instances of the registration
+ /// can be cast.</typeparam>
+ /// <typeparam name="TActivatorData">Activator builder type.</typeparam>
+ /// <typeparam name="TRegistrationStyle">Registration style type.</typeparam>
+ /// <returns></returns>
+ IRegistrationBuilder<TLimit, TActivatorData, TRegistrationStyle>
+ Mutate<TLimit, TActivatorData, TRegistrationStyle>(
+ IRegistrationBuilder<TLimit, TActivatorData, TRegistrationStyle> registration);
+ }
+}