Revit二次開發之讀取配置文件App.config 基礎操作（一）

版本：

VS2015

Revit2018

功能缺點：

沒有涉及sectionGroup的讀寫操作。

  <configSections>
    <sectionGroup name="Group">
      <section name="COp" type="System.Configuration.AppSettingsSection"/>
    </sectionGroup>
  </configSections>

參考文章：

https://www.cnblogs.com/durow/p/4840672.html

 

實現效果：生成並讀取了配置文件的內容

 

App.config

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <startup>
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/>
  </startup>
</configuration>

 

CfT.cs

 

using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Autodesk.Revit.DB;
using Autodesk.Revit.UI;
using Autodesk.Revit.UI.Selection;
using Autodesk.Revit.Attributes;
using Autodesk.Revit.UI.Events;
using System.Windows.Forms;
using System.Reflection;

namespace ConfigTest
{
    [Autodesk.Revit.Attributes.Transaction(Autodesk.Revit.Attributes.TransactionMode.Manual)]
    [Autodesk.Revit.Attributes.Regeneration(Autodesk.Revit.Attributes.RegenerationOption.Manual)]
    [Autodesk.Revit.Attributes.Journaling(Autodesk.Revit.Attributes.JournalingMode.NoCommandData)]
    public class CfT : IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
        {
            //創建或載入配置文件
            var config = ConfigFile.LoadOrCreateFile("config.test");

            //使用帶參數的屬性快速保存配置信息
            config["string"] = "這是一條文本記錄";
            //使用帶參數的屬性快速保存非字符串
            config["intX"] = 45.ToString();
            config["Date"] = DateTime.Now.ToString();
            //保存配置信息的一般方式
            config.AddOrSetConfigValue("intY", 88);
            config.AddOrSetConfigValue("bool", true);

            //讀取特定類型的數據
            var x = config.GetConfigValueInt("intX");
            //使用TryParse類方法讀取特定類型的數據
            int y;
            config.TryParseConfigValue("intY", out y);
            DateTime dt;
            config.TryParseConfigValue("Date", out dt);
            //使用GetConfigValueXXX方法讀取特定類型的數據
            bool b = config.GetConfigValueBool("bool");
            var c = x + y;//45+88=133

            //字符串類型數據直接讀取
            TaskDialog.Show("讀取結果", config["string"] + "\n" + c + "\n" + b + "\n" + dt);

            return Result.Succeeded;
        }

    }
}

 

ConfigFile.cs

 

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

namespace ConfigTest
{
    public class ConfigFile
    {

        protected readonly string configBasePath = "Root/Config";

        /// <summary>
        /// 當前配置文件的完整路徑
        /// </summary>
        public string FileName { get; private set; }

        /// <summary>
        /// 獲取或設置配置
        /// </summary>
        /// <param name="key">鍵名</param>
        /// <returns>鍵名對應的值</returns>
        public string this[string key]
        {
            get
            {
                return GetConfigValue(key);
            }
            set
            {
                AddOrSetConfigValue(key, value);
            }
        }

        /// <summary>
        /// 構造函數
        /// </summary>
        protected ConfigFile()
        {
        }

        /// <summary>
        /// 讀取配置文件
        /// </summary>
        /// <param name="filename">配置文件名</param>
        /// <returns>ConfigFile對象</returns>
        public static ConfigFile LoadFile(string filename)
        {
            if (!File.Exists(filename)) return null;
            return new ConfigFile { FileName = filename };
        }

        /// <summary>
        /// 讀取或創建配置文件
        /// </summary>
        /// <param name="filename">配置文件名</param>
        /// <returns>ConfigFile對象</returns>
        public static ConfigFile LoadOrCreateFile(string filename)
        {
            if (!File.Exists(filename))
            {
                var config = new ConfigFile { FileName = filename };
                config.CreateFile();
                return config;
            }
            return LoadFile(filename);
        }

        /// <summary>
        /// 創建配置文件，可在子類中重寫此方法
        /// </summary>
        protected virtual void CreateFile()
        {
            XmlDocument doc = new XmlDocument();
            XmlDeclaration dec = doc.CreateXmlDeclaration("1.0", "UTF-8", null);
            doc.AppendChild(dec);
            XmlElement root = doc.CreateElement("Root");
            doc.AppendChild(root);
            root.AppendChild(doc.CreateElement("Config"));
            doc.Save(FileName);
        }

        /// <summary>
        /// 根據Key從配置文件中獲取值
        /// </summary>
        /// <param name="key">鍵名</param>
        /// <returns>獲取的值，找不到返回""</returns>
        public string GetConfigValue(string key)
        {
            return GetKeyValue($"{configBasePath}/{key}");
        }

        /// <summary>
        /// 從配置文件中根據key獲取值並轉化爲相應數據類型
        /// </summary>
        /// <param name="key">鍵名</param>
        /// <param name="result">轉化後的值</param>
        /// <returns>轉化是否成功</returns>
        public bool TryParseConfigValue(string key, out int result)
        {
            var v = GetConfigValue(key);
            return int.TryParse(v, out result);
        }

        /// <summary>
        /// 從配置文件中根據key獲取值並轉化爲相應數據類型
        /// </summary>
        /// <param name="key">鍵名</param>
        /// <param name="result">轉化後的值</param>
        /// <returns>轉化是否成功</returns>
        public bool TryParseConfigValue(string key, out bool result)
        {
            var v = GetConfigValue(key);
            return bool.TryParse(v, out result);
        }

        /// <summary>
        /// 從配置文件中根據key獲取值並轉化爲相應數據類型
        /// </summary>
        /// <param name="key">鍵名</param>
        /// <param name="result">轉化後的值</param>
        /// <returns>轉化是否成功</returns>
        public bool TryParseConfigValue(string key, out DateTime result)
        {
            var v = GetConfigValue(key);
            return DateTime.TryParse(v, out result);
        }

