Detaillierte Erläuterung verschiedener Methoden zum Lesen und Schreiben von Konfigurationsdateien in .net

Heute werden wir über verschiedene Methoden zum Lesen und Schreiben von Konfigurationsdateien in .net sprechen. In diesem Blog werde ich die Lese- und Schreibvorgänge verschiedener Konfigurationsdateien vorstellen. Da der Inhalt relativ intuitiv ist, gibt es nicht zu viele leere Theorien, sondern nur echte Demonstrationscodes, und der Zweck besteht nur darin, verschiedene Szenarien in der tatsächlichen Entwicklung zu reproduzieren. Ich hoffe, es gefällt euch allen.

Normalerweise kommen wir während des .NET-Entwicklungsprozesses mit zwei Arten von Konfigurationsdateien in Kontakt: Konfigurationsdateien und XML-Dateien. Im heutigen Blog-Beispiel werden auch verschiedene Vorgänge dieser beiden Kategorien von Konfigurationsdateien vorgestellt. In der Konfigurationsdatei werde ich hauptsächlich zeigen, wie Sie Ihren eigenen benutzerdefinierten Konfigurationsknoten erstellen, und nicht die Verwendung von appSetting vorstellen.

Bitte beachten Sie: Die in diesem Artikel erwähnte Konfigurationsdatei bezieht sich speziell auf app.config oder web.config und nicht auf eine allgemeine XML-Datei. Da das .net-Framework einige Konfigurationsknoten für diese Art von Konfigurationsdatei definiert hat, können wir sie nicht einfach durch Serialisierung lesen und schreiben.

Konfigurationsdatei – benutzerdefinierter Konfigurationsknoten

Warum benötigen Sie einen benutzerdefinierten Konfigurationsknoten?

Tatsächlich verwenden viele Leute appSetting direkt, wenn sie Konfigurationsdateien verwenden, und legen dort alle Konfigurationsparameter ab, aber wenn es zu viele Parameter gibt, funktioniert dieser Ansatz nicht Es wird auch klargestellt: Auf die Konfigurationsparameterelemente in appSetting kann nur über den Schlüsselnamen zugegriffen werden, sie unterstützen keine komplexen hierarchischen Knoten und unterstützen keine starken Typen. Da sie nur diesen Satz verwenden, werden Sie Folgendes feststellen: völlig irrelevant Die Parameter sollten auch zusammengestellt werden!

Möchten Sie dieses Problem loswerden? Benutzerdefinierte Konfigurationsknoten wären eine praktikable Möglichkeit, dieses Problem zu lösen.

Schauen wir uns zunächst an, wie man einen benutzerdefinierten Konfigurationsknoten zu app.config oder web.config hinzufügt. In diesem Blog werde ich vier Möglichkeiten zum Anpassen der Knotenkonfiguration vorstellen. Die endgültige Konfigurationsdatei lautet wie folgt:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="MySection111" type="RwConfigDemo.MySection1, RwConfigDemo" />
    <section name="MySection222" type="RwConfigDemo.MySection2, RwConfigDemo" />
    <section name="MySection333" type="RwConfigDemo.MySection3, RwConfigDemo" />
    <section name="MySection444" type="RwConfigDemo.MySection4, RwConfigDemo" />
  </configSections>
 
  <MySection111 username="fish-li" url="http://www.jb51.net/"></MySection111>
 
  <MySection222>
    <users username="fish" password="liqifeng"></users>
  </MySection222>
 
  <MySection444>
    <add key="aa" value="11111"></add>
    <add key="bb" value="22222"></add>
    <add key="cc" value="33333"></add>
  </MySection444>
 
  <MySection333>
    <Command1>
      <![CDATA[
        create procedure ChangeProductQuantity(
          @ProductID int,
          @Quantity int
        )
        as
        update Products set Quantity = @Quantity 
        where ProductID = @ProductID;
      ]]>
    </Command1>
    <Command2>
      <![CDATA[
        create procedure DeleteCategory(
          @CategoryID int
        )
        as
        delete from Categories
        where CategoryID = @CategoryID;
      ]]>
    </Command2>
  </MySection333>  
</configuration>

