C# 用于突出显示的正则表达式

当我使用不同的正则表达式突出显示文档（RichEditControl）中的单词和注释（如SQL）时，我遇到了一个问题

这是我的第一个正则表达式：

(/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+/)|(--.*)

这在：

/*blahblah*/

和

--blahblah

我还有一个正则表达式：

((""(.|/[[:blank:]]/)*?"")|('(.|/[[:blank:]]/)*?'))

这在：

'blahblah'

（类似于sql字符串）中非常有效

但是，如果我这样做：

'/*blahblah*/'

在我编写最后一个

“

之前，程序会显示一个异常：

中发生类型为“System.ArgumentException”的未处理异常 DevExpress.Office.v15.2.Core.dll

提前感谢您的帮助。

这是完整的代码：

    private List<SyntaxHighlightToken> ParseTokens()
    {
        List<SyntaxHighlightToken> tokens = new List<SyntaxHighlightToken>();            
        DocumentRange[] ranges = null;            

        #region SearchSimpleCommas
        Regex quotations = new Regex(@"((""(.|/[[:blank:]]/)*?"")|('(.|/[[:blank:]]/)*?'))");
        ranges = document.FindAll(quotations);
        foreach (var range in ranges)
        {
            if (!IsRangeInTokens(range, tokens))
                tokens.Add(new SyntaxHighlightToken(range.Start.ToInt(), range.Length, StringSettings));   
        }
        #endregion

        #region SearchComment--/**/
        Regex comment = new Regex(@"(/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+/)|(--.*)", RegexOptions.IgnoreCase | RegexOptions.Multiline);
        ranges = document.FindAll(comment);
        for (int i = 0; i < ranges.Length; i++)
        {
            tokens.Add(new SyntaxHighlightToken(ranges[i].Start.ToInt(), ranges[i].Length, CommentsSettings));
        }
        #endregion

        tokens.Sort(new SyntaxHighlightTokenComparer());
        // fill in gaps in document coverage
        AddPlainTextTokens(tokens);
        return tokens;
    }

    private void AddPlainTextTokens(List<SyntaxHighlightToken> tokens)
    {
        int count = tokens.Count;
        if (count == 0)
        {
            tokens.Add(new SyntaxHighlightToken(0, document.Range.End.ToInt(), defaultSettings));
            return;
        }
        tokens.Insert(0, new SyntaxHighlightToken(0, tokens[0].Start, defaultSettings));
        for (int i = 1; i < count; i++)
        {
            tokens.Insert(i * 2, new SyntaxHighlightToken(tokens[i * 2 - 1].End, tokens[i * 2].Start - tokens[i * 2 - 1].End, defaultSettings));
        }
        tokens.Add(new SyntaxHighlightToken(tokens[count * 2 - 1].End, document.Range.End.ToInt() - tokens[count * 2 - 1].End, defaultSettings));
    }

    private bool IsRangeInTokens(DocumentRange range, List<SyntaxHighlightToken> tokens)
    {
        return tokens.Any(t => IsIntersect(range, t));            
    }
    bool IsIntersect(DocumentRange range, SyntaxHighlightToken token)
    {
        int start = range.Start.ToInt();
        if (start >= token.Start && start < token.End)
            return true;
        int end = range.End.ToInt() - 1;
        if (end >= token.Start && end < token.End)
            return true;
        return false;
    }

    #region ISyntaxHighlightServiceMembers
    public void ForceExecute()
    {
        Execute();
    }
    public void Execute()
    {//The Exepction show in this part
        document.ApplySyntaxHighlight(ParseTokens());
    }
    #endregion

private List ParseTokens（）
{
列表标记=新列表（）；
DocumentRange[]范围=空；
#区域搜索SimpleCommas
正则表达式引号=新正则表达式（@“（（.|/[：blank:]/）*？））（（.|/[：blank:]/）*？）”）；
范围=document.FindAll（报价）；
foreach（范围中的var范围）
{
如果（！IsRangeInTokens（范围、令牌））
添加（新的SyntaxHighlightToken（range.Start.ToInt（），range.Length，StringSettings））；
}
#端区
#区域搜索评论--/**/
正则表达式注释=新正则表达式（@“（/\*（[^*].[\r\n].[\r\n]））*\*+（[^*/].[\r\n]））*\*+/）|（-.*），RegexOptions.IgnoreCase | RegexOptions.Multiline）；
范围=document.FindAll（注释）；
对于（int i=0；iIsIntersect（range，t））；
}
bool IsIntersect（DocumentRange范围，SyntaxHighlightToken令牌）
{
int start=range.start.ToInt（）；
if（start>=token.start&&start=token.Start&&end

编辑：谢谢Harrison Mc。

我共享我使用的代码，以防任何人需要它，仅共享我修改的代码（在方法ParseTokens中）：

#区域搜索注释和字符串
正则表达式定义正则表达式=新正则表达式（@“（？”[^\\\']*（？>\[^\\']*）*”）|（？（？>/\*（？>[^*].[\r\n]|）（？>\*+（？>[^*/].[\r\n]））****+/（？>-.*）”；
MatchCollection matches=definitiveRegex.matches（document.Text）；
foreach（System.Text.RegularExpressions.Match中的匹配）
{
尝试
{
System.Text.RegularExpressions.GroupCollection groups=match.groups；
如果（组[“字符串”].Value.Length>0）
{
范围=空；
对于（int s=0；s0）
{
范围=空；
对于（int c=0；c

为了避免在字符串中突出显示注释和在注释中突出显示字符串，您需要某种“状态”，而正则表达式很难给出这种状态。这些情况对于单个字符串和注释正则表达式来说很难处理，因为在查找字符串时需要跟踪您是否在注释中，反之亦然

"This string looks like it contains a /*comment*/ but it does not."
/* This comment looks like it contains a 'string' but it does not. */

但是，如果您使用一个正则表达式，它具有不同的组来匹配字符串和注释，那么贪婪地使用字符将防止字符串中的“注释”或注释中的“字符串”弄乱事情

我测试了这个正则表达式，它似乎对“comm”和“comm”都有效

"This string looks like it contains a /*comment*/ but it does not."
/* This comment looks like it contains a 'string' but it does not. */

(?<string>'[^\\']*(?>\\.[^\\']*)*'|""[^\\""]*(?>\\.[^\\""]*)*"")|(?<comment>(?>/\*(?>[^*]|[\r\n]|(?>\*+(?>[^*/]|[\r\n])))*\*+/)|(?>--.*))

Regex stringAndCommentRegex = new Regex(@"(?<string>'[^\\']*...");
MatchCollection matches = stringAndCommentRegex.Matches(text);
foreach (Match match in matches)
{
    GroupCollection groups = match.Groups;
    if (match.groups["string"].Value.Length > 0)
    {
        // handle string
    }
    else if (match.groups["comment"].Value.Length > 0)
    {
        // handle comment
    }
}