Explication détaillée des différentes méthodes de lecture et d'écriture de fichiers de configuration dans .net

Aujourd'hui, nous parlerons de différentes méthodes de lecture et d'écriture de fichiers de configuration en .net. Dans ce blog, je présenterai les opérations de lecture et d'écriture de divers fichiers de configuration. Parce que le contenu est relativement intuitif, il n'y a pas trop de théories vides, seulement de vrais codes de démonstration, et le but est uniquement de reproduire divers scénarios dans le développement réel. J'espère que vous l'aimerez tous.

Habituellement, lors du processus de développement .NET, nous entrerons en contact avec deux types de fichiers de configuration : les fichiers de configuration et les fichiers XML. L'exemple de blog d'aujourd'hui présentera également diverses opérations de ces deux catégories de fichiers de configuration. Dans le fichier de configuration, je montrerai principalement comment créer votre propre nœud de configuration personnalisé, plutôt que de présenter comment utiliser appSetting.

Veuillez noter : le fichier de configuration mentionné dans cet article fait spécifiquement référence à app.config ou web.config, et non à un fichier XML général. Dans ce type de fichier de configuration, puisque le framework .net a défini certains nœuds de configuration pour eux, nous ne pouvons pas simplement le lire et l'écrire via la sérialisation.

fichier de configuration - nœud de configuration personnalisé

Pourquoi avez-vous besoin d'un nœud de configuration personnalisé ?

En effet, de nombreuses personnes utilisent appSetting directement lorsqu'elles utilisent des fichiers de configuration et y mettent tous les paramètres de configuration. Bien que ce soit une bonne chose, mais s'il y a trop de paramètres, cette approche ne fonctionnera pas. seront également clairement exposés : les éléments de paramètres de configuration dans appSetting ne sont accessibles que par nom de clé, ne peuvent pas prendre en charge les nœuds hiérarchiques complexes et ne prennent pas en charge les types forts, et comme ils utilisent uniquement cet ensemble, vous trouverez : complètement hors de propos. Les paramètres doivent également être mis ensemble!

Vous voulez vous débarrasser de ce problème ? Les nœuds de configuration personnalisés seraient un moyen réalisable de résoudre ce problème.

Tout d'abord, voyons comment ajouter un nœud de configuration personnalisé à app.config ou web.config. Dans ce blog, je présenterai 4 façons de personnaliser la configuration des nœuds. Le fichier de configuration final est le suivant :

<?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>

En même temps, je fournis également tous les exemples de codes (disponibles en téléchargement sur le site). fin de l'article), l'interface du programme de démonstration est la suivante :

fichier de configuration - Propriété

Regardons d'abord le nœud personnalisé le plus simple. Chaque valeur de configuration existe sous forme d'attributs. :

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

Le code d'implémentation est le suivant :

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; }
  }
}

Résumé :

1 . Personnalisez une classe avec ConfigurationSection comme classe de base. Chaque propriété doit être ajoutée avec [ConfigurationProperty]. La chaîne de nom passée dans le constructeur de ConfigurationProperty sera utilisée dans le fichier de configuration pour représenter le nom de propriété de chaque paramètre.

2. Pour lire et écrire la valeur d'un attribut, vous devez appeler this[], qui est enregistré par la classe de base. Veuillez ne pas concevoir de champ pour le sauvegarder vous-même.

3. Afin d'utiliser le nœud de configuration à analyser, vous devez vous inscrire dans f0c345cb8609a7447fbc7220c375eedc : 0e8695a814a38e2f86def8fe1118e99b , Et veuillez noter que name="MySection111" doit correspondre à af8cee00c51cd6e0e68b60333e386f8f.

Remarque : Nous présenterons ensuite trois autres nœuds de configuration, bien qu'ils soient un peu plus compliqués, certaines choses de base sont les mêmes que ce nœud, je ne répéterai donc pas l'explication plus tard.

fichier-élément de configuration

Regardons un élément plus compliqué. Chaque élément de configuration existe sous la forme d'éléments XML :

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

Le code d'implémentation est le suivant :

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; }
  }
}

Résumé :

1. Personnaliser une classe. à ConfigurationSection En tant que classe de base, chaque attribut doit être ajouté avec [ConfigurationProperty]

2. Le type est également personnalisé et les propriétés de configuration spécifiques sont écrites dans la classe d'héritage de ConfigurationElement.

fichier de configuration - CDATA

Parfois, les paramètres de configuration contiennent du texte long, comme un script SQL ou un code HTML, alors un nœud CDATA est nécessaire. Supposons que vous souhaitiez implémenter une configuration comprenant deux scripts SQL :

<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>

Le code d'implémentation est le suivant :

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; }
  }
}

Résumé :

1 Pour la mise en œuvre, vous pouvez généralement vous référer à MySection2,

