通过

演练：显示匹配大括号

  • 项目

通过定义要匹配的大括号，并将文本标记标记添加到匹配大括号（当插入符号位于其中一个大括号上）来实现基于语言的功能，例如大括号匹配。 可以在语言上下文中定义大括号，定义自己的文件扩展名和内容类型，并将标记应用于该类型或将标记应用于现有内容类型（如“text”）。 以下演练演示如何将大括号匹配标记应用于“text”内容类型。

创建托管扩展性框架 （MEF） 项目

创建 MEF 项目

  1. 创建编辑器分类器项目。 将解决方案命名为 BraceMatchingTest。

  2. 向项目添加编辑器分类器项模板。 有关详细信息，请参阅使用编辑器项模板创建扩展。

  3. 删除现有的类文件。

实现大括号匹配标记器

若要获取类似于 Visual Studio 中使用的大括号突出显示效果，可以实现类型 TextMarkerTag标记器。 以下代码演示如何在任何嵌套级别定义大括号对的标记器。 在此示例中，[] {} 的大括号对在标记器构造函数中定义，但在完整的语言实现中，相关大括号将在语言规范中定义。

实现大括号匹配标记器

  1. 添加类文件并将其命名为 BraceMatching。

  2. 导入以下命名空间。

    using System;
using System.Linq;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using Microsoft.VisualStudio.Text;
using Microsoft.VisualStudio.Text.Editor;
using Microsoft.VisualStudio.Text.Tagging;
using Microsoft.VisualStudio.Utilities;

  3. 定义继承自ITagger<T>类型的TextMarkerTag类BraceMatchingTagger。

    internal class BraceMatchingTagger : ITagger<TextMarkerTag>

  4. 为文本视图、源缓冲区、当前快照点以及一组大括号对添加属性。

    ITextView View { get; set; }
ITextBuffer SourceBuffer { get; set; }
SnapshotPoint? CurrentChar { get; set; }
private Dictionary<char, char> m_braceList;

  5. 在标记器构造函数中，设置属性并订阅视图更改事件 PositionChanged 和 LayoutChanged。 在此示例中，为了说明目的，匹配对也在构造函数中定义。

    internal BraceMatchingTagger(ITextView view, ITextBuffer sourceBuffer)
{
    //here the keys are the open braces, and the values are the close braces
    m_braceList = new Dictionary<char, char>();
    m_braceList.Add('{', '}');
    m_braceList.Add('[', ']');
    m_braceList.Add('(', ')');
    this.View = view;
    this.SourceBuffer = sourceBuffer;
    this.CurrentChar = null;

    this.View.Caret.PositionChanged += CaretPositionChanged;
    this.View.LayoutChanged += ViewLayoutChanged;
}

  6. 作为实现的 ITagger<T> 一部分，声明 TagsChanged 事件。

    public event EventHandler<SnapshotSpanEventArgs> TagsChanged;

  7. 事件处理程序更新属性的 CurrentChar 当前插入点位置并引发 TagsChanged 事件。

    void ViewLayoutChanged(object sender, TextViewLayoutChangedEventArgs e)
{
    if (e.NewSnapshot != e.OldSnapshot) //make sure that there has really been a change
    {
        UpdateAtCaretPosition(View.Caret.Position);
    }
}

