MVVM реализация конфигурации WPF приложения построенного на основе фреймворка Catel

Реализация управления настройками ПО это, вероятно, одна из тех вещей, которую практически в каждом приложении реализуют по своему. Большинство фреймворков и прочих надстроек обычно предоставляют свои средства для сохранения/загрузки значений из какого-либо key-value хранилища параметров.

Тем не менее, в большинстве случаев реализация, конкретного окна настроек и связанных с ним множества вещей оставлена на усмотрение пользователя. В данной заметке хочу поделиться подходом, к которому удалось придти. В моем случае нужно реализовать работу с настройками в MVVM-friendly стиле и с использованием специфики используемого в данном случае фреймворка Catel.

Disclaimer: в данной заметке не будет каких-либо технических тонкостей сложнее базовой рефлексии. Это просто описание подхода к решению небольшой проблемы, получившегося у меня за выходные. Захотелось подумать, как можно избавиться от стандартного boilerplate кода и копипасты, связанной с сохранением/загрузкой настроек приложения. Само решение оказалось довольно тривиальным благодаря удобным имеющимся средствам .NET/Catel, но возможно кому-нибудь сэкономит пару часов времени или наведет на полезные мысли.

Требования

Будем исходить того, что от средств конфигурации мы хотим следующее:

• Доступ к конфигурации в простом структурированном виде. Например
  CultureInfo culture = settings.Application.PreferredCulture;
TimeSpan updateRate = settings.Perfomance.UpdateRate;.
  
  • Все параметры представлены в виде обычных свойств. Способ их хранения инкапсулирован внутри. Для простых типов все должно происходить автоматически, для более сложных должна быть возможность сконфигурировать сериализацию значения в строку.
• Простота и надежность. Не хочется использовать хрупкие инструменты вроде сериализации всей модели настроек целиком или какого-нибудь Entity Framework. На нижнем уровне конфигурация остается простым хранилищем пар "параметр — значение".
• Возможность отменить внесенные в конфигурацию изменения, например в случае, если пользователь нажал "отмена" в окне настроек.
• Возможность подписки на обновления конфигурации. Например, мы хотим обновлять язык приложения сразу после того, как конфигурация была изменена.
• Миграция между версиями приложения. Должна быть возможность задать действия при переходе между версиями приложения (переименовать параметры и т.д.).
• Минимум boilerplate кода, минимум возможностей для опечаток. В идеале мы просто хотим задать автосвойство и не думать о том, как оно сохранится, под каким строковым ключом и т.д… Мы не хотим вручную заниматься копированием каждого из свойств во view-model окна настроек, все должно работать автоматически.

Стандартные средства

Catel предоставляет сервис IConfigurationService, позволяющий сохранять и загружать значения по строковым ключам из локального хранилища (файла на диске в стандартной реализации).

Если мы захотим использовать этот сервис в чистом виде, то придется эти ключи объявлять самостоятельно, например задав такие константы:

public static class Application
{
    public const String PreferredCulture = "Application.PreferredCulture";
    public static readonly String PreferredCultureDefaultValue = Thread.CurrentThread.CurrentUICulture.ToString();
}

Затем мы можем получать эти параметры примерно следующим образом:

var preferredCulture = new CultureInfo(configurationService.GetRoamingValue(
            Application.PreferredCulture,
            Application.PreferredCultureDefaultValue));

Много и нудно писать, легко сделать опечатки, когда настроек много. Кроме того, сервис поддерживает только простые типы, например CultureInfo без дополнительных преобразований сохранить не получится.

Для упрощения работы с этим сервисом получилась обертка, состоящая из нескольких компонент.

Полный код примера доступен в GitHub репозитории. Он содержит простейшее приложение с возможностью отредактировать пару параметров в настройках и убедиться, что все работает. С локализацией не стал заморачиваться, параметр "Language" в настройках используется исключительно для демонстрации работы конфигурации. Если интересует, в Catel есть удобные механизмы локализации, в том числе и на уровне WPF. Если не нравятся ресурсные файлы, можно сделать свою реализацию, работающую с GNU gettext, например.

Для удобства чтения, в примерах кода в тексте этой публикации удалены все xml-doc комментарии.

Сервис конфигурации

