Singleton serialization или сад камней

в 21:45, , рубрики: Без рубрики

image

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

Но зачем городить огород сад?

Первый логичный вопрос: если так проблем то зачем это вообще нужно? Такая хитрость, действительно, требуется не часто. Хотя многие люди, только начинающие работу с WPF или WinForms, пытаются реализовать таким образом файл с настройками приложения. Пожалуйста, не тратьте свое время и не изобретайте велосипед: для этого есть Application и User Settings (почитать про это можно здесь и здесь). Вот примеры, когда сериализация может потребоваться:
Хочется передать синглтон по сети или между AppDomain. К примеру, клиент и сервер одновременно работают с одним и тем же ftp и синхронизируют свои сведения о нем. Информацию об ftp можно хранить в синглтоне (и там же пристроить методы для работы с ним).
Сериализуется класс, которой присваивается различным элементам, но значение должно быть одинаковым для всех. Примером такого класса может являться DBNull.

Синглтон

В качестве несложного примера возьмем такой синглтон:

public sealed class Settings : ISerializable
{
    private static readonly Settings Inst = new Settings();
    private Settings()
    {
    }

    public static Settings Instance
    {
        get { return Inst; }
    }


    public String ServerAddress
    {
        get { return _servAddr; }
        set { _servAddr = value; }
    }

    public String Port
    {
        get { return _port; }
        set { _port = value; }
    }
    private String _port = "";
}

Сразу сделаю несколько комментариев по коду:

  • Намерено отсутствуют ленивые вычисления, чтобы не усложнять код.
  • Свойства не могут быть сделаны автоматическими, т.к. имена скрытых полей класса генерируются снова при каждой компиляции, и однажды честно сериализованный объект может уже не десериализоваться по причине различия этих имен.

Первый взгляд

В простых случаях для сериализации в C# хватает добавить атрибут Serializable. Что ж, не будем сильно задумываться на сколько наш случай сложен и добавим этот атрибут. Теперь попробуем сериализовать наш синглтон в трех вариантах: SOAP, Binary и обычный XML.
Для примера сериализуем и десериализуем бинарно (остальные способы аналогичны):

using (var mem = new MemoryStream())
{
    var serializer = new BinaryFormatter();
    serializer.Serialize(mem, Settings.Instance);
    mem.Seek(0, SeekOrigin.Begin);
    object o = serializer.Deserialize(mem);
    Console.WriteLine((Settings)o == Settings.Instance);
}

(Не)ожиданно на консоль будет выведено false, а это значит, что мы получили два объекта-синглтона. Такой результат можно предвидеть, если вспомнить, что в процессе десериализации с помощью рефлексии вызывается приватный конструктор и все десериализуемые значения присваиваются новому объекту. Именно эта особенность синглтона кладет первый камень в наш сад: синглтон перестает быть синглтоном.

Усложняем и… кладем еще каменей.

Так как не получилось сделать все просто, придется усложнить Если обратимся к более “ручному” процессу сериализации через интерфейс ISerializable, то на первый взгляд выгоды кажется никакой: прошлая беда не исчезла, а сложность возросла. Поэтому для дальнейшей действий нам еще потребуется достаточно редко используемый интерфейс IObjectReference. Все что он делает: показывает что объект класса, реализующего этот интерфейс, указывает на другой объект. Звучит странно, не правда ли? Но нам нужна другая особенность: после десериализации такого объекта будет возвращен указатель не на него самого, а на тот объект, на который он указывает. В нашем случае логично было бы возвращать указатель на синглтон. Класс будет выглядеть так:

[Serializable]
internal sealed class SettingsSerializationHelper : IObjectReference 
{
    public Object GetRealObject(StreamingContext context) 
    {
        return Settings.Instance;
    }
}

Теперь мы можем сериализовывать объект класса SettingsSerializationHelper, а при десериализации получать Settings.Instance. Правда здесь есть два еще два камня:

  • Перед тем как сериализовать синглтон требуется создать объект другого класса.
  • Поля синглтона по-прежнему не сериализуются.

Рассмотрим первый камень, который не очень критичен, но явно не приятен. Решение проблемы заключено в подмене класса для сериализации внутри GetObjectData. Выглядеть это будет так (внутри синглтона):

public void GetObjectData(SerializationInfo info, StreamingContext context)
{
    info.SetType(typeof(SettingsSerializationHelper));
}

Теперь когда мы будем сериализовывать синглтон вместо него будет сохранен объект SettingsSerializationHelper, а при десериализации мы получим обратно наш синглтон. Проверив вывод на консоль из ранее описанного примера сериализации, мы увидим, что в случае с Binary и SOAP будет выведено на консоль true, но для XML сериализации — false. Следовательно, XMLSerializer не вызывает GetObjectData и просто самостоятельно обрабатывает все public поля/свойства.

Грязные хаки

Проблема с сериализацией полей — самый крупный камень в нашем саду. К сожалению, мне не удалось найти совсем элегантное и честное решение, но получилось соорудить не очень честный, достаточно гибкий “хак”.
Для начала в методе GetObjectData добавим сохранение полей синглтона. Выглядеть это будет так:

public void GetObjectData(SerializationInfo info, StreamingContext context)
{
    info.SetType(typeof(SettignsSerializeHelper));
    info.AddValue("_servAddr", ServerAddressr);
    info.AddValue("_port", Port);
}

Если теперь сделать SOAP сериализацию, то можно увидеть, что все поля действительно сериализованны. Однако в действительности мы сериализовывали SettignsSerializationHelper, у которого эти поля отсутствуют, а значит при десериализации у возникнут проблемы. Есть два пути решения:

  • Полностью повторить все поля синглтона в SettignsSerializationHelper. Такую подмену десериализатор вполне скушает, заполнит все поля, а внутри метода GetRealObject их надо обратно присвоить синглтону. У такого подхода есть один большой и серьёзный недостаток: ручная поддержка дублирования полей, их добавление для сериализации и десериализации. Это явно не наш бро выбор.
  • Призвать на помощь рефлексию, суррогатный селектор и чуточку linq, чтобы все было сделано за нас. Рассмотрим это подробнее.

В начале изменим метод GetObjectData:

public void GetObjectData(SerializationInfo info, StreamingContext context)
{
    info.SetType(typeof (SettignsSerializeHelper));
    var fields = from field in typeof (Settings).GetFields(BindingFlags.Instance |
                    BindingFlags.NonPublic | BindingFlags.Public)
                    where field.GetCustomAttribute(typeof (NonSerializedAttribute)) == null
                    select field;
    foreach (var field in fields)
    {
        info.AddValue(field.Name, field.GetValue(Settings.Instance));
    }
}

Отлично, теперь когда мы захотим добавить поле в синглтон оно будет тоже сериалзованно без работы руками. Перейдем к десериализации.
Все поля синглтона должны быть повторены в SettignsSerializationHelper, но для того, чтобы избежать их реального дублирования, применим суррогатный селектор и изменим SettignsSerializationHelper.
Новый SettignsSerializationHelper:

[Serializable]
internal sealed class SettignsSerializeHelper : IObjectReference
{
    public readonly Dictionary<String, object> infos = 
            (from field in typeof (Settings).GetFields(BindingFlags.Instance 
             | BindingFlags.NonPublic | BindingFlags.Public) 
             where field.GetCustomAttribute(typeof (NonSerializedAttribute)) == null
             select field).ToDictionary(x => x.Name, x => new object());

    public object GetRealObject(StreamingContext context)
    {
        foreach (var info in infos)
        {
            typeof (Settings).GetField(info.Key, BindingFlags.Instance |  BindingFlags.NonPublic 
                                           | BindingFlags.Public).SetValue(Settings.Instance, info.Value);
        }
        return Settings.Instance;
    }
}

И так, внутри SettignsSerializationHelper создается хэш-мап, где key — имена сериализуемых полей, а value в будущем станут значениями этих полей после десериалазации. Здесь для большей инкапсуляции можно сделать infos как private и написать метод для доступка к его key-value парам, но мы не будем усложнять пример. Внутри GetRealObject мы устанавливаем синглтону его десериализованные значения полей и возвращаем ссылку на него.
Теперь осталось только заполнить infos значениями полей. Для этого будет использован селектор.

internal sealed class SettingsSurrogate : ISerializationSurrogate
{
    public void GetObjectData(object obj, SerializationInfo info, StreamingContext context)
    {
        throw new NotImplementedException();
    }
    public object SetObjectData(object obj, SerializationInfo info, StreamingContext context,
                                ISurrogateSelector selector)
    {
        var ssh = new SettignsSerializeHelper();
        foreach (var val in info)
        {
            ssh.infos[val.Name] = val.Value;
        }
        return ssh;
    }
}

Так как селектор будет использоваться только для десериализации, то мы напишем только SetObjectData. Когда obj (десериализуемый объект) приходит внутрь селектора, его поля заполнены 0 и null не зависимо от обстоятельств (obj получается после вызова в процессе десериализации метода GetUninitializedObject из FormatterServices). Поэтому в нашем случае проще создать новый SettignsSerializationHelper и вернуть его (этот объект будет считаться десериализованным). Далее, внутри foreach заполняем infos десериализованными данными, которые потом будут присвоены полям синглтона.
И теперь пример самого процесса сериализации/десериализации:

И теперь пример самого процесса сериализации/десериализации:
using (var mem = new MemoryStream())
{
    var soapSer = new SoapFormatter();
    soapSer.Serialize(mem, Settings.Instance);
    var ss = new SurrogateSelector();
    ss.AddSurrogate(typeof(SettignsSerializeHelper),
    soapSer.Context, new SettingsSurrogate());
    soapSer.SurrogateSelector = ss;
    mem.Seek(0, SeekOrigin.Begin);
    var o = soapSer.Deserialize(mem);
    Console.WriteLine((Settings)o == Settings.Instance);
}

На консоль будет выведено true и все поля будут восстановлены. Наконец, мы закончили и привели наш сад камней в должный вид.

Автор: Tronok

Источник

Поделиться

* - обязательные к заполнению поля