void CaretPositionChanged(object sender, CaretPositionChangedEventArgs e)
{
    UpdateAtCaretPosition(e.NewPosition);
}
void UpdateAtCaretPosition(CaretPosition caretPosition)
{
    CurrentChar = caretPosition.Point.GetPoint(SourceBuffer, caretPosition.Affinity);

    if (!CurrentChar.HasValue)
        return;

    var tempEvent = TagsChanged;
    if (tempEvent != null)
        tempEvent(this, new SnapshotSpanEventArgs(new SnapshotSpan(SourceBuffer.CurrentSnapshot, 0,
            SourceBuffer.CurrentSnapshot.Length)));
}

  8. 实现在 GetTags 当前字符为大括号或上一个字符是一个关闭大括号时（如 Visual Studio 中所示）时匹配大括号的方法。 找到匹配项后，此方法实例化两个标记，一个用于打开大括号，一个用于关闭大括号。

    public IEnumerable<ITagSpan<TextMarkerTag>> GetTags(NormalizedSnapshotSpanCollection spans)
{
    if (spans.Count == 0)   //there is no content in the buffer
        yield break;

    //don't do anything if the current SnapshotPoint is not initialized or at the end of the buffer
    if (!CurrentChar.HasValue || CurrentChar.Value.Position >= CurrentChar.Value.Snapshot.Length)
        yield break;

    //hold on to a snapshot of the current character
    SnapshotPoint currentChar = CurrentChar.Value;

    //if the requested snapshot isn't the same as the one the brace is on, translate our spans to the expected snapshot
    if (spans[0].Snapshot != currentChar.Snapshot)
    {
        currentChar = currentChar.TranslateTo(spans[0].Snapshot, PointTrackingMode.Positive);
    }

    //get the current char and the previous char
    char currentText = currentChar.GetChar();
    SnapshotPoint lastChar = currentChar == 0 ? currentChar : currentChar - 1; //if currentChar is 0 (beginning of buffer), don't move it back
    char lastText = lastChar.GetChar();
    SnapshotSpan pairSpan = new SnapshotSpan();

    if (m_braceList.ContainsKey(currentText))   //the key is the open brace
    {
        char closeChar;
        m_braceList.TryGetValue(currentText, out closeChar);
        if (BraceMatchingTagger.FindMatchingCloseChar(currentChar, currentText, closeChar, View.TextViewLines.Count, out pairSpan) == true)
        {
            yield return new TagSpan<TextMarkerTag>(new SnapshotSpan(currentChar, 1), new TextMarkerTag("blue"));
            yield return new TagSpan<TextMarkerTag>(pairSpan, new TextMarkerTag("blue"));
        }
    }
    else if (m_braceList.ContainsValue(lastText))    //the value is the close brace, which is the *previous* character 
    {
        var open = from n in m_braceList
                   where n.Value.Equals(lastText)
                   select n.Key;
        if (BraceMatchingTagger.FindMatchingOpenChar(lastChar, (char)open.ElementAt<char>(0), lastText, View.TextViewLines.Count, out pairSpan) == true)
        {
            yield return new TagSpan<TextMarkerTag>(new SnapshotSpan(lastChar, 1), new TextMarkerTag("blue"));
            yield return new TagSpan<TextMarkerTag>(pairSpan, new TextMarkerTag("blue"));
        }
    }
}

  9. 以下私有方法可在任何嵌套级别查找匹配大括号。 第一种方法查找与打开字符匹配的关闭字符：

    private static bool FindMatchingCloseChar(SnapshotPoint startPoint, char open, char close, int maxLines, out SnapshotSpan pairSpan)
{
    pairSpan = new SnapshotSpan(startPoint.Snapshot, 1, 1);
    ITextSnapshotLine line = startPoint.GetContainingLine();
    string lineText = line.GetText();
    int lineNumber = line.LineNumber;
    int offset = startPoint.Position - line.Start.Position + 1;

    int stopLineNumber = startPoint.Snapshot.LineCount - 1;
    if (maxLines > 0)
        stopLineNumber = Math.Min(stopLineNumber, lineNumber + maxLines);

    int openCount = 0;
    while (true)
    {
        //walk the entire line
        while (offset < line.Length)
        {
            char currentChar = lineText[offset];
            if (currentChar == close) //found the close character
            {
                if (openCount > 0)
                {
                    openCount--;
                }
                else    //found the matching close
                {
                    pairSpan = new SnapshotSpan(startPoint.Snapshot, line.Start + offset, 1);
                    return true;
                }
            }
            else if (currentChar == open) // this is another open
            {
                openCount++;
            }
            offset++;
        }

        //move on to the next line
        if (++lineNumber > stopLineNumber)
            break;

        line = line.Snapshot.GetLineFromLineNumber(lineNumber);
        lineText = line.GetText();
        offset = 0;
    }

    return false;
}

  10. 以下帮助程序方法查找与关闭字符匹配的打开字符：

    private static bool FindMatchingOpenChar(SnapshotPoint startPoint, char open, char close, int maxLines, out SnapshotSpan pairSpan)
{
    pairSpan = new SnapshotSpan(startPoint, startPoint);

    ITextSnapshotLine line = startPoint.GetContainingLine();

    int lineNumber = line.LineNumber;
    int offset = startPoint - line.Start - 1; //move the offset to the character before this one

    //if the offset is negative, move to the previous line
    if (offset < 0)
    {
        line = line.Snapshot.GetLineFromLineNumber(--lineNumber);
        offset = line.Length - 1;
    }

    string lineText = line.GetText();

    int stopLineNumber = 0;
    if (maxLines > 0)
        stopLineNumber = Math.Max(stopLineNumber, lineNumber - maxLines);

    int closeCount = 0;

    while (true)
    {
        // Walk the entire line
        while (offset >= 0)
        {
            char currentChar = lineText[offset];

            if (currentChar == open)
            {
                if (closeCount > 0)
                {
                    closeCount--;
                }
                else // We've found the open character
                {
                    pairSpan = new SnapshotSpan(line.Start + offset, 1); //we just want the character itself
                    return true;
                }
            }
            else if (currentChar == close)
            {
                closeCount++;
            }
            offset--;
        }

        // Move to the previous line
        if (--lineNumber < stopLineNumber)
            break;

        line = line.Snapshot.GetLineFromLineNumber(lineNumber);
        lineText = line.GetText();
        offset = line.Length - 1;
    }
    return false;
}

实现大括号匹配标记器提供程序

除了实现标记器之外，还必须实现和导出标记器提供程序。 在这种情况下，提供程序的内容类型为“text”。 因此，大括号匹配将显示在所有类型的文本文件中，但更完整的实现将大括号匹配仅适用于特定内容类型。

实现大括号匹配标记器提供程序

  1. 声明一个继承自IViewTaggerProvider的标记器提供程序，将其命名为 BraceMatchingTaggerProvider，并使用ContentTypeAttribute“text”和 a of.TagTypeAttribute TextMarkerTag 

    [Export(typeof(IViewTaggerProvider))]
[ContentType("text")]
[TagType(typeof(TextMarkerTag))]
internal class BraceMatchingTaggerProvider : IViewTaggerProvider

  2. CreateTagger实现实例化 BraceMatchingTagger 的方法。

    public ITagger<T> CreateTagger<T>(ITextView textView, ITextBuffer buffer) where T : ITag
{
    if (textView == null)
        return null;

    //provide highlighting only on the top-level buffer
    if (textView.TextBuffer != buffer)
        return null;

    return new BraceMatchingTagger(textView, buffer) as ITagger<T>;
}

生成并测试代码

若要测试此代码，请生成 BraceMatchingTest 解决方案并在实验实例中运行它。

生成和测试 BraceMatchingTest 解决方案

  1. 生成解决方案。

  2. 在调试器中运行此项目时，将启动 Visual Studio 的第二个实例。

  3. 创建文本文件并键入包含匹配大括号的某些文本。

    hello {
goodbye}

{}

{hello}

  4. 在打开大括号之前放置插入点时，应突出显示该大括号和匹配的关闭大括号。 将光标放在紧大括号之后时，应突出显示该大括号和匹配的打开大括号。

相关内容