I inherited the application I am working with.  When it was written, the original author(s) freely stored complex custom objects in session, fully expecting their component objects to also be stored and readily accessed after posting back the current page or navigating to new pages. Because the application was written using "In Process" session state, everything worked -- until we put it in a load balanced server farm.

To make the application work with "out of process" session state, I marked every class [Serializable] and manually coded an implementation of the ISerializable interface -- both the GetObjectData method and a de-serialization constructor. In the GetObjectData method, I call the SerializationInfo.AddValue(string, object, Type) method for each field of the class.  For collections, I call custom methods that iterate through each element, modifying the identifier string with the collection indices.  In the de-serialization constructor, I do the reverse calling the SerializationInfo.GetValue(string, Type) method and casting as appropriate.

Example:

[Serializable]
class MyClass : MyBase, ISerializable {
   public MyClass () {
   }
   public MyClass(SerializationInfo Info, StreamingContext Context) : base(Info, Context) {
       _field = ()Info.GetValue("field", typeof());
       _propertiesList = MiscUtilities.DeserializeHashtable("propertiesList", Info, Context);
   }

   private MyOtherClass _field = null;
   public MyOtherClass Field {
       get { return _field; }
       set { _field = value; }
   }

   private Hashtable _propertiesList = new Hashtable();
   public MyBase this[string key] {
       get { return (MyBase)_propertiesList[key]; }
       set { if (value is MyBase) { _propertiesList[key] = value; } }
   }

   public void GetObjectData(SerializationInfo Info, StreamingContext Context){
       base.GetObjectData(Info, Context);
       Info.AddValue("field", _field, typeof());
       MiscUtilities.SerializeHashtable("propertiesList", _propertiesList, Info, Context);
   }
}

class MyBase : ISerializable {
   // constructors
   MyBase(){};
   MyBase(..., ...) {...};
   // fields & properties
   // methods
   GetObjectData(..., ...) {...};
}

class MyOtherClass : MyBase, ISerializable {
   // constructors
   MyBase(){};
   MyBase(..., ...) {...};
   // fields & properties
   // methods
   GetObjectData(..., ...) {...};
}

class MiscUtilities {
   SerializeHashtable(string name, Hashtable table, SerializationInfo Info, StreamingContext Context) {
       int length = table.Count;
       Info.AddValue(name + ".length", length, typeof(int));
       int i = 0;
       foreach(DictionaryEntry entry in table) {
           Info.AddValue(name + "[" + i.ToString() + "].key", entry.Key, typeof(string));
           Type valueType = (entry.Value != null) ? entry.Value.GetType() : typeof(null);
           Info.AddValue(name + "[" + i.ToString() + "].valueType", valueType, typeof(Type));
           Info.AddValue(name + "[" + i.ToString() + "].value", entry.Value, valueType);
       }
   }
   DeserializeHashtable(string name, SerializationInfo Info, StreamingContext Context) {
       Hashtable hOut = new Hashtable();
       int length = Info.GetInt32(name + ".length");
       for(int i = 0; i < length; i++) {
           string key = Info.GetString(name + "[" + i.ToString() + "].key", typeof(string));
           Type valueType = (Type)Info.GetValue(name + "[" + i.ToString() + "].valueType", typeof(Type));
           object value = Info.GetValue(name + "[" + i.ToString() + "].value", valueType);
           hOut[key] = value;
       }
       return hOut;
   }
   // other collection serialization and de-serialization routines (ArrayList, ICollection, IDictionary, ...)
}

The above code is a very simplified example of what I am actually working with, but I think it conveys the idea that I have manually implemented the ISerializable interface to ensure each field of every custom object gets properly serialized and de-serialized.  But I am still losing data between postbacks and during page navigation which should have been stored in session.  While running the debugger, I set breakpoints in the "GetObjectData" methods of the disappearing objects -- the debugger never stops in those objects' GetObjectData methods.  The objects are stored in a custom collection, which is attached to yet another custom object and that object is the one placed into session.

From the documentation I have read, I believe the binary formatter is supposed to traverse the object graph from the topmost object all the way down to the bottom until every referenced object and collection has been serialized.  How come that is not happening?  The top level object, which is directly placed into session gets serialized and deserialized, but the collections and objects it references don't seem to make it. What am I missing?

Somewhere in code:

   MyClass MyObject = new MyClass();
   // MyObject properties are set, collections are filled,

Later, in code references are made and passed to MyObject as various methods operate on it or pass it on to another method.
Eventually, a reference to MyObject is passed to function that stores it in session.

   public void SomeMethod(MyBase obj) {
       // ...
       Session["MyObject"] = obj;
       // ...
   }

When following along with the debugger, it seems that "obj" really is "MyObject".  It has all the same values, it references all the same objects and collections, its collections reference the same set of objects; all the changes as methods operated on it and its components are still present.  However, when I write the Session object's contents to a log file, after Session["MyObject"] has been set to "obj", the content of Session["MyObject"] has lost changes that were made to MyObject's components.  Collections are reset to a previous state and component objects may also have lost their updates.  What is going on?  If I run the application with "In Process" session state the updates remain after placing the top level object into session -- they only disappear when running with "out of process" session state.