public static void SetHandler(IExceptionHandler handler)
 {
     lock (_lock)
     {
         _handler = handler;
     }
 }

 public DefaultApplicationConfigurationGetter(
     IExceptionHandler exceptionHandler, 
     List<IHttpEndpoint> httpEndpoints)
 {
     _exceptionHandler = exceptionHandler;
     _httpEndpoints = httpEndpoints;
 }

        internal static Task AddFromImdbId(INovaromaEngine engine, IExceptionHandler exceptionHandler, IDialogService dialogService, string imdbId) {
            var viewModel = new NewMediaWizardViewModel(engine, exceptionHandler, dialogService);
            var t = viewModel.AddFromImdbId(imdbId);

            new NewMediaWizard(viewModel).ForceShow();
            return t;
        }

        internal static Task NewMedia(INovaromaEngine engine, IExceptionHandler exceptionHandler, IDialogService dialogService, string searchQuery = null, string parentDirectory = null) {
            var viewModel = new NewMediaWizardViewModel(engine, exceptionHandler, dialogService);
            var t = viewModel.AddFromSearch(searchQuery, parentDirectory);

            new NewMediaWizard(viewModel).ForceShow();
            return t;
        }

 public ValueStack(IExceptionHandler handler, IExpressionContext expressionContext)
 {
     Values = new CustomDictionary();
     _exceptionHandler = handler;
     _evaluator = expressionContext.CreateEvaluator(this);
     Persistables = new Dictionary<string, IPersistable>();
 }

 public ArticleService(IUnitOfWork unitOfWork, IExceptionHandler exceptionHandler)
 {
     this.unitOfWork = unitOfWork;
     this.articleRepository = unitOfWork.ArticleRepository;
     this.articleVersionRepository = unitOfWork.ArticleVersionRepository;
     this.exceptionHandler = exceptionHandler;
 }

        private static async Task<HttpResponseMessage> HandleAsyncCore(IExceptionHandler handler,
            ExceptionHandlerContext context, CancellationToken cancellationToken)
        {
            Contract.Assert(handler != null);
            Contract.Assert(context != null);

            await handler.HandleAsync(context, cancellationToken);

            IHttpActionResult result = context.Result;

            if (result == null)
            {
                return null;
            }

            HttpResponseMessage response = await result.ExecuteAsync(cancellationToken);

            if (response == null)
            {
                throw new InvalidOperationException(Error.Format(SRResources.TypeMethodMustNotReturnNull,
                    typeof(IHttpActionResult).Name, "ExecuteAsync"));
            }

            return response;
        }

        protected HandleExceptionAndRetryActionDecorator(ITaskAction action, IExceptionHandler exceptionHandler)
        {
            RetryInterval = BackoffInterval.Default;

            _action = action;
            _exceptionHandler = exceptionHandler;
        }

        public PlayShellView(IEventAggregator eventBus, UserSettings settings,
            INotificationCenterMessageHandler handler,
            IDialogManager dialogManager, IExceptionHandler exceptionHandler) {
            InitializeComponent();

            Loaded += (sender, args) => DialogHelper.MainWindowLoaded = true;

            _userSettings = settings;
            _handler = handler;
            _dialogManager = dialogManager;
            _exceptionHandler = exceptionHandler;

            _snow = new Snow(ContentCanvas, eventBus);
            WorkaroundSystemMenu_Init();

            this.WhenActivated(d => {
                d(UserError.RegisterHandler<CanceledUserError>(x => CanceledHandler(x)));
                d(UserError.RegisterHandler<NotLoggedInUserError>(x => NotLoggedInDialog(x)));
                d(UserError.RegisterHandler<NotConnectedUserError>(x => NotConnectedDialog(x)));
                d(UserError.RegisterHandler<BusyUserError>(x => BusyDialog(x)));
                d(this.WhenAnyValue(x => x.ViewModel).BindTo(this, v => v.DataContext));
                d(this.OneWayBind(ViewModel, vm => vm.Overlay.ActiveItem, v => v.MainScreenFlyout.ViewModel));
                d(this.OneWayBind(ViewModel, vm => vm.SubOverlay, v => v.SubscreenFlyout.ViewModel));
                d(this.OneWayBind(ViewModel, vm => vm.StatusFlyout, v => v.StatusFlyout.ViewModel));
                d(this.WhenAnyObservable(x => x.ViewModel.ActivateWindows)
                    .ObserveOn(RxApp.MainThreadScheduler)
                    .Subscribe(x => DialogHelper.ActivateWindows(x)));
                d(_userSettings.AppOptions.WhenAnyValue(x => x.DisableEasterEggs)
                    .ObserveOn(RxApp.MainThreadScheduler)
                    .Subscribe(HandleEasterEgg));
                d(TryCreateTrayIcon());
            });

            ThemeManager.IsThemeChanged += CustomThemeManager.ThemeManagerOnIsThemeChanged;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MobileDevicesEditor"/> class.
        /// </summary>
        /// <param name="synchronizationService">The synchronization service to be used
        /// for manipulating devices at the tracking service.</param>
        /// <param name="resourceProvider">The instance of resource provider for obtaining
        /// messages.</param>
        /// <param name="workingStatusController">The instance of the controller to be used
        /// for managing application status.</param>
        /// <param name="exceptionHandler">The exception handler for tracking service
        /// related errors.</param>
        /// <exception cref="ArgumentNullException"><paramref name="synchronizationService"/>,
        /// <paramref name="resourceProvider"/>, <paramref name="workingStatusController"/>,
        /// <paramref name="exceptionHandler"/> or <paramref name="project"/> is a null
        /// reference.</exception>
        public MobileDevicesEditor(
            ISynchronizationService synchronizationService,
            IWorkingStatusController workingStatusController,
            IExceptionHandler exceptionHandler,
            IProject project)
        {
            if (synchronizationService == null)
            {
                throw new ArgumentNullException("synchronizationService");
            }

            if (workingStatusController == null)
            {
                throw new ArgumentNullException("workingStatusController");
            }

            if (exceptionHandler == null)
            {
                throw new ArgumentNullException("exceptionHandler");
            }

            if (project == null)
            {
                throw new ArgumentNullException("project");
            }

            _synchronizationService = synchronizationService;
            _workingStatusController = workingStatusController;
            _exceptionHandler = exceptionHandler;
            _project = project;
        }

        public ConfigurationWindow(NovaromaEngine engine, IExceptionHandler exceptionHandler, IDialogService dialogService) {
            InitializeComponent();

            _configurableEngine = engine;
            _engine = engine;
            _downloader = engine.Settings.Downloader.SelectedItem as IConfigurable;
            _exceptionHandler = exceptionHandler;
            _dialogService = dialogService;
            _initialMovieDir = engine.MovieDirectory;
            _initialTvShowDir = engine.TvShowDirectory;

            _engineSettings = engine.Settings;

            var utor = _downloader as UTorrentDownloader;
            if (utor != null && utor.IsAvailable) {
                _torrentSettings = utor.Settings;
                TorrentHowToHyperink.NavigateUri = new Uri(Properties.Resources.Url_HowToConfigureUtorrentWebUISettings);
            }
            else {
                var trantor = _downloader as TransmissionDownloader;
                if (trantor != null) {
                    _torrentSettings = trantor.Settings;
                    TorrentHowToHyperink.NavigateUri = new Uri(Properties.Resources.Url_HowToConfigureTransmissionWebUISettings);
                }
            }
            if (_torrentSettings == null)
                TorrentSettingsExpander.Visibility = Visibility.Collapsed;
            else if (_downloader != null)
                TorrentSettingsExpander.Tag = string.Format(Properties.Resources.TorrentWebUISettings, _downloader.SettingName);

            DataContext = this;

            Closing += OnClosing;
        }

 public FeatureSnapshot(IExceptionHandler exceptionhandler)
     : base("snapshot", "control/feature-snapshot", "control/snapshot/action",true, exceptionhandler)
 {
     actionKey = wmisession.GetXenStoreItem("control/snapshot/action");
     typeKey = wmisession.GetXenStoreItem("control/snapshot/type");
     statusKey = wmisession.GetXenStoreItem("control/snapshot/status");
     threadlock = new object();
 }

 public LanguageService(IUnitOfWork unitOfWork, IExceptionHandler exceptionHandler, ILocalStorageService storageService, HttpContextBase context)
 {
     this.unitOfWork = unitOfWork;
     this.languageRepository = unitOfWork.LanguageRepository;
     this.exceptionHandler = exceptionHandler;
     this.storageService = storageService;
     this.context = context;
 }

		public ExceptionHandledEventArgs(IExceptionHandler handler, Exception exception)
		{
			if(handler == null)
				throw new ArgumentNullException("handler");

			this.Handler = handler;
			this.Exception = exception;
		}

 public DownloadSearchViewModel(INovaromaEngine engine, IExceptionHandler exceptionHandler, IDialogService dialogService, IDownloadable downloadable, string directory)
     : base(dialogService) {
     _engine = engine;
     _exceptionHandler = exceptionHandler;
     _downloadable = downloadable;
     _directory = directory;
     _searchCommand = new RelayCommand(DoSearch, CanSearch);
 }

        public LastChanceExceptionHandler(IExceptionHandler innerHandler)
        {
            if (innerHandler == null)
            {
                throw Error.ArgumentNull("innerHandler");
            }

            this.innerHandler = innerHandler;
        }

 public StepClassInvoker(StepType stepType, Type stepClass, KeyValuePair<string,object>[] supportedParameters, IExceptionHandler exceptionHandler)
 {
     if (!typeof(Step).IsAssignableFrom(stepClass))
         throw new ArgumentException("The stepClass must inherit from Step", "stepClass");
     _stepClass = stepClass;
     _exceptionHandler = exceptionHandler;
     Type = stepType;
     Name = new StepName(Type, _stepClass.Name, supportedParameters);
     Parameters = _stepClass.GetConstructors().Single().BindParameters(supportedParameters);
 }

        /// <summary>
        /// Adds the exception intercept.
        /// </summary>
        /// <param name="builder">The builder.</param>
        /// <param name="exceptionIntercept">The exception intercept.</param>
        /// <returns></returns>
        public static IApplicationBuilder AddExceptionIntercept(this IApplicationBuilder builder, IExceptionHandler exceptionInspector)
        {
            var exceptionManager = builder.ApplicationServices.GetService<IExceptionInterceptManager>();
            if (exceptionManager != null)
            {
                exceptionManager.AddExceptionIntercept(exceptionInspector);
            }

            return builder;
        }

		public ConsoleApplication(ICommandParser commandParser,
		                          IResultHandler resultHandler,
		                          IInput input,
		                          IExceptionHandler exceptionHandler)
		{
			_commandParser = commandParser;
			_resultHandler = resultHandler;
			_input = input;
			_exceptionHandler = exceptionHandler;
		}

 public WebTokenCreator(
     IExceptionHandler exceptionHandler,
     IFactory<ITemporaryCredentials> applicationCredentialsUnityFactory,
     IOAuthWebRequestGenerator oAuthWebRequestGenerator,
     ITwitterRequestHandler twitterRequestHandler)
 {
     _exceptionHandler = exceptionHandler;
     _applicationCredentialsUnityFactory = applicationCredentialsUnityFactory;
     _oAuthWebRequestGenerator = oAuthWebRequestGenerator;
     _twitterRequestHandler = twitterRequestHandler;
 }