INotifyPropertyChangedを実装するクラスのインスタンスをシリアル化するときにSerializationExceptionが発生する

Question

私のクラスのフィールドをシリアル化しようとしています。それとSerializationはうまくいき、SerializationExceptionを取得します。

フィールドは次のとおりです。private readonly ObservableCollection<CellVM> Values; 例外は、私はフレームワーク3.5をターゲットにしています

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

です。

私は観察可能なコレクションのシリアル化に問題があるかもしれないが、それは3.5 sp1で修正する必要があるといういくつかの提案を見つけました。

これを修正する方法はありません。ありがとうございました。

CellVMクラス：

[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スーパークラス（祖先）：

[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

イベントPropertyChangedをマーキング試してみてください[NonSerialized]属性によって以下

は、イベントのための構文は次のとおりです。（MSDNを参照してください）

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