在本文中，将探讨一个强大的类库，它使用正则表达式来在对象序列中查找模式。这些模式可以是任何实现了IEnumerable<T>泛型接口的类实例，包括.NET框架中广为人知的类，如List<T>、HashSet<T>或Dictionary<K,V>，以及LINQ查询返回的对象。
要使用这个库的功能，可以通过调用CollectionRegex.Match方法来实现。这个方法提供了实例和静态两种版本。为了使用这些方法，需要提供以下信息：
当所有这些参数都已知时，可以调用Match方法并获取结果。Match方法返回所有匹配项的枚举，即IEnumerable<CollectionMatch<T>>。实现使用了yield return结构，因此操作是按需执行的。该库支持命名和未命名的捕获组。
以下代码分析一系列数字，以找到至少连续三个数字超出指定范围的位置。每个数字被归类为三个类别之一：“太低”（a）、“正常”（b）或“太高”（c）。将使用的正则表达式是：
[^b]{3,}
该表达式找到三个或更多连续字符的子序列，这些字符不是b。在集合的上下文中，它匹配了三个或更多连续数字，这些数字不在“正常”类别中。由于定义的类别是a、b和c，因此该表达式等同于[ac]{3,}。所需的.NET代码非常直接。当然，需要定义模式中字符和类别之间的关系。在这个例子中，这是通过lambda表达式完成的。它们是匿名方法，它们从集合中取每个数字并返回一个布尔值，当数字属于特定类别时为true。
var reg = new CollectionRegex<double>(@"[^b]{3,}");
double low = 3, high = 7;
reg.AddPredicate(s => s <= low, 'a');
reg.AddPredicate(s => s > low && s < high, 'b');
reg.AddPredicate(s => s >= high, 'c');
测试代码：
var collection = new List<double>{4, 5, 9, 6, 7, 8, 9, 8, 6, 4, 3, 2, 4, 2, 2, 3, 3, 5, 5, 5, 3, 2, 7, 5};
var actual = reg.Match(collection).ToList();
Assert.AreEqual(3, actual.Count());
Assert.AreEqual(4, actual[0].Index);
Assert.AreEqual(4, actual[0].Count);
Assert.AreEqual(13, actual[1].Index);
Assert.AreEqual(4, actual[1].Count);
Assert.AreEqual(20, actual[2].Index);
Assert.AreEqual(3, actual[2].Count);
测试集合在内部由字符串"bbcb cccc bbaa baaa abbb aacb"（无空格）表示。正则表达式匹配了三个子序列：{7, 8, 9, 8}（cccc）、{2, 2, 3, 3}（aaaa）和{3, 2, 7}（aac）。
对于那些习惯于C#编程的人来说，通过检查不使用CollectionRegex库的实现，可能更容易理解这个想法。
List<IEnumerable<double>> results = new List<IEnumerable<double>>();
for (int i = 0; i < collection.Count; i++) {
IEnumerable<double> enu = collection.Skip(i);
enu = enu.TakeWhile(x => x <= low || x >= high);
if (enu.Count() >= 3) {
results.Add(enu);
i += enu.Count() - 1;
}
}
以下代码在生产过程中找到未成功完成的请求。集合包含ProductionEvent类型的对象，这些对象代表生产项目（r）、成功报告（s）或失败报告（f）。如果无法生产项目，则将失败报告放入集合中。正则表达式应该找到根本没有生产的项目。
(?<item>r)f+(?=r|$)
(?<item>r)匹配一个项目的请求，并定义了一个名为item的命名组。f+匹配一个或多个失败报告。最后一部分(?=r|$)对另一个请求（r）或集合的结尾（$）进行正向查找，以确保在分析的请求之后没有成功报告。
例如，在序列rs rfff rffffs rff中，它找到了第二个和第四个请求（rfff和rff）。然而，它不匹配第三个请求（rffffs），因为它最终成功完成了，尽管在此过程中有四次失败。源代码假设有一个ProductionEvent类，它公开了两个属性：Type和ItemName。
var reg = new CollectionRegex<ProductionEvent>(@"(?<item>r)f+(?=r|$)");
reg.AddPredicate(s => s.Type == ProductionEventTypes.Success, 's');
reg.AddPredicate(s => s.Type == ProductionEventTypes.ItemRequest, 'r');
reg.AddPredicate(s => s.Type == ProductionEventTypes.Failure, 'f');
测试代码：
var collection = new List<ProductionEvent>{
new ProductionEvent { Type = ProductionEventTypes.ItemRequest, ItemName = "chocolade" },
new ProductionEvent { Type = ProductionEventTypes.Success },
new ProductionEvent { Type = ProductionEventTypes.ItemRequest, ItemName = "impossible1" },
new ProductionEvent { Type = ProductionEventTypes.Failure },
new ProductionEvent { Type = ProductionEventTypes.Failure },
new ProductionEvent { Type = ProductionEventTypes.Failure },
new ProductionEvent { Type = ProductionEventTypes.ItemRequest, ItemName = "problematic" },
new ProductionEvent { Type = ProductionEventTypes.Failure },
new ProductionEvent { Type = ProductionEventTypes.Failure },
new ProductionEvent { Type = ProductionEventTypes.Failure },
new ProductionEvent { Type = ProductionEventTypes.Failure },
new ProductionEvent { Type = ProductionEventTypes.Success },
new ProductionEvent { Type = ProductionEventTypes.ItemRequest, ItemName = "impossible2" },
new ProductionEvent { Type = ProductionEventTypes.Failure },
};
var actual = reg.Match(collection).ToList();
foreach (CollectionMatch<ProductionEvent> e in actual) {
Assert.IsTrue(e.Groups["item"].Single().ItemName.StartsWith("impossible"));
}
LINQ替代方案：
List<IEnumerable<ProductionEvent>> results = new List<IEnumerable<ProductionEvent>>();
List<ProductionEvent> requests = new List<ProductionEvent>();
for (int i = 0; i < collection.Count; i++) {
IEnumerable<ProductionEvent> begin = collection.Skip(i);
IEnumerable<ProductionEvent> enu = begin;
if (enu.Count() >= 2) {
var request = enu.First();
if (request.Type == ProductionEventTypes.ItemRequest) {
enu = enu.Skip(1);
var x = enu.First();
if (x.Type == ProductionEventTypes.Failure) {
enu = enu.SkipWhile(p => p.Type == ProductionEventTypes.Failure);
if (enu.Count() == 0) {
results.Add(begin);
requests.Add(request);
i += begin.Count();
} else if (enu.First().Type == ProductionEventTypes.ItemRequest) {
var result = begin.TakeWhile(p => !object.ReferenceEquals(p, enu.First()));
results.Add(result);
requests.Add(request);
i += result.Count();
}
}
}
}
}
谓词必须是互斥的。如果任何项匹配多个谓词，则Match方法将抛出ArgumentException。谓词是CollectionRegexPredicate抽象类的实例。如果想提供一个自定义的机制来检查对象是否属于某个类别，只需要实现IsMatch(T obj)方法。
没有被任何谓词匹配的项在正则表达式中由逗号（','）表示。因此，像[^ab]这样的否定组将匹配这些项。在ASCII表中，逗号被选中经过了深思熟虑，没有其他字符能在这里准确使用。（第一个可打印的，没有问题的，并且人类容易计数的字符）。
var predicates = new CollectionRegexDelegatePredicate<double>[] {
new CollectionRegexDelegatePredicate<double>(s => s <= low, 'a'),
new CollectionRegexDelegatePredicate<double>(s => s > low && s < high, 'b'),
new CollectionRegexDelegatePredicate<double>(s => s >= high, 'c'),
};
var actual = collection.MatchRegex(predicates, @"[^b]{3,}");