ParentHandlerWrapper
using Castle.Core;
using Castle.MicroKernel.Context;
using System;
namespace Castle.MicroKernel.Handlers
{
public class ParentHandlerWrapper : IHandler, ISubDependencyResolver, IDisposable
{
private readonly ISubDependencyResolver childResolver;
private readonly IReleasePolicy parentReleasePolicy;
private readonly IHandler parentHandler;
public virtual ComponentModel ComponentModel => parentHandler.ComponentModel;
public virtual HandlerState CurrentState => parentHandler.CurrentState;
public ParentHandlerWrapper(IHandler parentHandler, ISubDependencyResolver childResolver, IReleasePolicy parentReleasePolicy)
{
if (parentHandler == null)
throw new ArgumentNullException("parentHandler");
if (childResolver == null)
throw new ArgumentNullException("childResolver");
this.parentHandler = parentHandler;
this.childResolver = childResolver;
this.parentReleasePolicy = parentReleasePolicy;
}
public void Dispose()
{
Dispose(true);
}
public virtual void Init(IKernelInternal kernel)
{
}
public bool IsBeingResolvedInContext(CreationContext context)
{
if (context == null || !context.IsInResolutionContext(this))
return parentHandler.IsBeingResolvedInContext(context);
return true;
}
public virtual bool Release(Burden burden)
{
return parentHandler.Release(burden);
}
public virtual object Resolve(CreationContext context)
{
IReleasePolicy releasePolicy = null;
try {
releasePolicy = context.ReleasePolicy;
context.ReleasePolicy = parentReleasePolicy;
return parentHandler.Resolve(context);
} finally {
context.ReleasePolicy = releasePolicy;
}
}
public bool Supports(Type service)
{
return parentHandler.Supports(service);
}
public bool SupportsAssignable(Type service)
{
return parentHandler.SupportsAssignable(service);
}
public object TryResolve(CreationContext context)
{
IReleasePolicy releasePolicy = null;
try {
releasePolicy = context.ReleasePolicy;
context.ReleasePolicy = parentReleasePolicy;
return parentHandler.TryResolve(context);
} finally {
context.ReleasePolicy = releasePolicy;
}
}
public virtual bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
bool flag = false;
if (contextHandlerResolver != null)
flag = childResolver.CanResolve(context, null, model, dependency);
if (!flag)
flag = parentHandler.CanResolve(context, contextHandlerResolver, model, dependency);
return flag;
}
public virtual object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
object obj = childResolver.Resolve(context, null, model, dependency);
if (obj == null)
obj = parentHandler.Resolve(context, contextHandlerResolver, model, dependency);
return obj;
}
protected virtual void Dispose(bool disposing)
{
if (disposing) {
IHandler parentHandler2 = parentHandler;
}
}
}
}