Gleichzeitig stelle ich auch alle Beispielcodes zur Verfügung (zum Download verfügbar). Ende des Artikels) Die Schnittstelle des Demoprogramms lautet wie folgt:

Konfigurationsdatei - Eigenschaft

Schauen wir uns zunächst den einfachsten benutzerdefinierten Knoten an. Jeder Konfigurationswert existiert in Form von Attributen :

<MySection111 username="fish-li" url="http://www.php.cn/"></MySection111>

Der Implementierungscode lautet wie folgt:

public class MySection1 : ConfigurationSection
{
  [ConfigurationProperty("username", IsRequired = true)]
  public string UserName
  {
    get { return this["username"].ToString(); }
    set { this["username"] = value; }
  }
 
  [ConfigurationProperty("url", IsRequired = true)]
  public string Url
  {
    get { return this["url"].ToString(); }
    set { this["url"] = value; }
  }
}

Zusammenfassung:

1 . Passen Sie eine Klasse mit ConfigurationSection als Basisklasse an. Die im Konstruktor von ConfigurationProperty übergebene Namenszeichenfolge wird in der Konfigurationsdatei verwendet, um den Eigenschaftsnamen jedes Parameters darzustellen.

2. Um den Wert eines Attributs zu lesen und zu schreiben, müssen Sie dieses [] aufrufen, das von der Basisklasse gespeichert wird. Bitte entwerfen Sie kein Feld, um es selbst zu speichern.

3. Um den zu analysierenden Konfigurationsknoten zu verwenden, müssen Sie sich in f0c345cb8609a7447fbc7220c375eedc registrieren: 0e8695a814a38e2f86def8fe1118e99b Und bitte beachten Sie, dass name="MySection111" af8cee00c51cd6e0e68b60333e386f8f entsprechen muss.

Hinweis: Als nächstes stellen wir drei weitere Konfigurationsknoten vor. Obwohl sie etwas komplizierter sind, sind einige grundlegende Dinge mit diesem Knoten identisch, daher werde ich die Erklärung später nicht wiederholen.

config file-Element

Schauen wir uns ein komplizierteres Element an. Jedes Konfigurationselement existiert in Form von XML-Elementen:

<MySection222>
  <users username="fish" password="liqifeng"></users>
</MySection222>

Der Implementierungscode lautet wie folgt:

public class MySection2 : ConfigurationSection
{
  [ConfigurationProperty("users", IsRequired = true)]
  public MySectionElement Users
  {
    get { return (MySectionElement)this["users"]; }
  }
}
 
public class MySectionElement : ConfigurationElement
{
  [ConfigurationProperty("username", IsRequired = true)]
  public string UserName
  {
    get { return this["username"].ToString(); }
    set { this["username"] = value; }
  }
 
  [ConfigurationProperty("password", IsRequired = true)]
  public string Password
  {
    get { return this["password"].ToString(); }
    set { this["password"] = value; }
  }
}

Zusammenfassung:

1. Passen Sie eine Klasse an zu ConfigurationSection Als Basisklasse muss jedes Attribut mit [ConfigurationProperty]

2 hinzugefügt werden. Der Typ wird ebenfalls angepasst und die spezifischen Konfigurationseigenschaften werden in die Vererbungsklasse von ConfigurationElement geschrieben.

Konfigurationsdatei – CDATA

Manchmal enthalten die Konfigurationsparameter langen Text, wie zum Beispiel ein SQL-Skript oder einen HTML-Code, dann ist ein CDATA-Knoten erforderlich. Angenommen, Sie möchten eine Konfiguration implementieren, die zwei SQL-Skripte enthält:

<MySection333>
  <Command1>
    <![CDATA[
      create procedure ChangeProductQuantity(
        @ProductID int,
        @Quantity int
      )
      as
      update Products set Quantity = @Quantity
      where ProductID = @ProductID;
    ]]>
  </Command1>
  <Command2>
    <![CDATA[
      create procedure DeleteCategory(
        @CategoryID int
      )
      as
      delete from Categories
      where CategoryID = @CategoryID;
    ]]>
  </Command2>
</MySection333>

Der Implementierungscode lautet wie folgt:

