Как исключить несериализуемых наблюдателей из [Serializable] INotifyPropertyChanged разработчика?

Question

У меня есть почти сотня классов сущностей, выглядящих подобным образом:

[Serializable]
public class SampleEntity : INotifyPropertyChanged
{
    private string name;
    public string Name
    {
        get { return this.name; }
        set { this.name = value; FirePropertyChanged("Name"); }
    }

    [field:NonSerialized]
    public event PropertyChangedEventHandler PropertyChanged;

    private void FirePropertyChanged(string propertyName)
    {
        if (this.PropertyChanged != null)
            this.PropertyChanged(this,
                new PropertyChangedEventArgs(propertyName));
    }
}

Обратите внимание на [field:NonSerialized] атрибут на PropertyChanged.Это необходимо, поскольку некоторые наблюдатели (в моем случае - сетка, отображающая объекты для редакции) могут не быть сериализуемыми, а объект должен быть сериализуемым, поскольку он предоставляется - через удаленную связь - приложением, запущенным на отдельном компьютере.

Это решение отлично работает для тривиальных случаев.Однако вполне возможно, что некоторые из наблюдателей являются [Serializable], и должен был бы быть сохранен.Как я должен справиться с этим?

Решения, которые я рассматриваю:

• полный ISerializable - пользовательская сериализация требует написания большого количества кода, я бы предпочел этого не делать
• используя [OnSerializing] и [OnDeserializing] атрибуты для сериализации PropertyChanged вручную - но эти вспомогательные методы предоставляют только SerializationContext, в котором AFAIK не хранит данные сериализации (SerializationInfo делает это)

Answer 1

Вы правы в том, что первый вариант требует больше работы.Хотя потенциально это может дать вам более эффективную реализацию, это сильно усложнит ваши объекты.Учтите, что если у вас есть база Entity класс , который реализует ISerializable, все подклассы также должны вручную реализовать сериализацию!

Хитрость в том, чтобы заставить второй вариант работать, заключается в том, чтобы продолжать помечать событие как несериализуемое, но иметь второе поле, которое является сериализуемый и который вы заполняете самостоятельно во время соответствующих перехватов сериализации.Вот пример, который я только что написал, чтобы показать вам, как:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            var entity = new Entity();
            entity.PropertyChanged += new SerializableHandler().PropertyChanged;
            entity.PropertyChanged += new NonSerializableHandler().PropertyChanged;

            Console.WriteLine("Before serialization:");
            entity.Name = "Someone";

            using (var memoryStream = new MemoryStream())
            {
                var binaryFormatter = new BinaryFormatter();
                binaryFormatter.Serialize(memoryStream, entity);
                memoryStream.Position = 0;
                entity = binaryFormatter.Deserialize(memoryStream) as Entity;
            }

            Console.WriteLine();
            Console.WriteLine("After serialization:");
            entity.Name = "Kent";

            Console.WriteLine();
            Console.WriteLine("Done - press any key");
            Console.ReadKey();
        }

        [Serializable]
        private class SerializableHandler
        {
            public void PropertyChanged(object sender, PropertyChangedEventArgs e)
            {
                Console.WriteLine("  Serializable handler called");
            }
        }

        private class NonSerializableHandler
        {
            public void PropertyChanged(object sender, PropertyChangedEventArgs e)
            {
                Console.WriteLine("  Non-serializable handler called");
            }
        }
    }

    [Serializable]
    public class Entity : INotifyPropertyChanged
    {
        private string _name;
        private readonly List<Delegate> _serializableDelegates;

        public Entity()
        {
            _serializableDelegates = new List<Delegate>();
        }

        public string Name
        {
            get { return _name; }
            set
            {
                if (_name != value)
                {
                    _name = value;
                    OnPropertyChanged("Name");
                }
            }
        }

        [field:NonSerialized]
        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            var handler = PropertyChanged;

            if (handler != null)
            {
                handler(this, e);
            }
        }

        protected void OnPropertyChanged(string propertyName)
        {
            OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
        }

        [OnSerializing]
        public void OnSerializing(StreamingContext context)
        {
            _serializableDelegates.Clear();
            var handler = PropertyChanged;

            if (handler != null)
            {
                foreach (var invocation in handler.GetInvocationList())
                {
                    if (invocation.Target.GetType().IsSerializable)
                    {
                        _serializableDelegates.Add(invocation);
                    }
                }
            }
        }

        [OnDeserialized]
        public void OnDeserialized(StreamingContext context)
        {
            foreach (var invocation in _serializableDelegates)
            {
                PropertyChanged += (PropertyChangedEventHandler)invocation;
            }
        }
    }
}