C# ITextSnapshot.GetLineFromLineNumber方法代码示例

 private SnapshotSpan? CreateClassification(int sourceLine, string text, ITextSnapshot snapshot)
 {
     int descriptionStartPosition = snapshot.GetLineFromLineNumber(sourceLine).Start.Position;
     int lineNumber = text.Split(new[] { Environment.NewLine }, StringSplitOptions.None).Count() + sourceLine;
     if (snapshot.LineCount <= lineNumber)
         return null;
     int descriptionEndPosition = snapshot.GetLineFromLineNumber(lineNumber).Start.Position;
     var descriptionSpan = new Span(descriptionStartPosition, descriptionEndPosition - descriptionStartPosition);
     return new SnapshotSpan(snapshot, descriptionSpan);
 }

        public static SnapshotSpan CreateSpan(this IEnumerable<IGherkinFileBlock> changedBlocks, ITextSnapshot textSnapshot)
        {
            VisualStudioTracer.Assert(changedBlocks.Count() > 0, "there is no changed block");

            int minLineNumber = changedBlocks.First().GetStartLine();
            int maxLineNumber = changedBlocks.Last().GetEndLine();

            var minLine = textSnapshot.GetLineFromLineNumber(minLineNumber);
            var maxLine = minLineNumber == maxLineNumber ? minLine : textSnapshot.GetLineFromLineNumber(maxLineNumber);
            return new SnapshotSpan(minLine.Start, maxLine.EndIncludingLineBreak);
        }

        public List<MarkerLine> GetMarkerLinesForFile(ITextSnapshot textSnapshot)
        {
            var lines = new List<MarkerLine>();

            if (_threadFixPlugin == null || _threadFixPlugin.MarkerLookUp == null)
            {
                return lines;
            }

            var filename = textSnapshot.TextBuffer.GetTextDocument().FilePath.ToLower();
            var markers = new List<VulnerabilityMarker>();

            if(_threadFixPlugin.MarkerLookUp.TryGetValue(filename, out markers) && !string.IsNullOrEmpty(filename))
            {
                foreach (var marker in markers)
                {
                    if (marker.LineNumber.HasValue && marker.LineNumber.Value > 0 && marker.LineNumber.Value < textSnapshot.LineCount)
                    {
                        lines.Add(new MarkerLine(textSnapshot.GetLineFromLineNumber(marker.LineNumber.Value - 1), marker.GenericVulnName));
                    }
                }
            }

            return lines;
        }

        /// <summary>
        /// Asynchronously constructs a line map from a <paramref name="snapshot"/> and <paramref name="code"/>.
        /// </summary>
        /// <param name="snapshot">The current text snapshot.</param>
        /// <param name="code">The code to derive a line map from.</param>
        /// <param name="cancelToken">Cancellation token.</param>
        /// <returns>
        /// A <see cref="LineMap"/> if <paramref name="code"/> was parsed correctly,
        /// <c>null</c> if there was invalid code or it was canceled.
        /// </returns>
        internal static Task<LineMap> ConstructAsync(ITextSnapshot snapshot, string code, CancellationToken cancelToken)
        {
            if (snapshot == null)
                throw new ArgumentNullException ("snapshot");
            if (code == null)
                throw new ArgumentNullException ("code");

            return Task<LineMap>.Factory.StartNew (() =>
            {
                try
                {
                    var tree = SyntaxTree.Parse (code, cancellationToken: cancelToken);
                    if (tree.Errors.Any (p => p.ErrorType == ErrorType.Error))
                        return null;

                    var identifier = new IdentifyingVisitor();
                    tree.AcceptVisitor (identifier);

                    var spans = new Dictionary<int, ITrackingSpan> (identifier.LineMap.Count);
                    foreach (var kvp in identifier.LineMap)
                    {
                        ITextSnapshotLine line = snapshot.GetLineFromLineNumber (kvp.Value - 1);
                        ITrackingSpan span = snapshot.CreateTrackingSpan (line.Extent, SpanTrackingMode.EdgeExclusive);
                        spans.Add (kvp.Key, span);
                    }

                    return (cancelToken.IsCancellationRequested) ? null : new LineMap (spans);
                }
                catch (OperationCanceledException)
                {
                    return null;
                }
            }, cancelToken);
        }

        private async Task<Document> DetermineNewDocumentAsync(MemberInsertionCompletionItem completionItem, ITextSnapshot textSnapshot, CancellationToken cancellationToken)
        {
            // The span we're going to replace
            var line = textSnapshot.GetLineFromLineNumber(completionItem.Line);

            var sourceText = textSnapshot.AsText();
            var document = sourceText.GetOpenDocumentInCurrentContextWithChanges();
            Contract.ThrowIfNull(document);

            // Annotate the line we care about so we can find it after adding usings
            var tree = document.GetSyntaxTreeAsync(cancellationToken).WaitAndGetResult(cancellationToken);
            var token = GetToken(completionItem, tree, cancellationToken);
            var annotatedRoot = tree.GetRoot(cancellationToken).ReplaceToken(token, token.WithAdditionalAnnotations(_otherAnnotation));
            document = document.WithSyntaxRoot(annotatedRoot);

            var memberContainingDocument = await GenerateMemberAndUsingsAsync(document, completionItem, line, cancellationToken).ConfigureAwait(false);

            var insertionRoot = PrepareTreeForMemberInsertion(memberContainingDocument, cancellationToken);
            var insertionText = GenerateInsertionText(memberContainingDocument, cancellationToken);

            var destinationSpan = ComputeDestinationSpan(insertionRoot, insertionText);

            var finalText = insertionRoot.GetText(sourceText.Encoding).Replace(destinationSpan, insertionText.Trim());

            document = document.WithText(finalText);
            var newRoot = document.GetSyntaxRootAsync(cancellationToken).WaitAndGetResult(cancellationToken);
            var declaration = GetSyntax(newRoot.FindToken(destinationSpan.End));

            document = document.WithSyntaxRoot(newRoot.ReplaceNode(declaration, declaration.WithAdditionalAnnotations(_annotation)));
            return Formatter.FormatAsync(document, _annotation, cancellationToken: cancellationToken).WaitAndGetResult(cancellationToken);
        }

 private GherkinDialect GetGherkinDialect(ITextSnapshot textSnapshot)
 {
     try
     {
         return projectScope.GherkinDialectServices.GetGherkinDialect(
                 lineNo => textSnapshot.GetLineFromLineNumber(lineNo).GetText());
     }
     catch(Exception)
     {
         return null;
     }
 }

        public SnapshotParser(ITextSnapshot snapshot, IClassifier classifier)
        {
            Snapshot = snapshot;
            Classifier = classifier;
            ClassificationSpans = Classifier.GetClassificationSpans(new SnapshotSpan(Snapshot, 0, snapshot.Length));
            foreach (ClassificationSpan s in ClassificationSpans)
                SpanIndex.Add(s.Span.Start.Position, s);

            CurrentPoint = Snapshot.GetLineFromLineNumber(0).Start;
            if (SpanIndex.ContainsKey(0))
                CurrentSpan = SpanIndex[0];
        }

        IEnumerable<ITextSnapshotLine> GetLinesToAlign(ITextSnapshot snapshot)
        {
            int start = snapshot.GetLineNumberFromPosition(m_view.Selection.Start.Position);
            int end   = snapshot.GetLineNumberFromPosition(m_view.Selection.End.Position);

            if (start == end)
            {
                start = 0;
                end   = snapshot.LineCount -1;
            }

            return start.UpTo(end).Select(x => snapshot.GetLineFromLineNumber(x));
        }

 private static Span? GetRoxygenBlockPosition(ITextSnapshot snapshot, int definitionStart) {
     var line = snapshot.GetLineFromPosition(definitionStart);
     for (int i = line.LineNumber - 1; i >= 0; i--) {
         var currentLine = snapshot.GetLineFromLineNumber(i);
         string lineText = currentLine.GetText().TrimStart();
         if (lineText.Length > 0) {
             if (lineText.EqualsOrdinal("##")) {
                 return new Span(currentLine.Start, currentLine.Length);
             } else if (lineText.EqualsOrdinal("#'")) {
                 return null;
             }
             break;
         }
     }
     return new Span(line.Start, 0);
 }

        /// <summary>
        /// Returns the line on which the word "function" or other function initializers appear.
        /// </summary>
        /// <param name="capture">The text snapshot.</param>
        /// <param name="lineNumber">The line that should contain the open curlybrace for the function if one exists
        /// in the context of the comment, or the first line of the function itself.</param>
        /// <returns>Returns the line of the function declaration. -1 if one is not found that corresponds to the given
        /// line number.</returns>
        public static int GetFunctionDeclarationLineNumber(ITextSnapshot capture, int lineNumber, bool isAboveFunction = false)
        {
            string lineText = capture.GetLineFromLineNumber(lineNumber).GetText();
            string unCommentedLine = RemoveComments(lineText);

            //Ignore inline functions if this is an "inside-the-function" doc (i.e, vsdoc)
            if (!isAboveFunction && !unCommentedLine.Trim().EndsWith("{")) return -1;

            if (capture.ContentType.TypeName == "TypeScript")
            {
                return GetTypeScriptFunctionLine(capture, lineNumber, isAboveFunction, lineText);
            }
            else
            {
                return GetJavaScriptFunctionLine(capture, lineNumber, isAboveFunction, lineText);
            }
        }

        public static ITextSnapshotLine GetNonEmptyPreviousLine(ITextSnapshot snapshot, ITextSnapshotLine currentLine)
        {
            do
            {
                var previousLine = snapshot.GetLineFromLineNumber(Math.Max(currentLine.LineNumber - 1, 0));

                // first line in the file
                if (previousLine.LineNumber == currentLine.LineNumber)
                {
                    return currentLine;
                }

                if (previousLine.IsEmptyOrWhitespace())
                {
                    // keep goes up until it find non empty previous line
                    currentLine = previousLine;
                    continue;
                }

                return previousLine;
            }
            while (true);
        }

        internal LineTokenization TokenizeLine(ITextSnapshot snapshot, object previousLineState, int lineNo, int lineOffset)
        {
            ITextSnapshotLine line = snapshot.GetLineFromLineNumber(lineNo);
            SnapshotSpan lineSpan = new SnapshotSpan(snapshot, line.Start + lineOffset, line.LengthIncludingLineBreak - lineOffset);

            var tcp = new SnapshotSpanTextContentProvider(lineSpan);
            var scriptSource = _engine.CreateScriptSource(tcp, null, SourceCodeKind.File);

            _categorizer.Initialize(previousLineState, scriptSource, new SourceLocation(lineOffset, lineNo + 1, lineOffset + 1));
            var tokens = new List<TokenInfo>(_categorizer.ReadTokens(lineSpan.Length)).ToArray();
            return new LineTokenization(tokens, _categorizer.CurrentState);
        }

        private static IList<SnapshotSpan> CreateSnapshotSpans(ITextSnapshot snapshot, LineSpan lineSpan)
        {
            var result = new List<SnapshotSpan>();
            for (int i = lineSpan.Start; i < lineSpan.End; i++)
            {
                var line = snapshot.GetLineFromLineNumber(i);
                result.Add(line.Extent);
            }

            return result;
        }

		void UpdateAdornments_Performance(
			ITextSnapshot snapshot,
			ITextViewModel viewModel,
			ITextViewLine firstVisibleLine,
			IEnumerable<LineSpan> analysisLines
		) {
#endif
			double spaceWidth = firstVisibleLine.VirtualSpaceWidth;
			if (spaceWidth <= 0.0) return;
			double horizontalOffset = firstVisibleLine.TextLeft;

			var unusedLines = new HashSet<LineSpan>(Lines.Keys);

			var caret = CaretHandlerBase.FromName(Theme.CaretHandler, View.Caret.Position.VirtualBufferPosition, Analysis.TabSize);

			object perfCookie = null;
			PerformanceLogger.Start(ref perfCookie);
#if DEBUG
			var initialCount = Lines.Count;
#endif
			foreach (var line in analysisLines.Concat(GetPageWidthLines()))
			{
				double top = View.ViewportTop;
				double bottom = View.ViewportBottom;
				double left = line.Indent * spaceWidth + horizontalOffset;

				Line adornment;
				unusedLines.Remove(line);

				if (line.Type == LineSpanType.PageWidthMarker)
				{
					line.Highlight = (Analysis.LongestLine > line.Indent);
					if (!Lines.TryGetValue(line, out adornment))
					{
						Lines[line] = adornment = CreateGuide(Canvas);
					}
					UpdateGuide(line, adornment, left, top, bottom);
					continue;
				}

				if (Lines.TryGetValue(line, out adornment))
				{
					adornment.Visibility = Visibility.Hidden;
				}

				caret.AddLine(line, willUpdateImmediately: true);

				if (line.FirstLine >= 0 && line.LastLine < int.MaxValue)
				{
					var firstLineNumber = line.FirstLine;
					var lastLineNumber = line.LastLine;
					ITextSnapshotLine firstLine, lastLine;
					try
					{
						firstLine = snapshot.GetLineFromLineNumber(firstLineNumber);
						lastLine = snapshot.GetLineFromLineNumber(lastLineNumber);
					}
					catch (Exception ex)
					{
						Trace.TraceError("In GetLineFromLineNumber:\n{0}", ex);
						continue;
					}

					if (firstLine.Start > View.TextViewLines.LastVisibleLine.Start ||
						lastLine.Start < View.TextViewLines.FirstVisibleLine.Start)
					{
						continue;
					}

					while (
						!viewModel.IsPointInVisualBuffer(firstLine.Start, PositionAffinity.Successor) &&
						++firstLineNumber < lastLineNumber
					)
					{
						try
						{
							firstLine = snapshot.GetLineFromLineNumber(firstLineNumber);
						}
						catch (Exception ex)
						{
							Trace.TraceError("In GetLineFromLineNumber:\n{0}", ex);
							firstLine = null;
							break;
						}
					}

					while (
						!viewModel.IsPointInVisualBuffer(lastLine.Start, PositionAffinity.Predecessor) &&
						--lastLineNumber > firstLineNumber
					)
					{
						try
						{
							lastLine = snapshot.GetLineFromLineNumber(lastLineNumber);
						}
						catch (Exception ex)
						{
							Trace.TraceError("In GetLineFromLineNumber:\n{0}", ex);
							lastLine = null;
							break;
//.........这里部分代码省略.........

        private IList<LineCommentInfo> GetMatchingComments(
            ITextSnapshot snapshot,
            LineCommentInfo toMatch,
            int lineNumberStart,
            int lineNumberLimit)
        {
            var list = new List<LineCommentInfo>();

            var up = lineNumberLimit >= lineNumberStart;
            var delta = up ? 1 : -1;

            for (
                var lineNumber = lineNumberStart;
                up ? lineNumber < lineNumberLimit : lineNumber >= lineNumberLimit;
                lineNumber += delta)
            {
                var line = snapshot.GetLineFromLineNumber(lineNumber);
                var info = LineCommentInfo.FromLine(line, this.view.Options, this.classifier);

                // TODO: treat lines with code (non-comment) as non-matching so
                // that behavior is better?
                if (!toMatch.Matches(info))
                {
                    break;
                }

                list.Add(info);
            }

            if (!up)
            {
                list.Reverse();
            }

            return list;
        }