public class MySection3 : ConfigurationSection
{
  [ConfigurationProperty("Command1", IsRequired = true)]
  public MyTextElement Command1
  {
    get { return (MyTextElement)this["Command1"]; }
  }
 
  [ConfigurationProperty("Command2", IsRequired = true)]
  public MyTextElement Command2
  {
    get { return (MyTextElement)this["Command2"]; }
  }
}
 
public class MyTextElement : ConfigurationElement
{
  protected override void DeserializeElement(System.Xml.XmlReader reader, bool serializeCollectionKey)
  {
    CommandText = reader.ReadElementContentAs(typeof(string), null) as string;
  }
  protected override bool SerializeElement(System.Xml.XmlWriter writer, bool serializeCollectionKey)
  {
    if( writer != null )
      writer.WriteCData(CommandText);
    return true;
  }
 
  [ConfigurationProperty("data", IsRequired = false)]
  public string CommandText
  {
    get { return this["data"].ToString(); }
    set { this["data"] = value; }
  }
}

Zusammenfassung:

1 Zur Implementierung können Sie sich im Allgemeinen auf MySection2 beziehen,

2 Lesen und schreiben Sie jedes ConfigurationElement-XML, das heißt, die Methode SerializeElement, DeserializeElement überladen

Konfigurationsdatei - Sammlung

<MySection444>
  <add key="aa" value="11111"></add>
  <add key="bb" value="22222"></add>
  <add key="cc" value="33333"></add>
</MySection444>

Das ist ähnlich Konfigurationsmethode, in ASP.NETs HttpHandler und HttpModule sind zu häufig. Möchten Sie wissen, wie man sie implementiert? Der Code lautet wie folgt:

Zusammenfassung:

1 Erstellen Sie eine abgeleitete Klasse, die von ConfigurationElement für jedes Parameterelement in der Sammlung erbt, siehe MySection1

2. Erstellen Sie eine Sammlungsklasse, die von ConfigurationElementCollection für die Sammlung erbt. Die spezifische Implementierung besteht darin, die Basisklassenmethode aufzurufen.

3. Erstellen Sie beim Erstellen der geerbten Klasse von ConfigurationSection einfach eine Eigenschaft, die die Sammlung darstellt. Achten Sie auf die Parameter von [ConfigurationProperty].

Konfigurationsdatei – Lesen und Schreiben

Zuvor habe ich die Implementierungsklassen von 4 benutzerdefinierten Konfigurationsknoten nacheinander vorgestellt. Schauen wir uns an, wie man sie liest und schreibt.

Konfigurationsparameter lesen:

MySection1 mySectioin1 = (MySection1)ConfigurationManager.GetSection("MySection111");
txtUsername1.Text = mySectioin1.UserName;
txtUrl1.Text = mySectioin1.Url;
 
 
MySection2 mySectioin2 = (MySection2)ConfigurationManager.GetSection("MySection222");
txtUsername2.Text = mySectioin2.Users.UserName;
txtUrl2.Text = mySectioin2.Users.Password;
 
 
MySection3 mySection3 = (MySection3)ConfigurationManager.GetSection("MySection333");
txtCommand1.Text = mySection3.Command1.CommandText.Trim();
txtCommand2.Text = mySection3.Command2.CommandText.Trim();
 
 
MySection4 mySection4 = (MySection4)ConfigurationManager.GetSection("MySection444");
txtKeyValues.Text = string.Join("\r\n",
            (from kv in mySection4.KeyValues.Cast<MyKeyValueSetting>()
             let s = string.Format("{0}={1}", kv.Key, kv.Value)
             select s).ToArray());

Zusammenfassung: Beim Lesen eines benutzerdefinierten Knotens müssen wir ConfigurationManager.GetSection() aufrufen. Holen Sie sich die Konfigurationsknoten, konvertieren Sie ihn in die von uns definierte Konfigurationsknotenklasse und greifen Sie dann stark typisiert darauf zu.

写配置文件：

Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
 
MySection1 mySectioin1 = config.GetSection("MySection111") as MySection1;
mySectioin1.UserName = txtUsername1.Text.Trim();
mySectioin1.Url = txtUrl1.Text.Trim();
 
