public void Register(IContainerManager containerManager, ITypeFinder typeFinder)
{
//
var cacheProvider = new UserProvider(containerManager.Resolve<IUserProvider>());
containerManager.AddComponentInstance(typeof(IUserProvider), cacheProvider);
containerManager.AddComponentInstance(typeof(IProvider<User>), cacheProvider);
}
public void Register(IContainerManager containerManager, CMS.Common.Runtime.ITypeFinder typeFinder)
{
foreach (var type in typeFinder.FindClassesOfType<ICommerceDbProvider>())
{
CommerceDbProviders.Providers.Add((ICommerceDbProvider)containerManager.Resolve(type));
}
}
public void Register(IContainerManager containerManager, ITypeFinder typeFinder)
{
Kooboo.CMS.Sites.Globalization.DefaultRepositoryFactory.Instance = new LabelProvider.RepositoryFactory();
containerManager.AddComponent<IPageProvider, PageProvider.PageProvider>();
containerManager.AddComponent<IHtmlBlockProvider, HtmlBlockProvider.HtmlBlockProvider>();
containerManager.AddComponent<IUserProvider, UserProvider.UserProvider>();
}
public void Register(IContainerManager containerManager, ITypeFinder typeFinder)
{
containerManager.AddComponent<IProviderFactory, ProviderFactory>();
containerManager.AddComponent<ISchemaProvider, SchemaProvider>();
containerManager.AddComponent<IContentProvider<TextContent>, TextContentProvider>();
containerManager.AddComponent<ITextContentProvider, TextContentProvider>();
}
public void Register(IContainerManager containerManager, ITypeFinder typeFinder)
{
containerManager.AddComponent<IElementRepositoryFactory, LabelProvider.RepositoryFactory>();
containerManager.AddComponent<IPageProvider, PageProvider.PageProvider>();
containerManager.AddComponent<IHtmlBlockProvider, HtmlBlockProvider.HtmlBlockProvider>();
containerManager.AddComponent<IUserProvider, UserProvider.UserProvider>();
}
public void Register(IContainerManager containerManager, CMS.Common.Runtime.ITypeFinder typeFinder)
{
// Current instance providers
containerManager.AddComponent(typeof(ICurrentInstanceProvider), typeof(ThreadScopeCurrentInstanceProvider), "ThreadScopeCurrentInstanceProvider", ComponentLifeStyle.Singleton);
containerManager.AddComponent(typeof(ICurrentInstanceProvider), typeof(SiteAwareHttpCurrentInstanceProvider), "SiteAwareHttpCurrentInstanceProvider", ComponentLifeStyle.Transient);
// Data folder factory
containerManager.AddComponentInstance<DataFolderFactory>(DataFolderFactory.Current);
// Instance intializers
foreach (var type in typeFinder.FindClassesOfType<IInstanceInitializer>())
{
containerManager.AddComponent(typeof(IInstanceInitializer), type, type.FullName, ComponentLifeStyle.Transient);
}
// Repository and ICommerceDatabase
var container = ((Kooboo.CMS.Common.Runtime.Dependency.Ninject.ContainerManager)containerManager).Container;
container.Bind<CommerceInstance>()
.ToMethod(ctx => CommerceInstance.Current);
container.Bind<ICommerceDatabase>()
.ToMethod(ctx =>
{
var instance = CommerceInstance.Current;
if (instance == null)
throw new InvalidOperationException("Cannot resolve ICommerceDatabase, because there's no commerce instance in the context.");
return instance.Database;
});
container.Bind(typeof(IRepository<>)).To(typeof(CommerceRepository<>));
}
public TcpServer(IContainerManager containerManager, IJobManager jobManager, uint tcpPort, CancellationToken cancellationToken)
{
if (containerManager == null)
{
throw new ArgumentNullException("containerManager");
}
this.containerManager = containerManager;
if (jobManager == null)
{
throw new ArgumentNullException("jobManager");
}
this.jobManager = jobManager;
if (cancellationToken == null)
{
throw new ArgumentNullException("cancellationToken");
}
this.cancellationToken = cancellationToken;
if (tcpPort < 1025 || tcpPort > 65535)
{
throw new ArgumentOutOfRangeException("tcpPort", tcpPort, "TCP port must be within IANA specifications of 1025 to 65535");
}
this.endpoint = new IPEndPoint(IPAddress.Loopback, (int)tcpPort);
this.listener = new TcpListener(endpoint); // lib/dea/task.rb, 66
this.listener.Server.NoDelay = true;
}
public void Register(IContainerManager containerManager, CMS.Common.Runtime.ITypeFinder typeFinder)
{
var container = ((Kooboo.CMS.Common.Runtime.Dependency.Ninject.ContainerManager)containerManager).Container;
container.Bind<ICommerceInstanceNameResolver>().ToMethod(ctx =>
{
var resolver = new CompositeCommerceInstanceNameResolver
(
new HttpContextItemCommerceInstanceNameResolver(),
new QueryStringCommerceInstanceNameResolver(),
new HttpHeaderCommerceInstanceNameResolver("X-Kooboo-Commerce-Instance"),
new PostParamsCommerceInstanceNameResolver(),
new RouteDataCommerceInstanceResolver("instance")
);
return resolver;
});
container.Bind<ICommerceDatabase>()
.ToMethod(ctx =>
{
var context = ctx.Kernel.GetService(typeof(CommerceInstanceContext)) as CommerceInstanceContext;
if (context.CurrentInstance == null)
throw new InvalidOperationException("Cannot resolve current commerce instance. Ensure 'commerceName' parameter is included in the http request.");
return context.CurrentInstance.Database;
});
container.Bind(typeof(IRepository<>)).To(typeof(CommerceRepository<>));
}
public void Register(IContainerManager containerManager, ITypeFinder typeFinder)
{
containerManager.AddComponentInstance<IRepositoryProvider>(new RepositoryProvider(containerManager.Resolve<IRepositoryProvider>()));
containerManager.AddComponent<IMediaFolderProvider, MediaFolderProvider>();
containerManager.AddComponent<IMediaContentProvider, MediaContentProvider>();
containerManager.AddComponent<ITextContentFileProvider, TextContentFileProvider>();
}
public void Register(IContainerManager containerManager, ITypeFinder typeFinder)
{
//
var searchSettingProvider = new SearchSettingProvider(containerManager.Resolve<ISearchSettingProvider>());
containerManager.AddComponentInstance(typeof(ISearchSettingProvider), searchSettingProvider);
containerManager.AddComponentInstance(typeof(IProvider<SearchSetting>), searchSettingProvider);
}
public void Register(IContainerManager containerManager, CMS.Common.Runtime.ITypeFinder typeFinder)
{
foreach (var type in typeFinder.FindClassesOfType<ITabPlugin>())
{
containerManager.AddComponent(typeof(ITabPlugin), type, type.FullName, ComponentLifeStyle.Transient);
}
}
public void Register(IContainerManager containerManager, Common.ObjectContainer.ITypeFinder typeFinder)
{
var buttonGroupTypes = typeFinder.FindClassesOfType<IButtonGroup>();
containerManager.AddComponent(typeof(IButtonGroup), buttonGroupTypes);
var buttonPluginTypes = typeFinder.FindClassesOfType<IButtonPlugin>();
containerManager.AddComponent(typeof(IButtonPlugin), buttonPluginTypes);
}
public void Register(IContainerManager containerManager, ITypeFinder typeFinder)
{
containerManager.AddComponent(typeof(IRoleProvider), typeof(RoleProvider));
containerManager.AddComponent(typeof(IProvider<Role>), typeof(RoleProvider));
containerManager.AddComponent(typeof(IUserProvider), typeof(UserProvider));
containerManager.AddComponent(typeof(IProvider<User>), typeof(UserProvider));
}
public JobRequestHandler(IContainerManager containerManager, IJobManager jobManager, Request request)
: base(containerManager, request)
{
if (jobManager == null)
{
throw new ArgumentNullException("jobManager");
}
this.jobManager = jobManager;
}
public void Setup()
{
var build = new ContainerBuilder();
manager = new AutofacContainerManager(build.Build());
manager.AddComponent<ISubscriber<EntityEvent<User>>, UserModelSubscriber>("user");
manager.AddComponent<IObserverService, ObserverService>("service");
EngineContext.Initialize(manager, new ContainerConfig(), false);
}
public void Bind(IContainerManager cm)
{
Console.WriteLine("MyCommonBinder binding");
cm.Register<INormal, Normal>();
cm.Register<IKeyed, Keyed1>("keyed-1");
cm.Register<IKeyed, Keyed2>("keyed-2");
cm.Register<ISingleton>(new Singleton());
cm.Register<Glorp, Glorp>();
}
//public static void ResetProviders()
//{
// var dbContext = SiteDbContext.CreateDbContext();
// dbContext.Database.CreateIfNotExists();
// Kooboo.CMS.Sites.Globalization.DefaultRepositoryFactory.Instance = new LabelProvider.RepositoryFactory();
// var providerFactory = Kooboo.CMS.Sites.Persistence.Providers.ProviderFactory;
// providerFactory.RegisterProvider<IPageProvider>(new PageProvider.PageProvider());
// providerFactory.RegisterProvider<IHtmlBlockProvider>(new HtmlBlockProvider.HtmlBlockProvider());
// providerFactory.RegisterProvider<IUserProvider>(new UserProvider.UserProvider());
// // VersionManager.RegisterVersionLogger<Page>(new PageProvider.PageProvider.PageVersionLogger());
// //VersionManager.RegisterVersionLogger<HtmlBlock>(new HtmlBlockProvider.HtmlBlockProvider.HtmlBlockVersionLogger());
//}
public void Register(IContainerManager containerManager, ITypeFinder typeFinder)
{
Kooboo.CMS.Sites.Globalization.DefaultRepositoryFactory.Instance = new LabelProvider.RepositoryFactory();
containerManager.AddComponent<IPageProvider, PageProvider.PageProvider>();
containerManager.AddComponent<IHtmlBlockProvider, HtmlBlockProvider.HtmlBlockProvider>();
containerManager.AddComponent<IUserProvider, UserProvider.UserProvider>();
var dbContext = SiteDbContext.CreateDbContext();
dbContext.Database.CreateIfNotExists();
}
public void Register(IContainerManager containerManager, CMS.Common.Runtime.ITypeFinder typeFinder)
{
foreach (var type in typeFinder.FindClassesOfType<ICommerceDataSource>())
{
if (type.IsClass && !type.IsAbstract)
{
containerManager.AddComponent(typeof(ICommerceDataSource), type, type.FullName, ComponentLifeStyle.Transient);
}
}
}
public ListRequestHandler(IContainerManager containerManager, Request request)
: base(request)
{
if (containerManager == null)
{
throw new ArgumentNullException("containerManager");
}
this.containerManager = containerManager;
this.request = (ListRequest)request;
}
public void Register(IContainerManager containerManager, CMS.Common.Runtime.ITypeFinder typeFinder)
{
foreach (var type in typeFinder.FindClassesOfType<IRuleParameterProvider>())
{
if (type != typeof(DefaultRuleParameterProvider))
{
var provider = Activator.CreateInstance(type) as IRuleParameterProvider;
RuleParameterProviders.Providers.Add(provider);
}
}
}
public static IEngine Initialize(
IContainerManager containerManager, IContainerConfig containerConfig, bool forceRecreate)
{
if (Singleton<IEngine>.Instance == null || forceRecreate)
{
var config = ConfigurationManager.GetSection("core") as Config;
Singleton<IEngine>.Instance = CreateEngineInstance(config);
Singleton<IEngine>.Instance.Init(containerManager, containerConfig, config);
}
return Singleton<IEngine>.Instance;
}
public void Register(IContainerManager containerManager, CMS.Common.Runtime.ITypeFinder typeFinder)
{
containerManager.AddComponent(typeof(IMenuInjection), typeof(GlobalMenuInjection), "GlobalMenuInjection", ComponentLifeStyle.Singleton);
containerManager.AddComponent(typeof(IMenuInjection), typeof(InstanceMenuInjection), "InstanceMenuInjection", ComponentLifeStyle.Singleton);
foreach (var type in typeFinder.FindClassesOfType<IMenuInjection>())
{
if (typeof(CommerceMenuInjection).IsAssignableFrom(type)
&& type != typeof(GlobalMenuInjection)
&& type != typeof(InstanceMenuInjection))
{
containerManager.AddComponent(typeof(IMenuInjection), type, type.FullName, ComponentLifeStyle.Transient);
}
}
}
public CopyRequestHandler(IContainerManager containerManager, Request request, Response response)
: base(containerManager, request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
this.request = (ICopyRequest)request;
if (response == null)
{
throw new ArgumentNullException("response");
}
this.response = response;
}
public void Register(IContainerManager containerManager, CMS.Common.Runtime.ITypeFinder typeFinder)
{
RegisterActivities(containerManager, typeFinder);
var manager = EventSlotManager.Instance;
manager.Register<BrandCreated>("Brands", "Created");
manager.Register<BrandUpdated>("Brands", "Updated");
manager.Register<BrandDeleted>("Brands", "Deleted");
manager.Register<CategoryCreated>("Categories", "Created");
manager.Register<CategoryUpdated>("Categories", "Updated");
manager.Register<CategoryDeleted>("Categories", "Deleted");
manager.Register<ProductTypeEnabled>("Product Types", "Enabled");
manager.Register<ProductTypeDisabled>("Product Types", "Disabled");
manager.Register<ProductCreated>("Products", "Created");
manager.Register<ProductUpdated>("Products", "Updated");
manager.Register<ProductDeleted>("Products", "Deleted");
manager.Register<ProductPublished>("Products", "Published");
manager.Register<ProductUnpublished>("Products", "Unpublished");
manager.Register<GetPrice>("Products");
manager.Register<CustomerCreated>("Customers", "Created");
manager.Register<CustomerUpdated>("Customers", "Updated");
manager.Register<CustomerDeleted>("Customers", "Deleted");
manager.Register<PromotionEnabled>("Promotions", "Enabled");
manager.Register<PromotionDisabled>("Promotions", "Disabled");
manager.Register<CartCreated>("Carts", "Created");
manager.Register<CartItemAdded>("Carts", "Item Added");
manager.Register<CartItemQuantityChanged>("Carts", "Item Quantity Changed");
manager.Register<CartItemRemoved>("Carts", "Item Removed");
manager.Register<CartPriceCalculated>("Carts", "Price Calculated");
manager.Register<CartExpired>("Carts", "Expires");
manager.Register<OrderCreated>("Orders", "Created");
manager.Register<OrderStatusChanged>("Orders", "Status Changed");
manager.Register<PaymentStatusChanged>("Orders", "Payment Status Changed");
manager.Register<PaymentMethodEnabled>("Payment Methods", "Enabled");
manager.Register<PaymentMethodDisabled>("Payment Methods", "Disabled");
manager.Register<ShippingMethodEnabled>("Shipping Methods", "Enabled");
manager.Register<ShippingMethodDisabled>("Shipping Methods", "Disabled");
}
public Glorp(IContainerManager containerManager, INormal normal1, INormal normal2, ISingleton singleton1, ISingleton singleton2)
{
IKeyed keyed1_1 = containerManager.GetInstance<IKeyed>("keyed-1");
IKeyed keyed1_2 = containerManager.GetInstance<IKeyed>("keyed-1");
IKeyed keyed2_1 = containerManager.GetInstance<IKeyed>("keyed-2");
IKeyed keyed2_2 = containerManager.GetInstance<IKeyed>("keyed-2");
string format = "{0} Name={1}, Key={2}";
Console.WriteLine(format, "normal1", normal1.Name, normal1.Key);
Console.WriteLine(format, "normal2", normal2.Name, normal2.Key);
Console.WriteLine(format, "singleton1", singleton1.Name, singleton1.Key);
Console.WriteLine(format, "singleton2", singleton2.Name, singleton2.Key);
Console.WriteLine(format, "keyed1_1", keyed1_1.Name, keyed1_1.Key);
Console.WriteLine(format, "keyed1_2", keyed1_2.Name, keyed1_2.Key);
Console.WriteLine(format, "keyed2_1", keyed2_1.Name, keyed2_1.Key);
Console.WriteLine(format, "keyed2_2", keyed2_2.Name, keyed2_2.Key);
}
public void MyTestInitialize()
{
mocks = new MockRepository();
containerManager = ContainerUtil.Initialize(true);
windsorContainer = ((IWindsorContainerManager)containerManager).WindsorContainer;
LibInstaller.RegisterLogging(windsorContainer);
containerManager.Register<IAsyncTcpClient, AsyncTcpClient>();
Log = containerManager.GetInstance<ILogManager>();
Logger = Log.GetLogger(typeof(AsyncTcpClientTest));
//containerManager.Register<IMarqueeManager, MarqueeManager>();
//map = mocks.StrictMock<IMarqueeCharacterMap>();
//containerManager.Register<IMarqueeCharacterMap>(map);
//device = mocks.StrictMock<IMarqueeDevice>();
//containerManager.Register<IMarqueeDevice>(device);
}
public void Register(IContainerManager containerManager, ITypeFinder typeFinder)
{
//
var mediaFolderProvider = new MediaFolderProvider(containerManager.Resolve<IMediaFolderProvider>());
containerManager.AddComponentInstance(typeof(IMediaFolderProvider), mediaFolderProvider);
containerManager.AddComponentInstance(typeof(IProvider<MediaFolder>), mediaFolderProvider);
var repositoryProvider = new RepositoryProvider(containerManager.Resolve<IRepositoryProvider>());
containerManager.AddComponentInstance(typeof(IRepositoryProvider), repositoryProvider);
containerManager.AddComponentInstance(typeof(IProvider<Repository>), repositoryProvider);
var schemaProvider = new SchemaProvider(containerManager.Resolve<ISchemaProvider>());
containerManager.AddComponentInstance(typeof(ISchemaProvider), schemaProvider);
containerManager.AddComponentInstance(typeof(IProvider<Schema>), schemaProvider);
var textFolderProvider = new TextFolderProvider(containerManager.Resolve<ITextFolderProvider>());
containerManager.AddComponentInstance(typeof(ITextFolderProvider), textFolderProvider);
containerManager.AddComponentInstance(typeof(IProvider<TextFolder>), textFolderProvider);
}
public void Register(IContainerManager containerManager, CMS.Common.Runtime.ITypeFinder typeFinder)
{
var assemblies = typeFinder.GetAssemblies()
.Where(x => !IsIgnoredAssembly(x))
.ToList();
// Handler Registry
var handlerRegistry = new DefaultEventHandlerRegistry();
handlerRegistry.RegisterAssemblies(assemblies);
containerManager.AddComponentInstance<IEventHandlerRegistry>(handlerRegistry);
// Event Registry
var eventRegistry = new DefaultEventRegistry();
eventRegistry.RegisterAssemblies(assemblies);
containerManager.AddComponentInstance<IEventRegistry>(eventRegistry);
// Event Dispatcher
var eventDispatcher = new DefaultEventDispatcher(handlerRegistry);
containerManager.AddComponentInstance<IEventDispatcher>(eventDispatcher);
}
/// <summary>
/// register necessary type
/// </summary>
/// <param name="engine"></param>
/// <param name="containerManager"></param>
/// <param name="broker"></param>
/// <param name="configuration"></param>
public virtual void Init(IEngine engine, IContainerManager containerManager, EventBroker broker, Config configuration)
{
// register singleton instance
containerManager.AddComponentInstance<Config>(configuration, typeof(Config).Name);
containerManager.AddComponentInstance<IEngine>(engine, engine.GetType().Name);
containerManager.AddComponentInstance<EventBroker>(broker, broker.GetType().Name);
containerManager.AddComponentInstance<ContainerConfigBase>(this, this.GetType().Name);
// register type
containerManager.AddComponent<ISearcher, WebsiteSearcher>(typeof(WebsiteSearcher).Name);
// register type: should remove in future (to use configuration provider to config and register)
// TO-DO: Check if I register this time multi times (should not)
//containerManager.AddComponent<DatabaseSettings>(typeof(DatabaseSettings).Name); // to remove because data dll has been decoupled
// TO-DO: Check if register it before and figure out how to set it
containerManager.AddComponentInstance<StoreStateSettings>(
new StoreStateSettings
{
DefaultStoredThemeForDesktop = "Default",
DefaultStoredThemeForMobile = "Default",
EnableMiniProfile = true
},
typeof(StoreStateSettings).Name);
containerManager.AddComponentInstance<UserSettings>(new UserSettings
{
StoreLastVisitedPage = true,
UsingUserEmail = true
},
typeof(UserSettings).Name);
// TO-DO: Check if register it before and figure out how to set it
containerManager.AddComponentInstance<PageSettings>(new PageSettings { DefaultTitle = "HomePage" }, typeof(PageSettings).Name, Infrastructure.IoC.LifeStyle.Singleton);
// register IRegistrar
containerManager.UpdateContainer(build =>
{
var searcher = containerManager.Resolve<ISearcher>(typeof(WebsiteSearcher).Name);
searcher.RoutingToExecute<IRegistrar>(i => i.Register(build, searcher));
});
// TO-DO
}
public void Register(IContainerManager containerManager, CMS.Common.Runtime.ITypeFinder typeFinder)
{
var assemblies = typeFinder.GetAssemblies()
.Where(x => !IsIgnoredAssembly(x))
.ToList();
foreach (var assembly in assemblies)
{
foreach (var handlerType in assembly.GetTypes())
{
if (!handlerType.IsClass || handlerType.IsAbstract || handlerType.IsGenericType)
{
continue;
}
foreach (var eventType in GetHandledEventTypes(handlerType))
{
Event.Listen(eventType, handlerType);
}
}
}
}
public StopRequestHandler(IContainerManager containerManager, Request request)
: base(containerManager, request)
{
this.request = (StopRequest)request;
}
public LinkRequestHandler(IContainerManager containerManager, IJobManager jobManager, Request request)
: base(containerManager, jobManager, request)
{
this.request = (LinkRequest)request;
}
public MainViewModel(IContainerManager containerManager, IAppSettingsProvider appSettingsProvider, ILoginService loginService) : base(containerManager)
{
_appSettingsProvider = appSettingsProvider;
_loginService = loginService;
}
public ContainerSlot(string id, IContainerManager manager) : base(id, manager)
{
}
public ApplicationIoCEngine()
{
ContainerBuilder builder = new ContainerBuilder();
_containerManager = new AutoFacContainerManager(builder.Build());
}
/// <summary>
/// DO NOT CALL THIS METHOD DIRECTLY!
/// You want <see cref="IContainerManager.MakeContainer{T}(string)" /> or <see cref="Create" /> instead.
/// </summary>
public Container(string id, IContainerManager manager)
{
ID = id;
Manager = manager;
}
public void Register(IContainerManager containerManager, ITypeFinder typeFinder)
{
containerManager.AddComponent <IMediaFolderProvider, MediaFolderProvider>();
containerManager.AddComponent <IMediaContentProvider, MediaContentProvider>();
containerManager.AddComponent <ITextContentFileProvider, TextContentFileProvider>();
}
public void Register(IContainerManager containerManager, ITypeFinder typeFinder)
{
Kooboo.CMS.Content.Models.UserKeyGenerator.DefaultGenerator = new Kooboo.CMS.Content.UserKeyGenerator.Chinese.UserKeyGenerator();
}
/// <summary>
/// Initialize components and plugins in the nop environment.
/// </summary>
/// <param name="config">Config</param>
public void Initialize(CoreConfig config)
{
//dependencies
var builder = new ContainerBuilder();
builder.RegisterInstance(config).As <CoreConfig>().SingleInstance();
builder.RegisterInstance(this).As <IEngine>().SingleInstance();
ITypeFinder typeFinder = new WebAppTypeFinder(config);
builder.RegisterInstance(typeFinder).As <ITypeFinder>().SingleInstance();
//builder = new ContainerBuilder();
string fullNameCurrentFinder = typeFinder.GetType().FullName;
var listTypeFinder = typeFinder.FindClassesOfType <ITypeFinder>().ToList();
var tfInstances = new List <ITypeFinder>();
foreach (var tfType in listTypeFinder)
{
var ctor = tfType.GetConstructors().FirstOrDefault(c => c.GetParameters().Length == 1);
if (ctor != null && ctor.GetParameters()[0].ParameterType == typeof(CoreConfig))
{
tfInstances.Add((ITypeFinder)Activator.CreateInstance(tfType, config));
}
else
{
tfInstances.Add((ITypeFinder)Activator.CreateInstance(tfType));
}
}
var listConfig = typeFinder.FindClassesOfType <ConfigBase>();
foreach (var configType in listConfig)
{
var configBase = (ConfigBase)Activator.CreateInstance(configType);
var instanceConfig = ConfigContext.GetConfig(configBase.SectionName);
builder.RegisterInstance(instanceConfig).As(configType).SingleInstance();
}
//register dependencies provided by other assemblies
var drTypes = typeFinder.FindClassesOfType <IDependencyRegistrar>();
var drInstances = new List <IDependencyRegistrar>();
foreach (var drType in drTypes)
{
IDependencyRegistrar dependencyRegistrar = (IDependencyRegistrar)Activator.CreateInstance(drType);
drInstances.Add(dependencyRegistrar);
}
//sort
drInstances = drInstances.AsQueryable().OrderBy(t => t.Order).ToList();
foreach (var dependencyRegistrar in drInstances)
{
dependencyRegistrar.Register(builder, typeFinder, config);
}
//controllers
builder.RegisterControllers(typeFinder.GetAssemblies().ToArray());
var container = builder.Build();
_containerManager = new WebContainerManager(container);
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
}
public void Register(IContainerManager containerManager, ITypeFinder typeFinder)
{
containerManager.AddComponent <Kooboo.CMS.Content.Services.WorkflowManager, ContentWorkflowManager>();
containerManager.AddComponent <Kooboo.CMS.Content.Services.SendingSettingManager, SendingSettingManager>();
}
public MessageRecieved(IContainerManager containerManager)
{
this.containerManager = containerManager;
}
public LoggingRequestHandler(IContainerManager containerManager, Request request)
: base(containerManager, request)
{
this.request = (LoggingRequest)request;
}
/// <summary>
/// Gets a thing container from a location.
/// </summary>
/// <param name="fromLocation">The location from which to decode the container information.</param>
/// <param name="map">A reference to the map.</param>
/// <param name="containerManager">A reference to the container manager.</param>
/// <param name="index">The index within the cyclinder to target.</param>
/// <param name="carrierCreature">The creature that carries the decoded container. Required for locations of type <see cref="LocationType.InsideContainer"/> and <see cref="LocationType.InventorySlot"/>.</param>
/// <returns>An instance of the target <see cref="IItemsContainer"/> of the location.</returns>
public static IItemsContainer DecodeContainer(this Location fromLocation, IMap map, IContainerManager containerManager, out byte index, ICreature carrierCreature = null)
{
map.ThrowIfNull(nameof(map));
containerManager.ThrowIfNull(nameof(containerManager));
index = 0;
if (fromLocation.Type == LocationType.Map && map.HasTileAt(fromLocation, out ITile fromTile))
{
index = byte.MaxValue;
return(fromTile);
}
else if (fromLocation.Type == LocationType.InventorySlot)
{
carrierCreature.ThrowIfNull(nameof(carrierCreature));
index = (byte)fromLocation.Slot;
// creature?.Inventory[(byte)fromLocation.Slot] as IContainerItem
return(carrierCreature);
}
else if (fromLocation.Type == LocationType.InsideContainer)
{
carrierCreature.ThrowIfNull(nameof(carrierCreature));
index = fromLocation.ContainerIndex;
return(containerManager.FindForCreature(carrierCreature.Id, fromLocation.ContainerId));
}
return(null);
}
public static void RegisterConfig(this IContainerManager containerManager, XElement root)
{
var compEles = root.Element("components").Elements("component");
foreach (var ele in compEles)
{
var serviceType = GetTypeByFullName(ele.Attribute("type").Value);
var interfaceType = GetTypeByFullName(ele.Attribute("service").Value);
ComponentLifeStyle scope = ComponentLifeStyle.Transient;
if (ele.Attribute("scope") != null)
{
switch (ele.Attribute("scope").Value.ToLower())
{
case "singleton":
scope = ComponentLifeStyle.Singleton;
break;
case "request":
scope = ComponentLifeStyle.InRequestScope;
break;
case "thread":
scope = ComponentLifeStyle.InThreadScope;
break;
case "transiant":
default:
scope = ComponentLifeStyle.Transient;
break;
}
}
string name = ele.Attribute("name") == null ? null : ele.Attribute("name").Value;
if (ele.HasElements)
{
var paraEles = ele.Element("parameters").Elements("parameter");
var constructors = serviceType.GetConstructors();
foreach (var constructor in constructors)
{
var parameters = constructor.GetParameters();
List <object> pvals = new List <object>();
try
{
foreach (var para in parameters)
{
var pele = paraEles.FirstOrDefault(e => e.Attribute("name").Value.ToLower() == para.Name.ToLower());
object val = null;
if (pele != null)
{
val = ConvertTo(para.ParameterType, pele.Attribute("value").Value);
}
else
{
val = containerManager.TryResolve(para.ParameterType);
}
pvals.Add(val);
}
object instance = constructor.Invoke(pvals.ToArray());
containerManager.AddComponentInstance(interfaceType, instance, name);
}
catch
{
continue;
}
}
}
else
{
containerManager.AddComponent(interfaceType, serviceType, name, scope);
}
}
var moduleEles = root.Element("modules").Elements("module");
foreach (var ele in moduleEles)
{
var moduleType = Type.GetType(ele.Attribute("type").Value);
IIocModule module = Activator.CreateInstance(moduleType) as IIocModule;
containerManager.RegisterModule(module);
}
}
public CreateRequestHandler(IContainerManager containerManager, Request request)
: base(containerManager, request)
{
this.request = (CreateRequest)request;
}
public LimitMemoryRequestHandler(IContainerManager containerManager, Request request)
: base(containerManager, request)
{
this.request = (LimitMemoryRequest)request;
}
/// <summary>
/// DO NOT CALL THIS METHOD DIRECTLY!
/// You want <see cref="IContainerManager.MakeContainer{T}(string)" /> or <see cref="Create" /> instead.
/// </summary>
protected BaseContainer(string id, IContainerManager manager)
{
ID = id;
Manager = manager;
}
public static void RegisterModule(this IContainerManager containerManager, IIocModule module)
{
module.Load(containerManager);
}
public TaskRequestHandler(IContainerManager containerManager, Request request)
: base(containerManager, request)
{
}
public LoginViewModel(IContainerManager containerManager) : base(containerManager)
{
}
protected BaseViewModel(IContainerManager containerManager)
{
ContainerManager = containerManager;
}
public void Register(IContainerManager containerManager, ITypeFinder typeFinder)
{
containerManager.AddResolvingObserver(new ResolvingObserver());
}
public CopyInRequestHandler(IContainerManager containerManager, Request request)
: base(containerManager, request, new CopyInResponse())
{
}
public DependencyAttributeRegistrator(ITypeFinder finder, IContainerManager containerManager)
{
this._finder = finder;
this._containerManager = containerManager;
}
/// <summary>
/// 替换容器，实现自定义容器
/// </summary>
/// <param name="containerManager">容器</param>
/// <remarks></remarks>
public static void Replace(IContainerManager containerManager)
{
Singleton <IContainerManager> .Instance = containerManager;
}
/// <inheritdoc />
public ContainerOnlyContainer(string id, IContainerManager manager) : base(id, manager)
{
}
