In this case the lists do not serialize. Why?

Question

In the following code an attempt is made to use two lists as a natively serializable storage for a dictionary.

A very productive discussion and a number of alternative solutions have been proposed and discussed in this question. However, I'd like this question to focus on why this class doesn't work rather than finding ways to go around the problem.

Specifically, let's assume we start with an empty dictionary/lists and in edit mode we fill the dictionary with some values, i.e. through a custom inspector or a simple menu-based function.

First of all, I'm puzzled by the log of calls. The OnDisable/OnEnable pair get called three times, in this order: OnDisable(), OnEnable(), OnDisable(), OnEnable(), OnDisable(), OnEnable(). Why so many times?

More crucially, the first OnDisable() call seems to correctly store the content of the dictionary in the lists, as witnessed by logging the values of keys.Count and values.Count. But the first OnEnable() finds empty lists, as if they hadn't been serialized! What is going on? Lists, even generic ones, should be automatically serialized!

 using UnityEngine;
 using UnityEditor;
 using System.Collections.Generic;


 // the next line is crucial: switching from edit mode to play mode without it
 // would only invoke Awake(), and there wouldn't be a chance (i.e. in OnDisable())
 // to save the dictionary data into the lists.
 [ExecuteInEditMode]

 public class MyCustomDict : MonoBehaviour
 {

 // I know, it'd be better to use a single list:
 // bear with me for the sake of simplicity
 public List<string> keys = new List<string>();
 public List<int> values = new List<int>();
  
 // Unity doesn't serialize dictionaries even if you pray in Klingon,
 // that's why we need to use the lists.
 private Dictionary<string, int> dictionary = new Dictionary<string, int>();
  
 public void OnEnable()
 {
     Debug.Log("OnEnable!");

     // the following statement says the lists are empty
     // when switching from edit mode to play mode, but a
     // previous invocation of OnDisable() seems to have 
     // saved the content of the dictionary in them!
     Debug.Log("Count:"+keys.Count+"::"+values.Count);

     // here we -should- deserialize the lists and fill the dictionary
     string aKey;
     int aValue;
  
     for(int index = 0; index < keys.Count; index++)
     {
         aKey = keys[index];
         aValue = values[index];
  
         dictionary[aKey] = aValue;
     }

     // here we clear the lists in the hope to free
     // some memory and to clean things up for the
     // time we'll need the lists again
     keys.Clear();
     values.Clear();
 }
  
 public void OnDisable()
 {
     Debug.Log("OnDisable!");

     // here we serialize the content of the dictionary into
     // the lists, so that it gets "indirectly" serialized.
     int index = 0;
     foreach(var item in dictionary)
     {
         keys.Add(item.Key);
         values.Add(item.Value);
     }

     dictionary.Clear();

     // The following statement suggests that the dictionary
     // data has been moved into the lists, but the first
     // invocation to OnEnable() says otherwise.
     Debug.Log("Count:"+keys.Count+"::"+values.Count);
 } 

 // method to add an item to the dictionary (but not to the lists)
 // can be driven by functionality in a custom inspector or in a
 // menu-based function
 public void AddItem(string aKey, int anInt)
 {
      dictionary[aKey] = anInt;

      // this trigger the refresh of a custom inspector
      EditorUtility.SetDirty(this);
 }

 // method useful for a custom inspector, 
 // to show the content of the dictionary
 public Dictionary<string, int>.Enumerator GetEnumerator()
 {
      return dictionary.GetEnumerator();
 }
 }

Answer 1

Answer by Jamora · Jul 29, 2013 at 07:47 PM

