Common（十二）—— JXML

最新推荐文章于 2024-11-05 22:13:56 发布

原创最新推荐文章于 2024-11-05 22:13:56 发布 · 938 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#xml

本文介绍了一个用于简化XML操作的封装类库，包括JString、JNode、JAttribute和JXml等类的定义与使用方法。这些类使得XML的读写变得更为简便。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

目录为:Assets/Scripts/Common/
JXML.cs，
这个文件把XML又封装了一遍,下一篇看看怎么用。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using UnityEditor;
using UnityEngine;
using System.Collections;

//这里把XML又封装了一遍

public class JString
{
    string value;
    public JString(string str)
    {
        value = str;
    }

    public new string ToString()
    {
        return value;
    }

    //实现隐式转换 -string
    //JString隐式转换成string
    public static implicit operator string(JString xs)
    {
        return xs.value;
    }

    //string 隐式转换成JString
    public static implicit operator JString(string str)
    {
        return new JString (str);
    }

    //实现隐式转换-float
    //JStirng隐式转换成float
    public static implicit operator float(JString xs)
    {
        return xs.value == "" ? 0 : (float)Convert.ToDouble (xs.value);
    }

    //float隐式转换成JString
    public static implicit operator JString(float v)
    {
        return new JString (v.ToString ());
    }

    //实现隐式转换-int
    //JString隐式转换成int
    public static implicit operator int(JString xs)
    {
        return xs.value == "" ? 0 : (int)Convert.ToDouble (xs.value);
    }

    //int隐式转换成JString
    public static implicit operator JString(int v)
    {
        return new JString(v.ToString());
    }

    //实现隐式转换-int64
    //Int64隐式转换成JString
    public static implicit operator JString(Int64 v)
    {
        return new JString (v.ToString ());
    }

    //Jstring隐式转换成Int64
    public static implicit operator Int64(JString xs)
    {
        return xs.value == "" ? 0 : (Int64)Convert.ToDouble (xs.value);
    }

    //实现隐式转换-bool
    //bool隐式转换成JString
    public static implicit operator JString(bool v)
    {
        return new JString (v.ToString ());
    }

    //JString隐式转换成bool
    public static implicit operator bool(JString xs)
    {
        if (xs.value == "" || xs.value.ToLower() == "false" || xs.value == "0")
        {
            return false;
        }

        return true;
    }
}

//JNode
public class JNode
{
    //父节点
    JNode parent = null;

    //node name
    string nodeName;

    //node
    protected XmlNode node = null;

    //Attribute
    public JAttribute Attributes;

    //构造函数
    public JNode()
    {
        Attributes = new JAttribute (this);
    }

    //构造函数,获取一个JNode
    public JNode(JNode _parent, string _nodeName)
    {
        parent = _parent;
        nodeName = _nodeName;
        node = parent.GetChildXmlNode (nodeName);
        Attributes = new JAttribute (this);
    }

    //构造函数，获取一个JNode
    public JNode(JNode _parent, int _index)
    {
        parent = _parent;
        node = parent.GetChildXmlNode (_index);
        Attributes = new JAttribute (this);
    }

    /// <summary>
    /// 返回该JNode对应的XmlNode
    /// </summary>
    /// <param name="Create"></param>
    /// <returns></returns>
    public XmlNode GetXmlNode(bool Create = false)
    {
        if (Create && node == null)
        {
            XmlNode xn = parent.GetXmlNode (true);
            node = xn.AppendChild (xn.OwnerDocument.CreateNode (XmlNodeType.Element, nodeName, null));
        }

        return node;
    }

    //获取index处的子XmlNode
    XmlNode GetChildXmlNode(int _index)
    {
        if (node == null)
        {
            return null;
        }

        return node.ChildNodes [_index];
    }

    //获取名为name的XmlNode
    XmlNode GetChildXmlNode(string name)
    {
        if (node == null)
        {
            return null;
        }

        return node.SelectSingleNode (name);
    }

    /// <summary>
    /// 返回子节点的个数
    /// </summary>
    public int Count
    {
        get 
        {
            return node == null ? 0 : node.ChildNodes.Count;
        }
    }

    //InnerXml
    public string InnerXml
    {
        get
        {
            return node == null ? "" : node.InnerXml;
        }

        set
        {
            GetXmlNode (true).InnerXml = value;
        }
    }

    //通过NodeName来索引JNode
    public JNode this[string NodeName]
    {
        get
        {
            return new JNode (this, NodeName);
        }
    }

    public JNode this[int NodeIndex]
    {
        get
        {
            return new JNode (this, NodeIndex);
        }
    }
}

//JAttribute
public class JAttribute
{
    JNode node;

    //构造函数
    public JAttribute(JNode xn)
    {
        node = xn;
    }

    //获取这个Node的Attribute的个数
    public int Count
    {
        get
        {
            return node.Attributes.Count;
        }
    }

    //set一个Attribute
    public void SetAttribute(string name, string value)
    {
        //获取当前xmlNode节点
        XmlNode xn = node.GetXmlNode (true);
        //获取想要设置的Attribute
        XmlAttribute xa = xn.Attributes [name];
        //Attribute不存在则创建一个
        if (xa == null)
        {
            xa = xn.Attributes.Append (xn.OwnerDocument.CreateAttribute (name));
        }

        xa.Value = value;
    }

    //通过AttributeName来索引attribute的value
    public JString this[string AttributeName]
    {
        //返回attribute对应的value
        get
        {
            return (node.GetXmlNode (false) == null || node.GetXmlNode (false).Attributes [AttributeName] == null ?
                "" : node.GetXmlNode (false).Attributes [AttributeName].Value);
        }

        set
        {
            SetAttribute (AttributeName, value);
        }
    }

    //根据AttributeIndex返回XmlAttribute
    public XmlAttribute this[int AttributeIndex]
    {
        get
        {
            return node.GetXmlNode (false).Attributes [AttributeIndex];
        }
    }
}


//JXml
public class JXml: JNode
{
    XmlDocument xml;

    //构造函数
    public JXml()
        :base()
    {
        xml = new XmlDocument ();
        node = (XmlNode)xml.DocumentElement;
    }

    //构造函数
    public JXml(string xmlstring, bool hasDocumentElement = true)
        :base()
    {
        xml = new XmlDocument ();
        xml.LoadXml (xmlstring);
        node = hasDocumentElement ? (XmlNode)xml.DocumentElement : xml;
    }

    //保存到文件
    public void SaveToFile(string fileName)
    {
        System.IO.File.WriteAllText (fileName, xml.OuterXml);
    }

    //从文件中加载
    public void LoadFromFile(string fileName, bool hasDocumentElement = true)
    {
        xml.Load (fileName);
        node = hasDocumentElement ? (XmlNode)xml.DocumentElement : xml;
    }

}