C# Workspace.CreateSolution方法代码示例

        public static async Task<ISymbolSearchUpdateEngine> CreateEngineAsync(
            Workspace workspace, ISymbolSearchLogService logService, CancellationToken cancellationToken)
        {
            var outOfProcessAllowed = workspace.Options.GetOption(SymbolSearchOptions.OutOfProcessAllowed);
            if (outOfProcessAllowed)
            {
                var client = await workspace.GetRemoteHostClientAsync(cancellationToken).ConfigureAwait(false);
                if (client != null)
                {
                    var emptySolution = workspace.CreateSolution(workspace.CurrentSolution.Id);

                    // We create a single session and use it for the entire lifetime of this process.
                    // That single session will be used to do all communication with the remote process.
                    // This is because each session will cause a new instance of the RemoteSymbolSearchUpdateEngine
                    // to be created on the remote side.  We only want one instance of that type.  The
                    // alternative is to make that type static variable on the remote side.  But that's
                    // much less clean and would make some of the state management much more complex.
                    var session = await client.CreateServiceSessionAsync(
                        WellKnownServiceHubServices.RemoteSymbolSearchUpdateEngine,
                        emptySolution, logService, cancellationToken).ConfigureAwait(false);

                    return new RemoteUpdateEngine(session);
                }
            }

            // Couldn't go out of proc.  Just do everything inside the current process.
            return new SymbolSearchUpdateEngine(logService);
        }

            private void ConnectToWorkspace(Workspace workspace)
            {
                ResetLastParsedDocument();

                _workspace = workspace;

                if (_workspace != null)
                {
                    _isClassificationOnlyWorkspace = false;
                    _workspace.WorkspaceChanged += this.OnWorkspaceChanged;
                    _workspace.DocumentOpened += this.OnDocumentOpened;
                    _workspace.DocumentActiveContextChanged += this.OnDocumentActiveContextChanged;

                    var textContainer = _subjectBuffer.AsTextContainer();

                    var documentId = _workspace.GetDocumentIdInCurrentContext(textContainer);
                    if (documentId != null)
                    {
                        var document = workspace.CurrentSolution.GetDocument(documentId);
                        if (document != null)
                        {
                            EnqueueParseSnapshotTask(document);
                            return;
                        }
                    }
                }
                else
                {
                    // This buffer isn't being tracked by any workspace. In Visual Studio, this
                    // can happen if it is not in the Running Document Table. We'll try to do
                    // basic syntax classification based on the initial state of the snapshot.
                    // Changes to the buffer are not observed, but initial tags will track forward.

                    _isClassificationOnlyWorkspace = true;
                    if (_languageName != null)
                    {
                        _workspace = new AdhocWorkspace();
                        var solution = _workspace.CreateSolution(SolutionId.CreateNewId());
                        var project = solution.AddProject(name: string.Empty, assemblyName: string.Empty, language: _languageName);

                        var parsedSnapshot = _subjectBuffer.CurrentSnapshot;
                        var document = project.AddDocument(name: string.Empty, text: _subjectBuffer.CurrentSnapshot.AsText());

                        EnqueueParseSnapshotTask(document, parsedSnapshot);
                        return;
                    }
                }
            }