Сервис, который можно встроить через IoC и иметь доступ к работе с настройками из любой точки приложения.

Основная задача сервиса — предоставлять модель настроек, которая в свою очередь предоставляет простой и структурированный способ доступа к ним.

Кроме модели настроек, сервис также предоставляет возможность отменить или сохранить внесенные в настройки изменения.

Интерфейс:

public interface IApplicationConfigurationProviderService
{
    event TypedEventHandler<IApplicationConfigurationProviderService> ConfigurationSaved;
    ConfigurationModel Configuration { get; }
    void LoadSettingsFromStorage();
    void SaveChanges();
}

Реализация:

public partial class ApplicationConfigurationProviderService : IApplicationConfigurationProviderService
{
    private readonly IConfigurationService _configurationService;

    public ApplicationConfigurationProviderService(IConfigurationService configurationService)
    {
        _configurationService = configurationService;
        Configuration         = new ConfigurationModel();

        LoadSettingsFromStorage();
        ApplyMigrations();
    }

    public event TypedEventHandler<IApplicationConfigurationProviderService> ConfigurationSaved;

    public ConfigurationModel Configuration { get; }

    public void LoadSettingsFromStorage()
    {
        Configuration.LoadFromStorage(_configurationService);
    }

    public void SaveChanges()
    {
        Configuration.SaveToStorage(_configurationService);
        ConfigurationSaved?.Invoke(this);
    }

    private void ApplyMigrations()
    {
        var    currentVersion       = typeof(ApplicationConfigurationProviderService).Assembly.GetName().Version;
        String currentVersionString = currentVersion.ToString();
        String storedVersionString  = _configurationService.GetRoamingValue("SolutionVersion", currentVersionString);

        if (storedVersionString == currentVersionString)
            return; //Either migrations were already applied or we are on fresh install

        var storedVersion = new Version(storedVersionString);
        foreach (var migration in _migrations)
        {
            Int32 comparison = migration.Version.CompareTo(storedVersion);
            if (comparison <= 0)
                continue;

            migration.Action.Invoke();
        }

        _configurationService.SetRoamingValue("SolutionVersion", currentVersionString);
    }
}

Реализация тривиальна, содержимое ConfigurationModel описано в следующих разделах. Единственное, что вероятно привлекает внимание — метод ApplyMigrations.

В новой версии программы может что-то поменяться, например способ хранения какого-то сложного параметра или его название. Если мы не хотим терять наши настройки после каждого обновления, изменяющего существующие параметры, нужен механизм миграций. Метод ApplyMigrations реализует очень простую поддержку выполнения каких-либо действий при переходе между версиями.

Если в новой версии приложения что-то поменялось, мы просто добавляем необходимые действия (например сохранение параметра под новым именем) в для новой версии в список миграций, содержащийся в соседнем файле:

    private readonly IReadOnlyCollection<Migration> _migrations = new Migration[]
        {
            new Migration(new Version(1,1,0),
                () =>
                {
                    //...
                })
        }
        .OrderBy(migration => migration.Version)
        .ToArray();

    private class Migration
    {
        public readonly Version Version;
        public readonly Action  Action;

        public Migration(Version version, Action action)
        {
            Version = version;
            Action  = action;
        }
    }

Модель настроек

Автоматизация рутинных операций состоит в следующем. Конфигурация описывается как обычная модель (data-object). Catel предоставляет удобный базовый класс ModelBase, являющийся ядром всех его MVVM средств, например автоматических binding'ов между всеми тремя компонентами MVVM. В частности, он позволяет легко обращаться к свойствам модели, которые мы хотим сохранять.

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

Объявление параметров конфигурации

Так выглядит корневая модель:

public partial class ConfigurationModel : ConfigurationGroupBase
{
    public ConfigurationModel()
    {
        Application = new ApplicationConfiguration();
        Performance = new PerformanceConfiguration();
    }

    public ApplicationConfiguration Application { get; private set; }
    public PerformanceConfiguration Performance { get; private set; }
}

ApplicationConfiguration и PerfomanceConfiguration — подклассы, описывающие свои группы настроек:

public partial class ConfigurationModel
{
    public class PerformanceConfiguration : ConfigurationGroupBase
    {
        [DefaultValue(10)]
        public Int32 MaxUpdatesPerSecond { get; set; }
    }
}

