private void SetInterceptionBehaviorFor(Type typeToIntercept, Type typeOfInstance, string name)
{
if (!AllMatchingRulesApply(typeToIntercept, typeOfInstance))
{
return;
}
if (!TypeIsInterface(typeToIntercept))
{
return;
}
if (_interceptor.CanIntercept(typeOfInstance))
{
Container.Configure <unity.Interception>().SetDefaultInterceptorFor(typeOfInstance, _interceptor);
}
else if (_interceptor.CanIntercept(typeToIntercept))
{
Container.Configure <unity.Interception>().SetDefaultInterceptorFor(typeToIntercept, _interceptor);
}
_behaviors.ForEach(b =>
{
var interceptionBehavior = new InterceptionBehavior(b);
interceptionBehavior.AddPolicies(typeToIntercept, typeOfInstance, name, Context.Policies);
});
}
public static void Main(string[] args)
{
var container = new UnityContainer();
container.AddNewExtension <NotifyPropertyChangedExt>();
container.AddNewExtension <Interception>();
var interceptor = new Interceptor <InterfaceInterceptor>();
var interceptionBehavior = new InterceptionBehavior <NotifyPropertyChangedBehavior>();
container.RegisterType <IViewModel, ViewModel>(interceptor, interceptionBehavior);
var viewModel = container.Resolve <IViewModel>();
viewModel.HookPropertyChanged((s, e) =>
{
Console.WriteLine("This is called because the PropertyChanged event handler is attached from out side of the ViewModel");
});
viewModel.Name = "1";
var autoViewModel = container.Resolve <AutoViewModel>();
autoViewModel.HookPropertyChanged((s, e) =>
{
Console.WriteLine("This is called");
});
autoViewModel.Name = "1";
}
public override void PreBuildUp(IBuilderContext context)
{
Guard.ArgumentNotNull(context, "context");
if (!this.CanIntercept(context))
{
return;
}
IInstanceInterceptionPolicy interceptionPolicy = FindInterceptionPolicy <IInstanceInterceptionPolicy>(context, true);
if (null == interceptionPolicy)
{
IInstanceInterceptor interceptor = context.NewBuildUp <IInterceptor>(typeof(IInterceptor).AssemblyQualifiedName) as IInstanceInterceptor;
if (null == interceptor)
{
return;
}
if (!interceptor.CanIntercept(context.BuildKey.Type))
{
return;
}
context.Policies.Set <IInstanceInterceptionPolicy>(new FixedInstanceInterceptionPolicy(interceptor), context.BuildKey);
context.Policies.Clear <ITypeInterceptionPolicy>(context.BuildKey);
}
IInterceptionBehaviorsPolicy interceptionBehaviorsPolicy = FindInterceptionPolicy <IInterceptionBehaviorsPolicy>(context, true);
if (null == interceptionBehaviorsPolicy)
{
var policyInjectionBehavior = new InterceptionBehavior <PolicyInjectionBehavior>();
policyInjectionBehavior.AddPolicies(context.OriginalBuildKey.Type, context.BuildKey.Type, context.BuildKey.Name, context.Policies);
}
}
public IUnityContainer GetInstance()
{
UnityContainer container = new UnityContainer();
container.AddNewExtension <Interception>();
Interceptor interceptor = new Interceptor(new InterfaceInterceptor());
InterceptionBehavior interceptionBehavior = CreateInterceptionBehavior();
// Envios
container.RegisterType <IEnvioRepository, EnvioRepository>(interceptor, interceptionBehavior);
container.RegisterType <IEnvioService, EnvioService>(interceptor, interceptionBehavior);
// Paquetes
container.RegisterType <IPaqueteRepository, PaqueteRepository>(interceptor, interceptionBehavior);
container.RegisterType <IPaqueteService, PaqueteService>(interceptor, interceptionBehavior);
// Conversores
PaqueteConversor paqueteConversor = new PaqueteConversor();
EnvioConversor envioConversor = new EnvioConversor(paqueteConversor);
container.RegisterInstance(typeof(PaqueteConversor), paqueteConversor);
container.RegisterInstance(typeof(EnvioConversor), envioConversor);
// dbFactory
container.RegisterType <IPaqDBFactory, PaqDBFactory>();
return(container);
}
/// <summary>
/// Add policies to the <paramref name="policies"/> to configure the container with
/// an appropriate <see cref="IInstanceInterceptionPolicy"/>
/// </summary>
/// <param name="serviceType">Type of the interface being registered. This parameter is
/// ignored by this class.</param>
/// <param name="implementationType">Type to register.</param>
/// <param name="name">Name used to resolve the type object.</param>
/// <param name="policies">Policy list to add policies to.</param>
public override void AddPolicies(Type serviceType, Type implementationType, string name, IPolicyList policies)
{
var key = new NamedTypeBuildKey(implementationType);
policies.Set <IInstanceInterceptionPolicy>(new FixedInstanceInterceptionPolicy(Interceptor), key);
var piabInjectionMember = new InterceptionBehavior <PolicyInjectionBehavior>();
piabInjectionMember.AddPolicies(serviceType, implementationType, name, policies);
}
private static void InitialFactories()
{
var policy = new InterceptionBehavior <PolicyInjectionBehavior>();
var intercptor = new Interceptor <TransparentProxyInterceptor>();
var type = typeof(ServiceFactory);
Container.Current.RegisterType(
typeof(IServiceFactory),
type,
new ContainerControlledLifetimeManager(),
policy,
intercptor
);
}
public static IUnityContainer RegisterComponents()
{
var container = new UnityContainer();
container.AddNewExtension <Interception>();
var interceptor = new Interceptor <InterfaceInterceptor>();
var behaver = new InterceptionBehavior <LoggingInterceptionBehavior>();
container.RegisterType <DbContext, DatabaseContext>(new HierarchicalLifetimeManager());
container.RegisterType(typeof(IRepository <>), typeof(EfRepository <>));
return(container);
}
protected override void Initialize()
{
string loggerName = "liteLoggingBehavior";
var ii = new Interceptor <InterfaceInterceptor>();
var lb = new InterceptionBehavior <MethodInvokeLoggingBehavior>(loggerName);
var tb = new InterceptionBehavior <MethodIdentificationBehavior>();
if (!Container.IsRegistered <IUowFactory>())
{
Container
.RegisterType <IUowFactory, UowFactory>(new ContainerControlledLifetimeManager(), ii, lb);
}
if (!Container.IsRegistered <IDateProvider>())
{
Container
.RegisterType <IDateProvider, DateProvider>(new ContainerControlledLifetimeManager(), ii, lb);
}
if (!Container.IsRegistered <IUserApplicationRepository>())
{
Container.AddNewExtension <UserExtension>();
}
Container.RegisterFactory <IUnitOfWork>(c => c.Resolve <IUowFactory>().CreateUow(), FactoryLifetime.PerResolve);
Container
.AddNewExtension <Interception>()
.RegisterMethodInvokeLoggingBehavior(loggerName, "Debug")
.RegisterMethodIdentificationBehavior("pid")
.RegisterType <IApplicationService, ApplicationService>("applicationService", ii, lb)
.RegisterType <IApplicationService, UserValidationApplicationService>(
"userValidationApplicationService",
new InjectionConstructor(
new ResolvedParameter <IApplicationService>("applicationService"),
typeof(IUserContextRepository),
typeof(IUserApplicationRepository)
), ii, lb)
.RegisterType <IApplicationService, ManageDbConnectionApplicationService>(
new InjectionConstructor(
new ResolvedParameter <IApplicationService>("userValidationApplicationService"),
typeof(IUnitOfWork)
), ii, lb)
.RegisterType <IMapper <ApplicationListItemDbDto, ApplicationListItemDto>, ApplicationListItemDbDtoMapper>(new ContainerControlledLifetimeManager(), ii, lb)
.RegisterType <IApplicationRepository, ApplicationRepository>(ii, lb)
.RegisterType <IFileRepository, FileRepository>(ii, lb)
;
}
private void OnRegister(object sender, RegisterEventArgs e)
{
if (ShouldIntercept(e))
{
IUnityContainer container = sender as IUnityContainer;
var i = new Interceptor <InterfaceInterceptor>();
i.AddPolicies(e.TypeFrom, e.TypeTo, e.Name, Context.Policies);
behaviors.ForEach((b) =>
{
var ib = new InterceptionBehavior(b);
ib.AddPolicies(e.TypeFrom, e.TypeTo, e.Name, Context.Policies);
}
);
}
}
private InjectionMember[] GetInjectionMembers(IInterceptionBehavior[] interceptors)
{
InjectionMember[] injectionMember = null;
if (interceptors != null && interceptors.Length > 0)
{
injectionMember = new InjectionMember[interceptors.Length + 1];
injectionMember[0] = new Interceptor <VirtualMethodInterceptor>();
for (int i = 0; i < interceptors.Length; i++)
{
injectionMember[i + 1] = new InterceptionBehavior(interceptors[i]);
}
}
return(injectionMember);
}
private static void RegisterDependencies(IUnityContainer container)
{
var ii = new Interceptor <InterfaceInterceptor>();
var log = new InterceptionBehavior <MethodLogInterceptionBehavior>("log");
var pid = new InterceptionBehavior <MethodIdentityInterceptionBehavior>("pid");
container
.AddNewExtension <Interception>()
.RegisterMethodLogInterceptionBehavior <Log4netLogListenerFactory>("log", "Debug")
.RegisterMethodIdentityInterceptionBehavior <Log4netLogContext>("pid", "pid")
.RegisterType <IDemoApp, DemoApp>(ii, pid, log)
.RegisterType <IHelloWorldService, HelloWorldService>(ii, pid, log)
.RegisterType <IHelloService, HelloService>(ii, pid, log)
.RegisterType <IWorldService, WorldService>(ii, pid, log);
}
/// <summary>
/// The on register.
/// </summary>
/// <param name="sender">
/// The sender.
/// </param>
/// <param name="e">
/// The e.
/// </param>
private void OnRegister(object sender, RegisterEventArgs e)
{
if (this.InterceptionBehaviors != null && this.InterceptionBehaviors.Count > 0)
{
var container = sender as IUnityContainer;
if (e != null && e.TypeFrom != null && e.TypeFrom.IsInterface && !e.TypeFrom.IsAssignableFrom(typeof(ICallHandler)))
{
var interception = container.Configure <Interception>().SetInterceptorFor(e.TypeFrom, e.Name, new InterfaceInterceptor());
var behaviorsToAdd = this.InterceptionBehaviors.Where(b => b.ShouldIntercept(e));
foreach (var interceptConfig in behaviorsToAdd)
{
foreach (var interceptionBehavior in interceptConfig.InterceptionBehaviors)
{
var unityBehavior = new InterceptionBehavior(interceptionBehavior);
unityBehavior.AddPolicies(e.TypeFrom, e.TypeTo, e.Name, this.Context.Policies);
}
}
}
}
}
public static IUnityContainer RegisterComponents()
{
var container = new UnityContainer();
container.AddNewExtension <Interception>();
var interceptor = new Interceptor <InterfaceInterceptor>();
var behaver = new InterceptionBehavior <LoggingInterceptionBehavior>();
container.RegisterType <DbContext, DatabaseContext>(new HierarchicalLifetimeManager());
container.RegisterType <IdentityDbContext <ApplicationUser>, DatabaseContext>(new PerResolveLifetimeManager());
container.RegisterType(typeof(IRepository <>), typeof(EfRepository <>));
container.RegisterType <IInstitutionService, InstitutionService>(interceptor, behaver);
container.RegisterType <IHtmlContentService, HtmlContentService>(interceptor, behaver);
container.RegisterType <INotificationService, NotificationService>(interceptor, behaver);
container.RegisterType <IProposalService, ProposalService>(interceptor, behaver);
container.RegisterType <IApplicationAccountService, ApplicationAccountService>(interceptor, behaver);
container.RegisterType <INotificationService, NotificationService>(interceptor, behaver);
return(container);
}
