[OnDeserialized] || IDeserializationCallback

[Nahasapeemapetilon]

Hi,
kann es sein, dass beide Events zu früh eintreten bzw.
das zu de-serialisierende Object noch gar nicht komplett geladen wurde?

Ich hab mal folgendes Testszenario erstellt:
Eine Klasse ObjectToSave die hat eine
Liste -> mList die nicht gespeichert werden soll und beim Laden aus den geladenen Daten wiederhergestellt wird.
In der Klasse ist noch ein weitere List mit befüllt mit SubClassToSave Objekten.
Die Klasse SubClassToSave hat 3 Members die in den zwei Funktionen

[OnDeserialized]
      private void OnDeserialized(StreamingContext context)
//bzw.
       public void OnDeserialization(object sender)

bis auf das Dictionary wiederhergestellt sind.
Das Dictonary ist zwar schon ein konkretes Object allerdings noch nicht
mit den alten Daten befüllt. Warum ist das so?
Nach der LoadObject Funktion im Main sind alle Daten wieder da.

Hier der Code zum Testen:

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

namespace SerializeTest
{
  internal class Program
  {
    [Serializable()]
    internal class ObjectClassToSave : ISerializable, IDeserializationCallback
    {
      [NonSerialized]
      private List<string> mList;
      private List<SubClassToSave> mSubList;

      internal ObjectClassToSave()
      {
        mList = new List<string>(5);
        mSubList = new List<SubClassToSave>(5);
      }
      internal ObjectClassToSave(SerializationInfo pInfo, StreamingContext pContext)
        : this()
      {
        mSubList = (List<SubClassToSave>)pInfo.GetValue("mSubList", typeof(List<SubClassToSave>));
      }

      public void AddSubClass(SubClassToSave pAdd)
      {
        mSubList.Add(pAdd);
      }

      public void ReadStrings()
      {
        foreach (SubClassToSave tSub in mSubList)
        {
          try
          {
            foreach (string tS in tSub.SomeStrings)
            {
              if (!mList.Contains(tS))
                mList.Add(tS);
            }
          }
          catch (Exception)
          {
            System.Console.WriteLine("fail");
          }
        }
      }

      public void GetObjectData(SerializationInfo info, StreamingContext context)
      {
        info.AddValue("mSubList", mSubList, typeof(List<SubClassToSave>));
      }

      [OnDeserialized]
      private void OnDeserialized(StreamingContext context)
      {
     //   ReadStrings();
      }

      public void OnDeserialization(object sender)
      {
        ReadStrings(); 
      }
    }
    [Serializable()]
    internal class SubClassToSave : ISerializable
    {
      private string mSomeString;
      private Dictionary<string, List<string>> mStringsInDictionary;
      private List<string>  mStringsInList;

      internal SubClassToSave(string s)
      {
        mSomeString = s;
        mStringsInDictionary = new Dictionary<string, List<string>>(5);
        mStringsInList =new List<string>(5);
      }
      internal SubClassToSave(SerializationInfo pInfo, StreamingContext pContext)
      {
        mSomeString = (string)pInfo.GetValue("mSomeString", typeof(string));
        mStringsInDictionary = (Dictionary<string, List<string>>)pInfo.GetValue("mStringsInDictionary", typeof(Dictionary<string, List<string>>));
        mStringsInList =(List<string>) pInfo.GetValue("mStringsInList",typeof(List<string>)); ;
      }

      public void AddSomeStrings(string pKey, string[] pStrings)
      {
        mStringsInDictionary.Add(pKey, new List<string>(10));
        mStringsInDictionary[pKey].AddRange(pStrings);
        if (mStringsInList.Count == 0)
          mStringsInList.AddRange(pStrings);
      }

      public string[] SomeStrings
      {
        get
        {
          string[] tAllKeys = new string[mStringsInDictionary.Keys.Count];
          mStringsInDictionary.Keys.CopyTo(tAllKeys, 0);

          return tAllKeys;
        }
      }
      public void GetObjectData(SerializationInfo info, StreamingContext context)
      {
        info.AddValue("mSomeString", mSomeString, typeof(string));
        info.AddValue("mStringsInDictionary", mStringsInDictionary, typeof(Dictionary<string, string>));
        info.AddValue("mStringsInList", mStringsInList,typeof(List<string>));
      }
    }
    static void Main(string[] args)
    {
      ObjectClassToSave tObj = new ObjectClassToSave();
      AddSomeDummyValues(tObj);
      tObj.ReadStrings();

      MemoryStream tStream = SaveObject(tObj);
      tStream.Position = 0;
      ObjectClassToSave tObj2 = LoadObject(tStream);
      tObj2.ReadStrings();     // hier gehts dann...

    }

    static ObjectClassToSave LoadObject(MemoryStream pStream)
    {
      BinaryFormatter formatter = new BinaryFormatter();
      return (ObjectClassToSave)formatter.Deserialize(pStream);
    }
    static MemoryStream SaveObject(ObjectClassToSave pObj)
    {
      MemoryStream tStream = new MemoryStream();
      BinaryFormatter formatter = new BinaryFormatter();
      formatter.Serialize(tStream, pObj);
      return tStream;
    }

    static void AddSomeDummyValues(ObjectClassToSave pObj)
    {

      for (int b = 1; b < 10; b++)
      {
        SubClassToSave tSub = new SubClassToSave(b.ToString());
        for (int i = 1; i < 10; i++)
        {
          tSub.AddSomeStrings(i.ToString(), new string[]{ (1*i).ToString(),(2*i).ToString(),
                                (3*i).ToString(),(4*i).ToString(),
                                (5*i).ToString(),(6*i).ToString(),
                                (7*i).ToString(),(8*i).ToString(),
                                (9*i).ToString(),(10*i).ToString()});
        }
        pObj.AddSubClass(tSub);
      }
    }
  }
}

Grüße