MySection2 mySection2 = config.GetSection("MySection222") as MySection2;
mySection2.Users.UserName = txtUsername2.Text.Trim();
mySection2.Users.Password = txtUrl2.Text.Trim();
 
MySection3 mySection3 = config.GetSection("MySection333") as MySection3;
mySection3.Command1.CommandText = txtCommand1.Text.Trim();
mySection3.Command2.CommandText = txtCommand2.Text.Trim();
 
MySection4 mySection4 = config.GetSection("MySection444") as MySection4;
mySection4.KeyValues.Clear();
 
(from s in txtKeyValues.Lines
   let p = s.IndexOf('=')
   where p > 0
   select new MyKeyValueSetting { Key = s.Substring(0, p), Value = s.Substring(p + 1) }
).ToList()
.ForEach(kv => mySection4.KeyValues.Add(kv));
 
config.Save();

   

小结：在修改配置节点前，我们需要调用ConfigurationManager.OpenExeConfiguration()，然后调用config.GetSection()在得到节点后，转成我们定义的节点类型， 然后就可以按照强类型的方式来修改我们定义的各参数项，最后调用config.Save();即可。

注意：

1. .net为了优化配置节点的读取操作，会将数据缓存起来，如果希望使用修改后的结果生效，您还需要调用ConfigurationManager.RefreshSection(".....")

2. 如果是修改web.config，则需要使用 WebConfigurationManager

读写 .net framework中已经定义的节点

前面一直在演示自定义的节点，那么如何读取.net framework中已经定义的节点呢？

假如我想读取下面配置节点中的发件人。

<system.net>
  <mailSettings>
    <smtp from="Fish.Q.Li@newegg.com">
      <network />
    </smtp>
  </mailSettings>
</system.net>

   

读取配置参数：

SmtpSection section = ConfigurationManager.GetSection("system.net/mailSettings/smtp") as SmtpSection;
labMailFrom.Text = "Mail From: " + section.From;

   

写配置文件：

Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
 
SmtpSection section = config.GetSection("system.net/mailSettings/smtp") as SmtpSection;
section.From = "Fish.Q.Li@newegg.com2";
 
config.Save();

   

xml配置文件

前面演示在config文件中创建自定义配置节点的方法，那些方法也只适合在app.config或者web.config中，如果您的配置参数较多， 或者打算将一些数据以配置文件的形式单独保存，那么，直接读写整个XML将会更方便。 比如：我有一个实体类，我想将它保存在XML文件中，有可能是多条记录，也可能是一条。

这次我来反过来说，假如我们先定义了XML的结构，是下面这个样子的，那么我将怎么做呢？ 

<?xml version="1.0" encoding="utf-8"?>
<ArrayOfMyCommand xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns:xsd="http://www.w3.org/2001/XMLSchema">
 <MyCommand Name="InsretCustomer" Database="MyTestDb">
  <Parameters>
   <Parameter Name="Name" Type="DbType.String" />
   <Parameter Name="Address" Type="DbType.String" />
  </Parameters>
  <CommandText>insret into .....</CommandText>
 </MyCommand>
</ArrayOfMyCommand>

   

对于上面的这段XML结构，我们可以在C#中先定义下面的类，然后通过序列化及反序列化的方式来实现对它的读写。

C#类的定义如下：

public class MyCommand
{
  [XmlAttribute("Name")]
  public string CommandName;
 
  [XmlAttribute]
  public string Database;
 
  [XmlArrayItem("Parameter")]
  public List<MyCommandParameter> Parameters = new List<MyCommandParameter>();
 
  [XmlElement]
  public string CommandText;
}
 
public class MyCommandParameter
{
  [XmlAttribute("Name")]
  public string ParamName;
 
  [XmlAttribute("Type")]
  public string ParamType;
}

   

