C# visualstudiomef&；讽刺：没有语法突出显示

My

ITagger

正在生成标记，但是Visual Studio没有显示语法着色。 以下是ITagger的代码：

[Export（typeof（ITaggerProvider））]
[内容类型（“FDL”）]
[TagType（typeof（ClassificationTag））]
内部密封类FDLClassifierProvider:ITaggerProvider
{
[出口]
[名称（“FDL”）]
[基本定义（“代码”）]
内部静态ContentTypeDefinition FDLContentType=null；
[出口]
[文件扩展名（“.fdl”）]
[内容类型（“FDL”）]
内部静态FileExtensionContentTypeDefinition FDLFileType=null；
[进口]
内部ICClassificationTypeRegistryService ClassificationTypeRegistry=null；
[进口]
内部IBuffertagggregatorFactoryService聚合器工厂=null；
公共ITagger CreateTagger（ITextBuffer缓冲区），其中T:ITag
{
返回新的FDLClassifier（缓冲区，ClassificationTypeRegistry）作为ITagger；
}
}
/// 
///这实际上是从2008年起对LineScanner的更换。
///此类必须在GetTags（）期间处理非常快的处理时间
///因为它被称为非常频繁！
/// 
内部密封类FDL分类器：ITagger
{
ITextBuffer\u缓冲区；
语法；
Irony.Parsing.Parser\u Parser；
国际词典；
分类标签_注释标签；
公共事件事件处理程序TagsChanged；
字典_lineStates=新字典（）；
内部FDL分类器（ITextBuffer，
ICClassificationTypeRegistryService类型服务）
{
_缓冲区=缓冲区；
_语法=新语法（）；
_parser=new Irony.Parsing.parser（_grammar）；
_parser.Context.Mode=Irony.Parsing.ParseMode.VsLineScan；
_fdlTags=新字典（）；
_fdlTags[Irony.Parsing.TokenType.Text]=BuildTag（typeService，预定义的ClassificationTypeNames.Character）；
_fdlTags[Irony.Parsing.TokenType.Keyword]=BuildTag（typeService，预定义的ClassificationTypeNames.Keyword）；
_fdlTags[Irony.Parsing.TokenType.Identifier]=BuildTag（typeService，预定义的ClassificationTypeNames.Identifier）；
_fdlTags[Irony.Parsing.TokenType.String]=BuildTag（typeService，预定义的ClassificationTypeNames.String）；
_fdlTags[Irony.Parsing.TokenType.Literal]=BuildTag（typeService，预定义的ClassificationTypeNames.Literal）；
_fdlTags[Irony.Parsing.TokenType.Operator]=BuildTag（typeService，预定义的ClassificationTypeNames.Operator）；
_fdlTags[Irony.Parsing.TokenType.LineComment]=BuildTag（typeService，预定义的ClassificationTypeNames.Comment）；
_fdlTags[Irony.Parsing.TokenType.Comment]=BuildTag（typeService，预定义的ClassificationTypeNames.Comment）；
_commentTag=BuildTag（typeService，预定义的ClassificationTypeNames.Comment）；
初始化属性（_buffer.CurrentSnapshot）；
}
/// 
///在分类标记器的上下文中，这最初称为w/span for all
///文件中的内容。
///根据修改的文本范围，在用户修改文本后立即调用它。
///对于由于滚动而新可见的所有行，它也被调用。
///这个函数被多次调用。将处理时间保持在最小，并尝试一次只处理一行
///时间。
/// 
/// 
/// 
公共IEnumerable GetTags（normalizedSnapshotSpan集合范围）
{
如果（spans.Count==0）
屈服断裂；
var snapShot=span[0]。快照；
foreach（跨度中的变量跨度）
{
var startine=span.Start.GetContainingLine（）；
var endLine=span.End.GetContainingLine（）；
var STARTINENUMBER=STARTINE.LineNumber；
var endLineNumber=endLine.LineNumber；
例如（inti=startinenumber；i你有没有机会看一下Ben Morrison的文章，他在文章中解释了如何在VS语言服务中使用反讽（语法突出显示是其中的一部分）

更新：关于类似的线程，请参见

另外，你也可以在这里找到一些有价值的信息-
我所指的文章说，他们使用了最初的ManagedMyC示例（基于巴别塔的东西），并将其改为使用反讽而不是巴别塔。
[Export(typeof(ITaggerProvider))]
    [ContentType("FDL")]
    [TagType(typeof(ClassificationTag))]
    internal sealed class FDLClassifierProvider : ITaggerProvider
    {

        [Export]
        [Name("FDL")]
        [BaseDefinition("code")]
        internal static ContentTypeDefinition FDLContentType = null;

        [Export]
        [FileExtension(".fdl")]
        [ContentType("FDL")]
        internal static FileExtensionToContentTypeDefinition FDLFileType = null;

        [Import]
        internal IClassificationTypeRegistryService ClassificationTypeRegistry = null;

        [Import]
        internal IBufferTagAggregatorFactoryService aggregatorFactory = null;

        public ITagger<T> CreateTagger<T>(ITextBuffer buffer) where T : ITag
        {
            return new FDLClassifier(buffer, ClassificationTypeRegistry) as ITagger<T>;
        }
    }

    /// <summary>
    /// This is effectively the replacement to the LineScanner from 2008.
    /// This class must handle very quick processing times during GetTags() 
    /// as it is called very frequently!
    /// </summary>
    internal sealed class FDLClassifier : ITagger<ClassificationTag>
    {
        ITextBuffer _buffer;
        Grammar _grammar;
        Irony.Parsing.Parser _parser;

        IDictionary<Irony.Parsing.TokenType, ClassificationTag> _fdlTags;
        ClassificationTag _commentTag;


        public event EventHandler<SnapshotSpanEventArgs> TagsChanged;

        Dictionary<int, int> _lineStates = new Dictionary<int, int>();

        internal FDLClassifier(ITextBuffer buffer,
                               IClassificationTypeRegistryService typeService)
        {
            _buffer = buffer;

            _grammar = new Grammar();
            _parser = new Irony.Parsing.Parser(_grammar);
            _parser.Context.Mode = Irony.Parsing.ParseMode.VsLineScan;

            _fdlTags = new Dictionary<Irony.Parsing.TokenType, ClassificationTag>();
            _fdlTags[Irony.Parsing.TokenType.Text] = BuildTag(typeService, PredefinedClassificationTypeNames.Character);
            _fdlTags[Irony.Parsing.TokenType.Keyword] = BuildTag(typeService, PredefinedClassificationTypeNames.Keyword);
            _fdlTags[Irony.Parsing.TokenType.Identifier] = BuildTag(typeService, PredefinedClassificationTypeNames.Identifier);
            _fdlTags[Irony.Parsing.TokenType.String] = BuildTag(typeService, PredefinedClassificationTypeNames.String);
            _fdlTags[Irony.Parsing.TokenType.Literal] = BuildTag(typeService, PredefinedClassificationTypeNames.Literal);
            _fdlTags[Irony.Parsing.TokenType.Operator] = BuildTag(typeService, PredefinedClassificationTypeNames.Operator);
            _fdlTags[Irony.Parsing.TokenType.LineComment] = BuildTag(typeService, PredefinedClassificationTypeNames.Comment);
            _fdlTags[Irony.Parsing.TokenType.Comment] = BuildTag(typeService, PredefinedClassificationTypeNames.Comment);

            _commentTag = BuildTag(typeService, PredefinedClassificationTypeNames.Comment);

            InitializeLineStates(_buffer.CurrentSnapshot);
        }

        /// <summary>
        /// In the context of a classification tagger, this is called initially w/ spans for all
        /// content in the file.
        /// It is called immediately after the user modifies text given the span of text that was modified.
        /// It is also called for all lines that are newly visible due to scrolling.
        /// This function gets called ALOT.  Keep processing times to a minimal and try to only handle 1 line at a
        /// time.
        /// </summary>
        /// <param name="spans"></param>
        /// <returns></returns>
        public IEnumerable<ITagSpan<ClassificationTag>> GetTags(NormalizedSnapshotSpanCollection spans)
        {
            if (spans.Count == 0)
                yield break;

            var snapShot = spans[0].Snapshot;
            foreach (var span in spans)
            {
                var startLine = span.Start.GetContainingLine();
                var endLine = span.End.GetContainingLine();

                var startLineNumber = startLine.LineNumber;
                var endLineNumber = endLine.LineNumber;

                for (int i = startLineNumber; i <= endLineNumber; i++)
                {
                    var line = spans[0].Snapshot.GetLineFromLineNumber(i);
                    _parser.Scanner.VsSetSource(line.GetText(), 0);

                    int state = 0;
                    _lineStates.TryGetValue(i, out state);

                    var token = _parser.Scanner.VsReadToken(ref state);
                    while (token != null)
                    {
                        if (token.Category == Irony.Parsing.TokenCategory.Content)
                        {
                            if (token.EditorInfo != null)
                            {
                                ClassificationTag tag;
                                if (_fdlTags.TryGetValue(token.EditorInfo.Type, out tag))
                                {
                                    var location = new SnapshotSpan(snapShot, line.Start.Position + token.Location.Position, token.Length);
                                    yield return new TagSpan<ClassificationTag>(location, tag);

                                }
                            }
                        }
                        else if (token.Category == Irony.Parsing.TokenCategory.Comment)
                        {

                            var location = new SnapshotSpan(snapShot, line.Start.Position + token.Location.Position, token.Length);
                            yield return new TagSpan<ClassificationTag>(location, _commentTag);
                        }

                        token = _parser.Scanner.VsReadToken(ref state);
                    }

                    int oldState = 0;
                    _lineStates.TryGetValue(i + 1, out oldState);
                    _lineStates[i + 1] = state;

                    //We're going into overtime, process new tags and send the event that these spans need updating!
                    if (oldState != state)
                    {
                        var lineNumber = endLineNumber;
                        while (oldState != state && lineNumber < snapShot.LineCount)
                        {
                            lineNumber++;
                            var dummyToken = _parser.Scanner.VsReadToken(ref state);
                            while (dummyToken != null)
                            {
                                dummyToken = _parser.Scanner.VsReadToken(ref state);
                            }

                            _lineStates.TryGetValue(lineNumber + 1, out oldState);
                            _lineStates[lineNumber + 1] = state;
                        }

                        if (lineNumber >= snapShot.LineCount)
                            lineNumber = snapShot.LineCount - 1;

                        var lastLine = snapShot.GetLineFromLineNumber(lineNumber);
                        if (lastLine != null && this.TagsChanged != null)
                        {
                            int length = lastLine.End.Position - endLine.End.Position;
                            var snapShotSpan = new SnapshotSpan(snapShot, endLine.End.Position, length);
                            this.TagsChanged(this, new SnapshotSpanEventArgs(snapShotSpan));
                        }
                    }
                }
            }
        }

        private ClassificationTag BuildTag(IClassificationTypeRegistryService typeService, string type)
        {
            var classificationType = typeService.GetClassificationType(type);
            return new ClassificationTag(classificationType);
        }

        /// <summary>
        /// Initializes the line states based on the snapshot.
        /// </summary>
        private void InitializeLineStates(ITextSnapshot snapShot)
        {
            _lineStates[0] = 0;
            foreach (var line in snapShot.Lines)
            {
                int state = 0;
                _parser.Scanner.VsSetSource(line.GetText(), 0);

                var dummyToken = _parser.Scanner.VsReadToken(ref state);
                while (dummyToken != null)
                {
                    dummyToken = _parser.Scanner.VsReadToken(ref state);
                }

                _lineStates[line.LineNumber + 1] = state;
            }
        }
    }

[Language("FDL", "6.0", "Feature Description Language")]
    public class Grammar: Irony.Parsing.Grammar
    {
        public Grammar():base(true)
        {
            #region NonTerminals

            var blockComment = new CommentTerminal("block-comment", "/*", "*/");
            var lineComment = new CommentTerminal("line-comment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
            NonGrammarTerminals.Add(blockComment);
            NonGrammarTerminals.Add(lineComment);
            var identifier = new IdentifierTerminal("identifier");
            var stringLit = new StringLiteral("string");

            #endregion
            #region Symbols
            MarkPunctuation(";", ",", ":");
            RegisterBracePair("{", "}");
            RegisterBracePair("<", ">");
            RegisterBracePair("[", "]");
            RegisterBracePair("(", ")");
            #endregion
            #region Keywords
            var action = Keyword("action");
            var actionBoxFont = Keyword("actionBoxFont");
            var actionBoxFontSize = Keyword("actionBoxFontSize");
            var allocate = Keyword("allocate");
            // rest of grammar omitted for brevity.
            #endregion
        }
        KeyTerm Keyword(string keyword)
        {
            var term = ToTerm(keyword);
            MarkReservedWords(keyword);
            term.EditorInfo = new TokenEditorInfo(TokenType.Keyword, TokenColor.Keyword, TokenTriggers.None);
            return term;
        }
    }