public void Initialize()
{
IocManager.IocContainer.Install(new CoreInstaller());
_moduleManager = IocManager.Resolve<IModuleManager>();
_moduleManager.InitializeModules();
}
public MainPage(IModuleManager moduleManager)
{
InitializeComponent();
this.loginContainer.Child = new LoginStatus();
_moduleManager = moduleManager;
}
/// <summary>
/// Initializes a new instance of the <see cref="Shell"/> class.
/// </summary>
public Shell(IModuleManager moduleManager, IModuleTracker moduleTracker, CallbackLogger logger)
{
if (moduleManager == null)
{
throw new ArgumentNullException("moduleManager");
}
if (moduleTracker == null)
{
throw new ArgumentNullException("moduleTracker");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
this.moduleManager = moduleManager;
this.moduleTracker = moduleTracker;
this.logger = logger;
// I use the IModuleTracker as the data-context for data-binding.
// This quickstart only demonstrates modularity for Prism and does not use data-binding patterns such as MVVM.
this.DataContext = this.moduleTracker;
// I set this shell's Log method as the callback for receiving log messages.
this.logger.Callback = this.Log;
// I subscribe to events to help track module loading/loaded progress.
// The ModuleManager uses the Async Events Pattern.
this.moduleManager.LoadModuleCompleted += this.ModuleManager_LoadModuleCompleted;
this.moduleManager.ModuleDownloadProgressChanged += this.ModuleManager_ModuleDownloadProgressChanged;
InitializeComponent();
}
public ShellViewModel(IModuleManager moduleManager)
{
ModuleCommand = new DelegateCommand<object>(o =>
{
moduleManager.LoadModule("Module");
});
}
public virtual IDialog Create(object view, IModuleManager mm, XElement rootNode)
{
_moduleManager = mm;
_controlHash.Clear();
var context = new BuildContext();
context.RootNode = rootNode;
context.View = view;
context.TypeOfView = view.GetType();
context.CurrentNode = context.RootNode;
var resultDlg = (IDialog)GetBuilder("Dialog").Assembly(this, context);
resultDlg.Initialized += onDialogInitialized;
resultDlg.Closing += onDialogClosing;
_bindingEngine.Prepare();
_garbageList = new List<IDisposable>();
_garbageList.Add(_bindingEngine);
return resultDlg;
}
internal RegistrationManager(
IRegistrationContext registrationContext,
IModuleManager moduleManager,
IPublicRegistrationService publicRegistrationService,
ISdkInformation sdkInformation,
IEnvironmentInformation environmentInformation,
IServiceContext serviceContext,
ISecureRegistrationService secureRegistrationService,
IConfigurationManager configurationManager,
IEventBus eventBus,
IRefreshToken tokenRefresher,
ILogger logger,
IJsonSerialiser serialiser)
{
_registrationContext = registrationContext;
_moduleManager = moduleManager;
_publicRegistrationService = publicRegistrationService;
_sdkInformation = sdkInformation;
_environmentInformation = environmentInformation;
_serviceContext = serviceContext;
_secureRegistrationService = secureRegistrationService;
_configurationManager = configurationManager;
_eventBus = eventBus;
_tokenRefresher = tokenRefresher;
_logger = logger;
_serialiser = serialiser;
}
public Shell(IRegionManager regionManager, IModuleManager moduleManager)
{
this.regionManager = regionManager;
this.moduleManager = moduleManager;
InitializeComponent();
this.moduleManager.LoadModuleCompleted +=
(s, e) =>
{
// todo: 01 - Navigation on when modules are loaded.
// When using region navigation, be sure to use it consistently
// to ensure you get proper journal behavior. If we mixed
// usage of adding views directly to regions, such as through
// RegionManager.AddToRegion, and then use RegionManager.RequestNavigate,
// we may not be able to navigate back correctly.
//
// Here, we wait until the module we want to start with is
// loaded and then navigate to the view we want to display
// initially.
//
if (e.ModuleInfo.ModuleName == EmailModuleName)
{
this.regionManager.RequestNavigate(
RegionNames.MainContentRegion,
InboxViewUri);
}
};
}
public ModuleInit(IRegionManager regionManager, IUnityContainer container, IEventAggregator eventAggregator, IModuleManager moduleManager)
{
this.regionManager = regionManager;
this.container = container;
this.eventAggregator = eventAggregator;
this.moduleManager = moduleManager;
}
public ShellViewModel()
{
Messenger.Default.Register<KeyEventArgs>(this, shell_KeyDown);
Messenger.Default.Register<System.EventArgs>(this, shellContentLoaded);
this._moduleManager = ServiceLocator.Current.GetInstance<IModuleManager>();
this._moduleManager.LoadModuleCompleted += this.ModuleManager_LoadModuleCompleted;
MenuBar_Visibility = "Hidden";
}
public ApplicationController(IUnityContainer container, IModuleManager moduleManager, IEventAggregator eventMgr)
{
_container = container;
_moduleManager = moduleManager;
_eventMgr = eventMgr;
_modulesToLoad = new List<string>();
_modulesLoaded = new List<string>();
}
public Shell(IModuleManager moduleManager)
{
//Application.Current.MainWindow.KeyDown += shell_KeyDown;
Application.Current.MainWindow.PreviewKeyDown += shell_KeyDown;
this.moduleManager = moduleManager;
InitializeComponent();
this.DataContext = new ShellViewModel();
}
public NotificationManager(IDonkyClientDataContext dataContext, INotificationService notificationService, IModuleManager moduleManager, IAppState appState, IJsonSerialiser serialiser, ILogger logger)
{
_dataContext = dataContext;
_notificationService = notificationService;
_moduleManager = moduleManager;
_appState = appState;
_serialiser = serialiser;
_logger = logger;
}
public MainModule(
IRegionManager regionManager,
IEventAggregator eventAggregator,
IUnityContainer unityContainer,
IModuleManager moduleManager,
IModuleCatalog moduleCatalog) :
base(regionManager, eventAggregator, unityContainer, moduleManager, moduleCatalog)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpServer" /> class.
/// </summary>
/// <param name="moduleManager">The modules are used to process the HTTP requests. You need to specify at least one.</param>
public HttpServer(IModuleManager moduleManager)
{
_moduleManager = moduleManager;
BodyDecoder = new CompositeIMessageSerializer();
_configuration = new ChannelTcpListenerConfiguration(() => new HttpMessageDecoder(BodyDecoder), () => new HttpMessageEncoder());
_bufferSlicePool = new BufferSlicePool(65535, 100);
ApplicationInfo = new MemoryItemStorage();
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpServer" /> class.
/// </summary>
/// <param name="moduleManager">The modules are used to process the HTTP requests. You need to specify at least one.</param>
/// <param name="configuration">
/// You can override the configuration to your likings.
/// </param>
/// <exception cref="System.ArgumentNullException">moduleManager/configuration</exception>
public HttpServer(IModuleManager moduleManager, ChannelTcpListenerConfiguration configuration)
{
if (moduleManager == null) throw new ArgumentNullException("moduleManager");
if (configuration == null) throw new ArgumentNullException("configuration");
BodyDecoder = new CompositeIMessageSerializer();
_moduleManager = moduleManager;
_configuration = configuration;
_bufferSlicePool = new BufferSlicePool(65535, 100);
ApplicationInfo = new MemoryItemStorage();
}
// ----- Constructor
public Application(
IInstaller installer,
IModuleManager moduleManager,
IRemoteServerConnector remoteServerConnector,
IEnvironment environment)
{
_installer = installer;
_moduleManager = moduleManager;
_remoteServerConnector = remoteServerConnector;
_environment = environment;
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpService" /> class.
/// </summary>
public HttpService(IModuleManager moduleManager)
{
ApplicationInfo = new MemoryItemStorage();
BodyDecoder = new CompositeSerializer();
_service = this;
_moduleManager = moduleManager;
_encoder = new HttpMessageEncoder();
_decoder = new HttpMessageDecoder(BodyDecoder);
_decoder.MessageReceived = OnMessageReceived;
}
/// <summary>
/// CustomFormattedClass Constructor.
/// </summary>
public CSGOProcess()
{
moduleManager = new ModuleManager();
Logger = Log.GetLogger(this.GetType().Name.ToString());
Modules = new List<IModule<object>>();
moduleList = new Modules();
ConfigurationManager = new ConfigurationManager();
ConfigurationManager.SaveDefault(AppDomain.CurrentDomain.BaseDirectory + "\\" + modulesCfg, moduleList);
ConfigurationManager.SaveDefault(AppDomain.CurrentDomain.BaseDirectory + "\\" + settingsCfg, new Options());
// Construct.
}
public MainWindowViewModel(IRegionManager regionManager, IModuleManager moduleManager)
{
this.regionManager = regionManager;
this.moduleManager = moduleManager;
CreateNewTabCommand = new DelegateCommand<object>(CreateNewTab);
CreateAndActivateNewTabCommand = new DelegateCommand<object>(CreateAndActivateNewTab);
RemoveActiveTabCommand = new DelegateCommand<object>(RemoveActiveTab, CanRemoveActiveTab);
DeactivateActiveTabCommand = new DelegateCommand<object>(DeactivateActiveTab, CanDeactivateActiveTab);
LoadModuleAndShowTabCommand = new DelegateCommand<object>(LoadModule);
DemoTabAsRegionCommand = new DelegateCommand<object>(DemoTabAsRegion);
}
/// <summary>
/// Initializes a new instance of the <see cref="Shell"/> class.
/// </summary>
/// <param name="moduleManager">
/// The module Manager.
/// </param>
/// <param name="moduleTracker">
/// The module Tracker.
/// </param>
/// <param name="logger">
/// The logger.
/// </param>
/// <exception cref="System.ArgumentNullException">The <paramref name="logger"/> is <c>null</c>.</exception>
/// <exception cref="System.ArgumentNullException">The <paramref name="moduleTracker"/> is <c>null</c>.</exception>
/// <exception cref="System.ArgumentNullException">The <paramref name="moduleManager"/> is <c>null</c>.</exception>
public Shell(IModuleManager moduleManager, IModuleTracker moduleTracker, CallbackLogger logger)
{
Argument.IsNotNull("moduleManager", moduleManager);
Argument.IsNotNull("moduleTracker", moduleTracker);
Argument.IsNotNull("logger", logger);
this.moduleManager = moduleManager;
this.moduleTracker = moduleTracker;
this.logger = logger;
InitializeComponent();
}
public ShellViewModel(ILoggerFacade logger, IEventAggregator eventAggregator, IModuleManager moduleManager, IMessageBoxService messageBoxService)
: base(logger, eventAggregator)
{
Requires.NotNull(moduleManager, "moduleManager");
_moduleManager = moduleManager;
Requires.NotNull(messageBoxService, "messageBoxService");
_messageBoxService = messageBoxService;
_lazyLoadedCommand = new Lazy<ICommand>(() => new DelegateCommand(OnLoaded));
DisposableTracker.Instance.Add(this);
}
/// <summary>
/// CustomFormattedClass Constructor.
/// </summary>
public CSGOProcess()
{
moduleManager = new ModuleManager();
Logger = Log.GetLogger(this.GetType().Name.ToString());
Modules = new List<IModule<object>>();
moduleList = new List<string>
{
"AgaHackTools.Example.MemoryReadingModule",
"AgaHackTools.Example.CSGO.Misc",
"AgaHackTools.Example.Triggerbot",
};
ConfigurationManagerStatic.DefaultConfig(modulesCfg, moduleList);
// Construct.
ConfigurationManager = new ConfigurationManager();
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpServer" /> class.
/// </summary>
/// <param name="moduleManager">The modules are used to process the HTTP requests. You need to specify at least one.</param>
/// <param name="configuration">You can override the configuration to your likings. We suggest that you using the <see cref="HttpMessageFactory" /> to produce the messages.</param>
/// <exception cref="System.ArgumentNullException">moduleManager/configuration</exception>
public HttpServer(IModuleManager moduleManager, MessagingServerConfiguration configuration)
{
if (moduleManager == null) throw new ArgumentNullException("moduleManager");
if (configuration == null) throw new ArgumentNullException("configuration");
_moduleManager = moduleManager;
_server = new MessagingServer(this, configuration);
_bufferSliceStack = new BufferSliceStack(100, 65535);
ApplicationInfo = new MemoryItemStorage();
_workerConfiguration = new WorkerConfiguration
{
Application = ApplicationInfo,
BufferSliceStack = _bufferSliceStack,
ModuleManager = _moduleManager
};
}
public Shell(IModuleManager moduleManager, IModuleTracker moduleTracker, CallbackLogger logger)
{
if( moduleManager==null )
throw new ArgumentNullException("moduleManager");
_moduleManager = moduleManager;
if( moduleTracker==null )
throw new ArgumentNullException("moduleTracker");
_moduleTracker = moduleTracker;
if( logger==null )
throw new ArgumentNullException("logger");
_logger = logger;
InitializeComponent();
}
/// <summary>
/// Initializes a new instance of the <see cref="ModuleManagerViewModel" /> class.
/// </summary>
/// <exception cref="System.ArgumentNullException">The <paramref name="moduleCatalog"/> is <c>null</c>.</exception>
/// <exception cref="System.ArgumentNullException">The <paramref name="moduleManager"/> is <c>null</c>.</exception>
/// <exception cref="System.ArgumentNullException">The <paramref name="pleaseWaitService"/> is <c>null</c>.</exception>
public ModuleManagerViewModel(IModuleCatalog moduleCatalog, IModuleManager moduleManager, IPleaseWaitService pleaseWaitService)
{
Argument.IsNotNull(() => moduleManager);
Argument.IsNotNull(() => moduleCatalog);
Argument.IsNotNull(() => pleaseWaitService);
_moduleManager = moduleManager;
_pleaseWaitService = pleaseWaitService;
var modules = moduleCatalog.Modules;
var moduleTemplates = modules.Select(moduleInfo => new ModuleTemplate(moduleInfo)).OrderBy(template => template.ModuleName);
Modules = new ObservableCollection<ModuleTemplate>(moduleTemplates);
LoadModuleCommand = new Command<ModuleTemplate>(LoadModuleCommandExecute, LoadModuleCommandCanExecute);
}
public RoleController(IRoleService roleService,
IModuleManager moduleManager,
IPermissionManager permissionManager,
IMenuService menuService,
IRoleBelongsSystemService belongsSystemService,
IAuthorizer authorizer, ITranslation translation,
IRolePermissionsService rolePermissionsService)
{
_roleService = roleService;
_moduleManager = moduleManager;
_permissionManager = permissionManager;
_menuService = menuService;
_belongsSystemService = belongsSystemService;
_authorizer = authorizer;
_translation = translation;
_rolePermissionsService = rolePermissionsService;
}
public ModuleBViewModel(Calc calc, IModuleManager moduleManager)
{
this.AddCommand = new DelegateCommand(
() => this.Answer = calc.Add(int.Parse(this.Lhs), int.Parse(this.Rhs)),
() =>
{
var temp = 0;
if (!int.TryParse(this.Lhs, out temp))
{
return false;
}
return int.TryParse(this.Rhs, out temp);
})
.ObservesProperty(() => this.Lhs)
.ObservesProperty(() => this.Rhs);
this.LoadModuleCCommand = new DelegateCommand(() => moduleManager.LoadModule("ModuleCModule"));
}
protected RolodexModule(
IRegionManager regionManager,
IEventAggregator eventAggregator,
IUnityContainer unityContainer,
IModuleManager moduleManager,
IModuleCatalog moduleCatalog)
{
_regionManager = regionManager;
_eventAggregator = eventAggregator;
_unityContainer = unityContainer;
_moduleManager = moduleManager;
_moduleCatalog = moduleCatalog;
lock (Lock)
{
if (_serviceLoader == null)
{
_serviceLoader = UnityContainer.Resolve<IRolodexServiceLoader>();
}
}
}
public Shell(IModuleManager moduleManager, IModuleTracker moduleTracker, CallbackLogger logger)
{
if (moduleManager == null)
throw new ArgumentNullException("moduleManager");
_moduleManager = moduleManager;
if (moduleTracker == null)
throw new ArgumentNullException("moduleTracker");
_moduleTracker = moduleTracker;
if (logger == null)
throw new ArgumentNullException("logger");
_logger = logger;
DataContext = _moduleTracker;
_moduleManager.LoadModuleCompleted += PageLoadModuleCompleted;
_moduleManager.ModuleDownloadProgressChanged += PageModuleDownloadProgressChanged;
InitializeComponent();
}
/// <summary>
/// 启动模块初始化。启动模块初始化需要依赖的对象：
/// <see cref="IServiceLocator"/>、<see cref="IModuleInitializer"/>、<see cref="ILoggerFacade"/>
/// </summary>
protected override void InitializeModules()
{
try
{
serviceLocator = new ServiceLocator();
ModuleInitializer initializer = new Core.Modularity.ModuleInitializer(serviceLocator, Logger);
manager = new ModuleManager(initializer, ModuleCatalog, Logger);
manager.LoadModuleCompleted += new EventHandler<LoadModuleCompletedEventArgs>(manager_LoadModuleCompleted);
}
catch (Exception ex)
{
if (ex.Message.Contains("IModuleCatalog"))
{
throw new InvalidOperationException(Resources.NullModuleCatalogException);
}
throw;
}
if (manager != null)
manager.Run();
}
public ModuleControler(IBreadCrumbPresenter breadCrumb, IUnityContainer container, IModuleManager moduleManager)
{
this._breadCrumb = breadCrumb;
this._container = container;
this._moduleManager = moduleManager;
//ExecuteCommand = new DelegateCommand<XmlElement>(OnExecute, CanExecute);
ExecuteCommand = new DelegateCommand <XmlElement>(OnExecute, CanExecute);
}
/// <summary>
/// 关闭并清理对象池管理器。
/// </summary>
protected internal override void OnStop(IModuleManager t_IModuleManager)
{
}
public ForgotPassViewModel(INavigationService navigationService, IModuleManager module)
{
Nav = navigationService;
Mod = module;
}
public PageContentController(ILifetimeScope container)
{
_logger = container.Resolve <ILogger <PageContentController> >();
_moduleManager = container.Resolve <IModuleManager>();
_contentManager = container.Resolve <IContentManager>();
}
public ModuleAViewModel(IUnityContainer container, IUserInfo user, IServis servis, IModuleManager manager, IEventAggregator aggregator)
{
_container = container;
_user = user;
_servis = servis;
_manager = manager;
_aggregator = aggregator;
Adi = _user.AdiSoyadi;
LoadBModuleCommand = new DelegateCommand(LoadBModuleExecute);
SetTextCommand = new DelegateCommand <string>(SetTextExecute);
}
public Shell(IModuleManager moduleManager)
{
InitializeComponent();
}
public EdgeletCommandFactory(IModuleManager moduleManager, IConfigSource configSource, ICombinedConfigProvider <T> combinedConfigProvider)
{
this.moduleManager = Preconditions.CheckNotNull(moduleManager, nameof(moduleManager));
this.configSource = Preconditions.CheckNotNull(configSource, nameof(configSource));
this.combinedConfigProvider = Preconditions.CheckNotNull(combinedConfigProvider, nameof(combinedConfigProvider));
}
/// <summary>
/// Set the module manager. Not injected by castle.
/// </summary>
/// <param name="moduleManager">the module manager.</param>
public void SetModuleManager(IModuleManager moduleManager)
{
_moduleManager = moduleManager;
}
public VerboseModuleManager(IModuleManager moduleManager, ILogger logger)
{
_moduleManager = moduleManager;
_logger = logger;
}
/// <summary>
/// Initializes the modules. May be overwritten in a derived class to use a custom Modules Catalog
/// </summary>
protected virtual void InitializeModules()
{
IModuleManager manager = ContainerLocator.Container.Resolve <IModuleManager>();
manager.Run();
}
public MainWindow(IModuleManager moduleManager)
{
InitializeComponent();
_moduleManager = moduleManager;
}
internal static void RunModuleManager(IContainerProvider containerProvider)
{
IModuleManager manager = containerProvider.Resolve <IModuleManager>();
manager.Run();
}
public DashboardViewModel(INavigationService nav, IModuleManager mod) : base(nav, mod)
{
Title = "Dashboard";
}
public OnStartRoutingPageViewModel(INavigationService navigationService, IEventAggregator eventAggregator, IModuleManager moduleManager, IItemManagerWrapper itemManagerWrapper) :
base(navigationService, eventAggregator)
{
_itemManagerWrapper = itemManagerWrapper;
ModulesInitializer.ModuleManager = moduleManager;
}
public HostBootManager(IModuleManager moduleManager, IBootSequenceFactory bootSequenceFactory)
{
_moduleManager = moduleManager;
_bootSequenceFactory = bootSequenceFactory;
}
public NavigationService(IModuleManager moduleManager)
{
_moduleManager = moduleManager;
}
/// <summary>
/// Checks to see if the <see cref="IModule"/> exists in the <see cref="IModuleCatalog.Modules"/>
/// </summary>
/// <returns><c>true</c> if the Module exists.</returns>
/// <param name="manager">The <see cref="IModuleManager"/>.</param>
/// <typeparam name="T">The <see cref="IModule"/> to check for.</typeparam>
public static bool ModuleExists <T>(this IModuleManager manager)
where T : IModule =>
manager.Modules.Any(mi => mi.ModuleType == typeof(T).AssemblyQualifiedName);
/// <summary>
/// Initializes a new instance of the <see cref="AccountsModule"/> class.
/// </summary>
/// <param name="regionManager">The region manager.</param>
/// <param name="moduleManager">The module manager.</param>
/// <param name="eventagg">The eventagg.</param>
public AccountsModule(IRegionManager regionManager, IModuleManager moduleManager, IEventAggregator eventagg)
{
this.regionManager = regionManager;
this.moduleManager = moduleManager;
this.eventagg = eventagg;
}
public RecommendedQViewModel(INavigationService nav, IModuleManager mod) : base(nav, mod, true)
{
}
public ModularViewLocationExpander(IModuleManager moduleManager)
{
_moduleManager = moduleManager;
}
public AssemblyFinder(IModuleManager moduleManager)
{
_moduleManager = moduleManager;
}
/// <summary>
/// Initializes the modules. May be overwritten in a derived class to use a custom Modules Catalog
/// </summary>
protected virtual void InitializeModules()
{
IModuleManager manager = ServiceLocator.Current.GetInstance <IModuleManager>();
manager.Run();
}
/// <summary>
/// Initializes a new instance of the <see cref="PortfolioGridModule"/> class.
/// </summary>
/// <param name="regionManager">The region manager.</param>
/// <param name="moduleManager">The module manager.</param>
/// <param name="eventagg">The eventagg.</param>
public PortfolioGridModule(IRegionManager regionManager, IModuleManager moduleManager, IEventAggregator eventagg)
{
this.regionManager = regionManager;
this.moduleManager = moduleManager;
this.eventagg = eventagg;
}
/// <summary>
/// Initializes the modules. May be overwritten in a derived class to use a custom Modules Catalog
/// </summary>
protected override void InitializeModules()
{
IModuleManager manager = this.Container.GetExportedValue <IModuleManager>();
manager.Run();
}
public MainWindow(IModuleManager moduleManager)
{
InitializeComponent();
ViewModel = new MainWindowVM(new ApplicationCommands(), moduleManager);
}
public MainPageViewModel(IModuleManager moduleManager)
{
_moduleManager = moduleManager;
LoadModuleACommand = new DelegateCommand(LoadModuleA);
}
public MyPlansViewModel(INavigationService nav, IModuleManager mod) : base(nav, mod, true)
{
}
public void Initialize(IModuleManager manager)
{
m_ModuleManager = manager;
}
/// <summary>
/// Construct a <see cref="PullRequestController"/>
/// </summary>
/// <param name="gitHubManager">The value of <see cref="gitHubManager"/></param>
/// <param name="stringLocalizer">The value of <see cref="stringLocalizer"/></param>
/// <param name="generalConfigurationOptions">The <see cref="IOptions{TOptions}"/> containing value of <see cref="generalConfiguration"/></param>
/// <param name="githubConfigurationOptions">The <see cref="IOptions{TOptions}"/> containing value of <see cref="generalConfiguration"/></param>
/// <param name="moduleManager">The value of <see cref="moduleManager"/></param>
/// <param name="componentProvider">The value of <see cref="componentProvider"/></param>
public PullRequestController(IGitHubManager gitHubManager, IStringLocalizer <PullRequestController> stringLocalizer, IOptions <GeneralConfiguration> generalConfigurationOptions, IOptions <GitHubConfiguration> githubConfigurationOptions, IModuleManager moduleManager, IComponentProvider componentProvider)
{
this.gitHubManager = gitHubManager ?? throw new ArgumentNullException(nameof(gitHubManager));
this.stringLocalizer = stringLocalizer ?? throw new ArgumentNullException(nameof(stringLocalizer));
this.moduleManager = moduleManager ?? throw new ArgumentNullException(nameof(moduleManager));
this.componentProvider = componentProvider ?? throw new ArgumentNullException(nameof(componentProvider));
generalConfiguration = generalConfigurationOptions?.Value ?? throw new ArgumentNullException(nameof(generalConfigurationOptions));
gitHubConfiguration = githubConfigurationOptions?.Value ?? throw new ArgumentNullException(nameof(githubConfigurationOptions));
}
public MainViewModel(IModuleManager moduleManager, IRegionManager regionManager,
IEventAggregator eventAggregator) : base(regionManager)
{
this.moduleManager = moduleManager;
this.eventAggregator = eventAggregator;
}
