winform,xml读取与写入

创建两个xml文件，一个 xml做为模板配置项，另一个做为临时接收数据。

private static string localPath = System.Environment.CurrentDirectory + @"\test\";

private static string localPathOld = System.Environment.CurrentDirectory + @"\test\YUYUE_PRINTOld.xml";
private static string localPathAdd = System.Environment.CurrentDirectory + @"\test\YUYUE_PRINT.xml";

写入方法：

string path = localPath + "/YUYUE_PRINTOld.xml";

string stu_At= "{'name': '0000899112','BarcodeRecognition': 'UPC-E','Sex': '男','Age': '27','Blood': '全血','BarCode': '210720002147','Content': '网织红细胞计数','iMode': 0}";
var docment = CustomerFormBase.Json2Xml(stu_At);
docment.Save(path);

xml读取方法：

  /// <summary>
        /// xml读取
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button2_Click(object sender, EventArgs e)
        {
            string path = localPath + "/YUYUE_PRINTOld.xml";

            string stu_At = "{\"name\":\"0000899112 宁强\",\"BarcodeRecognition\": \"UPC-E\",\"Sex\":\"男\",\"Age\": \"27\",\"Blood\": \"全血\",\"BarCode\": \"210720002147\",\"Content\": \"网织红细胞计数\",\"iMode\": 0}";
            var docment = CustomerFormBase.Json2Xml(stu_At);
            docment.Save(path);

            StringBuilder m_sbData = new StringBuilder("");
            var xmlTemporary = CustomerFormBase.XmlTemporaryFiles(localPathOld);
            var xmlConfigurationF = CustomerFormBase.XmlConfigurationFile(localPathAdd);
            bool isXml = true;
            if (xmlTemporary==null)
            {
                isXml = false;
                MessageBox.Show("xml临时文件读取失败，请查看文件是text文件夹,以及对应文件是否存在！");
            }
            if (xmlConfigurationF==null)
            {
                isXml = false;
                MessageBox.Show("xml配置文件读取失败，请查看文件是text文件夹,以及对应文件是否存在！");
            }
            List<XmlOld> xmlData = new List<XmlOld>();
            if (isXml)
            {
                bool isXmlModel = true;
                foreach (DataRow drXML in xmlConfigurationF.Rows)
                {
                    var xmlModel = new XmlOld();
                    if (decimal.TryParse(drXML["X"].ToString(), out decimal xAt))
                    {
                        xmlModel.X = xAt;
                    }
                    else
                    {
                        isXmlModel = false;
                    }
                    if (decimal.TryParse(drXML["Y"].ToString(), out decimal yAt))
                    {
                        xmlModel.Y = yAt;
                    }
                    else
                    {
                        isXmlModel = false;
                    }
                    if (!string.IsNullOrWhiteSpace(drXML["Names"].ToString()))
                    {
                        xmlModel.Names = drXML["Names"].ToString();
                        xmlModel.NameInfo = xmlTemporary.GetValueByXmlNodeName(xmlModel.Names.Trim());
                    }
                    else
                    {
                        isXmlModel = false;
                    }
                    if (isXmlModel)
                    {
                        xmlData.Add(xmlModel);
                    }
                    else
                    {
                        MessageBox.Show("X/Y/Names都为必填项不可为空，并且X/Y只能位数字");
                        break;
                    }
                    SetPagedirection(0);//设置页模式打印方向
                    SetPagestartposition(Convert.ToInt32(xmlModel.X), Convert.ToInt32(xmlModel.Y));//设置页模式数据打印起始位置
                    m_sbData = new StringBuilder(xmlModel.NameInfo);//性别
                    PrintString(m_sbData, 0);//打印字符串
                }
                if (isXmlModel)
                {
                    this.txt_Xml.Text = "读取成功";
                }
                else
                {
                    this.txt_Xml.Text = "读取失败";
                }
            }
        }

