public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
 {
     // give out new option service per workspace
     return new OptionServiceFactory.OptionService(
         new GlobalOptionService(_providers, SpecializedCollections.EmptyEnumerable<Lazy<IOptionPersister>>()),
         workspaceServices);
 }

        private static IWorkspaceService GetVisualStudioProjectCache(HostWorkspaceServices workspaceServices)
        {
            var projectCacheService = new ProjectCacheService(workspaceServices.Workspace, ImplicitCacheTimeoutInMS);

            var documentTrackingService = workspaceServices.GetService<IDocumentTrackingService>();

            // Subscribe to events so that we can cache items from the active document's project
            var manager = new ActiveProjectCacheManager(documentTrackingService, projectCacheService);

            // Subscribe to requests to clear the cache
            var workspaceCacheService = workspaceServices.GetService<IWorkspaceCacheService>();
            if (workspaceCacheService != null)
            {
                workspaceCacheService.CacheFlushRequested += (s, e) => manager.Clear();
            }

            // Also clear the cache when the solution is cleared or removed.
            workspaceServices.Workspace.WorkspaceChanged += (s, e) =>
            {
                if (e.Kind == WorkspaceChangeKind.SolutionCleared || e.Kind == WorkspaceChangeKind.SolutionRemoved)
                {
                    manager.Clear();
                }
            };

            return projectCacheService;
        }

		public IWorkspaceService CreateService (HostWorkspaceServices workspaceServices)
		{
			if (microsoftFactory != null) {
				return microsoftFactory.CreateService (workspaceServices);
			}
			return new TemporaryStorageService ();
		}

 public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
 {
     var optionService = workspaceServices.GetService<IOptionService>();
     var errorReportingService = workspaceServices.GetService<IErrorReportingService>();
     var errorLoggerService = workspaceServices.GetService<IErrorLoggerService>();
     return new ExtensionManager(optionService, errorReportingService, errorLoggerService, _errorHandlers);
 }

        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
            var manager = workspaceServices.GetService<VisualStudioMetadataReferenceManager>();
            Debug.Assert(manager != null);

            return new Service(manager);
        }

        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
            if (_singleton == null)
            {
                _singleton = new DefaultSymbolNavigationService();
            }

            return _singleton;
        }

        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
            if (_singleton == null)
            {
                var temporaryStorage = workspaceServices.GetService<ITemporaryStorageService>();
                Interlocked.CompareExchange(ref _singleton, new VisualStudioMetadataReferenceManager(_serviceProvider, temporaryStorage), null);
            }

            return _singleton;
        }

        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
            // we support active document tracking only for visual studio workspace host.
            if (workspaceServices.Workspace is VisualStudioWorkspace)
            {
                return GetVisualStudioProjectCache(workspaceServices);
            }

            return GetMiscProjectCache(workspaceServices);
        }

        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
            if (_singleton == null)
            {
                var optionService = workspaceServices.GetService<IOptionService>();
                System.Threading.Interlocked.CompareExchange(ref _singleton, new PersistentStorageService(optionService), null);
            }

            return _singleton;
        }

        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
            lock (s_gate)
            {
                if (s_singleton == null)
                {
                    s_singleton = new VSDialogService(_uiShellService);
                }
            }

            return s_singleton;
        }

        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
            lock (s_gate)
            {
                if (s_singleton == null)
                {
                    s_singleton = new EditorDialogService();
                }
            }

            return s_singleton;
        }

        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
            if (cache == null)
            {
                var service = workspaceServices.GetService<IOptionService>();
                var newCache = CreateCache(service);

                Interlocked.CompareExchange(ref cache, newCache, null);
            }

            return cache;
        }

        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
            var options = workspaceServices.Workspace.Options;
            if (options.GetOption(ServiceComponentOnOffOptions.PackageSearch))
            {
                // Only support package search in vs workspace.
                if (workspaceServices.Workspace is VisualStudioWorkspace)
                {
                    return new PackageSearchService(_serviceProvider, workspaceServices.GetService<IPackageInstallerService>());
                }
            }

            return new NullPackageSearchService();
        }

        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
            var service = new ProjectCacheService(workspaceServices.Workspace, ImplicitCacheTimeoutInMS);

            // Also clear the cache when the solution is cleared or removed.
            workspaceServices.Workspace.WorkspaceChanged += (s, e) =>
            {
                if (e.Kind == WorkspaceChangeKind.SolutionCleared || e.Kind == WorkspaceChangeKind.SolutionRemoved)
                {
                    service.ClearImplicitCache();
                }
            };

            return service;
        }

        private static IWorkspaceService GetMiscProjectCache(HostWorkspaceServices workspaceServices)
        {
            if (workspaceServices.Workspace.Kind != WorkspaceKind.Host)
            {
                return new ProjectCacheService(workspaceServices.Workspace);
            }

            var projectCacheService = new ProjectCacheService(workspaceServices.Workspace, ImplicitCacheTimeoutInMS);

            // Also clear the cache when the solution is cleared or removed.
            workspaceServices.Workspace.WorkspaceChanged += (s, e) =>
            {
                if (e.Kind == WorkspaceChangeKind.SolutionCleared || e.Kind == WorkspaceChangeKind.SolutionRemoved)
                {
                    projectCacheService.ClearImplicitCache();
                }
            };

            return projectCacheService;
        }

 public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
 {
     return new Service(workspaceServices.Workspace as VisualStudioWorkspaceImpl);
 }

 public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
 {
     return this;
 }

 public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
 {
     return _singleton;
 }

 IWorkspaceService IWorkspaceServiceFactory.CreateService(HostWorkspaceServices workspaceServices)
 {
     return this;
 }

 public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
 {
     // all different workspace kinds will share same service
     return singleton;
 }