Class for storing QUERY STRING in XML files and manage query parameters collection

I recently needed to reuse HTTP query for a web robot, and I did'nt want to use a complex string like this one: "title=Using%20the%20Web%20Client%20Software%20Development%20Package&referringTitle=Getting%20Started"

I wanted to use a readable and reusable representation of a HTTP query that could be easilly serializable in files, easy to generate from a query string, easy to change in code or in files.

A simple StringDictionary would have been perfect, but unfortunately, dictionary collections are not serializable in .NET. I made a class that extends StringDictionary whitch write itself in simple XML format. The format is like this:

<MyQueryName>
<myfirsparamname>myFirsParamValue</myfirsparamname>
<postid>33</postid>
....



Two methods helps work with GET queries: ones (LoadValuesFromQueryString) loads the inner collection with name-values parameters frow a standard query string, and the other one, ToQueryString(), converts the object to a standard query string representation.

This class can be use to reuse, save, adapt and modify query strings.


Note: comments are in french, but method names are in english and should be self-describing enough.

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;


/// <summary>    
/// Objet représentant les champs d'un formulaire html (pour POST ou GET)
/// qui contient essentiellement une collection de clés/valeurs
/// 
/// À utiliser pour représenter, sauvegarder et produire des requêtes HTTP.
/// On peut ainsi sauvegarder les requêtes HTTP en fichier xml, les modifier, puis les réutiliser.
/// 
/// Des méthodes de sauvegarde en fichier en format XML ont été mise pour contourner
/// le manque de possibilité de sérialiser les collections telle que le StringDictionary
/// </summary>
public class FormDefinition : System.Collections.Specialized.StringDictionary
{

    string _nom = "";
    public FormDefinition(string nom)
    {
        this._nom = nom;
    }
    /// <summary>
    /// Convertit la collection de paramètres/valeurs en query string normal
    /// </summary>
    /// <returns></returns>
    public string ToQueryString()
    {
        StringBuilder sb = new StringBuilder();
        foreach (string k in this.Keys)
        {
            sb.Append(k + "=" + System.Web.HttpUtility.UrlEncode(this[k]) + "&");
        }
        return sb.ToString();
    }
    /// <summary>
    /// Initialise la collection de paramètres/valeurs à partir d'un query string
    /// </summary>
    /// <param name="query"></param>
    public void LoadValuesFromQueryString(string query)
    {
        if (query.IndexOf("?") > -1)
            query = query.Substring(query.IndexOf("?"));
        string[] queryParams = query.Split('&');

        string[] cleValeur;
        foreach (string parmametre in queryParams)
        {
            cleValeur = parmametre.Split('=');
            this.Add(cleValeur[0], System.Web.HttpUtility.UrlDecode(cleValeur[1]));
        }

    }
    /// <summary>
    /// Charge un objet FormDefinition à partir de sa représentation XML en fichier
    /// </summary>
    /// <param name="nomFichier"></param>
    /// <returns></returns>
    public static FormDefinition LoadFromFile(string nomFichier)
    {
        FormDefinition formulaire;
        XmlDocument doc = new XmlDocument();

        doc.Load(nomFichier);
        formulaire = FormDefinition.FromXmlDocument(doc);

        return formulaire;
    }
    /// <summary>
    /// Sauvegarde l'objet dans un fichier en représentation XML
    /// </summary>
    /// <param name="nomFichier"></param>
    public void SaveToFile(string nomFichier)
    {
        XmlDocument doc = this.ToXmlDocument();
        doc.Save(nomFichier);

    }
    /// <summary>
    /// Formatte l'objet (le StringDictionnary) en xml 
    /// </summary>
    /// <returns>xml avec balises nommées d'après les paramètres, contenant les valeurs</returns>
    protected XmlDocument ToXmlDocument()
    {
        XmlDocument doc = new XmlDocument();
        XmlElement root = doc.CreateElement(this._nom);
        doc.AppendChild(root);
        foreach (string k in this.Keys)
        {
            XmlElement nod = doc.CreateElement(k);
            nod.InnerText = this[k];
            root.AppendChild(nod);

        }
        return doc;
    }

    /// <summary>
    /// Construit l'objet à partir de la représentation xml
    /// </summary>
    /// <param name="doc"></param>
    /// <returns>Objet initialisé</returns>
    protected static FormDefinition FromXmlDocument(XmlDocument doc)
    {
        FormDefinition formulaire = new FormDefinition(doc.FirstChild.Name);

        foreach (XmlNode enfant in doc.FirstChild.ChildNodes)
        {
            formulaire.Add(enfant.Name, enfant.InnerText);
        }

        return formulaire;
    }



}