有了这二个C#类，读写这段XML就非常容易了。以下就是相应的读写代码：

   
private void btnReadXml_Click(object sender, EventArgs e)
{
  btnWriteXml_Click(null, null);
   
  List<MyCommand> list = XmlHelper.XmlDeserializeFromFile<List<MyCommand>>(XmlFileName, Encoding.UTF8);
 
  if( list.Count > 0 )
    MessageBox.Show(list[0].CommandName + ": " + list[0].CommandText,
      this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
 
}
 
private void btnWriteXml_Click(object sender, EventArgs e)
{
  MyCommand command = new MyCommand();
  command.CommandName = "InsretCustomer";
  command.Database = "MyTestDb";
  command.CommandText = "insret into .....";
  command.Parameters.Add(new MyCommandParameter { ParamName = "Name", ParamType = "DbType.String" });
  command.Parameters.Add(new MyCommandParameter { ParamName = "Address", ParamType = "DbType.String" });
 
  List<MyCommand> list = new List<MyCommand>(1);
  list.Add(command);
 
  XmlHelper.XmlSerializeToFile(list, XmlFileName, Encoding.UTF8);
}

   

小结：

1. 读写整个XML最方便的方法是使用序列化反序列化。

2. 如果您希望某个参数以Xml Property的形式出现，那么需要使用[XmlAttribute]修饰它。

3. 如果您希望某个参数以Xml Element的形式出现，那么需要使用[XmlElement]修饰它。

4. 如果您希望为某个List的项目指定ElementName，则需要[XmlArrayItem]

5. 以上3个Attribute都可以指定在XML中的映射别名。

6. 写XML的操作是通过XmlSerializer.Serialize()来实现的。

7. 读取XML文件是通过XmlSerializer.Deserialize来实现的。

8. List或Array项，请不要使用[XmlElement]，否则它们将以内联的形式提升到当前类，除非你再定义一个容器类。

XmlHelper的实现如下： 

public static class XmlHelper
{
  private static void XmlSerializeInternal(Stream stream, object o, Encoding encoding)
  {
    if( o == null )
      throw new ArgumentNullException("o");
    if( encoding == null )
      throw new ArgumentNullException("encoding");
 
    XmlSerializer serializer = new XmlSerializer(o.GetType());
 
    XmlWriterSettings settings = new XmlWriterSettings();
    settings.Indent = true;
    settings.NewLineChars = "\r\n";
    settings.Encoding = encoding;
    settings.IndentChars = "  ";
 
    using( XmlWriter writer = XmlWriter.Create(stream, settings) ) {
      serializer.Serialize(writer, o);
      writer.Close();
    }
  }
 
  /// <summary>
  /// 将一个对象序列化为XML字符串
  /// </summary>
  /// <param name="o">要序列化的对象</param>
  /// <param name="encoding">编码方式</param>
  /// <returns>序列化产生的XML字符串</returns>
  public static string XmlSerialize(object o, Encoding encoding)
  {
    using( MemoryStream stream = new MemoryStream() ) {
      XmlSerializeInternal(stream, o, encoding);
 
      stream.Position = 0;
      using( StreamReader reader = new StreamReader(stream, encoding) ) {
        return reader.ReadToEnd();
      }
    }
  }
 
  /// <summary>
  /// 将一个对象按XML序列化的方式写入到一个文件
  /// </summary>
  /// <param name="o">要序列化的对象</param>
  /// <param name="path">保存文件路径</param>
  /// <param name="encoding">编码方式</param>
  public static void XmlSerializeToFile(object o, string path, Encoding encoding)
  {
    if( string.IsNullOrEmpty(path) )
      throw new ArgumentNullException("path");
 
    using( FileStream file = new FileStream(path, FileMode.Create, FileAccess.Write) ) {
      XmlSerializeInternal(file, o, encoding);
    }
  }
 
  /// <summary>
  /// 从XML字符串中反序列化对象
  /// </summary>
  /// <typeparam name="T">结果对象类型</typeparam>
  /// <param name="s">包含对象的XML字符串</param>
  /// <param name="encoding">编码方式</param>
  /// <returns>反序列化得到的对象</returns>
  public static T XmlDeserialize<T>(string s, Encoding encoding)
  {
    if( string.IsNullOrEmpty(s) )
      throw new ArgumentNullException("s");
    if( encoding == null )
      throw new ArgumentNullException("encoding");
 
    XmlSerializer mySerializer = new XmlSerializer(typeof(T));
    using( MemoryStream ms = new MemoryStream(encoding.GetBytes(s)) ) {
      using( StreamReader sr = new StreamReader(ms, encoding) ) {
        return (T)mySerializer.Deserialize(sr);
      }
    }
  }
 
  /// <summary>
  /// 读入一个文件，并按XML的方式反序列化对象。
  /// </summary>
  /// <typeparam name="T">结果对象类型</typeparam>
  /// <param name="path">文件路径</param>
  /// <param name="encoding">编码方式</param>
  /// <returns>反序列化得到的对象</returns>
  public static T XmlDeserializeFromFile<T>(string path, Encoding encoding)
  {
    if( string.IsNullOrEmpty(path) )
      throw new ArgumentNullException("path");
    if( encoding == null )
      throw new ArgumentNullException("encoding");
 
    string xml = File.ReadAllText(path, encoding);
    return XmlDeserialize<T>(xml, encoding);
  }
}

   

xml配置文件 - CDATA

在前面的演示中，有个不完美的地方，我将SQL脚本以普通字符串的形式输出到XML中了：

<CommandText>insret into .....</CommandText>

   

显然，现实中的SQL脚本都是比较长的，而且还可能会包含一些特殊的字符，这种做法是不可取的，好的处理方式应该是将它以CDATA的形式保存， 为了实现这个目标，我们就不能直接按照普通字符串的方式来处理了，这里我定义了一个类 MyCDATA： 

public class MyCDATA : IXmlSerializable
{
  private string _value;
 
  public MyCDATA() { }
 
  public MyCDATA(string value)
  {
    this._value = value;
  }
 
  public string Value
  {
    get { return _value; }
  }
 
  XmlSchema IXmlSerializable.GetSchema()
  {
    return null;
  }
 
  void IXmlSerializable.ReadXml(XmlReader reader)
  {
    this._value = reader.ReadElementContentAsString();
  }
 
  void IXmlSerializable.WriteXml(XmlWriter writer)
  {
    writer.WriteCData(this._value);
  }
 
  public override string ToString()
  {
    return this._value;
  }
 
  public static implicit operator MyCDATA(string text)
  {
    return new MyCDATA(text);
  }
}

   

我将使用这个类来控制CommandText在XML序列化及反序列化的行为，让它写成一个CDATA形式， 因此，我还需要修改CommandText的定义，改成这个样子：

public MyCDATA CommandText;

   

最终，得到的结果是：

<?xml version="1.0" encoding="utf-8"?>
<ArrayOfMyCommand xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns:xsd="http://www.w3.org/2001/XMLSchema">
 <MyCommand Name="InsretCustomer" Database="MyTestDb">
  <Parameters>
   <Parameter Name="Name" Type="DbType.String" />
   <Parameter Name="Address" Type="DbType.String" />
  </Parameters>
  <CommandText><![CDATA[insret into .....]]></CommandText>
 </MyCommand>
</ArrayOfMyCommand>

   

xml文件读写注意事项

通常，我们使用使用XmlSerializer.Serialize()得到的XML字符串的开头处，包含一段XML声明元素：

<?xml version="1.0" encoding="utf-8"?>

   

由于各种原因，有时候可能不需要它。为了让这行字符消失，我见过有使用正则表达式去删除它的，也有直接分析字符串去删除它的。 这些方法，要么浪费程序性能，要么就要多写些奇怪的代码。总之，就是看起来很别扭。 其实，我们可以反过来想一下：能不能在序列化时，不输出它呢？ 不输出它，不就达到我们期望的目的了吗？

在XML序列化时，有个XmlWriterSettings是用于控制写XML的一些行为的，它有一个OmitXmlDeclaration属性，就是专门用来控制要不要输出那行XML声明的。 而且，这个XmlWriterSettings还有其它的一些常用属性。请看以下演示代码： 

using( MemoryStream stream = new MemoryStream() ) {
  XmlWriterSettings settings = new XmlWriterSettings();
  settings.Indent = true;
  settings.NewLineChars = "\r\n";
  settings.OmitXmlDeclaration = true;
  settings.IndentChars = "\t";
 
  XmlWriter writer = XmlWriter.Create(stream, settings);

   

使用上面这段代码，我可以：

1. 不输出XML声明。

2. 指定换行符。

3. 指定缩进字符。

如果不使用这个类，恐怕还真的不能控制XmlSerializer.Serialize()的行为。

Die Methode zum Lesen und Schreiben von XML wurde bereits früher eingeführt, aber wie fange ich an? Da keine XML-Datei vorhanden ist, kann das Programm sie nicht lesen. Wie erhält man also eine XML-Datei im richtigen Format? Die Antwort lautet: Schreiben Sie zuerst den Code, erstellen Sie ein zu lesendes Objekt, geben Sie einige Junk-Daten ein und schreiben Sie sie dann in XML (Deserialisierung). Anschließend können wir auf das spezifische Format der generierten XML-Datei verweisen oder andere Knoten hinzufügen (Liste) oder ändern Sie die oben genannten Junk-Daten und erhalten Sie schließlich eine verwendbare XML-Datei mit dem richtigen Format.

Empfohlene Möglichkeiten zum Speichern von Konfigurationsparametern

Es wird häufig festgestellt, dass es viele Komponenten oder Frameworks gibt, die Konfigurationsparameter gerne in Konfigurationsdateien ablegen. Diese Designer denken möglicherweise, dass die Parameter ihrer Arbeiten dies sind komplizierter und erstellt auch gerne benutzerdefinierte Konfigurationsknoten. Das Ergebnis ist: viele Konfigurationsparameter in der Konfigurationsdatei. Das Schwierigste ist: Wenn andere Projekte dieses Ding das nächste Mal verwenden möchten, müssen Sie es weiter konfigurieren!

.net hat sich immer für XCOPY eingesetzt, aber ich habe festgestellt, dass es nicht viele Komponenten oder Frameworks gibt, die dieser Konvention entsprechen. Daher möchte ich beim Entwerfen von Komponenten oder Frameworks Folgendes vorschlagen:

1. Diese Art der Konfiguration ist wirklich umständlich [Wiederverwendung].

2. Ob die Parameter gleichzeitig in Form von Konfigurationsdateien und API-Schnittstellen offengelegt werden können, ist dem Benutzer überlassen, wie er die Konfigurationsparameter speichert.

Der Unterschied zwischen Konfigurationsdateien und XML-Dateien

Im Wesentlichen sind Konfigurationsdateien auch XML-Dateien, aber sie unterscheiden sich ein wenig, nicht nur, weil das .net-Framework viele Konfigurationsdateien im Konfigurationsabschnitt vordefiniert. Wenn wir für ASP.NET-Anwendungen Parameter in web.config einfügen, wird die Website neu gestartet, solange web.config geändert wird. Dies hat einen Vorteil: Unser Code kann immer mit den neuesten Parametern aktualisiert werden laufen. Andererseits gibt es auch einen Nachteil: Möglicherweise möchten wir aus verschiedenen Gründen keinen Neustart der Website. Schließlich wird der Neustart der Website einige Zeit in Anspruch nehmen, was sich auf die Reaktion der Website auswirkt. Zu dieser Funktion kann ich nur sagen, dass web.config auf keinen Fall so ist.

Wenn wir jedoch XML verwenden, ist es offensichtlich, dass wir die oben genannten Funktionen nicht direkt erhalten können. Weil die XML-Datei von uns selbst gepflegt wird.

Haben Sie an dieser Stelle jemals darüber nachgedacht: Wie kann ich diese Vorteile bei der Verwendung von XML nutzen?

Ich hoffe, dass das Programm sofort mit den neuesten Parametern ausgeführt werden kann, nachdem der Benutzer die Konfigurationsdatei geändert hat, ohne die Website erneut aufrufen zu müssen.

Alle Beispielcodes für diesen Artikel können hier heruntergeladen werden. Demo

Das Obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, dass er zum Lernen aller beiträgt. Ich hoffe auch, dass jeder die PHP-Chinesisch-Website unterstützt.

Ausführlichere Erklärungen zu verschiedenen Methoden zum Lesen und Schreiben von Konfigurationsdateien in .net finden Sie auf der chinesischen PHP-Website für verwandte Artikel!