/// <summary>
/// 添加一个注释
/// </summary>
/// <returns></returns>
public NoteNode AddNote()
{
NoteNode node = new NoteNode();
this.Nodes.Add(node);
return(node);
}
/// <summary>
/// 获取节点对象
/// </summary>
/// <param name="xml"></param>
/// <param name="parent"></param>
/// <returns></returns>
public static XmlNodeCollection GetNodes(string xml, XmlNode parent = null)
{
// 初始化对象
XmlNodeCollection nodes = new XmlNodeCollection(parent);
BasicNode np = null;
// 当前解析器类型
ParserTypes pt = ParserTypes.None;
// 缓存
string tagName = null;
string pName = null;
string pValue = null;
StringBuilder sb = new StringBuilder();
// 文档数据
int line = 1;
int site = 0;
for (int i = 0; i < xml.Length; i++)
{
site++;
char chr = xml[i];
switch (chr)
{
case '<':
#region [=====左尖括号=====]
if (pt == ParserTypes.None)
{
// 当有内容独立文本时，增加文本节点
if (sb.Length > 0)
{
// 判断是否存在处理对象
if (np == null)
{
// 新增主对象
var node = new TextNode();
node.SetEncodeValue(sb.ToString());
nodes.Add(node);
}
else
{
// 新增子对象
var npNormal = (XmlNode)np;
var nodeNew = new TextNode();
npNormal.Nodes.Add(nodeNew);
nodeNew.SetEncodeValue(sb.ToString());
}
// 清理缓存
sb.Clear();
}
pt = ParserTypes.NodeName;
}
else if (pt == ParserTypes.CData || pt == ParserTypes.PropertyValue || pt == ParserTypes.Note)
{
sb.Append(chr);
}
else
{
throw new Exception($"规则外的字符'{chr}'");
}
break;
#endregion
case '>':
#region [=====右尖括号=====]
if (pt == ParserTypes.NodeName)
{
// 无属性情况
tagName = sb.ToString();
if (tagName.IsNone())
{
throw new Exception($"规则外的字符'{chr}'");
}
pt = ParserTypes.None;
// 判断是否存在处理对象
if (np == null)
{
// 新增主对象
var node = new XmlNode(tagName);
nodes.Add(node);
np = node;
}
else
{
// 新增子对象
var npNormal = (XmlNode)np;
var nodeNew = new XmlNode(tagName);
npNormal.Nodes.Add(nodeNew);
np = nodeNew;
}
// 清理缓存
tagName = null;
sb.Clear();
}
else if (pt == ParserTypes.NodeFinish)
{
// 处在标签结尾
if (np.NodeType == NodeType.Declaration)
{
if (sb.Length > 0)
{
throw new Exception($"规则外的字符'{chr}'");
}
// 返回上一层
np = np.Parent;
// 设置解析对象为空
pt = ParserTypes.None;
}
else
{
if (np.NodeType != NodeType.Normal)
{
throw new Exception($"规则外的字符'{chr}'");
}
var npNormal = (XmlNode)np;
tagName = sb.ToString();
// 单节点模式
if (npNormal.IsSingle)
{
if (!tagName.IsNone())
{
throw new Exception($"语法错误");
}
// 返回上一层
np = np.Parent;
// 过滤父对象
if (np == parent)
{
np = null;
}
}
else
{
if (tagName.IsNone())
{
throw new Exception($"缺少标签名称");
}
//if (np.Parent == null) throw new Exception($"多余的尾部标签");
if (npNormal.TagName != tagName)
{
throw new Exception($"首尾标签名不匹配");
}
// 返回上一层
np = np.Parent;
// 过滤父对象
if (np == parent)
{
np = null;
}
}
// 设置解析对象为空
pt = ParserTypes.None;
// 清理缓存
tagName = null;
sb.Clear();
}
}
else if (pt == ParserTypes.PropertyValueFinish)
{
// 设置解析对象为空
pt = ParserTypes.None;
// 清理缓存
sb.Clear();
}
else if (pt == ParserTypes.PropertyName)
{
if (sb.Length > 0)
{
throw new Exception($"规则外的字符'{chr}'");
}
// 设置解析对象为空
pt = ParserTypes.None;
// 清理缓存
sb.Clear();
}
else if (pt == ParserTypes.Note)
{
// 判断是否为注释结束
if (sb.Length >= 2)
{
if (sb[sb.Length - 1] == '-' && sb[sb.Length - 2] == '-')
{
// 结束注释
var npNote = (NoteNode)np;
sb.Remove(sb.Length - 2, 2);
npNote.Note = sb.ToString();
// 返回上层节点
np = np.Parent;
// 过滤父对象
if (np == parent)
{
np = null;
}
// 设置解析
pt = ParserTypes.None;
// 清理缓存
sb.Clear();
}
else
{
sb.Append(chr);
}
}
else
{
sb.Append(chr);
}
}
else if (pt == ParserTypes.CData)
{
// 判断是否为数据块结束
if (sb.Length >= 2)
{
if (sb[sb.Length - 1] == ']' && sb[sb.Length - 2] == ']')
{
// 结束注释
var npCData = (CDataNode)np;
sb.Remove(sb.Length - 2, 2);
npCData.Value = sb.ToString();
// 返回上层节点
np = np.Parent;
// 过滤父对象
if (np == parent)
{
np = null;
}
// 设置解析
pt = ParserTypes.None;
// 清理缓存
sb.Clear();
}
else
{
sb.Append(chr);
}
}
else
{
sb.Append(chr);
}
}
else if (pt == ParserTypes.PropertyValue)
{
sb.Append(chr);
}
else
{
throw new Exception($"规则外的字符'{chr}'");
}
break;
#endregion
case '/':
#region [=====斜杠=====]
if (pt == ParserTypes.NodeName)
{
// 设置为标签结尾
pt = ParserTypes.NodeFinish;
if (sb.Length > 0)
{
// 新增子对象，并设置为独立标签
tagName = sb.ToString();
var npNormal = (XmlNode)np;
var nodeNew = new XmlNode(tagName);
nodeNew.IsSingle = true;
npNormal.Nodes.Add(nodeNew);
np = nodeNew;
// 清理缓存
tagName = null;
sb.Clear();
}
}
else if (pt == ParserTypes.PropertyName)
{
if (sb.Length > 0)
{
throw new Exception($"规则外的字符'{chr}'");
}
// 设置为结尾标签，并设置为独立标签
pt = ParserTypes.NodeFinish;
var npNormal = (XmlNode)np;
npNormal.IsSingle = true;
}
else if (pt == ParserTypes.PropertyValueFinish)
{
// 设置为结尾标签，并设置为独立标签
pt = ParserTypes.NodeFinish;
var npNormal = (XmlNode)np;
npNormal.IsSingle = true;
}
else if (pt == ParserTypes.CData || pt == ParserTypes.PropertyValue || pt == ParserTypes.Note || pt == ParserTypes.None)
{
sb.Append(chr);
}
else
{
throw new Exception($"规则外的字符'{chr}'");
}
break;
#endregion
case ' ':
#region [=====空格=====]
if (pt == ParserTypes.NodeName)
{
// 标签名称设定
tagName = sb.ToString();
if (tagName.IsNone())
{
throw new Exception($"规则外的字符'{chr}'");
}
if (tagName == "?xml")
{
// 申明定义情况
if (parent != null)
{
throw new Exception($"定义只允许在文档开始位置定义");
}
if (np != null)
{
throw new Exception($"定义只允许在文档开始位置定义");
}
if (nodes.Count > 0)
{
throw new Exception($"定义只允许在文档开始位置定义");
}
// 新增主对象
var node = new DeclarationNode();
nodes.Add(node);
np = node;
// 设置解析类型为属性名称
pt = ParserTypes.PropertyName;
// 清理缓存
tagName = null;
sb.Clear();
}
else
{
// 判断是否存在处理对象
if (np == null)
{
// 新增主对象
var node = new XmlNode(tagName);
nodes.Add(node);
np = node;
}
else
{
// 新增子对象
var npNormal = (XmlNode)np;
var nodeNew = new XmlNode(tagName);
npNormal.Nodes.Add(nodeNew);
np = nodeNew;
}
// 设置解析类型为属性名称
pt = ParserTypes.PropertyName;
// 清理缓存
tagName = null;
sb.Clear();
}
}
else if (pt == ParserTypes.PropertyValueFinish)
{
// 设置解析类型为属性名称
pt = ParserTypes.PropertyName;
}
else if (pt == ParserTypes.CData || pt == ParserTypes.PropertyValue || pt == ParserTypes.Note)
{
sb.Append(chr);
}
else
{
//throw new Exception($"规则外的字符'{chr}'");
}
break;
#endregion
case '=':
#region [=====斜杠=====]
if (pt == ParserTypes.PropertyName)
{
// 填充名称
pName = sb.ToString();
// 设置为标签结尾
pt = ParserTypes.PropertyNameFinish;
// 清理缓存
sb.Clear();
}
else if (pt == ParserTypes.CData || pt == ParserTypes.PropertyValue || pt == ParserTypes.Note || pt == ParserTypes.None)
{
sb.Append(chr);
}
else
{
throw new Exception($"规则外的字符'{chr}'");
}
break;
#endregion
case '"':
#region [=====双引号=====]
if (pt == ParserTypes.PropertyNameFinish)
{
// 设置为标签值开始
pt = ParserTypes.PropertyValue;
}
else if (pt == ParserTypes.PropertyValue)
{
// 填充值
pValue = sb.ToString();
if (np.NodeType == NodeType.Declaration)
{
var npDeclaration = (DeclarationNode)np;
npDeclaration.Attr[pName] = pValue;
}
else if (np.NodeType == NodeType.Normal)
{
var npNormal = (XmlNode)np;
//npNormal.Attr[pName] = pValue;
npNormal.SetEncodeAttr(pName, pValue);
}
else
{
throw new Exception($"语法错误");
}
// 设置为标签值结束
pt = ParserTypes.PropertyValueFinish;
// 清理缓存
sb.Clear();
pName = null;
pValue = null;
}
else if (pt == ParserTypes.CData || pt == ParserTypes.Note || pt == ParserTypes.None)
{
sb.Append(chr);
}
else
{
throw new Exception($"规则外的字符'{chr}'");
}
break;
#endregion
case '-':
#region [=====横杠=====]
if (pt == ParserTypes.NodeName)
{
// 判断是否为注释
if (sb.Length == 2)
{
if (sb[0] == '!' && sb[1] == '-')
{
// 判断是否存在处理对象
if (np == null)
{
// 新增主对象
var node = new NoteNode();
nodes.Add(node);
np = node;
}
else
{
// 新增子对象
var npNormal = (XmlNode)np;
var nodeNew = new NoteNode();
npNormal.Nodes.Add(nodeNew);
np = nodeNew;
}
// 设置解析模式为注释
pt = ParserTypes.Note;
// 清理缓存
sb.Clear();
}
else
{
sb.Append(chr);
}
}
else
{
sb.Append(chr);
}
}
else if (pt == ParserTypes.CData || pt == ParserTypes.Note || pt == ParserTypes.PropertyName || pt == ParserTypes.PropertyValue || pt == ParserTypes.None)
{
sb.Append(chr);
}
else
{
throw new Exception($"规则外的字符'{chr}'");
}
break;
#endregion
case '[':
#region [=====中括号=====]
if (pt == ParserTypes.None)
{
//throw new Exception($"规则外的字符'{chr}'");
sb.Append(chr);
}
else if (pt == ParserTypes.NodeName)
{
// 判断是否为注释
if (sb.Length == 7)
{
if (sb[0] == '!' && sb[1] == '[' && sb[2] == 'C' && sb[3] == 'D' && sb[4] == 'A' && sb[5] == 'T' && sb[6] == 'A')
{
// 判断是否存在处理对象
if (np == null)
{
// 新增主对象
var node = new CDataNode();
nodes.Add(node);
np = node;
}
else
{
// 新增子对象
var npNormal = (XmlNode)np;
var nodeNew = new CDataNode();
npNormal.Nodes.Add(nodeNew);
np = nodeNew;
}
// 设置解析模式为注释
pt = ParserTypes.CData;
// 清理缓存
sb.Clear();
}
else
{
sb.Append(chr);
}
}
else
{
sb.Append(chr);
}
}
else if (pt == ParserTypes.CData || pt == ParserTypes.Note || pt == ParserTypes.PropertyName || pt == ParserTypes.PropertyValue)
{
sb.Append(chr);
}
else
{
throw new Exception($"规则外的字符'{chr}'");
}
break;
#endregion
case '?':
#region [=====问号=====]
if (pt == ParserTypes.PropertyName)
{
// 属性名称模式时，无属性定义继续
if (np.NodeType != NodeType.Declaration)
{
throw new Exception($"规则外的字符'{chr}'");
}
if (sb.Length > 0)
{
throw new Exception($"规则外的字符'{chr}'");
}
// 设置为标签结尾
pt = ParserTypes.NodeFinish;
}
else if (pt == ParserTypes.PropertyValueFinish)
{
// 设置为结尾标签，并设置为独立标签
if (np.NodeType != NodeType.Declaration)
{
throw new Exception($"规则外的字符'{chr}'");
}
pt = ParserTypes.NodeFinish;
}
else if (pt == ParserTypes.NodeName || pt == ParserTypes.CData || pt == ParserTypes.PropertyValue || pt == ParserTypes.Note || pt == ParserTypes.None)
{
sb.Append(chr);
}
else
{
throw new Exception($"规则外的字符'{chr}'");
}
break;
#endregion
case '\r': break; //忽略回车符
case '\n':
#region [=====换行符=====]
if (pt == ParserTypes.CData || pt == ParserTypes.Note)
{
sb.Append(chr);
}
else if (pt == ParserTypes.NodeName)
{
// 当作空格使用
// 标签名称设定
tagName = sb.ToString();
if (tagName.IsNone())
{
throw new Exception($"规则外的字符'{chr}'");
}
// 判断是否存在处理对象
if (np == null)
{
// 新增主对象
var node = new XmlNode(tagName);
nodes.Add(node);
np = node;
}
else
{
// 新增子对象
var npNormal = (XmlNode)np;
var nodeNew = new XmlNode(tagName);
npNormal.Nodes.Add(nodeNew);
np = nodeNew;
}
// 设置解析类型为属性名称
pt = ParserTypes.PropertyName;
// 清理缓存
tagName = null;
sb.Clear();
}
else if (pt == ParserTypes.PropertyValueFinish)
{
// 设置解析类型为属性名称
pt = ParserTypes.PropertyName;
}
else if (pt == ParserTypes.PropertyName || pt == ParserTypes.PropertyNameFinish || pt == ParserTypes.PropertyValue)
{
throw new Exception($"规则外的字符'{chr}'");
}
line++;
site = 0;
break;
#endregion
default:
#region [=====常规字符=====]
if (pt == ParserTypes.CData || pt == ParserTypes.PropertyValue || pt == ParserTypes.Note || pt == ParserTypes.NodeName || pt == ParserTypes.PropertyName || pt == ParserTypes.NodeFinish || pt == ParserTypes.None)
{
sb.Append(chr);
}
else
{
throw new Exception($"规则外的字符'{chr}'");
}
break;
#endregion
}
}
if (pt != ParserTypes.None)
{
throw new Exception($"内容尚未结束");
}
if (sb.Length > 0)
{
var node = new TextNode();
//node.Value = sb.ToString();
node.SetEncodeValue(sb.ToString());
nodes.Add(node);
// 清理缓存
sb.Clear();
}
return(nodes);
}