我正在尝试序列化我类(class)的一个领域。没有它序列化很好，有它一个 get SerializationException。

字段是:private readonly ObservableCollection<CellVM> Values; 异常(exception)是

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

我的目标是 Framework 3.5。

我发现了一些建议，它可能是可观察集合的序列化问题，但应该在 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 父类(super class)(祖先):

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

最佳答案

尝试通过 [NonSerialized] 属性标记事件 PropertyChanged

下面是事件的语法:(参见 MSDN)

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

关于c# - 序列化实现 INotifyPropertyChanged 的​​类的实例时出现 SerializationException，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/8879426/