private static void ExecuteSampleCommands(IDependencyInjector container)
{
var bus = container.Get <IBus>();
bus.SendCommand(new RegisterEmployeeCommand(
"12345",
new FullName("John", "Doe"),
100m
));
bus.SendCommand(new RegisterEmployeeCommand(
"54321",
new FullName("Mary", "Loo"),
103m
));
bus.SendCommand(new UpdateEmployeeHomeAddressCommand(
"12345",
BrazilianAddress.Factory.New("Nice street", 42, null, "Good Ville", "MyCity", "XX", "91234-123"))
);
bus.SendCommand(new RaiseEmployeeSalaryCommand(
id: "12345",
amount: 10m));
bus.SendCommand(new RaiseEmployeeSalaryCommand("12345", 20m));
bus.SendCommand(new RaiseEmployeeSalaryCommand("12345", 13m));
bus.SendCommand(new UpdateEmployeeHomeAddressCommand(
"12345",
BrazilianAddress.Factory.New("Main avenue", 42, null, "Good Ville", "MyCity", "XX", "91234-123"))
);
bus.SendCommand(new RaiseEmployeeSalaryCommand("12345", 21m));
bus.SendCommand(new RaiseEmployeeSalaryCommand("12345", 14m));
}
public Injector(IDependencyInjector injector, IDependencyFactory factory, IValueBinder valueBinder, IPresenterBinder controlBinder) : this()
{
SetInjector(injector);
SetFactory(factory);
SetBinder(valueBinder);
SetControlBinder(controlBinder);
}
public FolderNodeProvider(IFileSystem fs, IRepository<ContentItem> repository, IDependencyInjector dependencyInjector)
{
UploadFolderPaths = new FolderReference[0];
this.fs = fs;
this.repository = repository;
this.dependencyInjector = dependencyInjector;
}
internal static Items.Directory New(DirectoryData dir, ContentItem parent, IDependencyInjector injector)
{
var node = new Directory(dir, parent);
injector.FulfilDependencies(node);
return(node);
}
private void RegisterThemes(IDependencyInjector container)
{
foreach (var theme in Themes.Where(x => x.Theme != null))
{
container.Register(theme.Theme, true);
}
}
public FolderNodeProvider(IFileSystem fs, IRepository <ContentItem> repository, IDependencyInjector dependencyInjector)
{
UploadFolderPaths = new FolderPair[0];
this.fs = fs;
this.repository = repository;
this.dependencyInjector = dependencyInjector;
}
public FolderNodeProvider(IFileSystem fs, IPersister persister, IDependencyInjector dependencyInjector)
{
UploadFolderPaths = new FolderPair[0];
this.fs = fs;
this.persister = persister;
this.dependencyInjector = dependencyInjector;
}
private void RegisterThemeSettingsWindows(IDependencyInjector container)
{
foreach (var theme in Themes.Where(x => x.SettingEditWindow != null))
{
container.Register(theme.SettingEditWindow);
}
}
static Dojector()
{
multiBindMap = InternalFactory.Get <IMultiBindCollection>();
dependencies = InternalFactory.Get <IDependencyRepository>();
injector = InternalFactory.Get <IDependencyInjector>();
binder = InternalFactory.Get <IDependencyBinder>();
}
public DependencyInjectorPackageRegistrator(
IDependencyInjector dependencyInjector,
IEnumerable <IFieldNameFromDependencyGenerator> fieldNameGenerators)
{
_dependencyInjector = dependencyInjector;
_fieldNameGenerators = fieldNameGenerators;
}
private void RegisterPluginSettingsWindows(IDependencyInjector container)
{
foreach (var plugin in Plugins.Union(BuiltInPlugins).Where(x => x.SettingEditWindow != null))
{
container.Register(plugin.SettingEditWindow);
}
}
public DependencyBinder(IDependencyRepository dependencies, IDependencyInjector dependencyInjector)
{
this.dependencies = dependencies;
this.dependencyInjector = dependencyInjector;
cachedSingletons = new Dictionary <Type, Type>();
}
public static void Run(PersistenceStrategy strategy, IDependencyInjector container)
{
container.BindToConstant <ILogger>(new DefaultLogger());
container.Get <ILogger>().Trace("Bootstrapper", "starting the bootstrapper.");
SetupBus(container);
SetupDomainCommandHandlers(container);
switch (strategy)
{
case PersistenceStrategy.InMemory:
container.Get <ILogger>().Trace("Bootstrapper", "bootstrapping In-Memory strategy");
SetupInMemoryRepo(container);
break;
case PersistenceStrategy.InMemoryEventSourcing:
container.Get <ILogger>().Trace("Bootstrapper", "bootstrapping In-Memory ES strategy");
SetupInMemoryEsRepo(container);
break;
default:
container.Get <ILogger>().Trace("Bootstrapper", "bootstrapping RavenDb strategy");
SetupRavenDbRepo(container);
break;
}
container.Get <ILogger>().Trace("Bootstrapper", "done.");
}
internal RequestHandlerImpl(
IDependencyInjector dependencyInjector,
IEnumerable <Type> schemaTypes,
IEnumerable <Type> assemblyTypes,
IEnumerable <Type> exceptionsTreatedAsWarning,
bool useValidation,
bool useProfiling,
FieldResolutionStrategy fieldResolutionStrategy,
ComplexityConfiguration complexityConfiguration,
IEnumerable <Type> middleware,
ITypeResolver typeResolver)
{
_engine = new GraphQLEngine(typeResolver: typeResolver);
_dependencyInjector = dependencyInjector;
_engine.WithAttributesFromAssemblies(assemblyTypes);
_exceptionsTreatedAsWarnings.AddRange(exceptionsTreatedAsWarning);
_useValidation = useValidation;
_useProfiling = useProfiling;
_engine.WithFieldResolutionStrategy(fieldResolutionStrategy);
_engine.BuildSchema(schemaTypes.ToArray());
_complexityConfiguration = complexityConfiguration;
foreach (var type in middleware)
{
_engine.WithMiddleware(type);
}
}
public FolderNodeProvider(IFileSystem fs, IPersister persister, IDependencyInjector dependencyInjector)
{
UploadFolderPaths = new FolderPair[0];
this.fs = fs;
this.persister = persister;
this.dependencyInjector = dependencyInjector;
}
private static void SetupBus(IDependencyInjector container)
{
container.Get <ILogger>().Trace("Bootstrapper", "initializing In-Memory bus.");
var bus = container.Get <NaiveInMemoryBus>();
container.BindToConstant <IBus>(bus);
}
private static void SetupInMemoryRepo(IDependencyInjector container)
{
container.Get <ILogger>().Trace("Bootstrapper", "initialzing In-memory repository");
container.BindToConstant <IEmployeeRepository>(
container.Get <InMemoryEmployeeRepository>()
);
}
public override object Get(IDependencyInjector injector)
{
if (_instance != null)
return _instance;
_instance = base.Get(injector);
return _instance;
}
public Game(IDependencyInjector dependencyInjector)
{
if (dependencyInjector == null)
{
throw new ArgumentException("Dependency injector cannot be null.");
}
_dependencyInjector = dependencyInjector;
}
public SettingsWindow(ISettings settings, ISettingManager mananger, IPluginManager pluginManager, IDependencyInjector container, IEnvironment environment)
{
_settings = settings;
_mananger = mananger;
_pluginManager = pluginManager;
_container = container;
_environment = environment;
_mananger.PropertyChanged += _mananger_PropertyChanged;
SaveCommand = new SaveSettingsCommand(_settings);
CancelCommand = new CancelSettingsCommand(this, _settings);
DataContext = this;
InitializeComponent();
SettingsTree.SelectedItemChanged += SettingsTree_SelectedItemChanged;
foreach (var rootSetting in _pluginManager.BuiltInPlugins.Where(x => x.SettingEditWindow != null && !x.IsHidden()))
{
var builtinPlugin = new TreeViewItem
{
Header = rootSetting.Title,
IsSelected = SettingsTree.Items.IsEmpty,
Tag = _container.Resolve(rootSetting.SettingEditWindow)
};
SettingsTree.Items.Add(builtinPlugin);
}
var pluginsTree = new TreeViewItem
{
Header = "Plugins",
Tag = _container.Resolve(typeof(PluginManagerSettingWindow))
};
foreach (var customSettings in _pluginManager.ActivePlugins.Where(x => x.SettingEditWindow != null))
{
pluginsTree.Items.Add(new TreeViewItem
{
Header = customSettings.Title,
Tag = _container.Resolve(customSettings.SettingEditWindow)
});
}
SettingsTree.Items.Add(pluginsTree);
var aboutPage = new TreeViewItem {
Header = "About"
};
SettingsTree.Items.Add(aboutPage);
UpdateNotificationMessage();
Loaded += Settings_Loaded;
IsVisibleChanged += SettingsWindow_IsVisibleChanged;
}
private IEnumerable <IPlugin> RegisterPlugins(IDependencyInjector container)
{
foreach (var plugin in Plugins.Union(BuiltInPlugins).Where(x => x.Plugin != null))
{
container.Register(plugin.Plugin, true);
}
return(ActivePlugins.Union(BuiltInPlugins).Where(x => x.Plugin != null).Select(plugin => (IPlugin)container.Resolve(plugin.Plugin)).ToList());
}
private static void SetupDomainCommandHandlers(IDependencyInjector container)
{
container.Get <ILogger>().Trace("Bootstrapper", "registering command handlers.");
var bus = container.Get <IBus>();
bus.RegisterHandler <RegisterEmployeeHandler>();
bus.RegisterHandler <RaiseEmployeeSalaryHandler>();
bus.RegisterHandler <UpdateEmployeeHomeAddressHandler>();
}
public PluginManager(IDependencyInjector container, IEnumerable <IPluginMeta> metas, PluginManagerSettings settings, ISettings gloabalSettings)
{
_container = container;
_settings = settings;
ApplyMigration(settings, gloabalSettings);
_enabledPlugins = _settings.EnabledPlugins;
Plugins = metas;
}
private static void SetupInMemoryEsRepo(IDependencyInjector container)
{
container.Get <ILogger>().Trace("Bootstrapper", "initialzing In-memory event store repo");
var esrepo = container.Get <InMemoryEmployeeEventSourceRepository>();
container.BindToConstant <IEmployeeRepository>(esrepo);
container.BindToConstant(esrepo);
container.Get <IBus>().RegisterHandler <InMemoryEmployeeEventSourceRepository>();
}
public SearchController(IDependencyInjector di) :
base(di,
di.GetInstance <IAzureSearch <RegisterPersonModel> >(),
di.GetInstance <IAzureSearch <RegisterBusinessModel> >(),
di.GetInstance <IPersonFilterManager>(),
di.GetInstance <IBusinessFilterManager>(),
di.GetInstance <IFamilyProvider>(),
"(isInPreg or isInHpr or isInFlr)", new[] { "nin", "hprNrStr", "hprName", "pregName", "difiEmail", "difiPhoneNumber" }, surveillanceSearchOrderBy: new [] { "pregName", "hprName" })
{
}
private static void SetupDomainCommandHandlers(IDependencyInjector container)
{
var bus = container.Get <IBus>();
bus.RegisterHandler <RegisterEmployeeHandler>();
bus.RegisterHandler <RaiseEmployeeSalaryHandler>();
bus.RegisterHandler <UpdateEmployeeHomeAddressHandler>();
bus.RegisterHandler <FailedToRegisterEmployeeHandler>();
}
public TeamSchema(IDependencyInjector dependencyInjector = null)
{
_requestHandler = RequestHandler
.New()
.WithQueryAndMutation <TeamsQuery, TeamsMutation>()
//.WithSubscription<TeamsSubscription>()
.WithDependencyInjector(dependencyInjector)
.WithoutValidation()
.Generate();
}
public ThemeManager(IDependencyInjector container, IEnumerable <IThemeMeta> metas, ThemeManagerSettings settings)
{
_container = container;
_settings = settings;
Themes = metas;
RegisterThemes(container);
RegisterThemeSettings(container);
RegisterThemeSettingsWindows(container);
ActiveTheme = GetActiveTheme();
}
/// <summary>
/// Initializes a new instance of the DefaultCodeBuilder class.
/// </summary>
/// <param name="dependencyInjector">The dependency injector.</param>
/// <param name="language">The programming language to use for generating code.</param>
public DefaultCodeBuilder(
IDependencyInjector dependencyInjector,
IProgrammingLanguageStrategy language)
{
this.Log = Logger.Null;
this.injector = dependencyInjector;
this.language = language;
this.namespaceImports = new List<string>();
this.referenceAssemblies = new List<string>();
this.externalProperties = new Dictionary<string, ExternalProperty>();
}
private static void SetupRavenDbRepo(IDependencyInjector container)
{
container.Get <ILogger>().Trace("Bootstrapper", "initialzing RavenDB repositories");
container.BindToConstant <IEmployeeRepository>(
container.Get <RavenDbEmployeeRepository>()
);
container.BindToConstant(container.Get <RavenDbEmployeeEventStore>());
container.Get <IBus>().RegisterHandler <RavenDbEmployeeEventStore>();
}
/// <summary>
/// Initializes a new instance of the DefaultCodeBuilder class.
/// </summary>
/// <param name="dependencyInjector">The dependency injector.</param>
/// <param name="language">The programming language to use for generating code.</param>
public DefaultCodeBuilder(
IDependencyInjector dependencyInjector,
IProgrammingLanguageStrategy language)
{
this.Log = Logger.Null;
this.injector = dependencyInjector;
this.language = language;
this.namespaceImports = new List <string>();
this.referenceAssemblies = new List <string>();
this.externalProperties = new Dictionary <string, ExternalProperty>();
}
public SearchController(IDependencyInjector di, IAzureSearch <TPersonIndexEntity> personIndex, IAzureSearch <TBusinessIndexEntity> busIndex, IPersonFilterManager personFilterManager, IBusinessFilterManager businessFilterManager, IFamilyProvider familyProvider, string minimumCriteriaForPerson = null, string[] freetextPropertiesForPerson = null, string minimumCriteriaForBusiness = "", string[] freetextPropertiesForBusiness = null, string[] surveillanceSearchOrderBy = null) : base(di)
{
_personIndex = personIndex;
_busIndex = busIndex;
_personFilterManager = personFilterManager;
_businessFilterManager = businessFilterManager;
_familyProvider = familyProvider;
_minimumCriteriaForPerson = minimumCriteriaForPerson;
_freetextPropertiesForPerson = freetextPropertiesForPerson;
_minimumCriteriaForBusiness = minimumCriteriaForBusiness;
_freetextPropertiesForBusiness = freetextPropertiesForBusiness;
_surveillanceSearchOrderBy = surveillanceSearchOrderBy;
}
private InjectDependencyCommand(Package package)
{
_package = package;
_serviceProvider = package;
_dte = Package.GetGlobalService(typeof(SDTE)) as DTE;
_dependencyInjector = _serviceProvider.GetService <IDependencyInjector>();
_fieldNameGenerators = _serviceProvider.GetServices <IFieldNameFromDependencyGenerator>();
_dependencyNameProviders = _serviceProvider.GetServices <IDependencyNameProvider>();
_menuCommandService = _serviceProvider.GetService <IMenuCommandService>();
Initialize();
}
private void ConfigureDependencyInjectionContainer()
{
this.dependencyInjector = this.moduleDependencyInjectionContainer = new LightweightDependencyInjectionContainer();
var implementationSelector = new ImplementationSelector();
this.ConfigureImplementationSelector(implementationSelector);
var configurator = new DependencyInjectionConfigurator(implementationSelector, this.TestParameters);
configurator.RootLogger = this.rootLogger;
configurator.ConfigureDefaultDependencies(this.moduleDependencyInjectionContainer);
this.ConfigureDependencies(this.moduleDependencyInjectionContainer);
this.dependencyInjector.InjectDependenciesInto(this);
configurator.InitializeGlobalObjects(this.moduleDependencyInjectionContainer);
}
public override object Get(IDependencyInjector injector)
{
if (_alreadyInvoke)
throw new CyclicDependencyException(FactoryStack);
FactoryStack.Push(this);
_alreadyInvoke = true;
var parameters = new object[_constructorData.Count];
for (int i = 0; i < parameters.Length; i++)
{
ParameterData data = _constructorData.ParametersData[i];
parameters[i] = injector.Resolve(data.Type, data.InjectableAttribute, data.ServiceKey);
}
object instance = _constructorData.ConstructorInfo.Invoke(parameters);
foreach (FieldData field in _fieldsData)
{
object value;
injector.TryResolve(out value, field.Type, field.InjectableAttribute, field.ServiceKey);
field.FieldInfo.SetValue(instance, value);
}
foreach (PropertyData property in _propertiesData)
{
object value;
injector.TryResolve(out value, property.Type, property.InjectableAttribute, property.ServiceKey);
property.PropertyInfo.SetValue(instance, value);
}
_alreadyInvoke = false;
FactoryStack.Pop();
return instance;
}
public abstract object Get(IDependencyInjector injector);
private void ConfigureDependencyInjectionContainer()
{
this.dependencyInjector = this.moduleDependencyInjectionContainer = new LightweightDependencyInjectionContainer();
var implementationSelector = new ImplementationSelector();
this.ConfigureImplementationSelector(implementationSelector);
var configurator = new DependencyInjectionConfigurator(implementationSelector, this.TestParameters);
configurator.RootLogger = this.rootLogger;
configurator.ConfigureDefaultDependencies(this.moduleDependencyInjectionContainer);
this.ConfigureDependencies(this.moduleDependencyInjectionContainer);
this.dependencyInjector.InjectDependenciesInto(this);
configurator.InitializeGlobalObjects(this.moduleDependencyInjectionContainer);
}
public StartupChecker(JiraServiceConfiguration config, IEventManager eventManager, IDependencyInjector dependencyInjector) : base(eventManager, dependencyInjector) {
this.config = config;
}
public override object Get(IDependencyInjector injector)
{
return _factory.Get(injector);
}
public override object Get(IDependencyInjector injector)
{
return _instance;
}
internal static Directory CreateDirectory(FileSystemRoot folder, IFileSystem fs, IRepository<ContentItem> persister, IDependencyInjector dependencyInjector)
{
var dd = fs.GetDirectoryOrVirtual(folder.Path);
var parent = persister.Get(folder.GetParentID());
var dir = Directory.New(dd, parent, dependencyInjector);
dir.Name = folder.GetName();
dir.Title = folder.Title ?? dir.Name;
dir.UrlPrefix = folder.UrlPrefix;
Apply(folder.Readers, dir);
Apply(folder.Writers, dir);
return dir;
}
public RuntimeControllerFactory(IDependencyInjector denpedencyInjector, IRuntimeControllerPathProvider pathProvider)
{
this.denpedencyInjector = denpedencyInjector;
this.pathProvider = pathProvider;
}
public StartupChecker(IEventManager eventManager, IDependencyInjector dependencyInjector) : base(eventManager, dependencyInjector) { }
public LombiqOrchardVisualStudioExtensionPackage()
{
_dependencyInjector = new DependencyInjector();
_dte = Package.GetGlobalService(typeof(SDTE)) as DTE;
}
public StartupChecker(QcConfiguration configuration, IEventManager eventManager, IDependencyInjector dependencyInjector) : base(eventManager, dependencyInjector) {
this.configuration = configuration;
}
public static IDependencyType RegisterType(this Type type, IDependencyInjector injector) => (IDependencyType)typeof(IDependencyInjector).GetMethod(nameof(IDependencyInjector.RegisterType), BindingFlags.Instance | BindingFlags.Public)?.MakeGenericMethod(type)?.Invoke(injector, null);
public RuntimeControllerFactory(IDependencyInjector denpedencyInjector)
: this(denpedencyInjector, new DefaultPathProvider())
{
}
public void SetUp()
{
_registry = new DependencyRegistry();
_injector = new RegistryInjector(_registry);
}
internal static void TestResetCurrent()
{
DependencyProvider.s_injector = (IDependencyInjector)null;
}
protected StartupCheckerBase(IEventManager eventManager, IDependencyInjector dependencyInjector) {
this.eventManager = eventManager;
this.dependencyInjector = dependencyInjector;
}
internal static Items.Directory New(DirectoryData dir, ContentItem parent, IDependencyInjector injector)
{
var node = new Directory(dir, parent);
injector.FulfilDependencies(node);
return node;
}
