public override object GetInstance(IInstanceFactory factory, IResolver resolver)
        {
            if (!_threadLocalInstance.IsValueCreated)
                _threadLocalInstance.Value = factory.CreateInstance(resolver);

            return _threadLocalInstance.Value;
        }

 internal ModelMetadataProviders(IResolver<ModelMetadataProvider> resolver = null)
 {
     _resolver = resolver ?? new SingleServiceResolver<ModelMetadataProvider>(
                                 () => _currentProvider,
                                 new CachedDataAnnotationsModelMetadataProvider(),
                                 "ModelMetadataProviders.Current");
 }

 internal DefaultControllerFactory(IControllerActivator controllerActivator, IResolver<IControllerActivator> activatorResolver, IDependencyResolver dependencyResolver)
 {
     if (controllerActivator != null)
     this._controllerActivator = controllerActivator;
       else
     this._activatorResolver = activatorResolver ?? (IResolver<IControllerActivator>) new SingleServiceResolver<IControllerActivator>((Func<IControllerActivator>) (() => (IControllerActivator) null), (IControllerActivator) new DefaultControllerFactory.DefaultControllerActivator(dependencyResolver), "DefaultControllerFactory constructor");
 }

 public IndicatorUpdateCoordinator(ILog log, Repository<IIndicatorConfiguration> indicatorConfigurationRepository, Repository<IIndicatorState> indicatorStateRepository, IResolver resolver)
 {
     _log = log;
     _indicatorConfigurationRepository = indicatorConfigurationRepository;
     _indicatorStateRepository = indicatorStateRepository;
     _resolver = resolver;
 }

 internal ControllerBuilder(IResolver<IControllerFactory> serviceResolver) {
     _serviceResolver = serviceResolver ?? new SingleServiceResolver<IControllerFactory>(
         () => _factoryThunk(),
          new DefaultControllerFactory { ControllerBuilder = this },
         "ControllerBuilder.GetControllerFactory"
     );
 }

 public DispatchToEventSubscribers(
     ILog log,
     IResolver resolver)
 {
     _log = log;
     _resolver = resolver;
 }

 public CSSAssetsFileHasher(string hashQueryStringKeyName, IResolver fileResolver, IHasher hasher, IPathTranslator pathTranslator)
 {
     HashQueryStringKeyName = hashQueryStringKeyName;
     FileSystemResolver = fileResolver;
     Hasher = hasher;
     this.pathTranslator = pathTranslator;
 }

        public async Task ExecuteAsync(IResolver resolver, CancellationToken cancellationToken)
        {
            var queryProcessor = resolver.Resolve<IQueryProcessor>();
            var updateItineraryService = resolver.Resolve<IUpdateItineraryService>();
            var commandBus = resolver.Resolve<ICommandBus>();
            var routingService = resolver.Resolve<IRoutingService>();

            var cargo = (await queryProcessor.ProcessAsync(new GetCargosQuery(CargoId), cancellationToken).ConfigureAwait(false)).Single();
            var updatedItinerary = await updateItineraryService.UpdateItineraryAsync(cargo.Itinerary, cancellationToken).ConfigureAwait(false);

            if (cargo.Route.Specification().IsSatisfiedBy(updatedItinerary))
            {
                await commandBus.PublishAsync(new CargoSetItineraryCommand(cargo.Id, updatedItinerary), cancellationToken).ConfigureAwait(false);
                return;
            }

            var newItineraries = await routingService.CalculateItinerariesAsync(cargo.Route, cancellationToken).ConfigureAwait(false);

            var newItinerary = newItineraries.FirstOrDefault();
            if (newItinerary == null)
            {
                // TODO: Tell domain that a new itinerary could not be found
                throw DomainError.With("Could not find itinerary");
            }

            await commandBus.PublishAsync(new CargoSetItineraryCommand(cargo.Id, newItinerary), cancellationToken).ConfigureAwait(false);
        }

        ///<summary>
        /// Initializes a new instance of <see cref="SelectDatabaseStep"/>.
        ///</summary>
        ///<param name="serviceProvider">The service provider to use for service location.</param>
        ///<param name="sourceModel">The <see cref="ConfigurationSourceModel"/> to update on <see cref="WizardStep.Execute"/></param>
        ///<param name="validatorFactory">The factory creating new <see cref="Validator"/> instances.</param>
        ///<param name="elementLookup">The service for locating registered elements.</param>
        public SelectDatabaseStep(IServiceProvider serviceProvider,
                                ConfigurationSourceModel sourceModel,
                                IResolver<Validator> validatorFactory,
                                ElementLookup elementLookup
                                )
            : base(serviceProvider, validatorFactory, elementLookup)
        {
            this.sourceModel = sourceModel;

            var name = AddReflectedProperty(wizardData, propertyName);

            PropertyList.Add(new AssociatedWizardProperty(serviceProvider,
                                                          wizardData,
                                                          TypeDescriptor.GetProperties(wizardData)[propertyConnectionString],
                                                          validatorFactory,
                                                          elementLookup,
                                                          name));

            
            PropertyList.Add(new AssociatedWizardProperty(serviceProvider,
                                                          wizardData,
                                                          TypeDescriptor.GetProperties(wizardData)[propertyProviderName],
                                                          validatorFactory,
                                                          elementLookup,
                                                          name));

            SetDefaultDatabase(elementLookup);
        }

		public ServiceProviderAdapter(IResolver resolver)
		{
			if (resolver == null)
				throw new ArgumentNullException("resolver");

			_resolver = resolver;
		}

        internal BuildManagerViewEngine(IViewPageActivator viewPageActivator, IResolver<IViewPageActivator> activatorResolver,
            IDependencyResolver dependencyResolver, VirtualPathProvider pathProvider)
        {
            if (viewPageActivator != null)
            {
                _viewPageActivator = viewPageActivator;
            }
            else
            {
                _activatorResolver = activatorResolver ?? new SingleServiceResolver<IViewPageActivator>(
                                                              () => null,
                                                              new DefaultViewPageActivator(dependencyResolver),
                                                              "BuildManagerViewEngine constructor");
            }

            if (pathProvider != null)
            {
                Func<VirtualPathProvider> providerFunc = () => pathProvider;
                _fileExistsCache = new FileExistenceCache(providerFunc);
                VirtualPathProviderFunc = providerFunc;
            }
            else
            {
                if (_sharedFileExistsCache == null)
                {
                    // Startup initialization race is OK providing service remains read-only
                    _sharedFileExistsCache = new FileExistenceCache(() => HostingEnvironment.VirtualPathProvider);
                }

                _fileExistsCache = _sharedFileExistsCache;
            }
        }

 private ProcessStartInfo CreateStartInfo(Benchmark benchmark, string exeName, string args, string workingDirectory, IResolver resolver)
 {
     var start = new ProcessStartInfo
     {
         UseShellExecute = false,
         RedirectStandardOutput = true,
         RedirectStandardError = true,
         CreateNoWindow = true,
         WorkingDirectory = workingDirectory
     };
     var runtime = benchmark.Job.Env.HasValue(EnvMode.RuntimeCharacteristic)
         ? benchmark.Job.Env.Runtime
         : RuntimeInformation.GetCurrentRuntime();
         // TODO: use resolver
     switch (runtime)
     {
         case Runtime.Clr:
         case Runtime.Core:
             start.FileName = exeName;
             start.Arguments = args;
             break;
         case Runtime.Mono:
             start.FileName = "mono";
             start.Arguments = GetMonoArguments(benchmark.Job, exeName, args, resolver);
             break;
         default:
             throw new NotSupportedException("Runtime = " + runtime);
     }
     return start;
 }

        public bool TryGetConstructor(Type type, IResolver resolver, out ConstructorInfo constructor)
        {
            if (type.IsAbstract)
            {
                constructor = null;
                return false;
            }

            var rankedConstructors =
                type.GetConstructors()
                    .SelectMany(GetVirtualContructors)
                    .Where(v => v.CanResolve(resolver))
                    .GroupBy(v => v.GetScore())
                    .OrderByDescending(g => g.Key);

            var enumerator = rankedConstructors.GetEnumerator();

            if (!enumerator.MoveNext())
            {
                constructor = null;
                return false;
            }

            if (enumerator.Current.Count() > 1)
            {
                constructor = null;
                return false;
            }

            constructor = enumerator.Current.Single().Constructor;
            return true;
        }

        /// <summary>
        /// generates project.lock.json that tells compiler where to take dlls and source from
        /// and builds executable and copies all required dll's
        /// </summary>
        public BuildResult Build(GenerateResult generateResult, ILogger logger, Benchmark benchmark, IResolver resolver)
        {
            if (!DotNetCliCommandExecutor.ExecuteCommand(
                RestoreCommand, 
                generateResult.ArtifactsPaths.BuildArtifactsDirectoryPath, 
                logger, 
                DefaultTimeout))
            {
                return BuildResult.Failure(generateResult, new Exception("dotnet restore has failed"));
            }

            if (!DotNetCliCommandExecutor.ExecuteCommand(
                GetBuildCommand(TargetFrameworkMoniker),
                generateResult.ArtifactsPaths.BuildArtifactsDirectoryPath, 
                logger,
                DefaultTimeout))
            {
                // dotnet cli could have succesfully builded the program, but returned 1 as exit code because it had some warnings
                // so we need to check whether the exe exists or not, if it does then it is OK
                if (File.Exists(generateResult.ArtifactsPaths.ExecutablePath))
                {
                    return BuildResult.Success(generateResult);
                }

                return BuildResult.Failure(generateResult);
            }

            return BuildResult.Success(generateResult);
        }

 public SizesModel(IResolver resolver, IReadOnlyCollection<ImageInfo> images, string id)
 {
     this.ServiceName = resolver.ServiceName;
     this.Images = images;
     this.ServiceId = resolver.ServiceId;
     this.Id = id;
 }

        public object GetInstance(Func<IResolver, object> factory, IResolver resolver)
        {
            if (!_threadLocalInstance.IsValueCreated)
                _threadLocalInstance.Value = factory(resolver);

            return _threadLocalInstance.Value;
        }

        public LcdpServer(ILcdpPacketSerializer lcdpPacketSerializer, IListener listener, IForwarder forwarder, IResolver resolver)
        {
            this.lcdpPacketSerializer = lcdpPacketSerializer;

            this.listener = listener;
            this.forwarder = forwarder;

            this.messages = new ConcurrentDictionary<string, LcdpMessage>();

            this.ChunkExpirationTimeMilliseconds = 5000;

            this.compressors = new Dictionary<byte, ICompressor>();
            this.serializers = new Dictionary<byte, ISerializer>();

            for(byte b = 0; b < byte.MaxValue; ++b)
            {
                ICompressor compressor = resolver.Resolve<ICompressor>(b.ToString());
                if (compressor != null)
                {
                    compressors[b] = compressor;
                }

                ISerializer serializer = resolver.Resolve<ISerializer>(b.ToString());
                if (serializer != null)
                {
                    serializers[b] = serializer;
                }
            }
        }

 public DocumentPicturesCreator(
     IResolver<IDocumentPictureContext> resDocumentPictureContext,
     IResolver<IWebApiDocument> resWebApiDocument
     )
 {
     m_resWebApiDocument = resWebApiDocument;
     m_resDocumentPictureContext = resDocumentPictureContext;
 }

 public EmdFileParser(
     IResolver<IEmdFileStructure> resEmdFileStrcture,
     IResolver<IEmdFileMember> resEmdFileMember,
     IResolver<IEmdFileSection> resEmdFileSection)
 {
     m_resEmdFileStrcture = resEmdFileStrcture;
     m_resEmdFileMember = resEmdFileMember;
     m_resEmdFileSection = resEmdFileSection;
 }

 public JobRunner(
     IResolver resolver,
     IJobDefinitionService jobDefinitionService,
     IJsonSerializer jsonSerializer)
 {
     _resolver = resolver;
     _jobDefinitionService = jobDefinitionService;
     _jsonSerializer = jsonSerializer;
 }