c# xml 参数读取读取的简单使用

完整使用之测试参数的读取（xml）

保存一个xml文档（如果没有就会生成一个默认的 里面的参数用的是我们默认设置的），之后每次更改里面的某项，然后保存 类似于重新刷新一遍。
这里所用的xml测试参数前面需要加上private如

        //测试单号
        private string testnum = "NO.00001";
        public string TestNum
        {
            get { return this.testnum; }
            set
            {
                this.testnum = value;
            }
        }
1
2
3
4
5
6
7
8
9
10

Program.cs

创建一个Form1对象，因为以后操作 就是用

Form1.cs

也就是在这里使用的

namespace WinFormsApp1
{
    public partial class Form1 : Form
    {

        public ArgCfgXml ArgCfgXmlObj;
        //创建一个函数 返回值就是设定的参数那个类
        public ArgValue GetTestPata()
        {
            return ArgCfgXmlObj.ArgPtr;//通过 .具体调节值的函数 来改变值
        }


        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            string path = "F:\\log\\test.xml"; ;// Directory.GetCurrentDirectory() + "\\Config\\测试参数.xml";
            ArgCfgXmlObj = new ArgCfgXml(path);
        }

        private void button2_Click(object sender, EventArgs e)
        {
            Program.mainFrm.GetTestPata().SpeedOperate = double.Parse(speedtextBox1.Text);
            Program.mainFrm.GetTestPata().TemperatureOperate = double.Parse(temptextBox2.Text);

            Program.mainFrm.ArgCfgXmlObj.SetPtr();


        }

        private void button1_Click(object sender, EventArgs e)
        {
            speedtextBox1.Text = Program.mainFrm.GetTestPata().SpeedOperate.ToString();
            temptextBox2.Text = Program.mainFrm.GetTestPata().TemperatureOperate.ToString();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

ArgCfg.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Serialization;

namespace WinFormsApp1
{
    public class ArgValue
    {
        double speed = 70;//速度初始值
        public double SpeedOperate
        {
            get { return this.speed; }
            set
            {
                this.speed = value;
            }
        }

        double temperature = 20;//温度初始值
        public double TemperatureOperate
        {
            get { return this.temperature; }
            set
            {
                this.temperature = value;
            }
        }
    }

    public class ArgCfgXml
    {
        public ArgValue argvalue;//就是上面那个类  实例化对象是在ArgPtr函数中 然后调用XmlSerializer函数
        private string xmlFile;

        //构造函数
        //作用：初始化时调用 用来配置一遍
        //如果第一次使用 也就是还没有创建这个文件 此时会使用我们设定的默认参数创建一个文件
        //如果第二次使用 就不会使用默认参数了 而是使用之后的值，也就是我们可以更改参数值
        public ArgCfgXml(string _xmlFile)
        {
            this.xmlFile = _xmlFile;
            //如果没有读到数据 则为假 此时非假就为真了 就进入语句中；
            //这也是程序运行第一遍才会做的事情，因为第二遍了 里面已经有数据了 就不会执行下面的操作    
            if (!XMLDeserialize(_xmlFile))
            {
                argvalue = new ArgValue(); //实例化一个装满参数的对象
                XmlSerializer(_xmlFile);//将设定的初始值写入 
                XMLDeserialize(_xmlFile);//取出值 方便使用
            }
        }

        //函数的作用：获取/修改参数值 并保存（覆写的）
        //返回值为ArgValue这个类的函数
        public ArgValue ArgPtr
        {
            get { return this.argvalue; }//得到一整个的数据 然后通过 .某个得到具体的值
            set
            {
                this.argvalue = value;
                XmlSerializer(xmlFile);//保存一遍
            }
        }

        //作用：保存结果，且更新现在的对象
        public void SetPtr()
        {
            //先保存 然后将保存好的数据再赋值给 argvalue
            XmlSerializer(this.xmlFile);
            XMLDeserialize(this.xmlFile);
        }


        public bool XmlSerializer(string _xmlSerializerFile)
        {
            try
            {
                if (argvalue == null)
                    argvalue = new ArgValue();
                // Insert code to set properties and fields of the object.
               // XmlSerializer 类，它可以序列化的 XML 文档，将指定类型的对象反序列化 XML文档化为指定类型的对象。
                XmlSerializer mySerializer = new XmlSerializer(typeof(ArgValue));//using System.Xml.Serialization;
                // To write to a file, create a StreamWriter object.
                StreamWriter myWriter = new StreamWriter(_xmlSerializerFile);//默认就是覆写的 如果不想覆写 就加上true
                mySerializer.Serialize(myWriter, argvalue);//序列化后写入
                myWriter.Close();//将打开的文件关闭 不然后面就无法打开 也就无法写入和读取了
            }
            catch (Exception ee)
            {
                return false;
            }
            return true;
        }
        public bool XMLDeserialize(string _xmlDeserializeFile)
        {
            try
            {
                XmlSerializer mySerializer = new XmlSerializer(typeof(ArgValue));
                // To read the file, create a FileStream.
                using (FileStream myFileStream = new FileStream(_xmlDeserializeFile, FileMode.Open))
                {
                    // Call the Deserialize method and cast to the object type.
                    argvalue = (ArgValue)mySerializer.Deserialize(myFileStream);
                }
                // Call the Deserialize method and cast to the object type.

            }
            catch
            {
                return false;
            }
            return true;
        }

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120