Под капотом это свойство свяжется с параметром "Performance.MaxUpdatesPerSecond", название которого сгенерировано из названия типа PerformanceConfiguration.

Нужно заметить, что возможность объявить эти свойства настолько лаконично появилась благодаря использованию Catel.Fody, плагина к известному .NET кодогенератору Fody. Если по каким-то причинам вы не хотите его использовать, свойства нужно объявлять как обычно, согласно документации (визуально похоже на DependencyProperty из WPF).

При желании, уровень вложенности можно увеличить.

Реализация связывания свойств с IConfigurationService

Связывание происходит в базовом классе ConfigurationGroupBase, который в свою очередь унаследован от ModelBase. Рассмотрим его содержимое подробнее.

В первую очередь, составляем список свойств, которые мы хотим сохранять:

public abstract class ConfigurationGroupBase : ModelBase
{
    private readonly IReadOnlyCollection<ConfigurationProperty> _configurationProperties;
    private readonly IReadOnlyCollection<PropertyData>          _nestedConfigurationGroups;

    protected ConfigurationGroupBase()
    {
        var properties = this.GetDependencyResolver()
            .Resolve<PropertyDataManager>()
            .GetCatelTypeInfo(GetType())
            .GetCatelProperties()
            .Select(property => property.Value)
            .Where(property => property.IncludeInBackup && !property.IsModelBaseProperty)
            .ToArray();

        _configurationProperties = properties
            .Where(property => !property.Type.IsSubclassOf(typeof(ConfigurationGroupBase)))
            .Select(property =>
            {
                // ReSharper disable once PossibleNullReferenceException
                String configurationKeyBase = GetType()
                    .FullName
                    .Replace("+",                                       ".")
                    .Replace(typeof(ConfigurationModel).FullName + ".", string.Empty);

                configurationKeyBase = configurationKeyBase.Remove(configurationKeyBase.Length - "Configuration".Length);

                String configurationKey = $"{configurationKeyBase}.{property.Name}";
                return new ConfigurationProperty(property, configurationKey);
            })
            .ToArray();

        _nestedConfigurationGroups = properties
            .Where(property => property.Type.IsSubclassOf(typeof(ConfigurationGroupBase)))
            .ToArray();
    }
...
    private class ConfigurationProperty
    {
        public readonly PropertyData PropertyData;
        public readonly String       ConfigurationKey;

        public ConfigurationProperty(PropertyData propertyData, String configurationKey)
        {
            PropertyData     = propertyData;
            ConfigurationKey = configurationKey;
        }
    }
}

Здесь мы просто обращаемся к аналогу рефлексии для моделей Catel, получаем свойства (отфильтровав служебные или те, которые мы явно пометили атрибутом [ExcludeFromBackup]) и генерируем для них строковые ключи. Свойства, которые сами имеют тип ConfigurationGroupBase заносим в отдельный список.

Метод LoadFromStorage() записывает в полученные ранее свойства значения из конфигурации или стандартные, если ранее они не сохранялись. Для подгрупп вызываются их LoadFromStorage():

public void LoadFromStorage(IConfigurationService configurationService)
{
    foreach (var property in _configurationProperties)
    {
        try
        {
            LoadPropertyFromStorage(configurationService, property.ConfigurationKey, property.PropertyData);
        }
        catch (Exception ex)
        {
            Log.Error(ex, "Can't load from storage nested configuration group {Name}", property.PropertyData.Name);
        }
    }

    foreach (var property in _nestedConfigurationGroups)
    {
        var configurationGroup = GetValue(property) as ConfigurationGroupBase;
        if (configurationGroup == null)
        {
            Log.Error("Can't load from storage configuration property {Name}", property.Name);
            continue;
        }

        configurationGroup.LoadFromStorage(configurationService);
    }
}

protected virtual void LoadPropertyFromStorage(IConfigurationService configurationService, String configurationKey, PropertyData propertyData)
{
    var objectConverterService = this.GetDependencyResolver().Resolve<IObjectConverterService>();

    Object value = configurationService.GetRoamingValue(configurationKey, propertyData.GetDefaultValue());
    if (value is String stringValue)
        value = objectConverterService.ConvertFromStringToObject(stringValue, propertyData.Type, CultureInfo.InvariantCulture);

    SetValue(propertyData, value);
}

