private bool CheckIsDictRule(ref RuleInfo info)
{
bool isOk = true;
string rule = info._rule;
info._isKey = rule.StartsWith(KEY, StringComparison.OrdinalIgnoreCase);
info._isValue = rule.StartsWith(VALUE, StringComparison.OrdinalIgnoreCase);
bool isDict = _define.IsContainer && _define.OriginalType == Setting.DICT;
if (!isDict && info.IsDict)
{
isOk = info._isKey = info._isValue = false;
Warning("基本规则:非dict类型数据,使用key|value无法正常检查");
}
else
{
if (info._isKey)
{
rule = rule.Substring(KEY.Length);
}
if (info._isValue)
{
rule = rule.Substring(VALUE.Length);
}
if (rule.StartsWith(":"))
{
rule = rule.Substring(1);
}
info._rule = rule;
}
return(isOk);
}
private bool Check(Data data, RuleInfo file)
{
string relativePath = file._rule.Replace("*", data.ToString());
Uri uri = new Uri($"{Setting.ApplicationDir}\\{relativePath}");
string path = uri.LocalPath;
if (File.Exists(path))
{
return(true);
}
return(false);
}
public override bool VerifyRule()
{
bool isOk = base.VerifyRule();
if (_rules.IsEmpty() || _ruleTable.Length == 0)
{
Warning($"File检查规则:未填写内容!");
isOk = false;
}
if (_define.IsRaw && _define.OriginalType != Setting.STRING)
{
Warning($"File检查规则:基础类型数据类型仅支持string类型");
isOk = false;
}
for (int i = 0; i < _ruleTable.Length; i++)
{
RuleInfo info = _ruleTable[i];
string rule = info._rule;
if (rule.IsEmpty())
{
Warning($"File检查规则:表达式为空");
isOk = false;
}
switch (_define.OriginalType)
{
case Setting.LIST:
if (_define.GetItemDefine().FullName != Setting.STRING)
{
Warning($"File检查规则:list中数据类型仅支持string类型");
isOk = false;
}
break;
case Setting.DICT:
if (info._isKey && _define.GetKeyDefine().FullName != Setting.STRING)
{
Warning($"File检查规则:dict.key数据类型仅支持string类型");
isOk = false;
}
else if (info._isValue && _define.GetValueDefine().FullName != Setting.STRING)
{
Warning($"File检查规则:dict.value数据类型仅支持string类型");
isOk = false;
}
break;
}
}
return(isOk);
}
public Checker(FieldWrap define, string rules)
{
_define = define;
_rules = rules;
string[] nodes = rules.Split(Setting.CheckSplit, System.StringSplitOptions.RemoveEmptyEntries);
_ruleTable = new RuleInfo[nodes.Length];
for (int i = 0; i < nodes.Length; i++)
{
_ruleTable[i] = new RuleInfo()
{
_rule = nodes[i]
}
}
;
}
// 检查集合中文件路径是否存在
private bool Check(FList data)
{
bool isOk = true;
var list = (data as FList).Values;
for (int k = 0; k < list.Count; k++)
{
bool flag = false;
for (int i = 0; i < _ruleTable.Length; i++)
{
RuleInfo info = _ruleTable[i];
flag |= Check(list[k], info);
}
isOk &= flag;
}
return(isOk);
}
private bool Check(FDict data, RefRule rule, RuleInfo info)
{
bool isOk = true;
var dict = data.Values;
foreach (var item in dict)
{
if (info._isKey)
{
isOk &= Check(item.Key, rule);
}
if (info._isValue)
{
isOk &= Check(item.Value, rule);
}
}
return(isOk);
}
// 检查集合中文件路径是否存在
// key|Value均可作该检查
private bool Check(FDict data)
{
bool isOk = true;
var dict = (data as FDict).Values;
foreach (var item in dict)
{
bool flagk = false;
bool flagv = false;
bool hasKey = false;
bool hasValue = false;
for (int i = 0; i < _ruleTable.Length; i++)
{
RuleInfo info = _ruleTable[i];
if (info._isKey)
{
flagk |= Check(item.Key, info);
hasKey |= true;
}
else if (info._isValue)
{
flagv |= Check(item.Value, info);
hasValue |= true;
}
}
if (hasKey && hasValue)
{
isOk &= flagk && flagv;
}
else if (hasKey && !hasValue)
{
isOk &= flagk;
}
else if (!hasKey && hasValue)
{
isOk &= flagv;
}
else
{
Error("File检查规则:程序Bug,未检查出规则配置错误!");
}
}
return(isOk);
}
private bool SwitchData(Data data, string type, RangeRule range, RuleInfo info)
{
bool isOk = true;
switch (type)
{
case Setting.INT:
isOk &= Check((data as FInt).Value, range);
break;
case Setting.LONG:
isOk &= Check((data as FLong).Value, range);
break;
case Setting.FLOAT:
isOk &= Check((data as FFloat).Value, range);
break;
}
return(isOk);
}
public override bool VerifyData(Data data)
{
bool isOk = false;
var define = data.Define;
if (define.OriginalType == Setting.DICT)
{
isOk |= Check(data as FDict);
}
else if (define.OriginalType == Setting.LIST)
{
isOk |= Check(data as FList);
}
else
{
for (int i = 0; i < _ruleTable.Length; i++)
{
RuleInfo info = _ruleTable[i];
isOk |= Check(data, info);
}
}
return(isOk);
}
public override bool VerifyRule()
{
bool isOk = base.VerifyRule();
if (_define.IsRaw || _define.IsEnum)
{//.是一个最外层的基础类型字段,检查整列数据.
if (!_define.Host.IsConfig())
{
Warning($"Unique检查规则:仅支持目标表结构最外层基础类型字段数据!");
isOk = false;
}
}
else if (_define.IsContainer)
{ //.是一个集合结构,直接检查结构内部数据
if (_define.OriginalType == Setting.LIST &&
_define.GetItemDefine().IsClass)
{
Warning($"Unique检查规则:由于多态的复杂性,不支持list中数据类型为Class!仅支持基础类型.");
isOk = false;
}
else if (_define.OriginalType == Setting.DICT && _ruleTable.Length != 0 &&
_define.GetValueDefine().IsClass)//_ruleTable.Length != 0 表示需要检查dict.value
{
for (int i = 0; i < _ruleTable.Length; i++)
{
RuleInfo info = _ruleTable[i];
if (info._isValue)
{
Warning($"Unique检查规则:由于多态的复杂性,不支持dict.value数据类型为Class!仅支持基础类型.");
}
}
isOk = false;
}
}
return(isOk);
}
public override bool VerifyRule()
{
bool isOk = base.VerifyRule();
if (_define.IsRaw && !HASH.Contains(_define.OriginalType))
{
Warning($"Range检查规则:基础类型数据类型仅支持int,long,float类型!当前类型:{_define.OriginalType}");
isOk = false;
}
_ranges = new RangeRule[_ruleTable.Length];
for (int i = 0; i < _ruleTable.Length; i++)
{
RuleInfo info = _ruleTable[i];
string rule = info._rule;
if (rule.IsEmpty())
{
Warning($"Range检查规则:表达式为空");
isOk = false;
}
if (rule.Length < 5 || rule.IsEmpty())
{
Warning($"Range检查规则:表达式长度必定大于等于5,而当前长度为{rule.Length}!");
isOk = false;
}
char left = rule[0];
char right = rule[rule.Length - 1];
if (!(left == LEFT_FULL || left == LEFT_HALF || left == NEGATIVE) &&
(right == RIGHT_FULL || right == RIGHT_HALF || right == POSITIVE))
{
Warning("Range检查规则:支持区间标识符错误(),[],(],[)!");
isOk = false;
}
RangeRule range = new RangeRule();
switch (right)
{
case RIGHT_FULL: range._rightState = true; break;
case RIGHT_HALF: range._rightState = false; break;
}
switch (left)
{
case LEFT_FULL: range._leftState = true; break;
case LEFT_HALF: range._leftState = false; break;
}
string content = rule.Trim(ARRAY);
string[] nodes = content.Split(new char[] { ',' }, System.StringSplitOptions.RemoveEmptyEntries);
if (nodes.Length != 2)
{
Warning("Range检查规则:范围参数漏填!");
isOk = false;
}
switch (_define.OriginalType)
{
case Setting.INT:
case Setting.LONG:
case Setting.FLOAT:
isOk = PaserLeftRight(nodes, _define.OriginalType, ref range);
break;
case Setting.LIST:
var item = _define.GetItemDefine();
if (!HASH.Contains(item.OriginalType))
{
Warning($"Range检查规则:list中数据类型仅支持int,long,float类型");
isOk = false;
}
else
{
isOk = PaserLeftRight(nodes, item.OriginalType, ref range);
}
break;
case Setting.DICT:
if (info._isKey)
{
var key = _define.GetKeyDefine();
if (!HASH.Contains(key.FullName))
{
Warning($"Range检查规则:dict.key数据类型仅支持int,long,float类型");
isOk = false;
}
else
{
isOk = PaserLeftRight(nodes, key.FullName, ref range);
}
}
else if (info._isValue)
{
var value = _define.GetValueDefine();
if (!HASH.Contains(value.FullName))
{
Warning($"Range检查规则:dict.value数据类型仅支持int,long,float类型");
isOk = false;
}
else
{
isOk = PaserLeftRight(nodes, value.FullName, ref range);
}
}
break;
}
_ranges[i] = range;
}
return(isOk);
}
public override bool VerifyRule()
{
bool isOk = base.VerifyRule();
_refs = new RefRule[_ruleTable.Length];
for (int i = 0; i < _ruleTable.Length; i++)
{
RuleInfo info = _ruleTable[i];
string rule = info._rule;
if (rule.IsEmpty())
{
Warning($"Ref检查规则:表达式为空");
isOk = false;
}
else
{
string[] nodes = rule.Split(Setting.DotSplit, System.StringSplitOptions.RemoveEmptyEntries);
if (nodes.Length == 3)
{
RefRule refr = new RefRule();
string targetName = $"{nodes[0]}.{nodes[1]}";
if (!ConfigWrap.IsConfig(targetName))
{
Warning($"Ref检查规则:目标{targetName}配置表无法获取!");
isOk = false;
}
refr._target = ConfigWrap.Get(targetName);
refr._targetField = nodes[2];
if (refr._target == null)
{
Warning("Ref检查规则:仅支持引用表结构最外层基础类型字段数据");
isOk = false;
}
else
{
var targetCls = ClassWrap.Get(targetName);
var define = targetCls.Fields.Find(field => field.Name == refr._targetField);
if (define.IsContainer)
{
if (define.OriginalType == Setting.LIST &&
define.GetItemDefine().IsClass)
{
Warning($"Ref检查规则:由于多态的复杂性,不支持list中数据类型为Class!仅支持基础类型.");
isOk = false;
}
else if (define.OriginalType == Setting.DICT &&
define.GetValueDefine().IsClass)
{
Warning($"Ref检查规则:由于多态的复杂性,不支持dict.value数据类型为Class!仅支持基础类型.");
isOk = false;
}
}
else if (define.IsEnum || define.IsRaw)
{
}
else
{
Warning($"Ref检查规则:由于多态的复杂性,不支持数据类型为Class!仅支持基础类型.");
isOk = false;
}
}
_refs[i] = refr;
}
else
{
Warning($"Ref检查规则:格式错误,正确格式[Namespace.Class.Field]");
isOk = false;
}
}
}
return(isOk);
}
