理想情况下，您不应该为此使用正则表达式；但是看到 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));
};
}
}
这都是非常艰巨的工作，但它应该让您对自己应该做什么有一个很好的了解。