Метод LoadPropertyFromStorage определяет, как происходит перенос значения из конфигурации в свойство. Он виртуален и может быть переопределен для нетривиальных свойств.

Небольшая особенность внутренней работы сервиса IConfigurationService: можно заметить использование IObjectConverterService. Он нужен из-за того, что IConfigurationService.GetValue в данном случае вызывается с generic параметром типа Object и в таком случае он не будет сам преобразовывать загруженные строки в числа, например, поэтому нужно сделать это самим.

Аналогично с сохранением параметров:

public void SaveToStorage(IConfigurationService configurationService)
{
    foreach (var property in _configurationProperties)
    {
        try
        {
            SavePropertyToStorage(configurationService, property.ConfigurationKey, property.PropertyData);
        }
        catch (Exception ex)
        {
            Log.Error(ex, "Can't save to storage configuration property {Name}", property.PropertyData.Name);
        }
    }

    foreach (var property in _nestedConfigurationGroups)
    {
        var configurationGroup = GetValue(property) as ConfigurationGroupBase;
        if (configurationGroup == null)
        {
            Log.Error("Can't save to storage nested configuration group {Name}", property.Name);
            continue;
        }

        configurationGroup.SaveToStorage(configurationService);
    }
}

protected virtual void SavePropertyToStorage(IConfigurationService configurationService, String configurationKey, PropertyData propertyData)
{
    Object value = GetValue(propertyData);
    configurationService.SetRoamingValue(configurationKey, value);
}

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

• Типы групп настроек (кроме корневой) являются подклассами "родительской" группы и их имена оканчиваются на Configuration.
• Для каждого такого типа есть соответствующее ему свойство. Например группа ApplicationSettings и свойство Application. Название свойства ни на что не влияет, но это наиболее логичный и ожидаемый вариант.

Настройка сохранения отдельных свойств

Автомагия Catel.Fody и IConfigurationService (прямое сохранение значения в IConfigurationService и атрибут [DefaultValue]) будет работать только для простых типов и константных значений по умолчанию. Для сложных свойств придется расписать немного подлиннее:

public partial class ConfigurationModel
{
    public class ApplicationConfiguration : ConfigurationGroupBase
    {
        public CultureInfo PreferredCulture { get; set; }

        [DefaultValue("User")]
        public String Username { get; set; }

        protected override void LoadPropertyFromStorage(IConfigurationService configurationService, String configurationKey, PropertyData propertyData)
        {
            switch (propertyData.Name)
            {
                case nameof(PreferredCulture):
                    String preferredCultureDefaultValue = CultureInfo.CurrentUICulture.ToString();
                    if (preferredCultureDefaultValue != "en-US" || preferredCultureDefaultValue != "ru-RU")
                        preferredCultureDefaultValue = "en-US";

                    String value = configurationService.GetRoamingValue(configurationKey, preferredCultureDefaultValue);
                    SetValue(propertyData, new CultureInfo(value));
                    break;
                default:
                    base.LoadPropertyFromStorage(configurationService, configurationKey, propertyData);
                    break;
            }
        }

        protected override void SavePropertyToStorage(IConfigurationService configurationService, String configurationKey, PropertyData propertyData)
        {
            switch (propertyData.Name)
            {
                case nameof(PreferredCulture):
                    Object value = GetValue(propertyData);
                    configurationService.SetRoamingValue(configurationKey, value.ToString());
                    break;
                default:
                    base.SavePropertyToStorage(configurationService, configurationKey, propertyData);
                    break;
            }
        }
    }
}

Теперь мы можем, например, в окне настроек привязаться к любому из свойств модели:

<TextBox Text="{Binding Configuration.Application.Username}" />

Осталось не забыть переопределить операции при закрытии ViewModel окна настроек:

protected override Task<Boolean> SaveAsync()
{
    _applicationConfigurationProviderService.SaveChanges();

    return base.SaveAsync();
}

protected override Task<Boolean> CancelAsync()
{
    _applicationConfigurationProviderService.LoadSettingsFromStorage();

    return base.CancelAsync();
}

С ростом количества параметров и соответственно сложности интерфейса, вы сможете без проблем создать отдельные View и ViewModel для каждого раздела настроек.