public GoToDefinitionFilterProvider(
            [Import(typeof(SVsServiceProvider))] System.IServiceProvider serviceProvider,
            IVsEditorAdaptersFactoryService editorFactory,
            IEditorOptionsFactoryService editorOptionsFactory,
            ITextDocumentFactoryService textDocumentFactoryService,
            [Import(typeof(DotNetReferenceSourceProvider))] ReferenceSourceProvider referenceSourceProvider,
            VSLanguageService fsharpVsLanguageService,
            ProjectFactory projectFactory)
        {
            _serviceProvider = serviceProvider;
            _editorFactory = editorFactory;
            _editorOptionsFactory = editorOptionsFactory;
            _textDocumentFactoryService = textDocumentFactoryService;
            _referenceSourceProvider = referenceSourceProvider;
            _fsharpVsLanguageService = fsharpVsLanguageService;
            _projectFactory = projectFactory;

            var dte = serviceProvider.GetService(typeof(SDTE)) as DTE;
            var events = dte.Events as Events2;
            if (events != null)
            {
                _solutionEvents = events.SolutionEvents;
                _solutionEvents.AfterClosing += Cleanup;
            }
        }
 public QuickInfoMarginProvider(
     [Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider,
     ITextDocumentFactoryService textDocumentFactoryService,
     ProjectFactory projectFactory,
     VSLanguageService vsLanguageService)
 {
     _serviceProvider = serviceProvider;
     _textDocumentFactoryService = textDocumentFactoryService;
     _projectFactory = projectFactory;
     _vsLanguageService = vsLanguageService;
 }
Exemplo n.º 3
0
        static void CreateProjectUsingEditor()
        {
            var project = new ProjectFactory().GetProject();
            var editor = Editor.Create(project, null, false, false);

            var factory = new ShapeFactory(editor);
            factory.Line(30, 30, 60, 30);
            factory.Text(30, 30, 60, 60, "Sample2");

            Project.Save(project, "sample2.project", new NewtonsoftSerializer());
        }
 public RenameCommandFilterProvider(
     [Import(typeof(SVsServiceProvider))] System.IServiceProvider serviceProvider,
     ITextDocumentFactoryService textDocumentFactoryService,
     IVsEditorAdaptersFactoryService editorFactory,
     ProjectFactory projectFactory,
     VSLanguageService fsharpVsLanguageService)
 {
     _serviceProvider = serviceProvider;
     _textDocumentFactoryService = textDocumentFactoryService;
     _editorFactory = editorFactory;
     _projectFactory = projectFactory;
     _fsharpVsLanguageService = fsharpVsLanguageService;
 }
Exemplo n.º 5
0
 public ProjectService(CacheManager cacheManager,
                       IProjectUnitOfWork projectUnitOfWork,
                       IProjectRepository projectRepository, ProjectFactory projectFactory,
                       IOrganizationRepository organizationRepository,
                       ILabelRepository labelRepository,
                       LabelFactory labelFactory)
 {
     _cacheManager           = cacheManager;
     _projectUnitOfWork      = projectUnitOfWork;
     _projectRepository      = projectRepository;
     _projectFactory         = projectFactory;
     _organizationRepository = organizationRepository;
     _labelRepository        = labelRepository;
     _labelFactory           = labelFactory;
 }
 public FindReferencesFilterProvider(
     [Import(typeof(SVsServiceProvider))] System.IServiceProvider serviceProvider,
     ITextDocumentFactoryService textDocumentFactoryService,
     IVsEditorAdaptersFactoryService editorFactory,
     FileSystem fileSystem,
     ProjectFactory projectFactory,
     VSLanguageService fsharpVsLanguageService)
 {
     _serviceProvider = serviceProvider;
     _textDocumentFactoryService = textDocumentFactoryService;
     _editorFactory = editorFactory;
     _fileSystem = fileSystem;
     _projectFactory = projectFactory;
     _fsharpVsLanguageService = fsharpVsLanguageService;
 }
 public UnionPatternMatchCaseGeneratorSmartTaggerProvider(
     [Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider,
     ITextDocumentFactoryService textDocumentFactoryService,
     ITextUndoHistoryRegistry undoHistoryRegistry,
     ProjectFactory projectFactory,
     VSLanguageService fsharpVsLanguageService,
     IOpenDocumentsTracker openDocumentsTracker)
 {
     _serviceProvider            = serviceProvider;
     _textDocumentFactoryService = textDocumentFactoryService;
     _undoHistoryRegistry        = undoHistoryRegistry;
     _projectFactory             = projectFactory;
     _fsharpVsLanguageService    = fsharpVsLanguageService;
     _openDocumentsTracker       = openDocumentsTracker;
 }
Exemplo n.º 8
0
        public PrintfSpecifiersUsageTaggerProvider(
            [Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider,
            ITextDocumentFactoryService textDocumentFactoryService,
            ProjectFactory projectFactory,
            VSLanguageService fsharpVsLanguageService,
            PrintfColorManager printfColorManager)
        {
            _serviceProvider            = serviceProvider;
            _textDocumentFactoryService = textDocumentFactoryService;
            _projectFactory             = projectFactory;
            _fsharpVsLanguageService    = fsharpVsLanguageService;
            _printfColorManager         = printfColorManager;

            VSColorTheme.ThemeChanged += UpdateTheme;
        }
Exemplo n.º 9
0
 public Core(
     Config config,
     ProjectLoader projectLoader,
     TranslationService translationService,
     TemplateFunnel templateFunnel
     )
 {
     Config                  = config;
     this.projectLoader      = projectLoader ?? throw new NullReferenceException(projectLoader.GetType() + " was null.");
     this.translationService = translationService ?? throw new NullReferenceException(translationService.GetType() + " was null.");
     this.templateFunnel     = templateFunnel ?? throw new NullReferenceException(templateFunnel.GetType() + " was null.");
     projectFactory          = new ProjectFactory(this);
     projectManager          = new ProjectManager(this);
     windowFactory           = new WindowFactory(this);
 }
 public FindReferencesFilterProvider(
     [Import(typeof(SVsServiceProvider))] System.IServiceProvider serviceProvider,
     ITextDocumentFactoryService textDocumentFactoryService,
     IVsEditorAdaptersFactoryService editorFactory,
     FileSystem fileSystem,
     ProjectFactory projectFactory,
     VSLanguageService fsharpVsLanguageService)
 {
     _serviceProvider            = serviceProvider;
     _textDocumentFactoryService = textDocumentFactoryService;
     _editorFactory           = editorFactory;
     _fileSystem              = fileSystem;
     _projectFactory          = projectFactory;
     _fsharpVsLanguageService = fsharpVsLanguageService;
 }
Exemplo n.º 11
0
        public static IProjectAccessor ImplementOpenProjectForReadAsync <TResult>(string xml)
        {
            var rootElement       = ProjectRootElementFactory.Create(xml);
            var evaluationProject = ProjectFactory.Create(rootElement);

            var mock = new Mock <IProjectAccessor>();

            mock.Setup(a => a.OpenProjectForReadAsync(It.IsAny <ConfiguredProject>(), It.IsAny <Func <Project, TResult> >(), It.IsAny <CancellationToken>()))
            .ReturnsAsync((ConfiguredProject project, Func <Project, TResult> action, CancellationToken cancellationToken) =>
            {
                return(action(evaluationProject));
            });

            return(mock.Object);
        }
Exemplo n.º 12
0
        public async Task GetProject_WhenProjectIsExisted_ShouldReturnOk()
        {
            //Arrange
            SetUpAuthorization();
            var createdProject = await _projectSteps.AddProject(ProjectFactory.GetProjectModel());

            //Act
            var response = await _projectService.GetProject(createdProject.Id);

            //Assert
            response.ResponseStatusCode(HttpStatusCode.OK, "Expected OK status.");
            var responseProject = await response.GetContentModel <ProjectResponse>();

            ProjectAssertion.AssertProject(createdProject, responseProject);
        }
Exemplo n.º 13
0
 public CreateProjectHandler(
     SheepItDbContext dbContext,
     PackageFactory packageFactory,
     DeploymentProcessFactory deploymentProcessFactory,
     EnvironmentFactory environmentFactory,
     ProjectFactory projectFactory,
     ComponentFactory componentFactory)
 {
     _dbContext                = dbContext;
     _packageFactory           = packageFactory;
     _deploymentProcessFactory = deploymentProcessFactory;
     _environmentFactory       = environmentFactory;
     _projectFactory           = projectFactory;
     _componentFactory         = componentFactory;
 }
Exemplo n.º 14
0
        public void ATaskWithChildrenTasksHasProgressBasedOnItsChildren()
        {
            DateTime today     = DateTime.Today;
            DateTime monday    = CalulateNext(today, DayOfWeek.Monday);
            DateTime tuesday   = CalulateNext(monday, DayOfWeek.Tuesday);
            DateTime wednesday = CalulateNext(monday, DayOfWeek.Wednesday);
            DateTime thursday  = CalulateNext(monday, DayOfWeek.Thursday);
            DateTime friday    = CalulateNext(monday, DayOfWeek.Friday);

            Mock <IProjectCalendar> calendarMock = new Mock <IProjectCalendar>();

            calendarMock.Setup(x => x.GetWorkingHours(monday)).Returns(8);
            calendarMock.Setup(x => x.GetWorkingHours(tuesday)).Returns(8);
            calendarMock.Setup(x => x.GetWorkingHours(wednesday)).Returns(8);
            calendarMock.Setup(x => x.GetWorkingHours(thursday)).Returns(8);
            calendarMock.Setup(x => x.GetWorkingHours(friday)).Returns(8);

            Mock <IProjectCalendarFactory> calendarFactoryMock = new Mock <IProjectCalendarFactory>();

            calendarFactoryMock.Setup(x => x.CreateDefaultWorkingCalendar()).Returns(calendarMock.Object);

            ProjectFactory projectFactory = new ProjectFactory(calendarFactoryMock.Object);
            Project        project        = projectFactory.CreateProject(VALID_PROJECT_NAME);

            ProjectTask parentTask = project.AddTask(VALID_PROJECTTASK_NAME);
            ProjectTask childTask1 = parentTask.AddTask(VALID_PROJECTTASK_NAME);
            ProjectTask childTask2 = parentTask.AddTask(VALID_PROJECTTASK_NAME);
            ProjectTask childTask3 = parentTask.AddTask(VALID_PROJECTTASK_NAME);

            // 40 hours effort, 10% progress
            childTask1.ExpectedStartDate  = monday;
            childTask1.ExpectedFinishDate = friday;
            childTask1.SetProgress(10);

            // 40 hours effort, 25% progress
            childTask2.ExpectedStartDate  = monday;
            childTask2.ExpectedFinishDate = friday;
            childTask2.SetProgress(25);

            // 24 hours effort, 50% progress
            childTask3.ExpectedStartDate  = monday;
            childTask3.ExpectedFinishDate = wednesday;
            childTask3.SetProgress(50);

            int progress = parentTask.CalculateProgress();

            Assert.That(progress, Is.EqualTo(25));
        }
Exemplo n.º 15
0
        public async Task AddProject_ShouldReturnOK()
        {
            //Arrange
            SetAuthorization();
            var projectModel = ProjectFactory.GetProjectModel();

            //Act
            var response = await ProjectService.AddProject(projectModel);

            //Assert
            response.StatusCode.Should().Be(HttpStatusCode.OK);

            var responseProject = response.GetResponseProjectModel();

            ProjectAssert.ValidateProjectResult(projectModel, responseProject);
        }
        public void TestLoad_StaticProperties_ReadOk()
        {
            var fileInfo = TestUtils.GetSampleProject(@"DotNetProjectParser.SampleProjects.NetCore.Library.csproj");

            var project = ProjectFactory.GetProject(fileInfo);

            project.Should().NotBeNull();
            project.ProjectXml.Should().NotBeNull();
            project.Name.Should().Be("DotNetProjectParser.SampleProjects.NetCore.Library.csproj");
            project.FullPath.Should().Be(fileInfo.FullName);
            project.DirectoryPath.Should().Be(fileInfo.Directory.FullName);
            project.AssemblyName.Should().Be("DotNetProjectParser.SampleProjects.NetCore.Library");
            project.OutputType.Should().Be("Library");
            project.TargetExtension.Should().Be(".dll");
            project.TargetFramework.Should().Be("netcoreapp3.0");
        }
Exemplo n.º 17
0
        public static IEnumerable <object[]> ProjectMissingValues()
        {
            var missingName = ProjectFactory.GetProjectModel();

            missingName.Name = null;

            var serializeModel = JsonConvert.SerializeObject(missingName);

            return(new List <object[]>()
            {
                new object[]
                {
                    serializeModel
                }
            });
        }
Exemplo n.º 18
0
        public async Task DeleteProject_WhenProject_ShouldReturnOK()
        {
            //Arrange
            SetAuthorization();

            var projectModel = ProjectFactory.GetProjectModel();
            var project      = await ProjectService.AddProject(projectModel);

            var projectId = ProjectSteps.GetProjectId(project);

            //Act
            var response = await ProjectService.DeleteProject(projectId);

            //Assert
            response.StatusCode.Should().Be(HttpStatusCode.OK);
        }
Exemplo n.º 19
0
        private IEnumerable <IService> CreateServices()
        {
            var projectFact = new ProjectFactory();
            var project     = projectFact.Create("Betriebskosten");

            var currentProject = new CurentProjectService(project);

            projectFact.Project = currentProject;

            return(new IService[]
            {
                projectFact,
                currentProject,
                new CategoryFactory()
                {
                    Project = currentProject
                },
                new MonthFactory()
                {
                    Project = currentProject
                },
                new PaymentIntervalFactory()
                {
                    Project = currentProject
                },
                new PayPatternFactory()
                {
                    Project = currentProject
                },
                new PaymentFactory()
                {
                    Project = currentProject
                },
                new RepositoryService()
                {
                    Project = currentProject
                },
                new TransactionFactory()
                {
                    Project = currentProject
                },
                new YearFactory()
                {
                    Project = currentProject
                },
            });
        }
Exemplo n.º 20
0
        public async Task AddProject_WhenFieldsHaveCorrectValues_ShouldReturnOK()
        {
            //Arrange
            SetUpAuthorization();
            var projectModel = ProjectFactory.GetProjectModel();

            //Act
            var response = await _projectService.AddProject(projectModel);

            //Assert
            response.ResponseStatusCode(HttpStatusCode.OK, "Expected OK status.");
            var responseModel = await response.GetContentModel <ProjectResponse>();

            var expectedResponse = ProjectResponseFactory.GetProjectResponse(projectModel);

            ProjectAssertion.AssertProject(expectedResponse, responseModel);
        }
Exemplo n.º 21
0
 public OutliningTaggerProvider(
     [Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider,
     ITextDocumentFactoryService textDocumentFactoryService,
     ITextEditorFactoryService textEditorFactoryService,
     IProjectionBufferFactoryService projectionBufferFactoryService,
     IOutliningManagerService outliningManagerService,
     ProjectFactory projectFactory,
     VSLanguageService vsLanguageService)
 {
     _serviceProvider = serviceProvider;
     _textDocumentFactoryService = textDocumentFactoryService;
     _textEditorFactoryService = textEditorFactoryService;
     _projectionBufferFactoryService = projectionBufferFactoryService;
     _outliningManagerService = outliningManagerService;
     _projectFactory = projectFactory;
     _vsLanguageService = vsLanguageService;
 }
Exemplo n.º 22
0
        public DataLayerManager(IConfigProvider configProvider, Prototype prototype) : base("DotNet46", configProvider.GetValue("OutputFolderPath") + "\\" + "DataLayer", configProvider.GetValue("OutputFolderPath") + "\\" + "DataLayer", configProvider, prototype)
        {
            DataLayer = new ApplicationGenerator(configProvider.GetValue("OutputFolderPath") + "\\" + "DataLayer");
            Container.Kernel.Resolver.AddSubResolver(new CollectionResolver(Container.Kernel, true));

            RegisterDataLayer(prototype, Container);
            var dataLayerHandlers = Container.Kernel.GetAssignableHandlers(typeof(IGenerableFile));
            List <IGenerableFile> dataLayerFiles = ProjectFactory.ResolveHandlers(dataLayerHandlers, Container, NamingConstants.DataLayerProjectName);

            InitDataLayer(dataLayerFiles, Container);
            RegisterSolutionItems();


            var allFiles = ProjectFactory.ResolveHandlers(Container.Kernel.GetAssignableHandlers(typeof(IGenerableFile)), Container);

            DataLayer.Files.AddRange(allFiles);
        }
Exemplo n.º 23
0
        public static IEnumerable <object[]> ProjectIncorrectValues()
        {
            var incorrectName = ProjectFactory.GetProjectModel();

            incorrectName.Name = new Faker().Random.AlphaNumeric(NotesValidationConstants.NotesMaxLength + 1);
            var serializeProject = JsonConvert.SerializeObject(incorrectName);


            return(new List <object[]>()
            {
                new object[]
                {
                    serializeProject,
                    ErrorMessageConstants.IncorrectNameMessage
                }
            });
        }
Exemplo n.º 24
0
        public async Task AddProject_WhenUnauthorized_ShouldReturnUnauthorized()
        {
            //Arrange
            ClientExtended.ClearAuthorization();

            var projectModel = ProjectFactory.GetProjectModel();

            //Act
            var response = await ProjectService.AddProject(projectModel);

            //Assert
            response.StatusCode.Should().Be(HttpStatusCode.Unauthorized);

            var errorMessage = response.GetErrors();

            ErrorAssert.ValidateErrorMessage(errorMessage, ErrorMessage.FailedAuthentication);
        }
Exemplo n.º 25
0
        public virtual int Close()
        {
            if (this.site != null)
            {
                if (this.editorFactory != null)
                {
                    Guid editorGuid        = this.editorFactory.GetType().GUID;
                    IVsRegisterEditors vre = (IVsRegisterEditors)site.GetService(typeof(SVsRegisterEditors));
                    vre.UnregisterEditor(this.editorFactoryCookie);
                    this.editorFactory.Close();
                    this.editorFactory = null;
                }
                if (this.projectFactory != null)
                {
                    IVsRegisterProjectTypes rpt = (IVsRegisterProjectTypes)this.site.GetService(typeof(IVsRegisterProjectTypes));
                    if (rpt != null)
                    {
                        rpt.UnregisterProjectType(this.projectFactoryCookie);
                    }
                    this.projectFactoryCookie = 0;
                    this.projectFactory.Close();
                    this.projectFactory = null;
                }
            }
            foreach (ILanguageService svc in this.languageServices.Values)
            {
                svc.Done();
            }
            this.languageServices.Clear();

            if (this.componentID != 0)
            {
                this.componentManager.FRevokeComponent(this.componentID);
                this.componentID = 0;
            }
            this.componentManager = null;

            if (site != null)
            {
                site.Dispose();
            }
            this.site = null;
            GC.Collect();
            return(0);
        }
 public CodeFormattingHookHelper(
     [Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider, 
     IVsEditorAdaptersFactoryService adaptersFactory, 
     IEditorOptionsFactoryService editorOptionsFactory,
     IEditorOperationsFactoryService editorOperationsFactoryService,
     ITextBufferUndoManagerProvider textBufferUndoManagerProvider,
     ITextDocumentFactoryService textDocumentFactoryService,
     ProjectFactory projectFactory,
     VSLanguageService vsLanguageService,
     IOpenDocumentsTracker openDocumentTracker)
 {
     _serviceProvider = serviceProvider;
     _adaptersFactory = adaptersFactory;
     _editorOptionsFactory = editorOptionsFactory;
     _editorOperationsFactoryService = editorOperationsFactoryService;
     _textBufferUndoManagerProvider = textBufferUndoManagerProvider;
     _textDocumentFactoryService = textDocumentFactoryService;
     _projectFactory = projectFactory;
     _vsLanguageService = vsLanguageService;
     _openDocumentTracker = openDocumentTracker;
 }
Exemplo n.º 27
0
 /// <summary>
 /// Initializes a new instance of the <see cref="SolutionTask" /> class.
 /// </summary>
 public SolutionTask()
 {
     _customproperties = new ArrayList();
     _projects = new FileSet();
     _referenceProjects = new FileSet();
     _excludeProjects = new FileSet();
     _assemblyFolders = new FileSet();
     _webMaps = new WebMapCollection();
     _projectFactory = ProjectFactory.Create(this);
     _solutionFactory = SolutionFactory.Create();
     _configuration = new Configuration ();
 }
Exemplo n.º 28
0
    public virtual void SetSite(Microsoft.VisualStudio.OLE.Interop.IServiceProvider site){

      this.site = new ServiceProvider(site);
      this.editorFactory = CreateEditorFactory();
      if (this.editorFactory != null) {
        this.editorFactory.SetSite(site);
        Guid editorGuid = this.editorFactory.GetType().GUID;
        IVsRegisterEditors vre = (IVsRegisterEditors)this.site.QueryService( VsConstants.SID_SVsRegisterEditors, typeof(IVsRegisterEditors));
        vre.RegisterEditor(ref editorGuid, editorFactory, out this.editorFactoryCookie);
      }

      this.projectFactory = CreateProjectFactory();
      if (this.projectFactory != null) {
        this.projectFactory.SetSite(site);
        IVsRegisterProjectTypes rpt = (IVsRegisterProjectTypes)this.site.QueryService(VsConstants.SID_IVsRegisterProjectTypes, typeof(IVsRegisterProjectTypes));
        if (rpt != null) {
          Guid projectType = this.projectFactory.GetType().GUID;
          rpt.RegisterProjectType(ref projectType, this.projectFactory, out this.projectFactoryCookie);          
        }
      }

      uint lcid = VsShell.GetProviderLocale(this.site);
      
      languageServices = new Hashtable();
      string thisPackage = "{"+this.GetType().GUID.ToString() + "}";
      ServiceProvider thisSite = new ServiceProvider((Microsoft.VisualStudio.OLE.Interop.IServiceProvider)this);

      ILocalRegistry3 localRegistry = (ILocalRegistry3)this.site.QueryService( VsConstants.SID_SLocalRegistry, typeof(ILocalRegistry3));
      string root = null;        
      if (localRegistry != null) {
        localRegistry.GetLocalRegistryRoot(out root);
      }      
      using (RegistryKey rootKey = Registry.LocalMachine.OpenSubKey(root)) {
        if (rootKey != null) {
          using (RegistryKey languages = rootKey.OpenSubKey("Languages\\Language Services")) {
            if (languages != null) {
              foreach (string languageName in languages.GetSubKeyNames()) {
                using (RegistryKey langKey = languages.OpenSubKey(languageName)) {
                  object pkg = langKey.GetValue("Package");
                  if (pkg is string && string.Compare((string)pkg, thisPackage, false) == 0) {
                    object guid = langKey.GetValue(null);
                    if (guid is string) {
                      Guid langGuid = new Guid((string)guid);
                      if (!this.languageServices.Contains(langGuid.ToString())){
                        ILanguageService svc = CreateLanguageService(ref langGuid);
                        if (svc != null) {
                          svc.Init(thisSite, ref langGuid, lcid, GetFileExtensions(rootKey, (string)guid));
                          this.languageServices.Add(langGuid.ToString(), svc);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }

      //register with ComponentManager for Idle processing
      this.componentManager = (IOleComponentManager)this.site.QueryService(VsConstants.SID_SOleComponentManager, typeof(IOleComponentManager));
      if (componentID == 0)
      {
          OLECRINFO[]   crinfo = new OLECRINFO[1];
          crinfo[0].cbSize   = (uint)Marshal.SizeOf(typeof(OLECRINFO));
          crinfo[0].grfcrf   = (uint)OLECRF.olecrfNeedIdleTime |
                               (uint)OLECRF.olecrfNeedPeriodicIdleTime; 
          crinfo[0].grfcadvf = (uint)OLECADVF.olecadvfModal |
                               (uint)OLECADVF.olecadvfRedrawOff |
                               (uint)OLECADVF.olecadvfWarningsOff;
          crinfo[0].uIdleTimeInterval = 1000;
          this.componentManager.FRegisterComponent(this, crinfo, out componentID);
      }

    }
Exemplo n.º 29
0
    public virtual void Close()	{
      if (this.site != null) {
        if (this.editorFactory != null) {
          Guid editorGuid = this.editorFactory.GetType().GUID;
          IVsRegisterEditors vre = (IVsRegisterEditors)site.QueryService( VsConstants.SID_SVsRegisterEditors, typeof(IVsRegisterEditors));
          vre.UnregisterEditor(this.editorFactoryCookie);
          this.editorFactory.Close();
          this.editorFactory = null;
        }
        if (this.projectFactory != null) {
          IVsRegisterProjectTypes rpt = (IVsRegisterProjectTypes)this.site.QueryService(VsConstants.SID_IVsRegisterProjectTypes, typeof(IVsRegisterProjectTypes));
          if (rpt != null) {
            rpt.UnregisterProjectType(this.projectFactoryCookie);          
          }
          this.projectFactoryCookie = 0;
          this.projectFactory.Close();
          this.projectFactory = null;
        }

      }
      foreach (ILanguageService svc in this.languageServices.Values) {
        svc.Done();
      }
      this.languageServices.Clear();
      
      if (this.componentID != 0) {
        this.componentManager.FRevokeComponent(this.componentID);
        this.componentID = 0;
      }
      this.componentManager = null;

      if (site != null) site.Dispose();
      this.site = null;
      GC.Collect();
    }