/// <summary>
        /// Initializes a new instance of the MainViewModel class.
        /// </summary>
        public MainViewModel(IDatabaseService databaseService,
                             IAccountService accountService,
                             ICategoryService categoryService,
                             ITransactionService transactionService,
                             IOptionService optionService)
        {
            DatabaseService = databaseService;
            AccountService = accountService;
            TransactionService = transactionService;
            CategoryService = categoryService;
            OptionService = optionService;




            DatabaseService.Initialize();

            Rendu = new ObservableCollection<KeyValuePair<string, string>>();


            CategoryRunner = new RelayCommand(() =>  TestCategory());
            
            AccountRunner = new RelayCommand(() => TestAccount());

            TransactionRunner = new RelayCommand(() => TestTransaction());
           
        }

 public AccountController(ApplicationUserManager userManager, IOrderService orderService,
     IOptionService optionService)
 {
     this.orderService = orderService;
     this.optionService = optionService;
     UserManager = userManager;
 }

 public PagePropertiesService(IRepository repository, IUrlService urlService, IOptionService optionService, IMediaFileUrlResolver fileUrlResolver)
 {
     this.repository = repository;
     this.urlService = urlService;
     this.optionService = optionService;
     this.fileUrlResolver = fileUrlResolver;
 }

 public DefaultContentService(ISecurityService securityService, IRepository repository, IUnitOfWork unitOfWork, IOptionService optionService)
 {
     this.unitOfWork = unitOfWork;
     this.securityService = securityService;
     this.repository = repository;
     this.optionService = optionService;
 }

 public OptionCategoryController(IOptionCategoryService optionCategoryService, IOptionService optionService,
     ISettingService settingService)
 {
     this.optionCategoryService = optionCategoryService;
     this.optionService = optionService;
     this.settingService = settingService;
 }

 public DefaultContentProjectionService(PageContentProjectionFactory pageContentProjectionFactory,
     IOptionService optionService, IUnitOfWork unitOfWork)
 {
     this.optionService = optionService;
     this.pageContentProjectionFactory = pageContentProjectionFactory;
     this.unitOfWork = unitOfWork;
 }

 public DefaultPreviewService(PageContentProjectionFactory pageContentProjectionFactory, IOptionService optionService, IRepository repository, ISecurityService securityService)
 {
     this.pageContentProjectionFactory = pageContentProjectionFactory;
     this.repository = repository;
     this.optionService = optionService;
     this.securityService = securityService;
 }

 protected override void ConnectToWorkspace(Workspace workspace)
 {
     _optionService = workspace.Services.GetService<IOptionService>();
     if (_optionService != null)
     {
         _optionService.OptionChanged += OnOptionChanged;
     }
 }

 public AmazonListingServiceTests()
 {
     _amazonLogService = A.Fake<IAmazonLogService>();
     _amazonProductsApiService = A.Fake<IAmazonProductsApiService>();
     _productVariantService = A.Fake<IProductVariantService>();
     _optionService = A.Fake<IOptionService>();
     _amazonListingService = new AmazonListingService(Session,_amazonLogService,_productVariantService,_optionService,_amazonProductsApiService);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="DefaultLayoutService" /> class.
 /// </summary>
 /// <param name="repository">The repository.</param>
 /// <param name="optionService">The option service.</param>
 /// <param name="configuration">The configuration.</param>
 /// <param name="accessControlService">The access control service.</param>
 public DefaultLayoutService(IRepository repository, IOptionService optionService, ICmsConfiguration configuration,
     IAccessControlService accessControlService)
 {
     this.repository = repository;
     this.optionService = optionService;
     this.configuration = configuration;
     this.accessControlService = accessControlService;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="HtmlContentService" /> class.
 /// </summary>
 /// <param name="repository">The repository.</param>
 /// <param name="unitOfWork">The unit of work.</param>
 /// <param name="contentService">The content service.</param>
 /// <param name="optionService">The option service.</param>
 public HtmlContentService(IRepository repository, IUnitOfWork unitOfWork,
     Module.Root.Services.IContentService contentService, IOptionService optionService)
 {
     this.repository = repository;
     this.unitOfWork = unitOfWork;
     this.contentService = contentService;
     this.optionService = optionService;
 }

 public HtmlContentWidgetService(IRepository repository, IHtmlContentWidgetOptionsService optionsService,
     ISaveWidgetService widgetService, IOptionService optionService)
 {
     this.repository = repository;
     this.optionsService = optionsService;
     this.widgetService = widgetService;
     this.optionService = optionService;
 }

        public ForceLowMemoryMode(IOptionService optionService)
        {
            _optionService = optionService;

            optionService.OptionChanged += Options_OptionChanged;

            RefreshFromSettings();
        }

 public DesignerAttributeIncrementalAnalyzer(
     IServiceProvider serviceProvider,
     IOptionService optionService,
     IForegroundNotificationService notificationService,
     IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> asyncListeners) :
     base(serviceProvider, optionService, notificationService, asyncListeners)
 {
 }

        public FullSolutionAnalysisOptionBinding(IOptionService optionService, string languageName)
        {
            _optionService = optionService;
            _languageName = languageName;

            _fullSolutionAnalysis = RuntimeOptions.FullSolutionAnalysis;
            _closedFileDiagnostics = ServiceFeatureOnOffOptions.ClosedFileDiagnostic;
        }

        /// <summary>
        /// let one such as ETA to set logger for the service layer
        /// </summary>
        internal static void SetLogger(IOptionService optionsService, string loggerName)
        {
            if (loggerName == null)
            {
                ResetLogger();
            }

            Logger.SetLogger(GetLogger(optionsService, loggerName));
        }

 public PagesService(IRepository repository, IOptionService optionService, IMediaFileUrlResolver fileUrlResolver,
     ISearchPagesService searchPagesService, IAccessControlService accessControlService)
 {
     this.repository = repository;
     this.optionService = optionService;
     this.fileUrlResolver = fileUrlResolver;
     this.searchPagesService = searchPagesService;
     this.accessControlService = accessControlService;
 }

 public AmazonListingService(ISession session,
     IAmazonLogService amazonLogService, 
     IProductVariantService productVariantService, IOptionService optionService, IAmazonProductsApiService amazonProductsApiService)
 {
     _session = session;
     _amazonLogService = amazonLogService;
     _productVariantService = productVariantService;
     _optionService = optionService;
     _amazonProductsApiService = amazonProductsApiService;
 }

        /// <summary>
        /// let ones such as Perf setup to share loggingChecker func
        /// </summary>
        internal static Func<FunctionId, bool> GetLoggingChecker(IOptionService optionsService)
        {
            var functionIds = Enum.GetValues(typeof(FunctionId)).Cast<FunctionId>();
            var functionIdOptions = functionIds.ToDictionary(
                id => id, id => optionsService.GetOption(FunctionIdOptions.GetOption(id)));

            Func<FunctionId, bool> loggingChecker = (functionId) => functionIdOptions[functionId];

            return loggingChecker;
        }

        protected AbstractPersistentStorage(IOptionService optionService, string solutionFilePath, Action<AbstractPersistentStorage> disposer)
        {
            Contract.ThrowIfNull(disposer);

            this.SolutionFilePath = solutionFilePath;

            this.refCounter = 0;
            this.optionService = optionService;
            this.disposer = disposer;
        }