private void SetUpDbSettings()
{
if (!Program.Container.Kernel.HasComponent(typeof(DatabaseSettings)))
{
var dbSettings = new DatabaseSettings
{
Url = tbDbUrl.Text,
UserName = tbDdUserName.Text,
Password = tbDbPassword.Text
};
Program.Container.Register(Component.For <DatabaseSettings>().Instance(dbSettings));
}
else
{
var currentXmlApiSettings = Program.Container.Resolve <DatabaseSettings>();
currentXmlApiSettings.Url = tbDbUrl.Text;
currentXmlApiSettings.UserName = tbDdUserName.Text;
currentXmlApiSettings.Password = tbDbPassword.Text;
}
IDbProvider dbProvider = rbSqlProvider.Checked ? (IDbProvider) new SqlProvider() : new OracleProvider();
if (!Program.Container.Kernel.HasComponent(typeof(IDataContext)))
{
var dataContext = new DapperDataContext(Program.Container.Resolve <DatabaseSettings>(), dbProvider);
Program.Container.Register(Component.For <IDataContext>().Instance(dataContext));
}
else
{
var currentXmlApiSettings = Program.Container.Resolve <IDataContext>();
currentXmlApiSettings.DbProvider = dbProvider;
}
}
protected override void Arrange()
{
AssemblyLoader.EnsureLoaded <Marker_EdFi_Ods_Test_TestExtension>();
AssemblyLoader.EnsureLoaded <Marker_EdFi_Ods_Standard>();
_container = new WindsorContainerEx();
_container.Register(
Component
.For <IResourceModelProvider>()
.ImplementedBy <ResourceModelProvider>());
_container.Register(
Component.For <IExtensionNHibernateConfigurationProvider>()
.ImplementedBy <ExtensionNHibernateConfigurationProvider>());
_container.Register(
Component.For <IFilterCriteriaApplicatorProvider>()
.ImplementedBy <FilterCriteriaApplicatorProvider>());
_container.Register(Component.For <IOrmMappingFileDataProvider>()
.UsingFactoryMethod(kernel => new OrmMappingFileDataProvider(kernel.Resolve <IAssembliesProvider>(), DatabaseEngine.SqlServer, "EdFi.Ods.Standard"))
);
_container.Register(Component.For <IAssembliesProvider>().ImplementedBy <AssembliesProvider>());
}
public static IWindsorContainer RegisterType <TServiceType, TClassType>(this IWindsorContainer container, string name) where TClassType : TServiceType
{
return(container.Register(Component.For(typeof(TServiceType))
.ImplementedBy(typeof(TClassType))
.Named(name)
.LifeStyle.Transient));
}
public void RegisterDbSetTypes()
{
var method = this.GetType().GetMethods().First(m => m.IsGenericMethod && m.Name == "Set");
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
try
{
var entityTypes = assembly.GetTypes().Where(this.IsTypePersistent);
foreach (var type in entityTypes)
{
try
{
var generic = method.MakeGenericMethod(type);
var dbSet = generic.Invoke(this, null);
var dbSetType = typeof(DbSet <>).MakeGenericType(type);
this.WindsorContainer.Register(Component.For(dbSetType).LifestyleSingleton().Instance(dbSet).OnlyNewServices());
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
}
}
protected override void ConfigureWindsorContainer()
{
container.AddFacility <FactorySupportFacility>();
container.Register(Component.For <CommonPropertyStoreInterceptor>()
.LifeStyle.Transient);
container.Register(Component.For <EntityNameInterceptor>()
.LifeStyle.Transient);
container.Register(Component.For <CollectionPropertyInterceptor>()
.LifeStyle.Transient);
container.Register(Component.For <PropertyChangeInterceptor>()
.LifeStyle.Transient);
container.Register(Component.For <Store>()
.Interceptors(new InterceptorReference(
typeof(CollectionPropertyInterceptor))).Anywhere
.ImplementedBy <Store>()
.EnableNhibernateEntityCompatibility()
.LifeStyle.Transient);
container.Register(Component.For <IStore>()
.UsingFactoryMethod(kernel => kernel.Resolve <Store>())
.LifeStyle.Transient);
container.Register(Component.For <IProduct>()
.TargetIsCommonDatastore().LifeStyle.Transient);
}
private void InitFacility()
{
Kernel.Register(
Component
.For <TypedFactoryInterceptor>()
.NamedAutomatically(InterceptorKey));
if (!disableDelegateFactory)
{
Kernel.Register(
Component
.For <ILazyComponentLoader>()
.ImplementedBy <DelegateFactory>()
.NamedAutomatically(DelegateFactoryKey));
}
Kernel.Register(
Component
.For <ITypedFactoryComponentSelector>()
.ImplementedBy <DefaultTypedFactoryComponentSelector>()
.NamedAutomatically(DefaultInterfaceSelectorKey));
Kernel.Register(
Component
.For <ITypedFactoryComponentSelector>()
.ImplementedBy <DefaultDelegateComponentSelector>()
.NamedAutomatically(DefaultDelegateSelectorKey));
Kernel.ComponentModelBuilder.AddContributor(new TypedFactoryCachingInspector());
}
public void RegisterVirtualizingObservableDBSetPagedCollections()
{
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
try
{
var entityTypes = assembly.GetTypes().Where(this.IsTypePersistent);
foreach (var type in entityTypes)
{
try
{
var dbSetType = typeof(VirtualizingObservableDBSetPagedCollection <>).MakeGenericType(type);
//this.WindsorContainer.Register(Component.For(dbSetType).LifestyleSingleton().OnlyNewServices());
this.WindsorContainer.Register(Component.For(dbSetType).LifestyleTransient()); //Has to be transparent otherwise it cannot dynamically load appropriete items by filter
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
}
}
/// <summary>
/// Registers the theClassType on the container.
/// </summary>
/// <typeparam name="TServiceType">The theClassType of interface.</typeparam>
/// <typeparam name="TClassType">The theClassType of the service.</typeparam>
/// <param name="container">The container.</param>
/// <param name="singleton">if set to <c>true</c> theClassType will be registered as singleton.</param>
public static void RegisterType <TServiceType, TClassType>(this IWindsorContainer container, bool singleton)
{
if (!container.Kernel.HasComponent(typeof(TServiceType)))
{
var serviceType = container.TryResolve(typeof(TServiceType));
if (serviceType == null && !singleton)
{
container.Register(Component.For(typeof(TServiceType))
.ImplementedBy(typeof(TClassType))
.LifeStyle.Transient);
}
if (singleton)
{
if (serviceType == null)
{
container.Register(Component.For(typeof(TServiceType))
.ImplementedBy(typeof(TClassType))
.LifeStyle.Singleton);
}
}
//container.Kernel.AddComponent(typeof(TClassType).FullName, typeof(TServiceType), typeof(TClassType), singleton ? LifestyleType.Singleton : LifestyleType.Transient);
}
}
private void EnsureFactoryIsRegistered(string factoryId, Type factoryType)
{
if (!Kernel.HasComponent(factoryType))
{
Kernel.Register(Component.For(factoryType).Named(factoryId));
}
}
/// <summary>
/// Handles solution registrations.
/// </summary>
/// <param name="layerName">Base namespace in project.</param>
/// <param name="includes">Files to be included.</param>
/// <param name="contents">Content to be included.</param>
/// <param name="files">All files in project.</param>
/// <param name="projectType">Type of project.</param>
/// <param name="nugets">Nugets to be referenced.</param>
/// <param name="imports">Projects to be referenced.</param>
/// <param name="container">Container where to register project files.</param>
public static void RegisterSolutionLayer(string layerName, ProjectType projectType, List <PackageConfigInfo> nugets, List <IGenerableFile> files, List <IGenerableFile> includes, List <ContentInfo> contents, List <AssemblyBase> imports, WindsorContainer container)
{
IAssembly instance;
switch (projectType)
{
case ProjectType.Console:
instance = MakeConsoleProject(layerName,
layerName, includes, contents, files,
nugets,
imports);
break;
case ProjectType.Library:
instance = MakeLibraryProject(layerName,
layerName, includes, contents, files,
nugets,
imports);
break;
case ProjectType.WebApi:
instance = MakeWebApiProject(layerName,
layerName, includes, contents, files,
nugets,
imports);
break;
default:
throw new NotSupportedException("This type of project is not supported");
}
container.Register(
Component.For <IAssembly>().Instance(instance
).Named(layerName));
}
private void LegacyInit()
{
Kernel.Register(Component.For <FactoryInterceptor>().NamedAutomatically("typed.fac.interceptor"));
var converter = Kernel.GetConversionManager();
AddFactories(FacilityConfig, converter);
}
/// <summary>
///
/// </summary>
/// <param name="container"></param>
/// <param name="type"></param>
/// <param name="instance"></param>
/// <param name="name"></param>
/// <returns></returns>
public static IWindsorContainer RegisterInstance <TService, TClassType>(this IWindsorContainer container, object instance, string name = null) where TService : class
where TClassType : class
{
return(container.Register(Component.For(typeof(TService))
.ImplementedBy(typeof(TClassType))
.Instance(instance)
.LifeStyle.Transient));
}
//Resolver to map my interfaces with my implementations
//that should be called in the main method of the application.
private static void Resolver()
{
_container = new WindsorContainer();
_container.Register(Component.For <IFood>().ImplementedBy <FrenchCuisine>());
_container.Register(Component.For <IFood>().ImplementedBy <ComidaBrasileira>());
_container.Register(
Component.For <ITranslate>().ImplementedBy <FrenchTranslator>().DependsOn(new FrenchCuisine()));
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
_container.CrossWiresInto(services);
_container.Register(Component.For <IHttpContextAccessor>().ImplementedBy <HttpContextAccessor>());
_container.Register(Component.For <IScopeSomething>().ImplementedBy <ScopeSomething>().LifestyleScoped().CrossWired().IsDefault());
services.AddMvc();
return(services.AddWindsor(_container));
}
/// <summary>
/// Setup the IoC container and register needed types
/// </summary>
private void SetupContainer()
{
this.Container = new WindsorContainer();
this.Container.Register(Component.For <IWindsorContainer>().Instance(this.Container));
BooReader.Read(this.Container, "Global.boo");
}
/// <summary>
/// Resolves a service from the container. If the theClassType does not exist on the container,
/// first registers it with transient lifestyle.
/// </summary>
/// <param name="container"></param>
/// <param name="theClassType"></param>
/// <returns></returns>
public static object Resolve(this IWindsorContainer container, Type theClassType)
{
if (theClassType.IsClass && !container.Kernel.HasComponent(theClassType))
{
container.Register(Component.For(theClassType).Named(theClassType.FullName).LifeStyle.Transient);
}
return(container.Resolve(theClassType));
}
/// <summary>
///
/// </summary>
/// <param name="windsorContainer"></param>
/// <param name="serviceType"></param>
/// <returns></returns>
internal static object Resolve(IWindsorContainer windsorContainer, Type serviceType)
{
if (serviceType.IsClass && !windsorContainer.Kernel.HasComponent(serviceType))
{
windsorContainer.Register(Component.For(serviceType).Named(serviceType.FullName).LifeStyle.Transient);
}
return(windsorContainer.Resolve(serviceType));
}
public MvcControllerBuilderFactoryTest()
{
// LocalIocManager.Register<MvcControllerManager>();
LocalIocManager.IocContainer.Register(Component.For <MvcControllerManager>());
this.servicesType = LocalIocManager.IocContainer.Kernel.GetHandlers().SelectMany(t => t.Services).Where(t => t.Assembly == Assembly.GetExecutingAssembly());
}
protected override void ConfigureContainer()
{
base.ConfigureContainer();
Container.Register(
Component.For(typeof(ISagaPersister <>))
.ImplementedBy(typeof(InMemorySagaPersister <>))
);
}
protected override void ConfigureWindsorContainer()
{
container.AddFacility <FactorySupportFacility>();
container.AddFacility <ComponentBehaviorsFacility>();
var config = new BehaviorDictionary();
config.For <Album>().Add <NotifyPropertyChangedBehavior>().Add <EditableBehavior>();
container.Register(Component.For <IBehaviorStore>().Instance(config));
}
public ComponentReference(Type service)
{
_name = service.FullName;
if (kernel.HasComponent(_name) == false)
{
kernel.Register(ComponentReg.For(service).Named(_name));
}
}
protected override void ConfigureContainer()
{
base.ConfigureContainer();
Container.Register(
Component.For <IMessageModule>()
.ImplementedBy <EchoMessageModule>()
.Named("Echo"));
}
public Form1()
{
IWindsorContainer container = new WindsorContainer();
// Register the CompositionRoot type with the container
container.Register(Component.For <ITemp>().ImplementedBy <Temp>());
var root = container.Resolve <ITemp>();
int fgh = root.add(2, 3);
InitializeComponent();
}
void IContainer.RegisterService <I, T>(string key, ServiceLifetime lifetime)
{
var registration = Component.For <I>().ImplementedBy <T>();
if (!string.IsNullOrEmpty(key))
{
registration = registration.Named(key);
}
windsorContainer.Register(registration.LifeStyle.Is(GetLifestyle(lifetime)));
}
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);
}
private static void SetupUrlShortener(GlobalConfiguration globalConfiguration, WindsorContainer container)
{
var primary = Type.GetType(globalConfiguration.General.UrlShortener);
var secondary = globalConfiguration.General.SecondaryUrlShortener != null
? Type.GetType(globalConfiguration.General.SecondaryUrlShortener)
: null;
container.Register(
Component.For <IUrlShorteningService>().ImplementedBy(primary),
Component.For <IUrlShorteningService>().ImplementedBy(secondary).Named("secondaryShortener")
);
}
private void RegisterNHibernateConfigurationActivities(IWindsorContainer container)
{
container.Register(
Component
.For <INHibernateBeforeBindMappingActivity>()
.ImplementedBy <OwnershipBasedAuthorizationNHibernateConfigurationActivity>());
container.Register(
Component
.For(typeof(ICreateEntity <>))
.ImplementedBy(typeof(OwnershipInitializationCreateEntityDecorator <>)).IsDecorator());
}
protected override void GivenIRegister()
{
this.Sut.Register(
Component
.For <LoggingInterceptor>()
.LifeStyle.Transient,
Component
.For <IMovie>()
.ImplementedBy <NHMovie>()
.Interceptors(InterceptorReference.ForType <LoggingInterceptor>()).Anywhere
.LifeStyle.Transient
);
}
protected override void GivenIRegister()
{
this.Sut.Register(
Component
.For <NotifyPropertyChangedInterceptor>()
.LifeStyle.Transient,
Component
.For <IMovieViewModel>()
.ImplementedBy <MovieViewModel>()
.Interceptors(InterceptorReference.ForType <NotifyPropertyChangedInterceptor>()).Anywhere
.LifeStyle.Transient
);
}
public void SetUp()
{
container.Register(Component.For <IReader>().ImplementedBy <TXTReader>());
container.Register(Component.For <ISaver>().ImplementedBy <PNGSaver>());
container.Register(Component.For <IWordKeeper>()
.ImplementedBy <StandartWordKeeper>()
.DependsOn(new { delimiters = new [] { "\n" } })
.LifeStyle.Transient);
container.Register(Component.For <ICloudLayouter>()
.ImplementedBy <CircularCloudLayouter>()
.DependsOn(new { pointCenter = new Point(0, 0) })
.LifeStyle.Transient);
}