　创建一个CustomerFormBase类

  public abstract class CustomerFormBase
    {
        [JsonIgnore]
        public string ExtendData { get; set; }
        public static T Parse<T>(string v) where T : CustomerFormBase
        {
            var value = JsonConvert.DeserializeObject<T>(v);

            var xml = JsonConvert.DeserializeXmlNode(v, "root");
            value.ExtendData = xml.OuterXml;

            return value;
        }

        public static List<T> ParseToList<T>(string vs) where T : CustomerFormBase
        {
            var values = new List<T>();
            var valueStrs = JsonConvert.DeserializeObject<List<string>>(vs);
            foreach (var valueStr in valueStrs)
            {
                values.Add(Parse<T>(valueStr));
            }

            return values;

        }

        public virtual JObject ToMergedObject()
        {
            var json = "{}";

            if (!string.IsNullOrWhiteSpace(ExtendData))
            {
                var doc = new XmlDocument();
                doc.LoadXml(ExtendData);

                json = JsonConvert.SerializeXmlNode(doc, Newtonsoft.Json.Formatting.None, true);
            }

            var obj = JObject.Parse(json);
            var norObj = JObject.FromObject(this);

            obj.Merge(norObj);
            obj.Remove(nameof(ExtendData));

            return obj;
        }

        public override string ToString()
        {
            return ToMergedObject().ToString();
        }

        /// <summary>
        /// 根据xml节点获取对应的数据
        /// </summary>
        /// <param name="xmlNodeName">xml节点名称</param>
        /// <returns></returns>
        public string GetValueByXmlNodeName(string xmlNodeName)
        {
            var jObject = ToMergedObject();
            var tokenValue = jObject.SelectToken(xmlNodeName);
            if (tokenValue != null)
            {
                if (tokenValue.Type == JTokenType.Array)
                {
                    var arrayValue = tokenValue.Value<JArray>().Children();
                    return string.Join("|", arrayValue);
                }
                else
                {
                    return tokenValue.Value<string>();
                }
            }
            else
            {
                return string.Empty;
            }
        }

        /// <summary>
        /// 更新extendData的值
        /// </summary>
        /// <param name="keyValues"></param>
        /// <returns></returns>
        public bool addOrUpdateNodeValue<T>(Dictionary<string, string> keyValues) where T : CustomerFormBase
        {
            var jObject = ToMergedObject();

            foreach (var key in keyValues.Keys)
            {
                var jToken = jObject.SelectToken(key);
                if (jToken == null)
                {
                    jObject.Add(key, keyValues[key]);
                }
                else
                {
                    jObject[key] = keyValues[key];
                }
            }

            this.ExtendData = Parse<T>(jObject.ToString()).ExtendData;

            return true;
        }

        /// <summary>
        /// json字符串转换为Xml对象
        /// </summary>
        /// <param name="sJson"></param>
        /// <returns></returns>
        public static XmlDocument Json2Xml(string sJson)
        {
            JavaScriptSerializer oSerializer = new JavaScriptSerializer();
            Dictionary<string, object> Dic = (Dictionary<string, object>)oSerializer.DeserializeObject(sJson);
            XmlDocument doc = new XmlDocument();
            XmlDeclaration xmlDec;
            xmlDec = doc.CreateXmlDeclaration("1.0", "UTF-8", null);
            doc.InsertBefore(xmlDec, doc.DocumentElement);
            XmlElement nRoot = doc.CreateElement("root");
            doc.AppendChild(nRoot);
            foreach (KeyValuePair<string, object> item in Dic)
            {
                XmlElement element = doc.CreateElement(item.Key);
                KeyValue2Xml(element, item);
                nRoot.AppendChild(element);
            }
            return doc;
        }

        public static void KeyValue2Xml(XmlElement node, KeyValuePair<string, object> Source)
        {
            object kValue = Source.Value;
            if (kValue.GetType() == typeof(Dictionary<string, object>))
            {
                foreach (KeyValuePair<string, object> item in kValue as Dictionary<string, object>)
                {
                    XmlElement element = node.OwnerDocument.CreateElement(item.Key);
                    KeyValue2Xml(element, item);
                    node.AppendChild(element);
                }
            }
            else if (kValue.GetType() == typeof(object[]))
            {
                object[] o = kValue as object[];
                for (int i = 0; i < o.Length; i++)
                {
                    XmlElement xitem = node.OwnerDocument.CreateElement("Item");
                    KeyValuePair<string, object> item = new KeyValuePair<string, object>("Item", o);
                    KeyValue2Xml(xitem, item);
                    node.AppendChild(xitem);
                }

            }
            else
            {
                XmlText text = node.OwnerDocument.CreateTextNode(kValue.ToString());
                node.AppendChild(text);
            }
        }

        /// <summary>
        /// xml临时文件读取
        /// </summary>
        public static XmlOld XmlTemporaryFiles(string localPathOld)
        {
            if (!File.Exists(localPathOld))
            {
                return null;
            }
            else
            {
                var xmlModel = new XmlOld();
                XmlDocument xmlDoc = new XmlDocument();
                xmlDoc.Load(localPathOld);//读取xml文件
                XmlNode xn = xmlDoc.SelectSingleNode("root");
                var xmlText = xn.InnerXml.ToString();
                if (xmlText.Length > 0)
                {
                    xmlText = "<root>" + xmlText + "</root>";
                    xmlModel.ExtendData = xmlText;
                    return xmlModel;
                }
                else
                {
                    return null;
                }
            }
        }

        /// <summary>
        /// xml配置文件读取
        /// </summary>
        public static DataTable XmlConfigurationFile(string localPathAdd)
        {
            if (!File.Exists(localPathAdd))//若文件夹不存在则新建文件夹
            {
                return null;
            }
            else
            {
                DataSet ds = new DataSet();
                ds.ReadXml(localPathAdd);
                var xmlSet = ds.Tables["Line"];
                if (xmlSet != null)
                {
                    return xmlSet;
                }
                else
                {
                    return null;
                }
            }
        }
    }

创建XmlOld类：

 /// <summary>
    /// xml信息字段接收
    /// </summary>
    public partial class XmlOld: CustomerFormBase
    {
        /// <summary>
        /// X抽
        /// </summary>
        public decimal X { get; set; }
        /// <summary>
        /// Y抽
        /// </summary>
        public decimal Y { get; set; }
        /// <summary>
        /// 字段名称
        /// </summary>
        public string Names { get; set; }
    }