Question

请你帮我写一下正则表达式。

Name =“Windows产品.Net”
    Type =“软件编程”
    数量=“每包3”

我想在c＃中做这样的匹配，我需要RegEx。

If Name.contains(".Net") && (Type.Contains("Programming") || Type.Contains("Hardware")
{
// output will be a Match.
}
else 
{
// no match.
}

我想在这里采用的方法是，为每个条件指定正则表达式，然后应用逻辑操作数＆amp;＆amp; ，逻辑分组paranthesis然后逻辑操作数||。我已经为这些提出了所有正则表达式。如何为每个逻辑操作数提供适当顺序执行的逻辑操作数？

   string Name = "Windows Product for .Net";
   string Type = "Software Programming";

   string patternForName = ".*Net";
   Regex rgxName = new Regex(patternForName);
   Match matchName = rgx.Match(Name);
   string patternForType = ".*Programming";
   Regex rgxType = new Regex(patternForType);
   Match matchType = rgx.Match(Type);

   string patternForType1 = ".*Hardware";
   Regex rgxType1 = new Regex(patternForType1);
   Match matchType1 = rgx.Match(Type);

请注意 - 我们正在使它变得动态，在某种意义上，模式，操作数和regEx来自xml文件。所以这就是为什么我不想为上面写一个大的regEx。

Answer 1

首先，除非您想要完整匹配（即使用匹配时），否则表达式中不需要前导.*。只是为了一个简单的“它就在那里”你不需要它，因为模式可能匹配任何位置。

只为每个字段使用一个正则表达式（即一个用于Name，一个用于Type，一个用于Quantity：

string patternForName = "\\.Net"; // escaping the dot so it will match real dots only
string patternForType = "Programming|Hardware"; // | will result in "left side or right side"
string patternForQuantity = ".?"; // will match any string, even empty ones

检查所有内容：

bool match = rgxName.IsMatch(Name) && rgxType.IsMatch(Type) && rgx.IsMatch(Quantity);

Answer 2

您可以在不使用正则表达式的情况下使其动态化。使用正则表达式并不能真正为您节省任何时间或精力，因为代码的大小大致相同。按照上面的模式，您可以执行以下操作：

var names = new[] { "Net", "Programming" };
var types = new[] { "Hardware" };

bool matchFound = true;

foreach (string n in names)
    matchFound &= Name.Contains(n);

foreach (string t in types)
    matchFound |= Type.Contains(t);

上面的代码假设您要匹配所有“名称”和任何“类型”，但您可以替换所需的任何逻辑。

你问题的真正症结在于这些布尔组合;正则表达式不会帮助你了解这些逻辑，所以你最好不要使用string.Contains，除非你正在寻找的模式变得更加可变。在我看来，正则表达式会让你分散你真正的目标。

Answer 3

if (rgxName.IsMatch(Name) && (rgxType.IsMatch(Type) || rgxType1.IsMatch(Type))
{
...
}

Answer 4

在.NET中，Regex.Match匹配字符串中的任何位置，因此您不需要在模式上使用任意字符（。*）前缀。因此，要检查“.NET”，它只是：

Regex regexName = new Regex(@"\.NET", RegexOptions.IgnoreCase);
// IsMatch returns true/false, Match returns a Match object
bool nameMatches = regexName.IsMatch(name);

您的编程和硬件模式只是

new Regex(@"Programming", RegexOptions.IgnoreCase) // Or leave out IgnoreCase if you're case-sensitive
new Regex(@"Hardware")

如果你有一个名单模式列表和一个类型模式列表，你可以做类似的事情：

bool nameIsMatch = false;
bool typeIsMatch = false;

foreach (string namePattern in namePatterns)
{
    nameIsMatch = nameIsMatch || Regex.IsMatch(nameString, namePattern);
}

foreach (string typePattern in typePatterns)
{
    typeIsMatch = typeIsMatch || Regex.IsMatch(typeString, typePattern);
}

if (nameIsMatch && typeIsMatch)
{
    // Whatever you want to do
}

Answer 5

patternForName =“。Net” patternForType =“编程” patternForType1 =“硬件”

您可能会发现The Regex Coach很有用。

Answer 6

听起来你在问你应该如何处理问题的逻辑部分。如果您从xml文件中提取它，则可以按照构建逻辑的方式构建文件。

例如，有And和Or组：

<And>
   <Name Match=".Net"/>
   <Or>
      <Type Match="Programming"/>
      <Type Match="Hardware"/>
   </Or>
</And>

为每种类型创建类。为简洁起见，我没有使用属性或创建构造函数来定义类，但您可以根据需要填写它们：

class YourType
{
   string Name;
   string Type;
   string Quantity;
}

abstract class Test
{
   public abstract bool RunTest(YourType o);
}

class AndTest : Test
{
   public List<Test> Children;
   public bool RunTest(YourType o)
   {
      foreach (var test in Children)
      {
         if (!test.RunTest(o)) return false;
      }
      return true;
   }
}

class OrTest : Test
{
   public List<Test> Children;
   public bool RunTest(YourType o)
   {
      foreach (var test in Children)
      {
         if (test.RunTest(o)) return true;
      }
      return false;
   }
}

class NameTest : Test
{
   public string Match;

   public bool RunTest(YourType o)
   {
      return o.Name.Contains(Match);
   }
}

class TypeTest : Test
{
   public string Match;

   public bool RunTest(YourType o)
   {
      return o.Type.Contains(Match);
   }
}

从xml文件构建类结构，只需从顶级Test调用RunTest。这样你就可以做任何你喜欢的逻辑。为了方便示例，我只使用了Contains而不是Regex，但您可以轻松地将字符串匹配替换为正则表达式匹配。

RegEx - 请帮助形成此RegEx

6 个答案: