SerializationException khi tuần tự hóa thể hiện của một lớp thực hiện INotifyPropertyChanged

Question

tôi đang cố gắng tuần tự hóa một trường của lớp của tôi. Withou nó serialization là tốt, với nó một nhận SerializationException.

Field là: private readonly ObservableCollection<CellVM> Values; ngoại lệ là

Type System.ComponentModel.PropertyChangedEventManager in assembly WindowsBase, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35 is not marked as serializable. 

Tôi đang nhắm mục tiêu Framework 3.5.

Tôi đã tìm thấy một số gợi ý, rằng nó có thể là vấn đề với việc tuần tự hóa các bộ sưu tập quan sát, nhưng điều đó phải được cố định bằng 3,5 sp1.

Bạn không biết cách khắc phục điều đó, bất kỳ ý tưởng nào? cảm ơn bạn.

CellVM lớp:

[Serializable] 
public class CellVM:ANotifyPropertyChanged 
{ 
    public Cell model; 

    public int X 
    { 
     get { return model.X; } 
     set { model.X = value; OnPropertyChanged("X"); } 
    } 

    public int Y 
    { 
     get { return model.Y; } 
     set { model.Y = value; OnPropertyChanged("Y"); } 
    } 

    public string Value 
    { 
     get 
     { 
      return model.ActualValue; 
     } 
     set { model.ActualValue = value; OnPropertyChanged("Value"); } 
    } 

    [NonSerialized] 
    private bool _isActive; 
    public bool IsActive 
    { 
     get 
     { 
      return _isActive; 
     } 
     set 
     { 
      _isActive = value; 
      OnPropertyChanged("IsActive"); 
      OnPropertyChanged("BackgroundBrush"); 
      OnPropertyChanged("HighlightBrush"); 
     } 
    } 

    public bool IsReadOnly 
    { 
     get 
     { 
      if(model.InitialValue.Equals(model.RightValue)) 
      { 
       return true; 
      } 
      return false; 
     } 
    } 

    public bool IsHighLighted 
    { 
     get; 
     set; 
    } 

    private bool _isInvalid; 
    public bool IsInvalid 
    { 
     get { return _isInvalid; } 
     set 
     { 
      _isInvalid = value; 
      OnPropertyChanged("IsInvalid"); 
      OnPropertyChanged("BackgroundBrush"); 
     } 
    } 

    private bool _isValueMode; 
    public bool IsValueMode 
    { 
     get 
     { 
      return _isValueMode; 
     } 
     set 
     { 
      _isValueMode = value; 

      OnPropertyChanged("IsValueMode"); 
      OnPropertyChanged("ValueVisibility"); 
      OnPropertyChanged("PossibilityVisibility"); 
     } 
    } 

    [NonSerialized] 
    private FontWeight _valueFontWeight; 
    public FontWeight ValueFontWeight 
    { 
     get 
     { 
      return _valueFontWeight; 
     } 
     set { _valueFontWeight = value; OnPropertyChanged("ValueFontWeight");} 
    } 

    [NonSerialized] 
    private Brush _valueColor; 
    public Brush ValueColor 
    { 
     get 
     { 
      if(_valueColor == null) 
      { 
       return new SolidColorBrush(Colors.Black); 
      } 
      return _valueColor; 
     } 
     set { _valueColor = value; OnPropertyChanged("ValueColor"); } 
    } 

    public Visibility ValueVisibility 
    { 
     get 
     { 
      if(IsValueMode) 
      { 
       return Visibility.Visible; 
      } 
      return Visibility.Hidden; 
     } 
    } 

    public Visibility PossibilityVisibility 
    { 
     get 
     { 
      if (!IsValueMode) 
      { 
       return Visibility.Visible; 
      } 
      return Visibility.Hidden; 
     } 
    } 

    private bool _isCheckInvalid; 
    public bool IsCheckInvalid 
    { 
     get 
     { 
      return _isCheckInvalid; 
     } 
     set 
     { 
      _isCheckInvalid = value; 
      OnPropertyChanged("IsCheckInvalid"); 
      OnPropertyChanged("HighlightBrush"); 
     } 
    } 

    public Brush HighlightBrush 
    { 
     get 
     { 
      if(IsActive && IsReadOnly) 
      { 
       return ColorManager.CellActive; 
      } 

      if (IsCheckInvalid) 
      { 
       ColorAnimation animation = new ColorAnimation 
       { 
        From = Colors.Firebrick, 
        To = Colors.WhiteSmoke, 
        Duration = new Duration(TimeSpan.FromSeconds(1)), 
        AutoReverse = true 
       }; 
       SolidColorBrush brush = new SolidColorBrush(Colors.Firebrick); 
       animation.RepeatBehavior = RepeatBehavior.Forever; 
       animation.AccelerationRatio = 0.5; 

       brush.BeginAnimation(SolidColorBrush.ColorProperty, animation); 

       return brush; 
      } 

      return new SolidColorBrush(Colors.Transparent); 
     } 
    } 

