Can't serialize my `ObservableDictionary<TKey,TValue>` class

Question

I have wrote my public sealed class ObservableDictionary<TKey,TValue> : NotifyPropertyChangedClass, INotifyCollectionChanged, IDictionary<TKey, TValue> where TKey: IEquatable<TKey> class.

It marked as [Serializable].

But I got exception, when tried to serialize instance of ObservableDictionary<Int64, String>.

Exception message:

The MS.Internal.Data.EnumerableCollectionView type in assembly "PresentationFramework, Version=4.0.0.0, Culture=neutral," isn't marked with PublicKeyToken=31bf3856ad364e35 as serializable.

But I never used the MS.Internal.Data.EnumerableCollectionView type.

Where my mistake? My code below are located:

using System;
using System.ComponentModel;

namespace RememberEmployees {

    [Serializable]
    public abstract class NotifyPropertyChangedClass : INotifyPropertyChanged {        
        protected void NotifyPropertyChanged(string propertyName) {
            PropertyChangedEventHandler temp = PropertyChanged;
            if (temp != null) {
                temp(this, new PropertyChangedEventArgs(propertyName));
            }
        }        
        public event PropertyChangedEventHandler PropertyChanged;
    }
}

and

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using System.Collections.Specialized;

namespace RememberEmployees {   
    [Serializable]
    public sealed class ObservableDictionary<TKey,TValue> : NotifyPropertyChangedClass, 
        INotifyCollectionChanged, IDictionary<TKey, TValue> where TKey: IEquatable<TKey> {
        SortedDictionary<TKey, TValue> dict;

        IComparer<TKey> Comparer {
            get { return dict.Comparer; }
        }

        public ObservableDictionary() {
            dict = new SortedDictionary<TKey, TValue>();
            IsReadOnly = false;
        }

        private void NotifyCollectionChanged(NotifyCollectionChangedAction action) {
            NotifyCollectionChangedEventHandler temp = CollectionChanged;
            if (temp != null) {
                temp(this, new NotifyCollectionChangedEventArgs(action));
            }
        }

        private void NotifyCollectionChanged(NotifyCollectionChangedAction action, object item) {
            NotifyCollectionChangedEventHandler temp = CollectionChanged;
            if (temp != null) {
                temp(this, new NotifyCollectionChangedEventArgs(action, item));
            }
        }

        private void NotifyCollectionChanged(NotifyCollectionChangedAction action, int index) {
            NotifyCollectionChangedEventHandler temp = CollectionChanged;
            if (temp != null) {
                temp(this, new NotifyCollectionChangedEventArgs(action, index));
            }
        }

        private void NotifyCollectionChanged(NotifyCollectionChangedAction action, KeyValuePair<TKey, TValue> obj, int index) {
            NotifyCollectionChangedEventHandler temp = CollectionChanged;
            if (temp != null) {
                temp(this, new NotifyCollectionChangedEventArgs(action, obj, index));
            }
        }

        public event NotifyCollectionChangedEventHandler CollectionChanged;


        public void Add(TKey key, TValue value) {
            if (IsReadOnly)
                throw new Exception("Is Read Only");
            dict.Add(key, value);
            NotifyPropertyChanged("Count");
            NotifyCollectionChanged(NotifyCollectionChangedAction.Add, 
                dict.Cast<KeyValuePair<TKey, TValue>>().FirstOrDefault(n => n.Key.Equals(key)));
        }

        public bool ContainsKey(TKey key) {
            return dict.ContainsKey(key);
        }

        public ICollection<TKey> Keys {
            get { return dict.Keys; }
        }

        public bool Remove(TKey key) {
            if (IsReadOnly)
                throw new Exception("Is Read Only");
            if (!dict.Keys.Contains(key))
                return false;
            int x = 0;
            foreach (TKey item in dict.Keys) {
                if (item.Equals(key))
                    break;
                ++x;
            }
            KeyValuePair<TKey, TValue> val = dict.Cast<KeyValuePair<TKey, TValue>>().FirstOrDefault(n => n.Key.Equals(key));
            bool result = dict.Remove(key);
            if (result) {
                NotifyPropertyChanged("Count");
                NotifyCollectionChanged(NotifyCollectionChangedAction.Remove, val, x);
            }
            return result;
        }

        public bool Remove(KeyValuePair<TKey, TValue> item) {
            return Remove(item.Key);
        }

        public bool TryGetValue(TKey key, out TValue value) {
            return dict.TryGetValue(key, out value);
        }

        public ICollection<TValue> Values {
            get { return dict.Values; }
        }

        public TValue this[TKey key] {
            get {
                return dict[key];
            }
            set {
                dict[key] = value;
                NotifyCollectionChanged(NotifyCollectionChangedAction.Reset);
            }
        }

        public void Add(KeyValuePair<TKey, TValue> item) {
            Add(item.Key, item.Value);
        }

        public void Clear() {
            if (IsReadOnly)
                throw new Exception("Is Read Only");
            dict.Clear();
            NotifyCollectionChanged(NotifyCollectionChangedAction.Reset);
        }

        public bool Contains(KeyValuePair<TKey, TValue> item) {
            return dict.Contains(item);
        }

        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex) {
            if (arrayIndex > dict.Count)
                throw new IndexOutOfRangeException();
            int max = dict.Count - arrayIndex <= array.Count() ? dict.Count - arrayIndex : array.Count();
            for (int i = 0; i < max; i++) {
                array[i] = dict.Skip(arrayIndex).ToArray()[i];
            }
        }

        public int Count {
            get { return dict.Count; }
        }
        bool readOnly;

        public bool IsReadOnly {
            get { return readOnly; }
            set { readOnly = value; NotifyPropertyChanged("IsReadOnly"); }
        }

        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() {
            return dict.GetEnumerator();
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
            return dict.GetEnumerator();
        }
    }
}

Answer 1

This has less to do with your class but with the data you did store in your collection. It seems that in your collection you have stored a ViewObject which internally does contain an EnumerableCollectionView object.

When you serialize data you must be sure what parts of your object graph you do want to serialize. Just putting objects in your collection could cause half of you application data sent over the wire or to disc. There is a good reason why DataContractSerializer was invented.

You should know before the serialize call what data you are going to serialize. Otherwise it could happen that e.g. in a client server application you are trying to deserialize types which are located in assemblies that do exist only on the server.