4

我写了我的public sealed class ObservableDictionary<TKey,TValue> : NotifyPropertyChangedClass, INotifyCollectionChanged, IDictionary<TKey, TValue> where TKey: IEquatable<TKey>课。

它标记为[Serializable]。

但是当我试图序列化ObservableDictionary<Int64, String>.

异常消息：

程序集“PresentationFramework, Version=4.0.0.0, Culture=neutral”中的 MS.Internal.Data.EnumerableCollectionView 类型未使用 PublicKeyToken=31bf3856ad364e35 标记为可序列化。

但我从未使用过这种MS.Internal.Data.EnumerableCollectionView类型。

我的错在哪里？我的以下代码位于：

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;
    }
}

和

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();
        }
    }
}
4

1 回答 1

2

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.

于 2012-11-17T14:35:53.577 回答