public void TestInitialize()
{
windsorContainer = new WindsorContainer()
.AddFacility <WcfFacility>(f => f.CloseTimeout = TimeSpan.Zero)
.Register(
Component.For <ServiceHostListener>(),
Component.For <LoggingInterceptor>(),
Component.For <CallCountServiceBehavior>(),
Component.For <UnitOfworkEndPointBehavior>(),
Component.For <NetDataContractFormatBehavior>(),
Component.For <IOperations>().ImplementedBy <Operations>()
.Named("Operations")
.Interceptors(InterceptorReference.ForType <LoggingInterceptor>()).Anywhere
.DependsOn(new { number = 42 })
.AsWcfService(new DefaultServiceModel().AddEndpoints(
WcfEndpoint.BoundTo(new NetTcpBinding {
PortSharingEnabled = true
})
.At("net.tcp://localhost/Operations")
)
)
);
LoggingInterceptor.Calls.Clear();
CallCountServiceBehavior.CallCount = 0;
client = ChannelFactory <IOperations> .CreateChannel(
new NetTcpBinding { PortSharingEnabled = true }, new EndpointAddress("net.tcp://localhost/Operations"));
}
public void SetUp()
{
windsorContainer = new WindsorContainer()
.AddFacility <WcfFacility>(f => f.CloseTimeout = TimeSpan.Zero)
.Register(
Component.For <ServiceHostListener>(),
Component.For <CollectingInterceptor>(),
Component.For <UnitOfworkEndPointBehavior>(),
Component.For <NetDataContractFormatBehavior>(),
Component.For <IOne>().ImplementedBy <One>().LifeStyle.PerWcfSession()
.Interceptors(InterceptorReference.ForType <CollectingInterceptor>()).Anywhere,
Component.For <ITwo>().ImplementedBy <Two>().LifestylePerWcfSession()
.Interceptors(InterceptorReference.ForType <CollectingInterceptor>()).Anywhere,
Component.For <IServiceWithSession>().ImplementedBy <ServiceWithSession>().LifeStyle.Transient
.Named("Operations")
.AsWcfService(new DefaultServiceModel().AddEndpoints(
WcfEndpoint.BoundTo(new NetTcpBinding {
PortSharingEnabled = true
})
.At("net.tcp://localhost/Operations")
)
)
);
client = CreateClient();
}
public void ProcessModel(IKernel kernel, ComponentModel model)
{
if (model.Services.Any(s => s == typeof(IEventAppService)))
{
model.Interceptors.Add(InterceptorReference.ForType <MongoEventInterceptor>());
}
}
public void Register(IKernelInternal kernel)
{
// 1. Interceptor Registration
kernel.Register(
Component.For <LoggingInterceptor>()
.ImplementedBy <LoggingInterceptor>());
// Another Interceptor registration.
//kernel.Register(
// Component.For<AnotherInterceptor>()
// .ImplementedBy<AnotherInterceptor>());
// 2. Interceptor attached with Example Class.
kernel.Register(
Component.For <IExample>()
.ImplementedBy <Example>()
.Interceptors(InterceptorReference.ForType <LoggingInterceptor>()).Anywhere);
// Mutiple Interceptors for the same class can be registered with one line as below.
//kernel.Register(
// Component.For<IExample>()
// .ImplementedBy<Example>()
// .Interceptors(new InterceptorReference[] {
// InterceptorReference.ForType<LoggingInterceptor>(),
// InterceptorReference.ForType<AnotherInterceptor>()
// }).Anywhere);
}
public void ProcessModel(IKernel kernel, ComponentModel model)
{
if (model.Services.Any(s => s == typeof(IServiceDependency)))
{
model.Interceptors.Add(InterceptorReference.ForType <UoWInterceptor>());
}
}
static void Main(string[] args)
{
IWindsorContainer container = new WindsorContainer();
container.Register(Component.For(typeof(WcfProxyInterceptor <IService1>)));
container.Register(Component.For(typeof(IFoo)).ImplementedBy(typeof(Foo)));
container.Register(Component.For(typeof(IBar)).ImplementedBy(typeof(Bar)));
container.Register(Component.For <IService1>().Interceptors(InterceptorReference.ForType <WcfProxyInterceptor <IService1> >()).Anywhere);
var test = (IFoo)container.Resolve(typeof(IFoo));
test.Do();
test.Do();
test.Do();
test.Do();
test.Do();
var testBar = (IBar)container.Resolve(typeof(IBar));
testBar.Do();
Console.ReadLine();
}
public void Setup()
{
var supplier = TestSupplier.CreateNaked(session);
supplier.CreateSampleCore(session);
client = TestClient.CreateNaked(session);
address = client.CreateAddress();
user = client.Users.First();
session.Save(address);
ServiceContext.GetUserName = () => user.Login;
var container = new WindsorContainer();
container.AddComponent("RepositoryInterceptor", typeof(RepositoryInterceptor));
container.AddComponent("OfferRepository", typeof(IOfferRepository), typeof(OfferRepository));
container.AddComponent("Repository", typeof(IRepository <>), typeof(Repository <>));
var holder = new SessionFactoryHolder();
holder
.Configuration
.AddInputStream(HbmSerializer.Default.Serialize(Assembly.Load("Common.Models")));
container.Kernel.AddComponentInstance <ISessionFactoryHolder>(holder);
IoC.Initialize(container);
IoC.Container.Register(
Component.For <IInforoomOnlineService>()
.ImplementedBy <InforoomOnlineService>()
.Interceptors(InterceptorReference.ForType <ContextLoaderInterceptor>())
.Anywhere,
Component.For <ContextLoaderInterceptor>(),
Component.For <IClientLoader>().ImplementedBy <ClientLoader>());
service = IoC.Resolve <IInforoomOnlineService>();
}
public void ApplyInterceptor(ComponentModel model)
{
if (!model.HasInterceptors && CanIntercept(model).Any())
{
Validate(model);
model.Interceptors.AddIfNotInCollection(InterceptorReference.ForType(typeof(TInterceptor)));
}
}
public override IEnumerable <InterceptorReference> GetExpectedInterceptorsInCorrectOrder()
{
yield return(InterceptorReference.ForType <TestInterceptor1>());
yield return(InterceptorReference.ForType <TestInterceptor2>());
yield return(InterceptorReference.ForType <TestInterceptor3>());
}
public void RegisterServices()
{
_container.Register(Classes.FromAssembly(typeof(IBlogPostService).Assembly)
.Where(type => type.Name.EndsWith("Service"))
.WithServiceDefaultInterfaces()
.Configure(g => g.Interceptors(InterceptorReference.ForType <UnitOfWorkInterceptor>())
.First.LifestyleTransient())
.LifestyleTransient());
}
public void Apply(Component component, ComponentRegistration registration)
{
AbstractConfigurationRunner.Kernel.Register(
Castle.MicroKernel.Registration.Component.For(interceptorType).OnlyNewServices()
);
registration.Interceptors(InterceptorReference.ForType(interceptorType)).First
.OverWrite();
}
public void ProcessModel(IKernel kernel, ComponentModel model)
{
var cachedMethods = model.Implementation.GetMethods().Where(m => AttributesUtil.GetAttribute <LoggingAttribute>(m) != null).ToList();
if (cachedMethods.Any())
{
model.Interceptors.AddIfNotInCollection(InterceptorReference.ForType <LoggingInterceptor>());
}
}
public void Register(IKernelInternal kernel)
{
kernel.Register(Component.For <LoggingInterceptor>().ImplementedBy <LoggingInterceptor>());
kernel.Register(
Component.For <ITask>().ImplementedBy <Task>().Interceptors(
InterceptorReference.ForType <LoggingInterceptor>()).Anywhere);
//Anywhere tells the registration process that this interceptor could be attached anywhere.
}
public override void Initialize()
{
this.Container.RegisterIfNot <DomainServiceInterceptor>(DependencyLifeStyle.Transient);
this.Container.RegisterAssembly <IDomainService>(Assembly.GetAssembly(this.GetType()), configurer =>
{
_ = configurer.Named(configurer.Implementation.Name);
_ = configurer.Interceptors(InterceptorReference.ForType <DomainServiceInterceptor>()).Anywhere;
});
}
private void Kernel_ComponentModelCreated(ComponentModel model)
{
var aspectValidator = new AspectValidatorBuilder(_aspectConfiguration).Build();
if (aspectValidator.Validate(model.Implementation, false) || model.Services.Any(x => aspectValidator.Validate(x, true)))
{
model.Interceptors.AddIfNotInCollection(InterceptorReference.ForType <AspectCoreInterceptor>());
}
}
public void should_be_able_to_show_that_interceptor_was_called_when_wcf_service_is_invoked()
{
ServiceDebugBehavior returnFaults = new ServiceDebugBehavior();
returnFaults.IncludeExceptionDetailInFaults = true;
returnFaults.HttpHelpPageEnabled = true;
ServiceMetadataBehavior metadata = new ServiceMetadataBehavior();
metadata.HttpGetEnabled = true;
using (
new WindsorContainer()
.AddFacility <WcfFacility>(f => f.CloseTimeout = TimeSpan.Zero)
.Register(
Component.For <TestInterceptor>(), // The interceptor must be registered like this.
Component.For <IServiceBehavior>().Instance(returnFaults),
Component.For <IServiceBehavior>().Instance(metadata),
Component
.For <IOperations>()
.ImplementedBy <Operations>()
.Interceptors(InterceptorReference.ForType <TestInterceptor>()).Anywhere // Don't care what order this is called in (and there is only one interceptor on this any case).
.DependsOn(new { value = Expected }) // Notice how this constant is injected in to the service.
.AsWcfService(
new DefaultServiceModel()
//.OpenEagerly() // This is useful to force immediate creation of services and to see any errors that may result.
.AddBaseAddresses(BaseAddress)
.AddEndpoints(
WcfEndpoint
.ForContract <IOperations>()
.BoundTo(new WSHttpBinding())
.At(RelativeAddress)
)
)))
{
// This sleep is useful if/when you'd like to browse to http://localhost:8000/Operations.svc
// to verify that meta-data is being published for this service.
//Thread.Sleep(100000);
// Notice that we're using the standard WCF channel factory here,
// rather than the castle proxies.
IOperations client = ChannelFactory <IOperations> .CreateChannel(
new WSHttpBinding(),
new EndpointAddress(BaseAddress + "/" + RelativeAddress)
);
int result = client.GetValueFromConstructor();
Assert.AreEqual(Expected, result);
Assert.That(TestInterceptor.mostRecentMethodCallIntercepoted, Is.EqualTo("GetValueFromConstructor"));
}
}
public void Register(IKernelInternal kernel)
{
kernel.Register(
Component.For <MethodLoggerInterceptor>()
.ImplementedBy <MethodLoggerInterceptor>());
kernel.Register(
Component.For <IPdfDocumentBuilder>()
.ImplementedBy <PdfDocumentBuilder>()
.Interceptors(InterceptorReference.ForType <MethodLoggerInterceptor>()).Anywhere);
}
public void ProcessModel(IKernel kernel, ComponentModel model)
{
var cachedMethods = model.Implementation.GetMethods().Where(m => m.GetAttribute <CachedAttribute>() != null).ToList();
if (cachedMethods.Any())
{
cachedMethods.CheckThatMethodsAreVirtual();
model.Interceptors.AddIfNotInCollection(InterceptorReference.ForType <CacheInterceptor>());
}
}
protected override void Init()
{
Kernel.Register(Component.For <ProfilingInterceptor>().LifeStyle.PerThread);
Kernel.ComponentModelCreated += model => {
if (model.Implementation != typeof(ProfilingInterceptor))
{
model.Interceptors.AddFirst(InterceptorReference.ForType <ProfilingInterceptor>());
}
};
}
private void Kernel_ComponentModelCreated(ComponentModel model)
{
if (
!(model.Implementation.GetProperties()
.Any(prop => prop.PropertyType.GetInterfaces().Contains(typeof(ILogger))) ||
model.Implementation.GetFields()
.Any(l => l.FieldType.GetInterfaces().Contains(typeof(ILogger)))))
{
model.Interceptors.AddIfNotInCollection(InterceptorReference.ForType <AspectLogger>());
}
}
public void Register(IKernelInternal kernel)
{
kernel.Register(
Component.For <LoggingInterceptor>()
.ImplementedBy <LoggingInterceptor>());
kernel.Register(
Component.For <IRocket>()
.ImplementedBy <Rocket>()
.Interceptors(InterceptorReference.ForType <LoggingInterceptor>()).Anywhere);
}
public void Register(IKernelInternal kernel)
{
kernel.Register(
Component.For <IInterceptor>()
.ImplementedBy <ServiceInterceptor>());
kernel.Register(
Component.For <IDemoService>()
.ImplementedBy <DemoService>()
.Interceptors(InterceptorReference.ForType <ServiceInterceptor>()).Anywhere);
}
public void Install(Castle.Windsor.IWindsorContainer container, Castle.MicroKernel.SubSystems.Configuration.IConfigurationStore store)
{
//container.Register(Component.For<ErrorHandlingInterceptor>().LifestyleTransient());
//container.Register(Component.For<DbEntityValidationExceptionInterceptor>().LifestyleTransient());
container.Register(Classes.FromThisAssembly()
.BasedOn <IRepository>()
.WithService.FromInterface() // registers all class whose interfaces extended IService
.Configure(cc => cc.Interceptors(InterceptorReference.ForType <ErrorHandlingInterceptor>()).AtIndex(0).Configuration()
.Interceptors(InterceptorReference.ForType <DbEntityValidationExceptionInterceptor>()).AtIndex(1).Configuration()));
}
public void Register(IKernelInternal kernel)
{
kernel.Register(
Component.For <TestInterceptor>()
.ImplementedBy <TestInterceptor>());
kernel.Register(
Component.For <OrderLogic>()
.ImplementedBy <OrderLogic>()
.Interceptors(InterceptorReference.ForType <TestInterceptor>()).Anywhere);
}
public void Register(IKernelInternal kernel)
{
kernel.Register(
Component.For <StudentInterceptor>()
.ImplementedBy <StudentInterceptor>());
kernel.Register(
Component.For <IStudent>()
.ImplementedBy <Student>()
.Interceptors(InterceptorReference.ForType <StudentInterceptor>()).Anywhere);
}
public InterceptorReference[] SelectInterceptors(Castle.Core.ComponentModel model, Castle.Core.InterceptorReference[] interceptors)
{
var intercept = new List <InterceptorReference>();
String enableInstrumentation = ConfigurationManager.AppSettings["EnableInstrumentation"];
if (String.IsNullOrEmpty(enableInstrumentation) != true &&
Convert.ToBoolean(enableInstrumentation, CultureInfo.InvariantCulture))
{
intercept.Add(InterceptorReference.ForType <LoggingInterceptor>());
}
return(intercept.Concat(interceptors).ToArray());
}
public void AutomaticallyOmitTarget()
{
container.Register(
Component.For <ICalcService>()
.Interceptors(InterceptorReference.ForType <ReturnDefaultInterceptor>()).Last,
Component.For <ReturnDefaultInterceptor>()
);
var calcService = container.Resolve <ICalcService>();
Assert.AreEqual(0, calcService.Sum(1, 2));
}
public static void Initialize()
{
Container=new WindsorContainer();
Container.Register(Component.For<IInterceptor>().ImplementedBy<OrderProcessorInterceptor>());
Container.Register(
Component.For<IOrderProcessor>()
.ImplementedBy<OrderProcessor>()
.Interceptors(InterceptorReference.ForType<OrderProcessorInterceptor>())
.Anywhere);
}
public InterceptorReference[] SelectInterceptors(ComponentModel model, InterceptorReference[] interceptors)
{
ServiceAspectRegistry serviceAspectRegistry = new ServiceAspectRegistry();
serviceAspectApplier.Apply(model, serviceAspectRegistry);
InterceptorReference[] interceptorReferences = serviceAspectRegistry.Aspects
.Select(serviceAspect => InterceptorReference.ForType(serviceAspect))
.ToArray();
return(interceptorReferences);
}
protected void InitializeIOC(string[] args)
{
_logger.Debug("Attempting to initialize IOC container.");
_container = new WindsorContainer(new XmlInterpreter());
_container.Register(
Component.For(typeof(Repository)).Forward <IRepository>().ImplementedBy <Repository>().
Interceptors(InterceptorReference.ForType <LockInterceptor>()
//,InterceptorReference.ForType<TransactionInterceptor>()
).Anywhere
);
_container.Kernel.AddComponentInstance("nhFactory", typeof(ISessionFactory), build_session_factory());
infrastructure.containers.Container.initialize_with(new infrastructure.containers.custom.WindsorContainer(_container));
}
