正则表达式 - 请在形成这个表达式

Question

能否请你帮我写的正则表达式这个帮助。

NAME = “Windows产品为.NET”
TYPE = “软件编程”
数量= “3包”

我希望做一个匹配这样的在我需要RegEx的c＃中。

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

我想在这里拿，指定每个条件的正则表达式，然后应用逻辑操作数& &，逻辑分组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); 

请注意 - 我们正在创造一种动态的，模式，操作数和正则表达式从XML文件来的感觉。所以这就是为什么我不想为上面写一个大的regEx。

Answer 1

听起来好像你在问你应该如何处理问题的逻辑部分。如果你从一个xml文件中取出它，你可以用你想要的逻辑结构来构建你的文件。

例如，已经和和或团体：

<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文件中的类结构并调用的runTest从顶层测试。这样你可以做任何你喜欢的逻辑。我只是使用Contains而不是正则表达式来简化示例，但是您可以使用正则表达式匹配轻松替换字符串匹配。

Answer 2

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

Answer 3

首先，除非你想整场比赛（即用火柴工作时），你不要在你的表达需要的领先.*。只是一个简单的“是有”你不会需要它的模式可能匹配任何位置。

只需使用每个字段一个正则表达式（即一个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 4

在.NET中，正则表达式。匹配任何地方匹配的字符串，所以你不需要任何字符上你的模式前缀所以，检查“.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

你可以让他们不动使用正则表达式。使用正则表达式不会真正节省您的任何时间和精力，因为代码将是差不多大小两种方式。按照上面的图案，你可以做这样的事情：

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 6

patternForName = “净” patternForType = “编程” patternForType1 = “硬件”

您可能会发现正则表达式教练是有用的。