static public ContainerBuilder AddAutofaqDiagnostics(this ContainerBuilder autofaqBuilder)
{
if (!EnableDiagnostics)
{
return(autofaqBuilder);
}
var tracer = new DefaultDiagnosticTracer(); //0
tracer.OperationCompleted += (_, args) => { Console.WriteLine(args.TraceContent); };
autofaqBuilder.RegisterBuildCallback(lifetimeScope =>
{
var container = (IContainer)lifetimeScope;
container.SubscribeToDiagnostics(tracer);
});
return(autofaqBuilder);
//0 Add any Autofac modules or registrations This is called AFTER ConfigureServices so things we
// register here OVERRIDE things registered in ConfigureServices
//
// We must have the call to UseServiceProviderFactory(new AutofacServiceProviderFactory())
// when building the host or this wont be called
//
// Diagnostics get printed via a build callback Diagnostics arent free so we shouldnt just do this
// by default
//
// Note since we are diagnosing the container we cant ALSO resolve the logger to which the diagnostics
// get written so writing directly to the log destination is the way to go
}
public void DiagnosticTracerHandlesDecorators()
{
var tracer = new DefaultDiagnosticTracer();
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterType <Implementor>().As <IService>();
containerBuilder.RegisterDecorator <Decorator, IService>();
var container = containerBuilder.Build();
container.SubscribeToDiagnostics(tracer);
string lastOpResult = null;
tracer.OperationCompleted += (sender, args) =>
{
Assert.Same(tracer, sender);
lastOpResult = args.TraceContent;
};
container.Resolve <IService>();
Assert.Contains("Decorator", lastOpResult);
}
public void TypeAsInstancePerScope()
{
var builder = new ContainerBuilder();
builder.RegisterType <A>().InstancePerLifetimeScope();
var container = builder.Build();
var lifetime = container.BeginLifetimeScope();
var tracer = new DefaultDiagnosticTracer();
tracer.OperationCompleted += (sender, args) =>
{
_output.WriteLine(args.TraceContent);
};
container.SubscribeToDiagnostics(tracer);
var ctxA = lifetime.Resolve <A>();
var ctxA2 = lifetime.Resolve <A>();
Assert.Same(ctxA, ctxA2);
var targetA = container.Resolve <A>();
var targetA2 = container.Resolve <A>();
Assert.Same(targetA, targetA2);
Assert.NotSame(ctxA, targetA);
}
public void DiagnosticTracerRaisesEventsOnError()
{
var tracer = new DefaultDiagnosticTracer();
var containerBuilder = new ContainerBuilder();
containerBuilder.Register <string>(ctxt => throw new InvalidOperationException());
var container = containerBuilder.Build();
container.SubscribeToDiagnostics(tracer);
string lastOpResult = null;
tracer.OperationCompleted += (sender, args) =>
{
Assert.Same(tracer, sender);
lastOpResult = args.TraceContent;
Assert.False(args.OperationSucceeded);
};
try
{
container.Resolve <string>();
}
catch
{
}
Assert.Contains(nameof(InvalidOperationException), lastOpResult);
}
public void DiagnosticTracerRaisesEvents()
{
var tracer = new DefaultDiagnosticTracer();
var containerBuilder = new ContainerBuilder();
containerBuilder.Register(ctxt => "Hello");
var container = containerBuilder.Build();
container.SubscribeToDiagnostics(tracer);
string lastOpResult = null;
tracer.OperationCompleted += (sender, args) =>
{
Assert.Same(tracer, sender);
lastOpResult = args.TraceContent;
Assert.True(args.OperationSucceeded);
};
container.Resolve <string>();
Assert.Contains("Hello", lastOpResult);
}
public void DecoratedInstancePerDependencyRegistrationCanIncludeOtherServices()
{
var builder = new ContainerBuilder();
builder.RegisterGeneric(typeof(ImplementorA <>)).As(typeof(IDecoratedService <>)).As(typeof(IService <>));
builder.RegisterGenericDecorator(typeof(DecoratorA <>), typeof(IDecoratedService <>));
builder.RegisterGenericDecorator(typeof(DecoratorA <>), typeof(IService <>));
var container = builder.Build();
var tracer = new DefaultDiagnosticTracer();
container.SubscribeToDiagnostics(tracer);
tracer.OperationCompleted += (sender, args) =>
{
_outputHelper.WriteLine(args.TraceContent);
};
var serviceRegistration = container.RegistrationFor <IService <int> >();
var decoratedServiceRegistration = container.RegistrationFor <IDecoratedService <int> >();
Assert.NotNull(serviceRegistration);
Assert.NotNull(decoratedServiceRegistration);
Assert.Same(serviceRegistration, decoratedServiceRegistration);
var serviceInstance = container.Resolve <IService <int> >();
Assert.IsType <DecoratorA <int> >(serviceInstance);
var decoratedServiceInstance = container.Resolve <IDecoratedService <int> >();
Assert.IsType <DecoratorA <int> >(decoratedServiceInstance);
Assert.NotSame(serviceInstance, decoratedServiceInstance);
}
public void ConfigureContainer(ContainerBuilder builder)
{
var resolveOperationTracer = new DefaultDiagnosticTracer();
resolveOperationTracer.OperationCompleted += (sender, args) =>
{
// HERE
// this will try to resolve IHttpContextAccessor
LogManager.GetLogger(nameof(DefaultDiagnosticTracer)).Info(args.TraceContent);
};
builder.RegisterBuildCallback(c =>
{
var container = c as IContainer;
container.SubscribeToDiagnostics(resolveOperationTracer);
});
}
public void DiagnosticTracerDoesNotLeakMemory()
{
var tracer = new DefaultDiagnosticTracer();
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterType <Implementor>().As <IService>();
containerBuilder.RegisterDecorator <Decorator, IService>();
var container = containerBuilder.Build();
container.SubscribeToDiagnostics(tracer);
container.Resolve <IService>();
// The dictionary of tracked operations and
// string builders should be empty.
Assert.Equal(0, tracer.OperationsInProgress);
}
public void InstancePerDependencyDoesNotAllowCircularDependencies_PropertyOwnerResolved_WithTracerAttached()
{
var cb = new ContainerBuilder();
cb.RegisterType <DependsByCtor>();
cb.RegisterType <DependsByProp>().PropertiesAutowired(PropertyWiringOptions.AllowCircularDependencies);
var c = cb.Build();
string capturedTrace = null;
var tracer = new DefaultDiagnosticTracer();
tracer.OperationCompleted += (sender, args) =>
{
capturedTrace = args.TraceContent;
_output.WriteLine(capturedTrace);
};
c.SubscribeToDiagnostics(tracer);
Assert.Throws <DependencyResolutionException>(() => c.Resolve <DependsByProp>());
Assert.NotNull(capturedTrace);
}
public void DecoratedInstancePerLifetimeScopeRegistrationCanIncludeOtherServices()
{
var builder = new ContainerBuilder();
// #963: The InstancePerLifetimeScope here is important - a single component may expose multiple services.
// If that component is decorated, the decorator ALSO needs to expose all of those services.
builder.RegisterGeneric(typeof(ImplementorA <>)).As(typeof(IDecoratedService <>)).As(typeof(IService <>)).InstancePerLifetimeScope();
builder.RegisterGenericDecorator(typeof(DecoratorA <>), typeof(IDecoratedService <>));
var container = builder.Build();
var tracer = new DefaultDiagnosticTracer();
container.SubscribeToDiagnostics(tracer);
tracer.OperationCompleted += (sender, args) =>
{
_outputHelper.WriteLine(args.TraceContent);
};
var serviceRegistration = container.RegistrationFor <IService <int> >();
var decoratedServiceRegistration = container.RegistrationFor <IDecoratedService <int> >();
Assert.NotNull(serviceRegistration);
Assert.NotNull(decoratedServiceRegistration);
Assert.Same(serviceRegistration, decoratedServiceRegistration);
var serviceInstance = container.Resolve <IService <int> >();
Assert.IsType <ImplementorA <int> >(serviceInstance);
var decoratedServiceInstance = container.Resolve <IDecoratedService <int> >();
Assert.IsType <DecoratorA <int> >(decoratedServiceInstance);
Assert.Same(serviceInstance, decoratedServiceInstance.Decorated);
}
