public void SetUp()
{
container = new WindsorContainer();
container.Register(Component.For<INHibernateInstaller>().ImplementedBy<ExampleInstaller>());
container.AddFacility<AutoTxFacility>();
container.AddFacility<NHibernateFacility>();
container.Register(Component.For<ThreadedService>().LifeStyle.Transient);
}
public WindsorContainer Configure()
{
var container = new WindsorContainer();
container.AddFacility<FactorySupportFacility>();
container.AddFacility<TransactionalFacility>();
container.AddFacility<StartableFacility>(f => f.DeferredStart());
container.Install(FromAssembly.This());
return container;
}
public void Should_override_DefaultConfigurationBuilder()
{
var container = new WindsorContainer();
container.AddFacility<AutoTxFacility>();
container.AddFacility<NHibernateFacility>(f => f.ConfigurationBuilder<DummyConfigurationBuilder>());
Assert.AreEqual(typeof(DummyConfigurationBuilder), container.Resolve<IConfigurationBuilder>().GetType());
}
public void Should_override_DefaultConfigurationBuilder()
{
var file = "Castle.Facilities.NHibernateIntegration.Tests/MinimalConfiguration.xml";
var container = new WindsorContainer(new XmlInterpreter(new AssemblyResource(file)));
container.AddFacility<AutoTxFacility>();
container.AddFacility<NHibernateFacility>(f => f.ConfigurationBuilder<DummyConfigurationBuilder>());
Assert.AreEqual(typeof(DummyConfigurationBuilder), container.Resolve<IConfigurationBuilder>().GetType());
}
public void Should_be_able_to_revolve_ISessionManager_when_fluently_configured()
{
var container = new WindsorContainer();
container.AddFacility<AutoTxFacility>();
container.AddFacility<NHibernateFacility>(f => f.ConfigurationBuilder<TestConfigurationBuilder>());
var sessionManager = container.Resolve<ISessionManager>();
sessionManager.OpenSession();
Assert.AreEqual(typeof(TestConfigurationBuilder), container.Resolve<IConfigurationBuilder>().GetType());
}
public void ShouldUseDefaultSessionStore()
{
var container = new WindsorContainer();
container.AddFacility<AutoTxFacility>();
container.AddFacility<NHibernateFacility>(
f => f.ConfigurationBuilder<DummyConfigurationBuilder>());
var sessionStore = container.Resolve<ISessionStore>();
Assert.IsInstanceOf(typeof(LogicalCallContextSessionStore), sessionStore);
}
private static WindsorContainer GetWindsorContainer()
{
var c = new WindsorContainer();
c.AddFacility<LoggingFacility>(f => f.UseNLog());
c.Register(Component.For<INHibernateInstaller>().ImplementedBy<ExampleInstaller>());
c.AddFacility<AutoTxFacility>();
c.AddFacility<NHibernateFacility>();
Assert.That(c.Kernel.HasComponent(typeof(ITransactionManager)));
return c;
}
public void Should_override_IsWeb()
{
var file = "Castle.Facilities.NHibernateIntegration.Tests/MinimalConfiguration.xml";
var container = new WindsorContainer(new XmlInterpreter(new AssemblyResource(file)));
container.AddFacility<AutoTxFacility>();
container.AddFacility<NHibernateFacility>(f => f.IsWeb().ConfigurationBuilder<DummyConfigurationBuilder>());
var sessionStore = container.Resolve<ISessionStore>();
Assert.IsInstanceOf(typeof(CallContextSessionStore), sessionStore);
}
//public static IWindsorContainer Container;
public static IWindsorContainer Configure(StartFlag startFlag)
{
var container = new WindsorContainer();
container.AddFacility<StartableFacility>(sf => sf.DeferredStart(startFlag));
container.AddFacility<TypedFactoryFacility>();
container.Kernel.Resolver.AddSubResolver(new CollectionResolver(container.Kernel, allowEmptyCollections: false));
container.Install(FromAssembly.This());
//WindsorConfig.Container = container;
return container;
}
void Application_Start(object sender, EventArgs e)
{
var container = new WindsorContainer();
container.AddFacility<TypedFactoryFacility>();
container.AddFacility<CollectionFacility>();
RegisterViews(container);
RegisterPresentersByConvention(container);
RegisterMigrationTypes(container);
RegisterExtensions(container);
CatalogueExtensions(container);
PresenterBinder.Factory = new CastlePresenterFactory(container.Kernel);
}
static void Main(string[] args)
{
var container = new WindsorContainer();
container.AddFacility <TypedFactoryFacility>();
container.Install(new LogInstaller());
container.Register(
Component.For <IIntegrationEventHandlerFactory>().AsFactory(new IntegrationEventHandlerComponentSelector()),
Component.For <IEventBusSubscriptionsManager>()
.ImplementedBy <InMemoryEventBusSubscriptionsManager>(),
Component.For <IRabbitMQPersistentConnection>()
.ImplementedBy <DefaultRabbitMQPersistentConnection>(),
Component.For <IEventBus>()
.ImplementedBy <EventBusRabbitMQ>()
.DependsOn(new { queueName = "TestIntegrationEvent" }),
Component.For <TestIntegrationEventHandler>());
var x = container.Resolve <IEventBus>();
x.Subscribe <TestIntegrationEvent, TestIntegrationEventHandler>();
x.StartConsumerChannel();
Console.ReadLine();
container.Dispose();
}
public static IWindsorContainer Initialize()
{
//We need to apply some additional attributes to auto generated code using *_Metadata classes.
System.ComponentModel.TypeDescriptor.AddProviderTransparent(new AssociatedMetadataTypeTypeDescriptionProvider(typeof(LoginRequestType), typeof(LoginRequestType_Metadata)), typeof(LoginRequestType));
string serviceName = Utils.GetServiceName();
IWindsorContainer container = new WindsorContainer();
container.Register(Component.For <IAvlRepository>().ImplementedBy <AvlRepository>()
.DynamicParameters((k, parameters) => {
parameters["connectionString"] = ConfigurationManager.ConnectionStrings["avl"].ConnectionString;
parameters["serviceName"] = serviceName;
}).LifestyleSingleton());
container.Register(Component.For <IAvlConfiguration>().ImplementedBy <ConfigurationObject>()
.DynamicParameters((k, parameters) =>
{
parameters["getDictionary"] = (Func <string, Dictionary <string, string> >)k.Resolve <IAvlRepository>().GetConfigurationDictionary;
parameters["componentName"] = "AVLAggregator";
}
).LifestyleSingleton());
container.Register(Component.For <IAvlLogger>().ImplementedBy <AvlLogger>().DependsOn(Dependency.OnValue("loggerName", "HSC.RTD.AvlAggregator")).LifestyleSingleton());
container.Register(Component.For <IncomingMessageInspector>().ImplementedBy <IncomingMessageInspector>().DynamicParameters((k, parameters) =>
{
parameters["logger"] = k.Resolve <IAvlLogger>();
}
).LifestyleSingleton());
container.AddFacility <WcfFacility>().Register(
Component.For <IAvlAggregatorServiceBL>().ImplementedBy <AvlAggregatorServiceBL>().DynamicParameters((k, parameters) => {
parameters["serviceName"] = serviceName;
}),
Component.For <IAvlAggregatorService, AvlAggregatorService>()
);
return(container);
}
public void SetUp()
{
_Container = new WindsorContainer();
_Container.AddFacility <AutoTxFacility>();
_Container.Register(Component.For <MyService>());
ThreadPool.SetMinThreads(5, 5);
}
static void Main(string[] args)
{
WeatherService.WeatherService weatherServiceClient = new WeatherService.WeatherService();
var weatherResults = weatherServiceClient.ConvertCelciusToFahrenheit(30);
WindsorContainer Container = new WindsorContainer();
Container.AddFacility <WcfFacility>();
Container.Register(
Component.For <IRepository <Employee> >().ImplementedBy <Repository <Employee> >()
);
IEmployeeRepository _employeeRepository = Container.Resolve <EmployeeRepository>();
WcfServiceHost.EmployeeService employeeServiceClient = new WcfServiceHost.EmployeeService(_employeeRepository);
var employees = employeeServiceClient.GetEmployees();
var emp = new Employee();
emp.Name = "CiaranMary";
emp.Gender = "Male";
emp.DateOfBirth = Convert.ToDateTime("08/12/1982");
employeeServiceClient.AddEmployee(emp);
// var testEmployee = employeeServiceClient.GetEmployee(emp);
}
public void InstallShouldThrowExceptionFromFailedInstaller()
{
using (var container = new WindsorContainer())
{
container.AddFacility <StartableFacility>(f => f.DeferredStart());
// I would expect NotImplementedException to be thrown here
// because it is thrown in the install method of the ExceptionThrowingInstaller
// however, what appears to be happening is that after the NotImplementedException
// is thrown, the DependencyInstaller never runs, but the "deferred start" code
// in OptimizeDependencyResolutionDisposable.Dispose() kicks in anyway
// and tries to create the StartableComponent, which it fails to do
// because IDependencyOfStartableComponent is not registered
// The net effect is that the NotImplementedException thrown by ExceptionThrowingInstaller
// is "swallowed" and instead I see a Kernel HandlerException telling me that
// IDependencyOfStartableComponent is not registered
// expected :
Assert.Throws <NotImplementedException>(
() =>
container.Install(new ActionBasedInstaller(c => c.Register(Component.For <UsesIEmptyService>().Start())),
new ActionBasedInstaller(c => { throw new NotImplementedException(); }),
new ActionBasedInstaller(c => c.Register(Component.For <IEmptyService>().ImplementedBy <EmptyServiceA>()))));
}
}
public void TestBasicOperationsWithInterfaceService()
{
WindsorContainer container = new WindsorContainer(new DefaultConfigurationStore());
container.AddFacility(new AutoTxFacility());
container.Register(Component.For <ITransactionManager>().ImplementedBy <MockTransactionManager>().Named("transactionmanager"));
container.Register(Component.For <ICustomerService>().ImplementedBy <AnotherCustomerService>().Named("services.customer"));
ICustomerService service = container.Resolve <ICustomerService>("services.customer");
service.Insert("TestCustomer", "Rua P Leite, 33");
MockTransactionManager transactionManager = container.Resolve <MockTransactionManager>("transactionmanager");
Assert.AreEqual(1, transactionManager.TransactionCount);
Assert.AreEqual(1, transactionManager.CommittedCount);
Assert.AreEqual(0, transactionManager.RolledBackCount);
try
{
service.Delete(1);
}
catch (Exception)
{
// Expected
}
Assert.AreEqual(2, transactionManager.TransactionCount);
Assert.AreEqual(1, transactionManager.CommittedCount);
Assert.AreEqual(1, transactionManager.RolledBackCount);
}
public void StartableComponentShouldNotStartIfExceptionThrownByInstaller()
{
UsesIEmptyService.instancesCreated = 0;
using (var container = new WindsorContainer())
{
container.AddFacility <StartableFacility>(f => f.DeferredStart());
Assert.Throws <NotImplementedException>(
() =>
container.Install(new ActionBasedInstaller(c => c.Register(Component.For <UsesIEmptyService>().Start())),
new ActionBasedInstaller(c => c.Register(Component.For <IEmptyService>().ImplementedBy <EmptyServiceA>())),
new ActionBasedInstaller(c => { throw new NotImplementedException(); })));
// In this scenario, I've registered IDependencyOfStartableComponent
// before the ExceptionThrowingInstaller gets a chance to gum up the works
// I would expect that the "deferred start" code NOT run here,
// and the StartableComponent remain un-instantiated.
// However, Castle is creating the StartableComponent anyway
// and then allows the NotImplementedException to bubble out.
// Presumably, this is due to the "deferred start" mechanism
// being implemented by a using() block or something similar
// via OptimizeDependencyResolutionDisposable.Dispose()
Assert.AreEqual(0, UsesIEmptyService.instancesCreated);
}
}
private void BootstrapWindsorContainer()
{
_container = new WindsorContainer();
_container.AddFacility <TypedFactoryFacility>();
_container.Register(Component.For <ITravelClubEntitiesContext>()
.ImplementedBy <TravelClubEntitiesContext>());
_container.Register(Component.For <IHttpControllerActivator>()
.ImplementedBy <ContextCapturingControllerActivator>());
_container.Register(Component.For <IHttpControllerActivator>()
.ImplementedBy <DefaultHttpControllerActivator>());
_container.Register(Component.For <Func <TaskCompletionSource <ContextWrapper> > >()
.AsFactory());
_container.Register(Component.For <TaskCompletionSource <ContextWrapper> >()
.LifestylePerWebRequest());
_container.Register(Component.For <ContextWrapper>()
.UsingFactoryMethod(k =>
k.Resolve <TaskCompletionSource <ContextWrapper> >().Task.Result).LifestylePerWebRequest());
_container.Register(Component.For <IResourceLinker>()
.ImplementedBy <RouteLinker>());
_container.Install(FromAssembly.This());
_container.Register(Component.For <HttpConfiguration>().Instance(GlobalConfiguration.Configuration));
}
public void Test_AddFacility()
{
var container = new WindsorContainer(new DefaultConfigurationStore());
container.AddFacility <LoggingFacility>(
f => f.LogUsing(LoggerImplementation.NLog).WithConfig("LoggingFacility\\NLog.facilities.test.config"));
}
public void SetConnectionTimeoutInMulticore()
{
const string core0url = "http://localhost:8983/solr/core0";
const string core1url = "http://localhost:8983/solr/core1";
var solrFacility = new SolrNetFacility("http://localhost:8983/solr/defaultCore");
solrFacility.AddCore("core0-id", typeof(Document), core0url);
solrFacility.AddCore("core1-id", typeof(Document), core1url);
solrFacility.AddCore("core2-id", typeof(Core1Entity), core1url);
var container = new WindsorContainer();
container.Kernel.ComponentModelCreated += model => {
if (model.Implementation == typeof(SolrConnection))
{
model.Parameters.Add("Timeout", "2000");
}
};
container.AddFacility("solr", solrFacility);
var allTimeouts = container.ResolveAll <ISolrConnection>().Cast <SolrConnection>().Select(x => x.Timeout);
foreach (var t in allTimeouts)
{
Assert.AreEqual(2000, t);
}
}
public void TestBasicOperations()
{
WindsorContainer container = new WindsorContainer(new DefaultConfigurationStore());
container.AddFacility("transactionmanagement", new TransactionFacility());
container.AddComponent("transactionmanager",
typeof(ITransactionManager), typeof(MockTransactionManager));
container.AddComponent("services.customer", typeof(CustomerService));
CustomerService service = (CustomerService)container["services.customer"];
service.Insert("TestCustomer", "Rua P Leite, 33");
MockTransactionManager transactionManager = (MockTransactionManager)
container["transactionmanager"];
Assert.AreEqual(1, transactionManager.TransactionCount);
Assert.AreEqual(1, transactionManager.CommittedCount);
Assert.AreEqual(0, transactionManager.RolledBackCount);
try
{
service.Delete(1);
}
catch (Exception)
{
// Expected
}
Assert.AreEqual(2, transactionManager.TransactionCount);
Assert.AreEqual(1, transactionManager.CommittedCount);
Assert.AreEqual(1, transactionManager.RolledBackCount);
}
public void ExternalConfigurationUsage()
{
WindsorContainer container = new WindsorContainer( ConfigHelper.ResolvePath("../aop_castle_config.xml") );
container.AddFacility( "aspectsharp", new AspectSharpFacility() );
// Logger implementation
container.AddComponent( "logger", typeof(ILogger), typeof(MemoryLogger) );
// AopAlliance interceptors
container.AddComponent( "log4netinterceptor", typeof(LoggerTraceInterceptor) );
// Protocol handlers
container.AddComponent( "protocolhandler.miranda",
typeof(IProtocolHandler), typeof(MirandaProtocolHandler) );
container.AddComponent( "protocolhandler.messenger",
typeof(IProtocolHandler), typeof(MessengerProtocolHandler) );
// using...
ILogger logger = (ILogger) container[ typeof(ILogger) ];
Assert.AreEqual( 0, logger.Contents.Length );
IProtocolHandler handler = (IProtocolHandler)
container[ "protocolhandler.miranda" ];
handler.Handle( "contents" );
handler = (IProtocolHandler) container[ "protocolhandler.messenger" ];
handler.Handle( "contents" );
Assert.AreEqual( "Entering Handle Leaving Handle Entering Handle Leaving Handle ",
logger.Contents );
}
public void TestBasicOperations()
{
WindsorContainer container = new WindsorContainer(new DefaultConfigurationStore());
container.AddFacility("transactionmanagement", new TransactionFacility());
container.Register(Component.For<ITransactionManager>().ImplementedBy<MockTransactionManager>().Named("transactionmanager"));
container.Register(Component.For<CustomerService>().Named("services.customer"));
CustomerService service = container.Resolve<CustomerService>("services.customer");
service.Insert("TestCustomer", "Rua P Leite, 33");
MockTransactionManager transactionManager = container.Resolve<MockTransactionManager>("transactionmanager");
Assert.AreEqual(1, transactionManager.TransactionCount);
Assert.AreEqual(1, transactionManager.CommittedCount);
Assert.AreEqual(0, transactionManager.RolledBackCount);
try
{
service.Delete(1);
}
catch (Exception)
{
// Expected
}
Assert.AreEqual(2, transactionManager.TransactionCount);
Assert.AreEqual(1, transactionManager.CommittedCount);
Assert.AreEqual(1, transactionManager.RolledBackCount);
}
public void InstallShouldThrowExceptionFromFailedInstaller()
{
using (var container = new WindsorContainer())
{
container.AddFacility<StartableFacility>(f => f.DeferredStart());
// I would expect NotImplementedException to be thrown here
// because it is thrown in the install method of the ExceptionThrowingInstaller
// however, what appears to be happening is that after the NotImplementedException
// is thrown, the DependencyInstaller never runs, but the "deferred start" code
// in OptimizeDependencyResolutionDisposable.Dispose() kicks in anyway
// and tries to create the StartableComponent, which it fails to do
// because IDependencyOfStartableComponent is not registered
// The net effect is that the NotImplementedException thrown by ExceptionThrowingInstaller
// is "swallowed" and instead I see a Kernel HandlerException telling me that
// IDependencyOfStartableComponent is not registered
// expected :
Assert.Throws<NotImplementedException>(
() =>
container.Install(new ActionBasedInstaller(c => c.Register(Component.For<UsesIEmptyService>().Start())),
new ActionBasedInstaller(c => { throw new NotImplementedException(); }),
new ActionBasedInstaller(c => c.Register(Component.For<IEmptyService>().ImplementedBy<EmptyServiceA>()))));
}
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
var windsor = new WindsorContainer();
windsor.Register(
Classes
.FromThisAssembly()
.Where(type => type.IsHandler() && type != typeof(MainForm))
.WithServiceAllHandlers()
.LifestyleTransient());
windsor.Register(
Component
.For<IDispatcher>()
.ImplementedBy<SynchronizationContextDispatcher<WindowsFormsSynchronizationContext>>()
.LifestyleSingleton(),
Component
.For<MainForm>()
.LifestyleSingleton(),
Component
.For<IHellowStrategy>()
.ImplementedBy<HellowStrategy>()
.LifestyleSingleton());
windsor.AddFacility<PublisherFacility>();
Application.Run(windsor.Resolve<MainForm>());
}
public void CanCreateDuplexProxyWithCallbackType()
{
IWindsorContainer localContainer = new WindsorContainer();
localContainer.AddFacility<WcfFacility>();
DuplexClientModel model = new DuplexClientModel
{
Endpoint = WcfEndpoint.ForContract<IServiceWithCallback>()
.BoundTo(new NetTcpBinding())
.At("net.tcp://localhost/ServiceWithCallback")
}.WithCallback<ICallbackService>();
localContainer.Register(WcfClient.ForChannels(model));
localContainer.Register(Component.For<ICallbackService>()
.ImplementedBy<CallbackService>());
var callbackService = localContainer.Resolve<ICallbackService>();
Assert.AreEqual(0, ((CallbackService)callbackService).ValueFromTheOtherSide);
IServiceWithCallback proxy = localContainer.Resolve<IServiceWithCallback>();
proxy.DoSomething(21);
Assert.IsAssignableFrom(typeof(CallbackService), callbackService);
Assert.AreEqual(42, ((CallbackService)callbackService).ValueFromTheOtherSide);
}
public void SetUp()
{
_Container = new WindsorContainer();
_Container.AddFacility("autotx", new AutoTxFacility());
_Container.Register(Component.For<ConcreteService>());
_Container.Register(Component.For<ExtendedConcreteService>());
}
public void ShouldResolveHandler()
{
var container = new WindsorContainer();
container.AddFacility<TypedFactoryFacility>();
container
.Register(
Component
.For<IHandlerFactory>()
.AsFactory());
container
.Register(
Classes
.FromAssemblyContaining<RequestProcessor>()
.BasedOn(typeof(IHandler<,>))
.WithServiceAllInterfaces()
.LifestyleTransient());
container.Register(Component.For<IMediator>().ImplementedBy<RequestProcessor>());
var sut = container.Resolve<IMediator>();
var response =
sut.Send<CreateRetailerRequest, CreateRetailerResponse>(
new CreateRetailerRequest
{
Name = "Test Retailer",
Url = "www.testretailer.com"
});
}
public void TestBasicOperationsWithInterfaceService()
{
WindsorContainer container = new WindsorContainer(new DefaultConfigurationStore());
container.AddFacility("transactionmanagement", new TransactionFacility());
container.AddComponent("transactionmanager",
typeof(ITransactionManager), typeof(MockTransactionManager));
container.AddComponent("services.customer", typeof(ICustomerService), typeof(AnotherCustomerService));
ICustomerService service = (ICustomerService)container["services.customer"];
service.Insert("TestCustomer", "Rua P Leite, 33");
MockTransactionManager transactionManager = (MockTransactionManager)
container["transactionmanager"];
Assert.AreEqual(1, transactionManager.TransactionCount);
Assert.AreEqual(1, transactionManager.CommittedCount);
Assert.AreEqual(0, transactionManager.RolledBackCount);
try
{
service.Delete(1);
}
catch (Exception)
{
// Expected
}
Assert.AreEqual(2, transactionManager.TransactionCount);
Assert.AreEqual(1, transactionManager.CommittedCount);
Assert.AreEqual(1, transactionManager.RolledBackCount);
}
private static IKernel CreateKernel()
{
IWindsorContainer container = new WindsorContainer();
container.AddFacility<WcfFacility>();
container.Install(FromAssembly.This());
return container.Kernel;
}
public void AddCoreFromXML()
{
var solrFacility = new SolrNetFacility();
var container = new WindsorContainer(new XmlInterpreter(new StaticContentResource(@"<castle>
<facilities>
<facility id='solr'>
<solrURL>http://localhost:8983/solr/defaultCore</solrURL>
<cores>
<core id='core0-id'>
<documentType>Castle.Facilities.SolrNetIntegration.Tests.Tests+Document, Castle.Facilities.SolrNetIntegration.Tests</documentType>
<url>http://localhost:8983/solr/core0</url>
</core>
<core id='core1-id'>
<documentType>Castle.Facilities.SolrNetIntegration.Tests.Tests+Document, Castle.Facilities.SolrNetIntegration.Tests</documentType>
<url>http://localhost:8983/solr/core1</url>
</core>
<core id='core2-id'>
<documentType>Castle.Facilities.SolrNetIntegration.Tests.Tests+Core1Entity, Castle.Facilities.SolrNetIntegration.Tests</documentType>
<url>http://localhost:8983/solr/core1</url>
</core>
</cores>
</facility>
</facilities>
</castle>")));
container.AddFacility("solr", solrFacility);
TestCores(container);
}
static void Main(string[] args)
{
var manager = new DatabaseManager("DataLayer");
manager.DropCreateDatabase();
var container = new WindsorContainer();
container.AddFacility<TypedFactoryFacility>();
container.Install(new DataInstaller());
var repositoryFactory = container.Resolve<IRepositoryFactory>();
repositoryFactory.WithRepository(r =>
{
r.Context.Add(new Person("Richard", "Castle"));
r.Context.Add(new Person("Kate", "Becket"));
r.Context.Add(new Person("Nikki", "Heat"));
r.Context.Add(new Person("Derrick", "Storm"));
r.Context.Add(new Person("Richard", "Nixon"));
r.Context.Commit();
});
var richards = new List<Person>();
repositoryFactory.WithRepository(r =>
{
richards = r.Find(new PeopleByFirstName("Richard")).ToList();
});
Console.WriteLine("People named Richard");
richards.ForEach(r=>Console.WriteLine("{0} {1}", r.FirstName, r.LastName));
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
private static IWindsorContainer BuildContainer()
{
var container = new WindsorContainer();
container.Kernel.Resolver.AddSubResolver(
new ArrayResolver(container.Kernel, false));
container.AddFacility<TypedFactoryFacility>();
container.Register(
Component.For<ICommandController>().ImplementedBy<CommandController>().LifeStyle.Transient,
Component.For<IConsoleFacade>().ImplementedBy<ConsoleFacade>().LifeStyle.Transient,
Component.For<IUnitOfWork>().ImplementedBy<UnitOfWork>()
.LifeStyle.Transient,
Component.For<IFormatter>().ImplementedBy<Formatter>().LifeStyle.Transient,
Component.For(typeof(IRepository<>)).ImplementedBy(typeof(Repository<>))
.LifeStyle.Transient,
Component.For<IUnknownInputHandler>().ImplementedBy<UnknownInputHandler>()
.LifeStyle.Transient,
Component.For<IMasterRoomFactory>().ImplementedBy<MasterRoomFactory>().LifeStyle.Transient,
Component.For<IPlayerFactory>().ImplementedBy<PlayerFactory>().LifeStyle.Transient,
Component.For<IPlayer>().UsingFactoryMethod(k => k.Resolve<IPlayerFactory>().FindPlayer()).LifeStyle.Singleton,
Component.For<IMasterRoom>().UsingFactoryMethod(k => k.Resolve<IMasterRoomFactory>().FindRoom()).LifeStyle.Singleton,
AllTypes.FromAssemblyContaining<EchoCommand>().BasedOn<ICommand>()
.Configure(c=> c.LifeStyle.Transient)
.WithService.FromInterface(typeof(ICommand))
);
return container;
}
public void SetUp()
{
_Container = new WindsorContainer();
_Container.AddFacility<AutoTxFacility>();
_Container.Register(Component.For<MyService>());
ThreadPool.SetMinThreads(5, 5);
}
static void Main(string[] args)
{
IWindsorContainer container = new WindsorContainer();
container.AddFacility<TypedFactoryFacility>();
container.Register(Component.For<IDummyComponent>().ImplementedBy<DummyComponent>().Named("Action").LifeStyle.Transient);
container.Register(Component.For<IDummyComponentFactory>().AsFactory().LifeStyle.Transient);
IDummyComponentFactory factory = container.Resolve<IDummyComponentFactory>();
for (int i = 0; i < 10; i++)
{
Console.WriteLine("{0:N0} bytes used at the start", GC.GetTotalMemory(true));
IDummyComponent[] array = new IDummyComponent[10];
for (int j = 0; j < array.Length; j++)
array[j] = factory.GetAction();
Console.WriteLine("{0:N0} bytes used at the mezivysledek", GC.GetTotalMemory(true));
for (int j = 0; j < array.Length; j++)
{
factory.Release(array[j]);
array[j] = null;
}
Console.WriteLine("{0:N0} bytes used at the end", GC.GetTotalMemory(true));
}
}
public void AddCoreFromXML()
{
var solrFacility = new SolrNetFacility();
var container = new WindsorContainer(new XmlInterpreter(new StaticContentResource(@"<castle>
<facilities>
<facility id='solr'>
<solrURL>http://localhost:8983/solr/defaultCore</solrURL>
<cores>
<core id='core0-id'>
<documentType>Castle.Facilities.SolrNetIntegration.Tests.Tests+Document, Castle.Facilities.SolrNetIntegration.Tests</documentType>
<url>http://localhost:8983/solr/core0</url>
</core>
<core id='core1-id'>
<documentType>Castle.Facilities.SolrNetIntegration.Tests.Tests+Document, Castle.Facilities.SolrNetIntegration.Tests</documentType>
<url>http://localhost:8983/solr/core1</url>
</core>
<core id='core2-id'>
<documentType>Castle.Facilities.SolrNetIntegration.Tests.Tests+Core1Entity, Castle.Facilities.SolrNetIntegration.Tests</documentType>
<url>http://localhost:8983/solr/core1</url>
</core>
</cores>
</facility>
</facilities>
</castle>")));
container.AddFacility("solr", solrFacility);
TestCores(container);
}
public void SetUp()
{
XmlConfigurator.Configure();
_Container = new WindsorContainer();
_Container.AddFacility("autotx", new AutoTxFacility());
_Container.Register(Component.For<IMyService>().ImplementedBy<MyService>());
}
public IWindsorContainer Create()
{
IWindsorContainer ioc = new WindsorContainer();
ioc.AddFacility<FactorySupportFacility>();
ioc.Register(Component.For<ValidatorEngine>().UsingFactoryMethod(CreateValidatorEngine));
ioc.Register(Component.For<Rhino.Security.Mgmt.Infrastructure.IValidator>().ImplementedBy<NHibernateValidator>());
ioc.Register(Component.For<ISessionFactory>().UsingFactoryMethod(CreateSessionFactory));
// start setup Rhino Security services
ioc.Register(Component.For<AuthorizationRepositoryFactory>());
ioc.Register(Component.For<PermissionsServiceFactory>());
ioc.Register(Component.For<PermissionsBuilderServiceFactory>());
// end setup Rhino Security services
ioc.Register(Component.For<SecurityUsersToUsersGroupsAssociationSynchronizer>());
ioc.Register(Component.For<IConversationFactory>().UsingFactoryMethod(CreateConversationFactory));
ioc.Register(Component.For<IConversation>().UsingFactoryMethod(CreateConversation).LifeStyle.PerWebRequest);
ioc.Register(Component.For<IMappingEngine>().UsingFactoryMethod(MappingEngineBuilder.Build));
ioc.Register(AllTypes.FromAssemblyContaining<UserStringConverter>().BasedOn(typeof(IStringConverter<>)).WithService.Base());
ioc.Register(AllTypes.FromAssemblyContaining<UserFactory>().BasedOn(typeof(IFactory<>)).WithService.Base());
ioc.Register(AllTypes.FromAssemblyContaining<UserRepository>().BasedOn<IRepository>());
// ValueProviderFactories.Factories.Add(new JsonValueProviderFactory());
ServiceLocator.SetLocatorProvider(() => new WindsorServiceLocator(ioc));
return ioc;
}
public void DefaultAlias_comes_from_facility()
{
var container = new WindsorContainer();
container.AddFacility<NHibernateFacility>(f => f.DefaultAlias = "NAX-677");
var configurationResolver = container.Resolve<IConfigurationResolver>();
Assert.AreEqual("NAX-677", configurationResolver.DefaultAlias);
}
public void SimpleCase()
{
String contents =
"import Castle.Facilities.AspectSharp.Tests.Components in Castle.Facilities.AspectSharp.Tests " +
"import Castle.Facilities.AspectSharp.Tests.Interceptors in Castle.Facilities.AspectSharp.Tests " +
" " +
" aspect MyAspect for SimpleService " +
" " +
" pointcut method|property(*)" +
" advice(LoggerInterceptor)" +
" end" +
" " +
" end ";
MutableConfiguration config = new MutableConfiguration("facility", contents);
DefaultConfigurationStore store = new DefaultConfigurationStore();
store.AddFacilityConfiguration("aop", config);
WindsorContainer container = new WindsorContainer(store);
container.AddFacility( "aop", new AspectSharpFacility() );
container.AddComponent("comp1", typeof(SimpleService));
SimpleService service = container[ typeof(SimpleService) ] as SimpleService;
service.DoSomething();
service.DoSomethingElse();
Assert.AreEqual( "Enter DoSomething\r\nEnter DoSomethingElse\r\n",
LoggerInterceptor.Messages.ToString() );
}
public static void SetupContainer()
{
Assembly.Load(_implicitDependency.Assembly.FullName);
var container = new WindsorContainer();
container.AddFacility<TypedFactoryFacility>();
container.Register(Component.For<ILazyComponentLoader>().ImplementedBy<LazyOfTComponentLoader>());
container.Register(Component.For<IControllerFactory>().ImplementedBy<WindsorControllerFactory>());
container.Register(Classes.FromAssembly(ReflectionUtil.GetAssemblyNamed("Web")).BasedOn<IController>().LifestylePerWebRequest());
container.Register(Component.For<IMyService>().ImplementedBy<MyService>());
container.Register(Component.For<IPersitenceServiceConfigDependent>().ImplementedBy<PersitenceServiceConfigDependent>());
container.Register(Component.For<IAzureServiceConfigurationProvider>().ImplementedBy<DefaultAzureServiceConfigurationProvider>());
container.Register(Component.For<IMicrosoftStorageConfig>().UsingFactoryMethod(GetAzureServiceConfig),
Component.For<IAzureServiceConfiguration>().UsingFactoryMethod(GetAzureServiceConfiguration),
Component.For<IConnectionStrings>().UsingFactoryMethod(GetConnectionStrings),
Component.For<IAppConfigSettings>().UsingFactoryMethod(GetWebConfiuration));
DependencyResolver.SetResolver(new WindsorDependencyResolver(container.Kernel));
Container = container;
}
public void StartableComponentShouldNotStartIfExceptionThrownByInstaller()
{
UsesIEmptyService.instancesCreated = 0;
using (var container = new WindsorContainer())
{
container.AddFacility<StartableFacility>(f => f.DeferredStart());
Assert.Throws<NotImplementedException>(
() =>
container.Install(new ActionBasedInstaller(c => c.Register(Component.For<UsesIEmptyService>().Start())),
new ActionBasedInstaller(c => c.Register(Component.For<IEmptyService>().ImplementedBy<EmptyServiceA>())),
new ActionBasedInstaller(c => { throw new NotImplementedException(); })));
// In this scenario, I've registered IDependencyOfStartableComponent
// before the ExceptionThrowingInstaller gets a chance to gum up the works
// I would expect that the "deferred start" code NOT run here,
// and the StartableComponent remain un-instantiated.
// However, Castle is creating the StartableComponent anyway
// and then allows the NotImplementedException to bubble out.
// Presumably, this is due to the "deferred start" mechanism
// being implemented by a using() block or something similar
// via OptimizeDependencyResolutionDisposable.Dispose()
Assert.AreEqual(0, UsesIEmptyService.instancesCreated);
}
}
public void Application_OnStart()
{
container = new WindsorContainer(new XmlInterpreter());
container.AddFacility("rails", new RailsFacility());
AddControllers(container);
}
public void MappingValidationManager()
{
var solrFacility = new SolrNetFacility("http://localhost:8983/solr");
var container = new WindsorContainer();
container.AddFacility("solr", solrFacility);
var validator = container.Resolve <IMappingValidator>();
}
public void DictionaryDocument_Operations()
{
var solrFacility = new SolrNetFacility("http://localhost:8983/solr");
var container = new WindsorContainer();
container.AddFacility("solr", solrFacility);
container.Resolve <ISolrOperations <Dictionary <string, object> > >();
}
public void Resolve_ISolrOperations()
{
var solrFacility = new SolrNetFacility("http://localhost:8983/solr");
var container = new WindsorContainer();
container.AddFacility("solr", solrFacility);
container.Resolve <ISolrOperations <Document> >();
}
public void Container_has_ISolrDocumentPropertyVisitor()
{
var solrFacility = new SolrNetFacility("http://localhost:8983/solr");
var container = new WindsorContainer();
container.AddFacility("solr", solrFacility);
container.Resolve <ISolrDocumentPropertyVisitor>();
}
public void Container_has_ISolrFieldSerializer()
{
var solrFacility = new SolrNetFacility("http://localhost:8983/solr");
var container = new WindsorContainer();
container.AddFacility("solr", solrFacility);
container.Resolve <ISolrFieldSerializer>();
}
public void Wire()
{
container.AddFacility <FactorySupportFacility>();
(new ServiceLocatorGuyWire(container)).Wire();
(new NhSessionManagementGuyWire(container)).Wire();
(new DaosGuyWire(container)).Wire();
}
protected void Application_Start(object sender, EventArgs e)
{
Container = new WindsorContainer();
Container.AddFacility <WcfFacility>();
Container.Register(
Component.For <ITaskRepository>().ImplementedBy <TaskRepository>(),
Component.For <IDownloadService>().ImplementedBy <DownloadService>().Named("DownloadService"));
}
public void Application_OnStart()
{
container = new PestControlContainer(new XmlInterpreter(new ConfigResource()));
container.AddFacility("rails", new RailsFacility());
AddFiltersAndControllers(container);
}
public void Startable_and_components_in_single_Installer_works()
{
using (var container = new WindsorContainer())
{
container.AddFacility <StartableFacility>(f => f.DeferredStart());
container.Install(new AllInstaller());
}
}
protected override IServiceProvider InitializeContainer(IServiceCollection services)
{
var c = new WindsorContainer();
c.AddFacility <TypedFactoryFacility>();
return(WindsorRegistrationHelper.CreateServiceProvider(c, services));
}
public void Should_not_accept_non_implementors_of_IConfigurationBuilder_for_override()
{
var file = "Castle.Facilities.NHibernateIntegration.Tests/MinimalConfiguration.xml";
var container = new WindsorContainer(new XmlInterpreter(new AssemblyResource(file)));
container.AddFacility <NHibernateFacility>("nhibernatefacility", f => f.ConfigurationBuilder(GetType()));
}
public override void BeginInit()
{
base.BeginInit();
container = new WindsorContainer();
container.AddFacility <LoggingFacility>(f => f.LogUsing <Log4netFactory>().WithConfig("log4net.xml"));
container.Install(FromAssembly.This());
container.Register(Component.For <Application>().Instance(this.Application));
}
public static IWindsorContainer Build()
{
var container = new WindsorContainer();
container.AddFacility <TypedFactoryFacility>();
container.Install(new DependenciesInstaller());
return(container);
}
public void Container_has_ISolrFieldParser()
{
var solrFacility = new SolrNetFacility("http://localhost:8983/solr/techproducts");
var container = new WindsorContainer();
container.AddFacility(solrFacility);
container.Resolve <ISolrFieldParser>();
}
public void Should_throw_if_controller_assembly_is_not_set()
{
Assert.Throws <ControllerAssemblyWasNotSetException>(() =>
{
var container = new WindsorContainer();
container.AddFacility <AspNetMvcFacility>();
});
}
public void ComponentCanNotBeProjectionAndCommandsHandlerSimultaneousely()
{
using (var container = new WindsorContainer())
{
container.AddFacility <CqrsFacility>(f => f.RunInMemory().BoundedContexts(LocalBoundedContext.Named("bc")));
container.Register(Component.For <CommandsHandler>().AsCommandsHandler("bc").AsProjection("bc", "remote"));
}
}
public void SetUp()
{
container = new WindsorContainer();
container.AddFacility("preconditions", new PreconditionFacility());
container.Register(Component.For <TestDomainObject>());
testCustomer = container.Resolve <TestDomainObject>();
}
