My class wont serialize properly
<p>Sorry for super long question i did not want to leave out any code.</p>

<p>This is the code to encrypt and serialize...</p>

<pre><code>public class EncryptionSerialiser
{
    byte[] key = {1, 2, 3, 4, 5, 6, 7, 8}; // Where to store these keys is the tricky part, 
    // you may need to obfuscate them or get the user to input a password each time
    byte[] iv = {1, 2, 3, 4, 5, 6, 7, 8};
    //string path = Application.StartupPath + @"\" + "test.ser";
    DESCryptoServiceProvider des = new DESCryptoServiceProvider();

    public void EncryptThenSerialise(object obj, string pathandfilename)
    {
        // Encryption
        using (var fs = new FileStream(pathandfilename, FileMode.Create, FileAccess.Write))
        using (var cryptoStream = new CryptoStream(fs, des.CreateEncryptor(key, iv), CryptoStreamMode.Write))
        {
            BinaryFormatter formatter = new BinaryFormatter();

            // This is where you serialize the class
            try
            {
                formatter.Serialize(cryptoStream, obj);
            }
            catch (Exception ex)
            {
                // MessageBox.Show(ex.ToString());
            }
            //  cryptoStream.Close();
        }
    }

    public T DecryptThenDeSerialise&lt;T&gt;(object obj, string pathandfilename)
    {
        // Decryption
        using (var fs = new FileStream(pathandfilename, FileMode.Open, FileAccess.Read))
        using (var cryptoStream = new CryptoStream(fs, des.CreateDecryptor(key, iv), CryptoStreamMode.Read))
        {
            BinaryFormatter formatter = new BinaryFormatter();

            // This is where you deserialize the class
            T deserialized = (T) formatter.Deserialize(cryptoStream);

            return deserialized;
        }
    }
</code></pre>

<p>My High Level Dictionary class...</p>

<pre><code>[Serializable]
public class HighLevelDictionary : SerializableDictionary&lt;string, LowLevelDictionary&gt;
{
    protected HighLevelDictionary(SerializationInfo info, StreamingContext context)
    {
        int itemCount = info.GetInt32("ItemCount");
        for (int i = 0; i &lt; itemCount; i++)
        {
            KeyValuePair&lt;string,  LowLevelDictionary&gt; kvp =
                (KeyValuePair&lt;string, LowLevelDictionary&gt;)
                info.GetValue(String.Format("Item{0}", i),
                    typeof(KeyValuePair&lt;string,  LowLevelDictionary

            this.Add(kvp.Key, kvp.Value);
        }
    }

    public HighLevelDictionary()
    {          
    }
}
</code></pre>

<p>My LowlevelDictionary class...</p>

<pre><code>[Serializable]
public class LowLevelDictionary : SerializableDictionary&lt;string, decimal&gt;
{
    protected LowLevelDictionary(SerializationInfo info, StreamingContext context)
    {
        int itemCount = info.GetInt32("ItemCount");
        for (int i = 0; i &lt; itemCount; i++)
        {
            KeyValuePair&lt;string, decimal&gt; kvp =
                (KeyValuePair&lt;string, decimal&gt;)
                info.GetValue(String.Format("Item{0}", i),
                    typeof(KeyValuePair&lt;string, decimal&gt;));

            this.Add(kvp.Key, kvp.Value);
        }
    }

    public LowLevelDictionary()
    {
    }
}
</code></pre>

<p>My serializable SerializableDictionary Class...</p>

<pre><code>using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Xml;
using System.Xml.Serialization;

[Serializable()]
public class SerializableDictionary&lt;TKey, TVal&gt; : Dictionary&lt;TKey, TVal&gt;, IXmlSerializable, ISerializable
{
    #region Constants
    private const string DictionaryNodeName = "Dictionary";
    private const string ItemNodeName = "Item";
    private const string KeyNodeName = "Key";
    private const string ValueNodeName = "Value";
    #endregion
    #region Constructors
    public SerializableDictionary()
    {
    }

    public SerializableDictionary(IDictionary&lt;TKey, TVal&gt; dictionary)
        : base(dictionary)
    {
    }

    public SerializableDictionary(IEqualityComparer&lt;TKey&gt; comparer)
        : base(comparer)
    {
    }

    public SerializableDictionary(int capacity)
        : base(capacity)
    {
    }

    public SerializableDictionary(IDictionary&lt;TKey, TVal&gt; dictionary, IEqualityComparer&lt;TKey&gt; comparer)
        : base(dictionary, comparer)
    {
    }

    public SerializableDictionary(int capacity, IEqualityComparer&lt;TKey&gt; comparer)
        : base(capacity, comparer)
    {
    }

    #endregion
    #region ISerializable Members

    protected SerializableDictionary(SerializationInfo info, StreamingContext context)
    {
        int itemCount = info.GetInt32("ItemCount");
        for (int i = 0; i &lt; itemCount; i++)
        {
            KeyValuePair&lt;TKey, TVal&gt; kvp = (KeyValuePair&lt;TKey, TVal&gt;)info.GetValue(String.Format("Item{0}", i), typeof(KeyValuePair&lt;TKey, TVal&gt;));
            this.Add(kvp.Key, kvp.Value);
        }
    }

    void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
    {
        info.AddValue("ItemCount", this.Count);
        int itemIdx = 0;
        foreach (KeyValuePair&lt;TKey, TVal&gt; kvp in this)
        {
            info.AddValue(String.Format("Item{0}", itemIdx), kvp, typeof(KeyValuePair&lt;TKey, TVal&gt;));
            itemIdx++;
        }
    }

    #endregion
    #region IXmlSerializable Members

    void IXmlSerializable.WriteXml(System.Xml.XmlWriter writer)
    {
        //writer.WriteStartElement(DictionaryNodeName);
        foreach (KeyValuePair&lt;TKey, TVal&gt; kvp in this)
        {
            writer.WriteStartElement(ItemNodeName);
            writer.WriteStartElement(KeyNodeName);
            KeySerializer.Serialize(writer, kvp.Key);
            writer.WriteEndElement();
            writer.WriteStartElement(ValueNodeName);
            ValueSerializer.Serialize(writer, kvp.Value);
            writer.WriteEndElement();
            writer.WriteEndElement();
        }
        //writer.WriteEndElement();
    }

    void IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
    {
        if (reader.IsEmptyElement)
        {
            return;
        }

        // Move past container
        if (!reader.Read())
        {
            throw new XmlException("Error in Deserialization of Dictionary");
        }

        //reader.ReadStartElement(DictionaryNodeName);
        while (reader.NodeType != XmlNodeType.EndElement)
        {
            reader.ReadStartElement(ItemNodeName);
            reader.ReadStartElement(KeyNodeName);
            TKey key = (TKey)KeySerializer.Deserialize(reader);
            reader.ReadEndElement();
            reader.ReadStartElement(ValueNodeName);
            TVal value = (TVal)ValueSerializer.Deserialize(reader);
            reader.ReadEndElement();
            reader.ReadEndElement();
            this.Add(key, value);
            reader.MoveToContent();
        }
        //reader.ReadEndElement();

        reader.ReadEndElement(); // Read End Element to close Read of containing node
    }

    System.Xml.Schema.XmlSchema IXmlSerializable.GetSchema()
    {
        return null;
    }

    #endregion
    #region Private Properties
    protected XmlSerializer ValueSerializer
    {
        get
        {
            if (valueSerializer == null)
            {
                valueSerializer = new XmlSerializer(typeof(TVal));
            }
            return valueSerializer;
        }
    }

    private XmlSerializer KeySerializer
    {
        get
        {
            if (keySerializer == null)
            {
                keySerializer = new XmlSerializer(typeof(TKey));
            }
            return keySerializer;
        }
    }
    #endregion
    #region Private Members
    private XmlSerializer keySerializer = null;
    private XmlSerializer valueSerializer = null;
    #endregion
}
</code></pre>

<p>My Test Code...</p>

<pre><code>EncryptionSerialiser encryptionSerialiser = new EncryptionSerialiser();

GlobalApplicationSettings globalApplicationSettings = new GlobalApplicationSettings();
// CurrentSingleValueOperation.Save();

HighLevelDictionary highLevelDictionary = new HighLevelDictionary();

LowLevelDictionary lowLevelDictionary = new LowLevelDictionary();
lowLevelDictionary.Add("S1", 0.00m);
lowLevelDictionary.Add("S2", 0.00m);

LowLevelDictionary lowLevelDictionary2 = new LowLevelDictionary();
lowLevelDictionary2.Add("S1", 4.00m);
lowLevelDictionary2.Add("S2", 4.00m);

highLevelDictionary.Add("One", lowLevelDictionary);
highLevelDictionary.Add("tWO", lowLevelDictionary2);

encryptionSerialiser.EncryptThenSerialise(highLevelDictionary,
    globalApplicationSettings.PriceSetsFullPath + "SVO0.crypt");

HighLevelDictionary extraHighLevelDictionary = new HighLevelDictionary();

extraHighLevelDictionary = encryptionSerialiser.DecryptThenDeSerialise&lt;HighLevelDictionary&gt;(extraHighLevelDictionary,
    globalApplicationSettings.PriceSetsFullPath + "SVO0.crypt");
</code></pre>

<p><a href="https://i.stack.imgur.com/QEqeK.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/QEqeK.png" alt="Issue"></a></p>

<p>As you can see from the above image the lowered level dictionary stuff seems lost after deserialization (indicated by the null value, although before serialisation i checked and it seems fine.</p>

<p>Any ideas anyone?</p>