C# 解析自定义筛选器Syntax的最佳方法
我有一个程序，允许用户在DataGridView列标题的文本框中输入过滤器。 然后将此文本解析为筛选器操作列表 目前，我将字符串标记化，然后在hunge For循环中构建列表 我可以用什么样的设计模式来摆脱巨大的建筑需求 我还可以采取其他措施来改进设计吗 在当前状态下，很难添加对另一个操作符、数据类型的支持或构建除filterlist之外的其他内容。假设我需要用构建一个表达式（很快就会出现这种情况）或构建一个SQLWHERE子句来替换filterlist 过滤综合税 筛选器遵循此语法，对字符串、数字和日期时间有效： 范围运算符 下限。上限 29..52将被解析为过滤器列表“x>=29”和“x 29”中的两个元素 通配符C# 解析自定义筛选器Syntax的最佳方法,c#,parsing,filter,tokenize,C#,Parsing,Filter,Tokenize,我有一个程序，允许用户在DataGridView列标题的文本框中输入过滤器。 然后将此文本解析为筛选器操作列表 目前，我将字符串标记化，然后在hunge For循环中构建列表 我可以用什么样的设计模式来摆脱巨大的建筑需求 我还可以采取其他措施来改进设计吗 在当前状态下，很难添加对另一个操作符、数据类型的支持或构建除filterlist之外的其他内容。假设我需要用构建一个表达式（很快就会出现这种情况）或构建一个SQLWHERE子句来替换filterlist 过滤综合税 筛选器遵循此语法，对字符串、
*someText*publicstaticfilterlistparse（stringfilter，stringcolumnname，Type dataType），其中T:class
{
if（数据类型！=typeof（float）&&dataType！=typeof（DateTime）&&dataType！=typeof（string））
抛出新的NotSupportedException（String.Format（“不支持数据类型“{0}”，数据类型））；
Token[]filterParts=tokenize（过滤器）；
filterParts=清理（filterParts）；
StringBuilder sb=新的StringBuilder（）；
for（int i=0；i3）
{
抛出新的FilterException（“RangeOperator不能与其他运算符混合”）；
}
如果（i==0）
{
如果（filterParts.Length==2）
{
//Bis运算符
令牌权限=过滤器部件[1]；
if（right.TokenType！=TokenType.Text）
抛出新的FilterException（“预期为TextToken”）；
if（String.IsNullOrEmpty（right.Text））
抛出新的FilterException（“文本必须有值”）；
if（right.Text.StartsWith（“.”）
抛出新的FilterException（“以点开头的文本无效”）；
if（数据类型==typeof（字符串））
返回新的FilterList{{columnname，FilterOperator.Less，right.Text}；
//filterString=String.Format（（{0}<'{1}'或{0}为NULL）”，columnname，right.Text）；
如果（数据类型==typeof（浮点））
{
浮动权f；
如果（！float.TryParse（right.Text，out rightF））
抛出新筛选器异常(
Format（“right参数具有错误的格式“{0}”，right.Text））；
返回新的FilterList{{columnname，FilterOperator.Less，rightF}；
//filterString=String.Format（（{0}<{1}或{0}为NULL）”，columnname，rightF.ToString（CultureInfo.InvariantCulture））；
}
if（数据类型==typeof（日期时间））
{
DateTime righdt=parseDateTime（right.Text）；
返回新的FilterList{{columnname，FilterOperator.Less，rightDt}；
//filterString=String.Format（（{0}<'{1}'或{0}为NULL）”，columnname，rightDT.ToString（CultureInfo.InvariantCulture））；
}
打破
}
抛出新的FilterException（“参数太多”）；
}
如果（i==1）
{
如果（filterParts.Length==2）
{
//冯算子
左令牌=过滤器部件[0]；
if（left.TokenType！=TokenType.Text）
抛出新的FilterException（“预期为TextToken”）；
if（String.IsNullOrEmpty（left.Text））
抛出新的FilterException（“参数必须有值”）；
if（数据类型==typeof（字符串））
返回新的FilterList{{columnname，FilterOperator.Greater，left.Text}；
//filterString=String.Format（（{0}>'{1}'），columnname，left.Text）；
如果（数据类型==typeof（浮点））
{
浮动左F；
如果（！float.TryParse（left.Text，out leftF））
抛出新的FilterException（String.Format(
“左参数已打开
public static FilterList<T> Parse<T>(string filter, string columnname, Type dataType) where T : class
{
if (dataType != typeof(float) && dataType != typeof(DateTime) && dataType != typeof(string))
throw new NotSupportedException(String.Format("Data Type is not supported '{0}'", dataType));
Token[] filterParts = tokenize(filter);
filterParts = cleanUp(filterParts);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < filterParts.Length; i++)
{
Token currentToken = filterParts[i];
//BereichsFilter prüfen und bauen
if (currentToken.TokenType == TokenType.RangeOperator)
{
if (filterParts.Length < 2)
{
throw new FilterException("Missing argument for RangeOperator");
}
if (filterParts.Length > 3)
{
throw new FilterException("RangeOperator can't be mixed with other operators");
}
if (i == 0)
{
if (filterParts.Length == 2)
{
//Bis Operator
Token right = filterParts[1];
if (right.TokenType != TokenType.Text)
throw new FilterException("TextToken expected");
if (String.IsNullOrEmpty(right.Text))
throw new FilterException("Text must have value");
if (right.Text.StartsWith("."))
throw new FilterException("Text starting with a dot is not valid");
if (dataType == typeof(string))
return new FilterList<T> { { columnname, FilterOperator.Less, right.Text } };
//filterString = String.Format("({0} < '{1}' OR {0} IS NULL)", columnname, right.Text);
if (dataType == typeof(float))
{
float rightF;
if (!float.TryParse(right.Text, out rightF))
throw new FilterException(
String.Format("right parameter has wrong format '{0}'", right.Text));
return new FilterList<T> { { columnname, FilterOperator.Less, rightF } };
//filterString = String.Format("({0} < {1} OR {0} IS NULL)", columnname, rightF.ToString(CultureInfo.InvariantCulture));
}
if (dataType == typeof(DateTime))
{
DateTime rightDt = parseDateTime(right.Text);
return new FilterList<T> { { columnname, FilterOperator.Less, rightDt } };
//filterString = String.Format("({0} < '{1}' OR {0} IS NULL)", columnname, rightDT.ToString(CultureInfo.InvariantCulture));
}
break;
}
throw new FilterException("too many arguments");
}
if (i == 1)
{
if (filterParts.Length == 2)
{
//Von Operator
Token left = filterParts[0];
if (left.TokenType != TokenType.Text)
throw new FilterException("TextToken expected");
if (String.IsNullOrEmpty(left.Text))
throw new FilterException("Argument must have value");
if (dataType == typeof(string))
return new FilterList<T> { { columnname, FilterOperator.Greater, left.Text } };
//filterString = String.Format("({0} > '{1}')", columnname, left.Text);
if (dataType == typeof(float))
{
float leftF;
if (!float.TryParse(left.Text, out leftF))
throw new FilterException(String.Format(
"left parameter has wrong format '{0}'", left.Text));
return new FilterList<T> { { columnname, FilterOperator.Greater, leftF } };
//filterString = String.Format("({0} > {1})", columnname, leftF.ToString(CultureInfo.InvariantCulture));
}
if (dataType == typeof(DateTime))
{
DateTime leftDt = parseDateTime(left.Text);
return new FilterList<T> { { columnname, FilterOperator.Greater, leftDt } };
//filterString = String.Format("({0} > '{1}')", columnname, leftDT.ToString(CultureInfo.InvariantCulture));
}
break;
}
else
{
//BereichsOperator
Token left = filterParts[0];
if (left.TokenType != TokenType.Text)
throw new FilterException("TextToken expected");
if (String.IsNullOrEmpty(left.Text))
throw new FilterException("parameter must have value");
Token right = filterParts[2];
if (right.TokenType != TokenType.Text)
throw new FilterException("TextToken expected");
if (String.IsNullOrEmpty(right.Text))
throw new FilterException("parameter must have value");
if (dataType == typeof(string))
return new FilterList<T>
{
{columnname, FilterOperator.GreaterOrEqual, left.Text},
{columnname, FilterOperator.LessOrEqual, right.Text}
};
//filterString = String.Format("{0} >= '{1}' AND {0} <= '{2}'", columnname, left.Text, right.Text);
if (dataType == typeof(float))
{
float rightF;
if (!float.TryParse(right.Text, out rightF))
throw new FilterException(
String.Format("right parameter has wrong format '{0}'", right.Text));
float leftF;
if (!float.TryParse(left.Text, out leftF))
throw new FilterException(String.Format(
"left parameter has wrong format'{0}'", left.Text));
return new FilterList<T>
{
{columnname, FilterOperator.GreaterOrEqual, leftF},
{columnname, FilterOperator.LessOrEqual, rightF}
};
//filterString = String.Format("{0} >= {1} AND {0} <= {2}", columnname, leftF.ToString(CultureInfo.InvariantCulture), leftF.ToString(CultureInfo.InvariantCulture));
}
if (dataType == typeof(DateTime))
{
DateTime rightDt = parseDateTime(right.Text);
DateTime leftDt = parseDateTime(left.Text);
return new FilterList<T>
{
{columnname, FilterOperator.GreaterOrEqual, leftDt},
{columnname, FilterOperator.LessOrEqual, rightDt}
};
//filterString = String.Format("{0} >= '{1}' AND {0} <= '{2}'", columnname, leftDT.ToString(CultureInfo.InvariantCulture), rightDT.ToString(CultureInfo.InvariantCulture));
}
break;
}
}
throw new FilterException("unexpected parameter");
}
//Stringsuche Bauen
if (currentToken.TokenType == TokenType.Wildcard)
{
if (dataType != typeof(string))
throw new FilterException("Operator not allowed with this Data Type");
//Fehler wenn Datentyp kein string
sb.Append("%");
}
else if (currentToken.TokenType == TokenType.Text)
sb.Append(escape(currentToken.Text));
}
//Filterung auf Zeichenfolge
string text = sb.ToString();
if (dataType == typeof(string))
return new FilterList<T> { { columnname, FilterOperator.Like, text } };
//filterString = String.Format("{0} LIKE '{1}' ESCAPE '\\'", columnname, text);
if (dataType == typeof(DateTime))
{
DateTime dt = parseDateTime(text);
return new FilterList<T> { { columnname, FilterOperator.Equal, dt } };
//filterString = String.Format("{0} = '{1}'", columnname, DT.ToString(CultureInfo.InvariantCulture));
}
if (dataType == typeof(float))
{
float f;
if (!float.TryParse(text, out f))
throw new FilterException(String.Format("parameter has wrong format '{0}'", text));
return new FilterList<T> { { columnname, FilterOperator.Equal, f } };
//filterString = String.Format("{0} = {1}", columnname, F.ToString(CultureInfo.InvariantCulture));
}
return null;
}
start
= filters
filters
= left:filter " " right:filters { return {filter: left, operation: "AND", filters: right};}
/ filter
filter
= applicableRange:range {return {type: "range", range: applicableRange};}
/ openWord:wildcard {return {type: "wildcard", word: openWord};}
/ simpleWord:word {return simpleWord;}
/ sentence:sentence {return sentence;}
sentence
= "'" + letters:[0-9a-zA-Z *.]* "'" {return {type: "sentence", value: letters.join("")};}
word "aword"
= letters:[0-9a-zA-Z]+ { return {type: "word", value: letters.join("")}; }
wildcard
=
"*" word:word "*" {return {type: "wildcardBoth", value: word};}
/ "*" word:word {return {type: "wildcardStart", value: word};}
/ word:word "*" {return {type: "wildcardEnd", value: word};}
range "range"
= left:word? ".." right:word? {return {from: left, to: right};}
'testing range' 123..456 123.. ..abc 'and testing wildcards' word1* *word2 *word3* cool heh
{
"filter": {
"type": "sentence",
"value": "testing range"
},
"operation": "AND",
"filters": {
"filter": {
"type": "range",
"range": {
"from": {
"type": "word",
"value": "123"
},
"to": {
"type": "word",
"value": "456"
}
}
},
"operation": "AND",
"filters": {
"filter": {
"type": "range",
"range": {
"from": {
"type": "word",
"value": "123"
},
"to": null
}
},
"operation": "AND",
"filters": {
"filter": {
"type": "range",
"range": {
"from": null,
"to": {
"type": "word",
"value": "abc"
}
}
},
"operation": "AND",
"filters": {
"filter": {
"type": "sentence",
"value": "and testing wildcards"
},
"operation": "AND",
"filters": {
"filter": {
"type": "wildcard",
"word": {
"type": "wildcardEnd",
"value": {
"type": "word",
"value": "word1"
}
}
},
"operation": "AND",
"filters": {
"filter": {
"type": "wildcard",
"word": {
"type": "wildcardStart",
"value": {
"type": "word",
"value": "word2"
}
}
},
"operation": "AND",
"filters": {
"filter": {
"type": "wildcard",
"word": {
"type": "wildcardBoth",
"value": {
"type": "word",
"value": "word3"
}
}
},
"operation": "AND",
"filters": {
"filter": {
"type": "word",
"value": "cool"
},
"operation": "AND",
"filters": {
"type": "word",
"value": "heh"
}
}
}
}
}
}
}
}
}
}