2. lire et écrire chaque ConfigurationElement XML, c'est-à-dire surcharger la méthode SerializeElement, DeserializeElement

fichier de configuration - Collection

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

Ce similaire méthode de configuration, dans ASP.NET, HttpHandler et HttpModule sont trop courants. Voulez-vous savoir comment les implémenter ? Le code est le suivant :

Résumé :

1 Créez une classe dérivée qui hérite de ConfigurationElement pour chaque élément de paramètre de la collection, veuillez vous référer à MySection1

2. Créez une classe de collection qui hérite de ConfigurationElementCollection pour la collection. L'implémentation spécifique consiste à appeler la méthode de classe de base.

3. Lors de la création de la classe héritée de ConfigurationSection, créez simplement une propriété représentant la collection. Faites attention aux paramètres de [ConfigurationProperty].

fichier de configuration - lecture et écriture

Plus tôt, j'ai présenté les classes d'implémentation des quatre nœuds de configuration personnalisés un par un. Voyons comment les lire et les écrire.

Lire les paramètres de configuration :

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());

Résumé : Lors de la lecture d'un nœud personnalisé, nous devons appeler ConfigurationManager.GetSection() Obtenez le nœud de configuration et convertissez-le dans la classe de nœud de configuration que nous avons définie, puis accédez-y de manière fortement typée.

写配置文件：

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()的行为。

La méthode de lecture et d'écriture XML a été introduite plus tôt, mais par où commencer ? Puisqu’il n’y a pas de fichier XML, le programme ne peut pas le lire, alors comment obtenir un XML au bon format ? La réponse est : écrivez d'abord le code, créez un objet à lire, saisissez des données indésirables, puis écrivez-le en XML (désérialisation). Ensuite, nous pouvons nous référer au format spécifique du fichier XML généré, ou ajouter d'autres nœuds. (liste), ou modifiez les données indésirables mentionnées ci-dessus, et obtenez enfin un fichier XML utilisable avec le format correct.

Moyens recommandés pour enregistrer les paramètres de configuration

On constate souvent qu'il existe de nombreux composants ou frameworks qui aiment mettre des paramètres de configuration dans des fichiers de configuration. Ces concepteurs peuvent penser que les paramètres de leurs travaux le sont. plus compliqué et j'aime également créer des nœuds de configuration personnalisés. Le résultat est : beaucoup de paramètres de configuration dans le fichier de configuration. Le plus gênant est : la prochaine fois que d'autres projets voudront utiliser cette chose, vous devrez continuer à la configurer !

.net a toujours préconisé XCOPY, mais j'ai trouvé qu'il n'y avait pas beaucoup de composants ou de frameworks conformes à cette convention. Par conséquent, je voudrais suggérer que lors de la conception de composants ou de frameworks :

1. Veuillez ne pas mettre vos paramètres dans le fichier de configuration. Ce type de configuration est vraiment peu pratique à [réutiliser].

2. Si les paramètres peuvent être divulgués sous forme de fichiers de configuration et d'interfaces API en même temps, c'est à l'utilisateur de décider comment enregistrer les paramètres de configuration.

La différence entre les fichiers de configuration et les fichiers XML

Essentiellement, les fichiers de configuration sont également des fichiers XML, mais ils sont un peu différents, pas seulement parce que le framework .net prédéfinit de nombreux fichiers de configuration dans la section Configuration. Pour les applications ASP.NET, si nous mettons des paramètres dans web.config, tant que web.config est modifié, le site Web sera redémarré. Il y a un avantage à ce moment-là : notre code peut toujours être mis à jour avec les derniers paramètres. courir. D'un autre côté, il y a aussi un inconvénient : peut-être pour diverses raisons, nous ne voulons pas que le site Web soit redémarré. Après tout, le redémarrage du site Web prendra un certain temps, ce qui affectera la réponse du site Web. Pour cette fonctionnalité, je peux seulement dire qu'il n'y a aucun moyen, web.config est comme ça.

Cependant, lorsque nous utilisons XML, nous ne pouvons évidemment pas obtenir directement les fonctionnalités ci-dessus. Parce que le fichier XML est géré par nous-mêmes.

À ce stade, avez-vous déjà pensé : Comment puis-je bénéficier de ces avantages en utilisant XML ?

J'espère qu'une fois que l'utilisateur aura modifié le fichier de configuration, le programme pourra s'exécuter immédiatement avec les derniers paramètres sans avoir à re-site Web.

Tous les exemples de codes pour cet article peuvent être téléchargés ici. démo

Ce qui précède est l'intégralité du contenu de cet article. J'espère qu'il sera utile à l'apprentissage de chacun. J'espère également que tout le monde soutiendra le site Web PHP chinois.

Pour des explications plus détaillées sur les différentes méthodes de lecture et d'écriture de fichiers de configuration en .net, veuillez faire attention au site Web PHP chinois pour les articles connexes !