Question

我有一个类似于堆栈溢出时使用的文本编辑器。我正在处理c＃中的文本字符串，但也允许用户使用自定义标记格式化其中的文本。例如..

<year /> will output the current year.
"Hello <year /> World" would render Hello 2012 World

我想要做的是创建一个正则表达式来搜索字符串以查找<year />的任何出现并替换它。除此之外，我还想为标记添加属性，并能够提取它们<year offset="2" format="5" />。我对RegEx不太满意，但希望那里有人知道怎么做？

由于

Answer 1

理想情况下，您不应该使用正则表达式;但看到Html Agility Pack没有HtmlReader，我想你必须这样做。

话虽如此，在查看其他标记解决方案时，他们经常使用正则表达式模式列表和相关替换 - 所以我们不应该写一个“通用”案例（例如<([A-Z][A-Z0-9]*)>.*?</\1>将是错误的在这里，我们希望<year>.*?</year>）。

最初，您可能会创建一个类来保存有关已识别标记的信息，例如：

public class Token
{
    private Dictionary<string, string> _attributes = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
    public string InnerText { get; private set; }

    public string this[string attributeName]
    {
        get
        {
            string val;
            _attributes.TryGetValue(attributeName, out val);
            return val;
        }
    }

    public Token(string innerText, IEnumerable<KeyValuePair<string, string>> values)
    {
        InnerText = innerText;
        foreach (var item in values)
        {
            _attributes.Add(item.Key, item.Value);
        }
    }

    public int GetInteger(string name, int defaultValue)
    {
        string val;
        int result;
        if (_attributes.TryGetValue(name, out val) && int.TryParse(val, out result))
            return result;
        return defaultValue;
    }
}

现在我们需要创建正则表达式。例如，匹配year元素的正则表达式如下所示：

<Year(?>\s*(?<aname>\w*?)\s*=\s*"(?<aval>[^"]*)"\s*)*>(?<itext>.*?)</Year>

所以我们可以将其概括为：

<{0}\s*(?>(?<aname>\w*?)\s*=\s*"(?<aval>[^"]*)"\s*)*>(?<itext>.*?)</{0}>
<{0}\s*(?>(?<aname>\w*?)\s*=\s*"(?<aval>[^"]*)"\s*)*/>

鉴于这些通用标记正则表达式，我们可以编写标记类：

public class MyMarkup
{
    // These are used to build up the regex.
    const string RegexInnerText = @"<{0}\s*(?>(?<aname>\w*?)\s*=\s*""(?<aval>[^""]*)""\s*)*>(?<itext>.*?)</{0}>";
    const string RegexNoInnerText = @"<{0}\s*(?>(?<aname>\w*?)\s*=\s*""(?<aval>[^""]*)""\s*)*/>";

    private static LinkedList<Tuple<Regex, MatchEvaluator>> _replacers = new LinkedList<Tuple<Regex, MatchEvaluator>>();

    static MyMarkup()
    {
        Register("year", false, tok =>
        {
            var count = tok.GetInteger("digits", 4);
            var yr = DateTime.Now.Year.ToString();
            if (yr.Length > count)
                yr = yr.Substring(yr.Length - count);
            return yr;
        });
    }

    private static void Register(string tagName, bool supportsInnerText, Func<Token, string> replacement)
    {
        var eval = CreateEvaluator(replacement);

        // Add the no inner text variant.
        _replacers.AddLast(Tuple.Create(CreateRegex(tagName, RegexNoInnerText), eval));
        // Add the inner text variant.
        if (supportsInnerText)
            _replacers.AddLast(Tuple.Create(CreateRegex(tagName, RegexInnerText), eval));
    }

    private static Regex CreateRegex(string tagName, string format)
    {
        return new Regex(string.Format(format, Regex.Escape(tagName)), RegexOptions.Compiled | RegexOptions.IgnoreCase);
    }

    public static string Execute(string input)
    {
        foreach (var replacer in _replacers)
            input = replacer.Item1.Replace(input, replacer.Item2);
        return input;
    }

    private static MatchEvaluator CreateEvaluator(Func<Token, string> replacement)
    {
        return match =>
        {
            // Grab the groups/values.
            var aname = match.Groups["aname"];
            var aval = match.Groups["aval"];
            var itext = match.Groups["itext"].Value;

            // Turn aname and aval into a KeyValuePair.
            var attrs = Enumerable.Range(0, aname.Captures.Count)
                .Select(i => new KeyValuePair<string, string>(aname.Captures[i].Value, aval.Captures[i].Value));

            return replacement(new Token(itext, attrs));
        };
    }
}

这一切都非常艰苦，但它应该能让你对自己应该做的事情有所了解。

Answer 2

string.Replace足以满足第一个要求 - 不需要RegEx。

string.Replace(myString, "<year />", @"<year offset=""2"" /">")

为了提取属性值，您可以split上的"：

var val = @"<year offset=""2"" /">".Split('"')[1];

更新（以下评论）：

您可以尝试使用Html Agility Pack来解析和操作文本。它在HTML片段上运行良好 - 虽然我不确定它如何处理自定义标签（值得一试）。但可能过度杀伤。

c＃替换自定义标签

2 个答案: