public CommandLineCommand(CommandLineParserOptions parserOptions, IArgumentResolverFactory resolverFactory, IContainerResolver containerResolver, TOption option)
{
m_parserOptions = parserOptions;
m_commandOption = new TCommandOption();
m_containerResolver = containerResolver;
m_resolverFactory = resolverFactory;
m_baseOption = option;
if (m_parserOptions.EnableHelpOption)
{
var tokens = m_parserOptions.HelpOptionName.Split('|');
if (tokens.Length > 1)
{
m_helpOptionName = $"{m_parserOptions.PrefixShortOption}{tokens[0]}";
m_helpOptionNameLong = $"{m_parserOptions.PrefixLongOption}{tokens[1]}";
}
else
{
m_helpOptionName = $"{m_parserOptions.PrefixLongOption}{tokens[0]}";
m_helpOptionNameLong = null;
}
}
InitialzeModel();
}
/// <summary>
/// Container Resolver pipeline is used to resolve dependencies or cleanup the dependencies of the container
/// </summary>
public static IContainerResolver Pipe <T>(this IContainerResolver container) where T : class, IContainerResolverPipeline, new()
{
var pipeline = new T();
var newContainer = pipeline.Pipe(container);
return(newContainer);
}
private static ICache GetCache(IContainerResolver resolver)
{
var appSettings = resolver.Resolve <IAppEnvironment>();
var cacheSettings = resolver.Resolve <CacheSettings>();
ICache cache;
var keyspace = appSettings.Name;
if (string.Equals(cacheSettings.Type, CacheSettings.RedisCacheKey, StringComparison.OrdinalIgnoreCase))
{
var redisCacheFactory = resolver.Resolve <Func <string, RedisCacheImpl> >();
cache = redisCacheFactory(keyspace);
}
else if (string.Equals(cacheSettings.Type, CacheSettings.TwoLayerCacheKey, StringComparison.OrdinalIgnoreCase))
{
var memoryCacheFactory = resolver.Resolve <Func <string, MemoryCacheImpl> >();
var redisCacheFactory = resolver.Resolve <Func <string, RedisCacheImpl> >();
var twoLayerCacheFactory = resolver.Resolve <TwoLayerCacheFactory>();
cache = twoLayerCacheFactory(memoryCacheFactory(keyspace), redisCacheFactory(keyspace));
}
else
{
var memoryCacheFactory = resolver.Resolve <Func <string, MemoryCacheImpl> >();
cache = memoryCacheFactory(keyspace);
}
return(cache);
}
/// <summary>
/// Initializes a new instance of the ContainerControllerFactory class that will initialize
/// controllers through StructureMap containers
/// </summary>
/// <param name="resolver">
/// Dependency container resolver from which to pull dependency instances
/// </param>
/// <exception cref="System.ArgumentNullException">Thrown when <paramref name="resolver"/> is null</exception>
public ContainerControllerFactory(IContainerResolver resolver)
{
Ensure.Argument.NotNull(resolver, "resolver");
this.ContainerResolver = resolver;
this.typeCache = new ThreadSafeDictionary<IContainer, IDictionary<string, Type>>();
ContainerControllerFactory._sessionStateCache = new ConcurrentDictionary<Type, SessionStateBehavior>();
}
/// <summary>
/// Initializes a new instance of the ContainerControllerFactory class that will initialize
/// controllers through StructureMap containers
/// </summary>
/// <param name="resolver">
/// Dependency container resolver from which to pull dependency instances
/// </param>
/// <exception cref="System.ArgumentNullException">Thrown when <paramref name="resolver"/> is null</exception>
public ContainerControllerFactory(IContainerResolver resolver)
{
Ensure.Argument.NotNull(resolver, "resolver");
this.ContainerResolver = resolver;
this.typeCache = new ThreadSafeDictionary <IContainer, IDictionary <string, Type> >();
ContainerControllerFactory._sessionStateCache = new ConcurrentDictionary <Type, SessionStateBehavior>();
}
static void Test(IContainerResolver resolver)
{
var a = resolver.Get <A>();
var b = resolver.Get <B>();
Assert.NotNull(b.A);
Assert.Equal(b.A, a);
}
public override Result Execute(IContainerResolver container, ExternalCommandData commandData, ref string message, ElementSet elements)
{
// Asks the container for a new instance of a view
var wpfView = container.Resolve <IHelloWpfView>();
wpfView.ShowDialog();
return(Result.Succeeded);
}
public override Result Execute(IContainerResolver container, ExternalCommandData commandData, ref string message, ElementSet elements)
{
// Asks the container for a new instance a message service
var messageService = container.Resolve <IMessageService>();
messageService.Show("Hello Onbox Framework!");
return(Result.Succeeded);
}
public IOwinHostingContext CreateOwinHostingContext(HostingConfig hostingConfig)
{
var autofacContainerBuilder = new ContainerBuilder();
var containerModuleScanner = new BaseDirectoryContainerModuleScanner();
// Поиск всех доступных модулей
var containerModules = containerModuleScanner.FindContainerModules();
foreach (var moduleInfo in containerModules)
{
var containerModule = CreateContainerModule(moduleInfo);
// Регистрация очередного модуля
autofacContainerBuilder.RegisterModule(new AutofacContainerModule(containerModule));
}
// Регистрация IoC-модуля для OWIN
autofacContainerBuilder.RegisterType <AutofacOwinHostingModule>()
.As <IOwinHostingModule>()
.SingleInstance();
// ReSharper disable AccessToModifiedClosure
// Регистрация самого Autofac-контейнера
IContainer autofacRootContainer = null;
Func <IContainer> autofacRootContainerFactory = () => autofacRootContainer;
autofacContainerBuilder.RegisterInstance(autofacRootContainerFactory);
autofacContainerBuilder.Register(r => r.Resolve <Func <IContainer> >()()).As <IContainer>().SingleInstance();
// Регистрация обертки над контейнером
IContainerResolver containerResolver = null;
Func <IContainerResolver> containerResolverFactory = () => containerResolver;
autofacContainerBuilder.RegisterInstance(containerResolverFactory);
autofacContainerBuilder.Register(r => r.Resolve <Func <IContainerResolver> >()()).As <IContainerResolver>().SingleInstance();
// Регистрация контейнера для WebApi
IDependencyResolver webApiDependencyResolver = null;
Func <IDependencyResolver> webApiDependencyResolverFactory = () => webApiDependencyResolver;
autofacContainerBuilder.RegisterInstance(webApiDependencyResolverFactory);
autofacContainerBuilder.Register(r => r.Resolve <Func <IDependencyResolver> >()()).As <IDependencyResolver>().SingleInstance();
// ReSharper restore AccessToModifiedClosure
// Построение контейнера зависимостей
autofacRootContainer = autofacContainerBuilder.Build();
containerResolver = new AutofacContainerResolver(autofacRootContainer, Middleware.AutofacRequestLifetimeScopeOwinMiddleware.TryGetRequestContainer);
webApiDependencyResolver = new AutofacWebApiDependencyResolver(autofacRootContainer);
return(new OwinHostingContext(hostingConfig, containerResolver, new AutofacOwinMiddlewareResolver()));
}
public void ShouldArrangeAndAssertExpressionInvolvingCollectionInitializerSyntax()
{
IContainerResolver containerResolver = Mock.Create <IContainerResolver>();
Mock.Arrange(() => containerResolver.Resolve <MockDirectoryInfo>(new Dictionary <string, object> {
{ "path", @"pptestRoot\DrivesData\TestFamily" }
})).Returns(new MockDirectoryInfo("ss")).OccursOnce();
var ex = Assert.Throws <AssertionException>(() => Mock.Assert(containerResolver));
Assert.True(ex.Message.Contains("Occurrence expectation failed."));
}
public void Activate(object instance, IContainerResolver resolver)
{
var instanceType = instance.GetType();
var properties = instanceType.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Where(p => p.PropertyType == typeof(T) && p.CanWrite &&
p.GetIndexParameters().Length == 0);
foreach (var propToSet in properties)
{
propToSet.SetValue(instance, _logFactory(instanceType), null);
}
}
public override Result Execute(IContainerResolver container, ExternalCommandData commandData, ref string message, ElementSet elements)
{
var doc = commandData.Application.ActiveUIDocument.Document;
// Get current grids
var gridCollector = container.Resolve <IGridCollector>();
var horizontalGrids = gridCollector.CollectHorizontalGrids(doc);
var verticalGrids = gridCollector.CollectVerticalGrids(doc);
// Convert Grids to GridInfo
var revitGridService = container.Resolve <IRevitGridService>();
var horizontalGridInfoList = revitGridService.ConvertToGridInfoList(horizontalGrids, false);
var verticalGridInfoList = revitGridService.ConvertToGridInfoList(verticalGrids, true);
// Instantiate view and set grid info lists
var gridGeneratorView = container.Resolve <IGridGeneratorView>();
gridGeneratorView.SetHorizontalGrids(horizontalGridInfoList);
gridGeneratorView.SetVerticalGrids(verticalGridInfoList);
var dialogResult = gridGeneratorView.ShowDialog();
if (dialogResult == true)
{
var grids = new List <GridInfo>();
grids.AddRange(gridGeneratorView.GetHorizontalGrids());
grids.AddRange(gridGeneratorView.GetVerticalGrids());
using (var t = new Transaction(doc, "Create grids"))
{
t.Start();
// Clear Existing grids and create the new ones
revitGridService.DeleteGrids(doc);
revitGridService.CreateRevitGrids(doc, grids);
t.Commit();
}
}
return(Result.Succeeded);
}
private static UserManager <IdentityApplicationUser> CreateUserManager(IContainerResolver resolver)
{
var appUserStore = resolver.Resolve <IApplicationUserStore>();
var appPasswordHasher = resolver.Resolve <IApplicationUserPasswordHasher>();
// Хранилище учетных записей пользователей для AspNet.Identity
var identityUserStore = new IdentityApplicationUserStore(appUserStore);
// Сервис проверки учетных записей пользователей для AspNet.Identity
var identityUserValidator = new IdentityApplicationUserValidator(identityUserStore);
// Сервис хэширования паролей пользователей для AspNet.Identity
var identityPasswordHasher = new IdentityApplicationUserPasswordHasher(appPasswordHasher);
var userManager = new UserManager <IdentityApplicationUser>(identityUserStore)
{
UserValidator = identityUserValidator,
PasswordHasher = identityPasswordHasher
};
return(userManager);
}
private static IMessageBusPublisher GetMessageBusPublisher(IContainerResolver resolver)
{
var appSettings = resolver.Resolve <IAppEnvironment>();
var cacheSettings = resolver.Resolve <CacheSettings>();
var keyspace = appSettings.Name;
IMessageBusPublisher messageBusPublisher;
if (string.Equals(cacheSettings.Type, CacheSettings.RedisCacheKey, StringComparison.OrdinalIgnoreCase) ||
string.Equals(cacheSettings.Type, CacheSettings.TwoLayerCacheKey, StringComparison.OrdinalIgnoreCase))
{
var redisMessageBusPublisherFactory = resolver.Resolve <Func <string, RedisMessageBusPublisher> >();
messageBusPublisher = redisMessageBusPublisherFactory(keyspace);
}
else
{
messageBusPublisher = resolver.Resolve <MemoryMessageBusPublisher>();
}
return(messageBusPublisher);
}
/// <summary>
/// Creates a new instance of the commandline parser
/// </summary>
/// <param name="argumentResolverFactory">argument resolver to use</param>
/// <param name="containerResolver">container resolver to use</param>
/// <param name="parserOptions">The options the parser will use</param>
public CommandLineParser(CommandLineParserOptions parserOptions, IArgumentResolverFactory argumentResolverFactory, IContainerResolver containerResolver)
{
ParserOptions = parserOptions;
m_option = new TOption();
m_options = new Dictionary <string, CommandLineOptionBase>();
m_commands = new List <CommandLineCommandBase>();
ArgumentResolverFactory = argumentResolverFactory;
ContainerResolver = containerResolver;
if (string.IsNullOrWhiteSpace(ParserOptions.AppName))
{
ParserOptions.AppName = Process.GetCurrentProcess().ProcessName;
}
Printer = new UsagePrinter(parserOptions, this, new UsageBuilder(parserOptions));
if (ParserOptions.EnableHelpOption)
{
var tokens = ParserOptions.HelpOptionName.Split('|');
if (tokens.Length > 1)
{
m_helpOptionName = $"{ParserOptions.PrefixShortOption}{tokens[0]}";
m_helpOptionNameLong = $"{ParserOptions.PrefixLongOption}{tokens[1]}";
}
else
{
m_helpOptionName = $"{ParserOptions.PrefixLongOption}{tokens[0]}";
m_helpOptionNameLong = null;
}
}
InitialzeModel();
}
/// <summary>
/// Initializes a new instance of the ContainerControllerFactory class that will initialize
/// controllers through StructureMap containers
/// </summary>
/// <param name="resolver">
/// Dependency container resolver from which to pull dependency instances
/// </param>
/// <exception cref="System.ArgumentNullException">Thrown when <paramref name="resolver"/> is null</exception>
public ContainerControllerFactory(IContainerResolver resolver)
{
Ensure.Argument.NotNull(resolver, "resolver");
this.ContainerResolver = resolver;
this.typeCache = new ThreadSafeDictionary<IContainer, IDictionary<string, Type>>();
}
T exec <T>(IContainerResolver resolver)
{
return(resolver.ResolveOrDefault <T>());
}
public DocumentStorageProviderFactory(IContainerResolver containerResolver, Func <string, IDocumentStorageProvider> storageProviderFactory)
{
_containerResolver = containerResolver;
_storageProviderFactory = storageProviderFactory;
}
/// <summary>
/// Initializes a new instance of the ContainerControllerActionInvoker class
/// </summary>
/// <param name="containerResolver">Dependency container resolver used to inject containers when necessary</param>
public ContainerControllerActionInvoker(IContainerResolver containerResolver)
{
Ensure.Argument.NotNull(containerResolver, "containerResolver");
this.containerResolver = containerResolver;
}
/// <summary>
/// Creates a new instance of the commandline parser
/// </summary>
/// <param name="parserOptions">options that the parser will use</param>
/// <param name="containerResolver">container resolver to use</param>
public CommandLineParser(CommandLineParserOptions parserOptions, IContainerResolver containerResolver)
: this(parserOptions, new DefaultArgumentResolverFactory(), containerResolver)
{
}
public override Result OnShutdown(IContainerResolver container, UIControlledApplication application)
{
// No Need to cleanup the Container, the framework will do it for you
return(Result.Succeeded);
}
T exec <T>(IContainerResolver container)
{
T result = container.ResolveOrAuto <T>();
return(result);
}
public OwinContextProvider(IContainerResolver containerResolver)
{
_containerResolver = containerResolver;
}
/// <summary>
/// Initializes a new instance of the ContainerControllerActionInvoker class
/// </summary>
/// <param name="containerResolver">Dependency container resolver used to inject containers when necessary</param>
public ContainerControllerActionInvoker(IContainerResolver containerResolver)
{
Ensure.Argument.NotNull(containerResolver, "containerResolver");
this.containerResolver = containerResolver;
}
public TestContainerControllerFactory(IContainerResolver resolver)
: base(resolver)
{
}
public override Result Execute(IContainerResolver container, ExternalCommandData commandData, ref string message, ElementSet elements)
{
throw new System.Exception("Boooom!");
}
public bool CanResolve(ParameterInfo parameterInfo, IContainerResolver resolver)
{
return(parameterInfo.ParameterType == typeof(T));
}
public object Resolve(ParameterInfo parameterInfo, IContainerResolver resolver)
{
return(_logFactory(parameterInfo.Member.DeclaringType));
}
public override Result Execute(IContainerResolver container, ExternalCommandData commandData, ref string message, ElementSet elements)
{
return(Result.Succeeded);
}
private static MongoConnectionSettings GetMongoConnectionSettings(IContainerResolver resolver)
{
return(resolver.Resolve <IAppConfiguration>().GetSection <MongoConnectionSettings>(MongoConnectionSettings.SectionName));
}
public CommandBus(IContainerResolver resolver)
{
this.resolver = resolver;
}
private static MongoConnection GetMongoConnection(IContainerResolver resolver)
{
return(new MongoConnection(resolver.Resolve <IAppEnvironment>().Name, resolver.Resolve <MongoConnectionSettings>()));
}
public DocumentHttpServiceFactory(IContainerResolver containerResolver)
{
_containerResolver = containerResolver;
}
public override Result OnShutdown(IContainerResolver container, UIControlledApplication application)
{
return(Result.Succeeded);
}
