public void ShareImage(IImageService service)
        {
            string imagePath = GetCapturedImage();

            if (SynchronizationContext.Current == null)
                SynchronizationContext.SetSynchronizationContext(new WindowsFormsSynchronizationContext());

            var worker = Task.Run(() =>
            {
                StartAsyncOutput();
                var uploadTask = service.UploadImage(imagePath);
                uploadTask.ContinueWith(task => HandleError(task.Exception), 
                    TaskContinuationOptions.AttachedToParent | TaskContinuationOptions.OnlyOnFaulted);
                return uploadTask.Result;
            });
            worker.ContinueWith(previousTask => HandleResult(previousTask.Result),
                CancellationToken.None,
                TaskContinuationOptions.OnlyOnRanToCompletion,
                TaskScheduler.FromCurrentSynchronizationContext())
                .ContinueWith(task =>
                {
                    FinishAsyncOutput();
                    File.Delete(imagePath);
                });
        }

 public WatchController(IWatchService watchService, IImageService imageService, IOrderService orderService, IRequestContext requestContext)
 {
     _watchService = watchService;
     _imageService = imageService;
     _orderService = orderService;
     _requestContext = requestContext;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ImageDimensionMinValidator"/> class.
 /// </summary>
 /// <param name="width">The width.</param>
 /// <param name="height">The height.</param>
 /// <param name="imageService">The image service.</param>
 public ImageDimensionMinValidator(int width, int height, IImageService imageService)
     : base(Errors.ImageDimensionMinNotValid)
 {
     this.Width = width;
     this.Height = height;
     this.ImageService = imageService;
 }

 public MemoryCachedImageService(IImageService serviceToCache)
 {
     this.serviceToCache = serviceToCache;
     isLoading = new Dictionary<Uri, bool>();
     images = new Dictionary<Uri, byte[]>();
     callbacks = new Dictionary<Uri, List<Action<byte[]>>>();
 }

 public DishController(IDishService dishservice, IUserService userservice, IDishTypeService dishtypeservice, IImageService imageservice)
 {
     DishSvc = dishservice;
     UserSvc = userservice;
     DishTypeSvc = dishtypeservice;
     ImageSvc = imageservice;
 }

 public ArticleController(IArticleService articleService, IRubricService rubricService, IImageService imageService, ITagService tagService)
 {
     this.articleService = articleService;
     this.rubricService = rubricService;
     this.imageService = imageService;
     this.tagService = tagService;
 }

 public ImageController(
     IImageProcessor imageProcessor,
     IImageService imageService)
 {
     _imageProcessor = imageProcessor;
     _imageService = imageService;
 }

 public AccountController(IClientService clientService, IRoleService roleService, IUtilisateurService<Client> utilisateurService, IImageService imageService)
 {
     ClientService = clientService;
     RoleService = roleService;
     UtilisateurService = utilisateurService;
     ImageService = imageService;
 }

 public EmployeController(IEmployeService employeService, IRoleService roleService, IUtilisateurService<Employe> utilisateurService, IImageService imageService)
 {
     EmployeService = employeService;
     RoleService = roleService;
     UtilisateurService = utilisateurService;
     ImageService = imageService;
 }

 public ActivityController(IAllReadyDataAccess dataAccess, UserManager<ApplicationUser> userManager, IImageService imageService, IMediator bus)
 {
     _dataAccess = dataAccess;
     _userManager = userManager;
     _imageService = imageService;
     _bus = bus;
 }

        public FlickrSearchViewModel(IImageService imageService)
        {
            Images = new ReactiveList<SearchResultViewModel>();

            var canExecute = this.WhenAnyValue(x => x.SearchText)
                .Select(x => !String.IsNullOrWhiteSpace(x));

            Search = ReactiveCommand.CreateAsyncObservable(
                canExecute,
                _ =>
                {
                    Images.Clear();
                    ShowError = false;
                    return imageService.GetImages(SearchText);
                });

            Search.Subscribe(images => Images.Add(images));

            Search.ThrownExceptions.Subscribe(_ => ShowError = true);

            isLoading = Search.IsExecuting.ToProperty(this, vm => vm.IsLoading);

            canEnterSearchText = this.WhenAnyValue(x => x.IsLoading)
                .Select(x => !x)
                .ToProperty(this, vm => vm.CanEnterSearchText);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="EstatesController" /> class.
 /// </summary>
 /// <param name="unitsRepository">The units repository.</param>
 /// <param name="imageService">The image service.</param>
 /// <param name="accountService">The account service.</param>
 /// <param name="unitFinder">The unit finder.</param>
 public EstatesController(IRepository<Unit> unitsRepository, IImageService imageService, IAccountService accountService, IUnitFinderService unitFinder)
 {
     this.unitsRepository = unitsRepository;
     this.imageService = imageService;
     this.accountService = accountService;
     this.unitFinder = unitFinder;
 }

 public AccountController(IUserService userService, ICryptographyService cryptographyService, IEmailService emailService, IImageService imageService)
 {
     _userService = userService;
     _cryptographyService = cryptographyService;
     _emailService = emailService;
     _imageService = imageService;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ServicesController"/> class.
 /// </summary>
 /// <param name="imageService">The image service.</param>
 /// <param name="imageConverter">The image converter.</param>
 /// <param name="queueFileService">The queue file service.</param>
 public ServicesController(IImageService imageService, 
     IImageConverter imageConverter, IQueueFileService queueFileService)
 {
     _imageConverter = imageConverter;
     _queueFileService = queueFileService;
     _imageService = imageService;
 }

 public CreditRequestService(IUnitOfWork iUnitOfWork, IImageService iImageService, 
     ICustomerService iCustomerService, IValidationService iValidationService)
 {
     _iUnitOfWork = iUnitOfWork;
     _iImageService = iImageService;
     _iCustomerService = iCustomerService;
     _iValidationService = iValidationService;
 }

 public HomeController(IPlatformProxy platformProxy, IPlatformSettings platformSettings, IImageService imageService, IBoardsRepository boardsRepository, IBoardItemsRepository boardItemsRepository)
 {
     _platformProxy = platformProxy;
     _platformSettings = platformSettings;
     _imageService = imageService;
     _boardsRepository = boardsRepository;
     _boardItemsRepository = boardItemsRepository;
 }

 public UserController(IUserService userService,ICryptographyService cryptographyService,IImageService imageService, IEmailService emailService,ISessionService sessionService)
 {
     _userService = userService;
     _cryptographyService = cryptographyService;
     _imageService = imageService;
     _emailService = emailService;
     _sessionService = sessionService;
 }

 public UserService(INoSqlDb db, IHistoryService history, IImageService image, ILogger logger, IDateTimeProvider dtp)
 {
     _db = db;
     _history = history;
     _image = image;
     _logger = logger;
     _dtp = dtp;
 }

 public AccountController(IUserService userservice, IDishService dishservice, IGeoCoder geocodeservice, IImageService imageservice, IReservationService reservationservice)
 {
     UserSvc = userservice;
     DishSvc = dishservice;
     GeocodeSvc = geocodeservice;
     ImageSvc = imageservice;
     ReservationSvc = reservationservice;
 }

        public HoutaiController(IImageService imageService, IManageService manageService)
        {
            this.ImageSerivce = imageService;
            this.AddDisposableObject(imageService);

            this.ManageService = manageService;
            this.AddDisposableObject(manageService);
        }