public void ActivatorScope_should_release_scoped_service_dependencies_when_disposed()
{
using (var container = new WindsorContainer())
{
ExampleDependency releasedDependency = null;
container.Register(
Component.For <JobWithScopedDependency>().LifestyleTransient(),
Component.For <ExampleDependency>()
.OnDestroy(x => { releasedDependency = x; })
.LifestyleScoped()
);
var activator = new WindsorJobActivator(container.Kernel);
using (var scope = activator.BeginScope(null))
{
// Resolve the new job
var job = scope.Resolve(typeof(JobWithScopedDependency)) as JobWithScopedDependency;
Assert.IsNotNull(job);
Assert.AreSame(job.Dependency, container.Resolve <ExampleDependency>(),
"assumed ExampleDependency has scoped lifestyle");
// sanity check
Assert.IsNull(releasedDependency);
}
Assert.IsNotNull(releasedDependency, "service was not released by container");
Assert.IsTrue(releasedDependency.IsDisposed, "service was not disposed");
}
}
public async Task Correctly_Resolves_TwoDeps()
{
// arrange
var dep = new ExampleDependency
{
Resolved = false
};
var services = new ServiceCollection();
services.AddSingleton(dep);
var pipelineBuilder = services.ConfigurePipelineFor <TestCtx>();
pipelineBuilder.Use <TestCtx, ExampleDependency, ExampleDependency>((_, dependency1, dependency2, next) =>
{
dependency1.Resolved = true;
Assert.AreSame(dependency1, dependency2);
return(next());
});
var sp = services.BuildServiceProvider();
var pipeline = sp.GetRequiredService <IPipeline <TestCtx> >();
// act
await pipeline.ExecuteAsync(new TestCtx());
// assert
Assert.IsTrue(dep.Resolved, "Dependency flag resolved is not true");
}
public void Experiment_windsor_scoped_service_registration()
{
using (var container = new WindsorContainer())
{
ExampleDependency releasedDependency = null;
container.Register(
Component.For <JobWithScopedDependency>().LifestyleTransient(),
Component.For <ExampleDependency>()
.OnDestroy(x => { releasedDependency = x; })
.LifestyleScoped()
);
using (container.BeginScope())
{
var job1 = container.Resolve <JobWithScopedDependency>();
var job2 = container.Resolve <JobWithScopedDependency>();
Assert.AreNotSame(job1, job2,
"assumed JobWithScopedDependency has transient lifestyle");
Assert.AreSame(job1.Dependency, job2.Dependency,
"assumed ExampleDependency has scoped lifestyle");
// sanity check
Assert.IsNull(releasedDependency);
}
Assert.IsNotNull(releasedDependency, "service was not released by container");
Assert.IsTrue(releasedDependency.IsDisposed, "service was not disposed");
}
}
public string UseJobsFromDependency(string sessionId)
{
// This uses a dependency on the other project (DependencyProject),
// but because DependencyProject is merged, MergedProject.dll has
// everything it needs to do this without the separate DependencyProject.dll.
var dependency = new ExampleDependency();
var jobs = dependency.GetSomeJobs(sessionId);
return($"Dependent dll function returned {jobs.JobCount.ToString()} jobs");
}
public void ExampleMethod()
{
try
{
}
finally
{
#pragma warning disable 219
ExampleDependency foo = null;
#pragma warning restore 219
}
}
public async Task Should_BeCorrect_PipelineExecutionOrder_WithDeps()
{
// arrange
var services = new ServiceCollection();
var dep = new ExampleDependency();
services.AddSingleton(dep);
var sp = services.BuildServiceProvider();
var pipelineBuilder = new PipelineBuilder <TestCtx>();
pipelineBuilder.Use <Middleware1>();
pipelineBuilder.Use <Middleware2>();
pipelineBuilder.Use <TestCtx, ExampleDependency>(async(ctx, deps, next) =>
{
ctx.ExecutedMiddlewaresCount++;
deps.Resolved = true;
ctx.Msg += "Before_LambdaMiddleware";
await next();
ctx.Msg += "After_LambdaMiddleware";
});
var pipeline = pipelineBuilder.Build(sp);
var testContext = new TestCtx();
Assert.IsFalse(dep.Resolved);
// act
await pipeline.ExecuteAsync(testContext);
// assert
Assert.IsTrue(dep.Resolved, "Dependency is not resolved");
}
public Func <object> ExampleMethod()
{
ExampleDependency test = null;
return(() => test);
}
public async Task ExampleMethod()
{
var test = new ExampleDependency();
await Task.CompletedTask;
}
private ConstructorPrivate()
{
var test = new ExampleDependency();
}
public ExampleAdapterB(ExampleDependency dependency, ExamplePortB port)
{
_dependnecy = dependency;
_value = port.Value;
}
public void Foo(out ExampleDependency example)
{
example = null;
}
#pragma warning disable 8321
static void LocalFunction()
{
var y = new ExampleDependency();
}
private void ExampleMethod()
{
var test = new ExampleDependency();
}
public void ExampleMethod()
{
var test = new ExampleDependency();
}
public void ExampleMethod()
{
object dep = new ExampleDependency();
}
public VariableGeneric()
{
#pragma warning disable 219
ExampleDependency <int> dependecy = null;
#pragma warning restore 219
}
public void Example()
{
var reference = new ExampleDependency();
}
private void ExampleMethod(ExampleDependency exampleDependency)
{
}
public Variable()
{
#pragma warning disable 219
ExampleDependency test = null;
#pragma warning restore 219
}
private static extern int MessageBox(ExampleDependency hWnd);
public PublicConstructor()
{
var test = new ExampleDependency();
}
public void Foo(ref ExampleDependency example)
{
}