    public Brush BackgroundBrush 
    { 
     get 
     { 

      if (IsActive) 
      { 
       if (!IsReadOnly) 
       { 
        return ColorManager.CellActive; 
       } 
      } 
      if (IsInvalid) 
      { 
       return ColorManager.CellInvalid; 
      } 
      if (IsHighLighted) 
      { 
       return ColorManager.CellHighlighted; 
      } 

      return new SolidColorBrush(Colors.White); 
     } 
    } 

    [NonSerialized] 
    private Brush _backgroundAnimationBrush; 
    public Brush BackgroundAnimationBrush 
    { 
     get { return _backgroundAnimationBrush; } 
     set { _backgroundAnimationBrush = value;    OnPropertyChanged("BackgroundAnimationBrush"); } 
    } 

    public Brush PossibilitiesBrush 
    { 
     get 
     { 
      return new SolidColorBrush(PossibilitiesColor); 
     } 
    } 

    private Colour _possibilitiesColor; 
    public Colour PossibilitiesColor 
    { 
     get 
     { 
      if (_possibilitiesColor == null) 
      { 
       return new Colour(Colors.Black); 
      } 
      return _possibilitiesColor; 
     } 
     set 
     { 
      _possibilitiesColor = value; 
      OnPropertyChanged("PossibilitiesColor"); 
      OnPropertyChanged("PossibilitiesBrush"); 
     } 
    } 

    public ObservableCollection<string> Possibilities 
    { 
     get { return model.Possibilities; } 
     set 
     { 
      model.Possibilities = value; 
      OnPropertyChanged("Possibilities"); 
      OnPropertyChanged("PossibilityVisibility"); 
     } 
    } 

    private string _toolTip; 
    public string ToolTip 
    { 
     get { return _toolTip; } 
     set { _toolTip = value; OnPropertyChanged("ToolTip"); } 
    } 

    public CellVM(Cell model,bool isHighlighted) 
    { 
     this.model = model; 
     IsValueMode = true; 
     IsHighLighted = isHighlighted; 
    } 

    public void signalError(string message) 
    { 
     ToolTip = message; 
     IsInvalid = true; 
    } 

    public void resetError() 
    { 
     if(IsCheckInvalid) 
     { 
      return; 
     } 
     ToolTip = null; 
     IsInvalid = false; 
    } 


    public void AnimateError() 
    { 
     ColorAnimation animation = new ColorAnimation 
     { 
      From = Colors.Firebrick, 
      To = Colors.Transparent, 
      Duration = new Duration(TimeSpan.FromSeconds(1.5)), 
      AutoReverse = false 
     }; 
     animation.Completed += new EventHandler(animation_Completed); 
     SolidColorBrush brush = new SolidColorBrush(Colors.Transparent); 
     animation.AccelerationRatio = 0.5; 

     BackgroundAnimationBrush = brush; 
     brush.BeginAnimation(SolidColorBrush.ColorProperty, animation); 
    } 

    public void AnimateHint() 
    { 
     ColorAnimation animation = new ColorAnimation 
     { 
      From = Colors.DarkGreen, 
      To = Colors.Transparent, 
      Duration = new Duration(TimeSpan.FromSeconds(1.5)), 
      AutoReverse = false 
     }; 
     animation.Completed += new EventHandler(animation_Completed); 
     SolidColorBrush brush = new SolidColorBrush(Colors.Transparent); 
     animation.AccelerationRatio = 0.5; 

     BackgroundAnimationBrush = brush; 
     brush.BeginAnimation(SolidColorBrush.ColorProperty, animation); 

    } 

    private void animation_Completed(object sender, EventArgs e) 
    { 
     BackgroundAnimationBrush = null; 
    } 
} 

CellVM SuperClass (tổ tiên):

[Serializable] 
public abstract class ANotifyPropertyChanged : INotifyPropertyChanged 
{ 
    public event PropertyChangedEventHandler PropertyChanged; 

    protected virtual void OnPropertyChanged(string propertyName) 
    { 
     PropertyChangedEventHandler handler = this.PropertyChanged; 
     if (handler != null) 
     { 
      var e = new PropertyChangedEventArgs(propertyName); 
      handler(this, e); 
     } 
    } 
} 

Answer 1

Thử đánh dấu sự kiện PropertyChanged bởi [NonSerialized] thuộc tính

dưới đây là cú pháp cho các sự kiện: (xem MSDN)

[field:NonSerializedAttribute()] 
public event ChangedEventHandler Changed;