I experimented some, and by serendipity (I never though I'd get to use that word in a sentence) I found out that by commenting out the clearing of the lists in OnEnable, it works fine. I found out because I set them to different sizes, causing an exception whereby they serialized. The only lines not run because of that error were the clearing ones...

Empirical knowledge: If they serialized when moving from game to edit, all the changes you made during game would remain in edit mode. I think it's possible to have custom serialization from game to edit using the onplaymodechange callback, but that's still uncofirmed.

I don't really know of any tutorials.. serialization seems to be quite skimpily documented. I did read these pages, among others

http://blogs.unity3d.com/2012/10/25/unity-serialization/

http://m50blog.wordpress.com/2010/12/04/joys-of-serialization-in-unity/

However, I think the best way is to get creative with the Unity's API. I would imagine for custom serialization you'll at least need

http://docs.unity3d.com/Documentation/ScriptReference/AssetDatabase.html

Add comment · Show 1 · Share

manu3d · Jul 29, 2013 at 10:02 PM 0

Share

Very interesting Jamora! Have you tried to move those clearing lines to the beginning of OnDisable()? Ultimately they are necessary, or the content of the dictionary gets added to the content of the lists ins$$anonymous$$d of overwriting. I can't do the test right now (nearly bedtime) but I shall do it tomorrow. Perhaps I'll simplify the whole thing to one serializable list and one public but explicitely non-serializable one, removing completely the dictionary from the equation. Perhaps the problem persists.

Also thanks for the links provided. I was familiar with the first two, must investigate more on the AssetDatabase. Good night!

Answer 2

Answer by _methotec_ · Jul 27, 2013 at 09:24 AM

Hi there - maybe looking at this how-to-serialize-dictionary-with-unity-serialization may help

Add comment · Show 5 · Share

manu3d · Jul 27, 2013 at 09:47 AM 0

Share

Dear methotec, the focus of this question is not on how to do things differently (that's the focus of the question I provided the link for) but why the code provided doesn't work.

_methotec_ · Jul 27, 2013 at 10:22 AM 1

Share

Oh - well... The OnEnable(), OnDisable() issue is because when Unity goes from the editor mode in playmode all objects are thrown away and all is freshly new instatiated.... so they have to come up at least twice - going from edit mode to play - disable them enable them all and back - disable and enable them all... this is especially making trouble if you're working with singletons... If it's co$$anonymous$$g up 4 times - look into the Debug.Log who's calling.. I guess 2 come from engine 2 from editor... that's because using UnityEditor will cause additional problems when mixed within UnityEngine. $$anonymous$$eep in $$anonymous$$d that the UnityEditor is NOT part of the release. You could exclude all Editor related calls with

 #if UNITY_EDITOR    
 using UnityEditor;
 #endif

When doing so - be sure you exclude them all! Because EditorUtility.SetDirty(this); is not going to work in Release...

And - I personally try to avoid OnEnable() whenever possible... I'd recommend to use Awake() ins$$anonymous$$d... BUT - this also has to come twice...

To show your Class in the Editor - you should use an editor script.. Try extending the editor - don't mix it with runtime logic

manu3d · Jul 27, 2013 at 12:18 PM 0

Share

Thank you methotec for your contribution.

What you mention about the OnEnable/OnDisable issue is partially correct. Switching from edit to play mode involves, I seem to understand, a recompilation step (which accounts for one OnDisable-OnEnable pair) and then starting the play mode, which accounts for a OnDisable-OnEnable-OnDestroy-Awake-OnEnable sequence of calls. One OnDisable/OnEnable pair, between edit mode and play mode, therefore remain unaccounted for. To be clear, what I see switching from edit mode to play mode is:

 OnDisable (edit mode before recompilation?)
 OnEnable  (edit mode after recompilation?)
 OnDisable (unaccounted for)
 OnEnable  (unaccounted for)
 OnDisable (edit mode tyding up for the switch to play mode?)
 OnDestroy (edit mode tyding up for the switch to play mode?)
 Awake   (play mode)
 OnEnable (play mode)

Furthermore, it still not clear why the lists are empty on the first OnEnable after the first OnDisable, when they are filled with the dictionary data.

Concerning showing the class in an editor, indeed I do use that, I haven't included the code because it is simple enough. However, I needed a way to tell the editor when the dictionary has been updated, hence the EditorUtility.SetDirty() call which, somewhat surprisingly, works!

Thank you though for mentioning the issue of Editor-related calls in Release. It is a useful point and I must remember that.

_methotec_ · Jul 27, 2013 at 01:39 PM 0

Share

probably the c# first pass compilation? Don't know that just guessing! What does the Debug.log() say who's calling? You could add an instance id to the log so you can figure out for which object the log is written. You know that the enable is also called if you enable / disable the script in the inspector? Is this really what you want? I guess your Lists are emptied before the new instances are there and so you are copying empty lists... Also you could check with:

 if (keys.Count == 0)
             Debug.Log(keys + " - it's empty!");

manu3d · Jul 27, 2013 at 09:13 PM 0

Share

Thank you again for your effort methotec.

The list of method calls I've compiled above comes from the Debug.Log() statements in the code above.

At this stage there is no need to check the instance id because all the tests I'm doing are happening on a single cube in an empty scene.

I am aware Enabling/Disabling causes those method's invocation and I don't think it's related: I need the data to survive going into play mode and back.

Also, if you notice my code does have checks like the one you suggest, printing out the Count attribute of the lists.

In this case the lists do not serialize. Why?

2 Replies

Your answer

Follow this Question

Related Questions