        /// <summary>
        /// 從配置文件中根據key獲取值並轉化爲相應數據類型
        /// </summary>
        /// <param name="key">鍵名</param>
        /// <param name="result">轉化後的值</param>
        /// <returns>轉化是否成功</returns>
        public bool TryParseConfigValue(string key, out float result)
        {
            var v = GetConfigValue(key);
            return float.TryParse(v, out result);
        }

        /// <summary>
        /// 從配置文件中根據key獲取值並轉化爲相應數據類型
        /// </summary>
        /// <param name="key">鍵名</param>
        /// <param name="result">轉化後的值</param>
        /// <returns>轉化是否成功</returns>
        public bool TryParseConfigValue(string key, out double result)
        {
            var v = GetConfigValue(key);
            return double.TryParse(v, out result);
        }

        /// <summary>
        /// 從配置文件中根據key獲取值並轉化爲相應數據類型
        /// </summary>
        /// <param name="key">鍵名</param>
        /// <param name="result">轉化後的值</param>
        /// <returns>轉化是否成功</returns>
        public bool TryParseConfigValue(string key, out decimal result)
        {
            var v = GetConfigValue(key);
            return decimal.TryParse(v, out result);
        }

        /// <summary>
        /// 在配置文件中根據key取出值並轉化爲int類型
        /// </summary>
        /// <param name="key"></param>
        /// <returns>返回的值</returns>
        public int GetConfigValueInt(string key)
        {
            var v = GetConfigValue(key);
            return int.Parse(v);
        }

        /// <summary>
        /// 在配置文件中根據key取出值並轉化爲bool類型
        /// </summary>
        /// <param name="key"></param>
        /// <returns>返回的值</returns>
        public bool GetConfigValueBool(string key)
        {
            var v = GetConfigValue(key);
            return bool.Parse(v);
        }

        /// <summary>
        /// 在配置文件中根據key取出值並轉化爲float類型
        /// </summary>
        /// <param name="key"></param>
        /// <returns>返回的值</returns>
        public float GetConfigValueFloat(string key)
        {
            var v = GetConfigValue(key);
            return float.Parse(v);
        }

        /// <summary>
        /// 在配置文件中根據key取出值並轉化爲double類型
        /// </summary>
        /// <param name="key"></param>
        /// <returns>返回的值</returns>
        public double GetConfigValueDouble(string key)
        {
            var v = GetConfigValue(key);
            return double.Parse(v);
        }

        /// <summary>
        /// 在配置文件中根據key取出值並轉化爲DateTime類型
        /// </summary>
        /// <param name="key"></param>
        /// <returns>返回的值</returns>
        public DateTime GetConfigValueDateTime(string key)
        {
            var v = GetConfigValue(key);
            return DateTime.Parse(v);
        }

        /// <summary>
        /// 在配置文件中根據key取出值並轉化爲decimal類型
        /// </summary>
        /// <param name="key"></param>
        /// <returns>返回的值</returns>
        public decimal GetConfigValueDecimal(string key)
        {
            var v = GetConfigValue(key);
            return decimal.Parse(v);
        }

        /// <summary>
        /// 修改Key對應的值，如果Key不存在則添加後存入值
        /// </summary>
        /// <param name="key">Key</param>
        /// <param name="value">要存入的值</param>
        public void AddOrSetConfigValue(string key, string value)
        {
            AddOrSetKeyValue(configBasePath, key, value);
        }

        /// <summary>
        /// 保存key/value鍵值對，對於非string類型會調用ToString()方法
        /// </summary>
        /// <typeparam name="T">要保存的值的類型</typeparam>
        /// <param name="key">要保存的鍵名</param>
        /// <param name="value">要保存的值</param>
        public void AddOrSetConfigValue<T>(string key, T value)
        {
            var v = value.ToString();
            AddOrSetConfigValue(key, v);
        }

        /// <summary>
        /// 保存key/value鍵值對
        /// </summary>
        /// <param name="basePath">要保存的根節點路徑</param>
        /// <param name="key">要保存的鍵名</param>
        /// <param name="value">要保存的值</param>
        public void AddOrSetKeyValue(string basePath, string key, string value)
        {
            var doc = GetXmlDocument();
            var node = doc.SelectSingleNode($"{basePath}/{key}");
            if (node == null)
            {
                node = doc.CreateElement(key);
                doc.SelectSingleNode(basePath).AppendChild(node);
            }
            node.InnerText = value;
            doc.Save(FileName);
        }

        /// <summary>
        /// 根據xpath獲取值
        /// </summary>
        /// <param name="xpath">要獲取的路徑</param>
        /// <returns>獲取的值</returns>
        public string GetKeyValue(string xpath)
        {
            var doc = GetXmlDocument();
            var node = doc.SelectSingleNode(xpath);
            return node?.InnerText ?? "";
        }

        /// <summary>
        /// 刪除Key以及對應的值
        /// </summary>
        /// <param name="key">Key</param>
        public void DeleteConfigKey(string key)
        {
            var doc = GetXmlDocument();
            var node = doc.SelectSingleNode($"{configBasePath}/{key}");
            if (node == null) return;
            doc.SelectSingleNode("Root/Config")?.RemoveChild(node);
            doc.Save(FileName);
        }

        /// <summary>
        /// 讀取XML文檔
        /// </summary>
        /// <returns></returns>
        private XmlDocument GetXmlDocument()
        {
            var doc = new XmlDocument();
            doc.Load(FileName);
            return doc;
        }
    }
}