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

  • Tutorial

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


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


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


Краткое описание фреймворка Catel

Как и другие WPF фреймворки (Prism, MVVM Light, Caliburn.Micro и т.д.), Catel предоставляет удобные средства для построения приложений в MVVM стиле.
Главные компоненты:


  • IoC (интегрированный с MVVM компонентами)
  • ModelBase: базовый класс, предоставляющий автоматическую реализацию PropertyChanged (особенно в связке с Catel.Fody), сериализацию и BeginEdit/CancelEdit/EndEdit (классические "применить"/"отмена").
  • ViewModelBase, умеющий привязываться к модели, оборачивая ее свойства.
  • Работа с представлениями (views), которые умеют автоматически создавать и привязываться к ViewModel. Поддерживаются вложенные контролы.

Требования


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


  • Доступ к конфигурации в простом структурированном виде. Например
    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 для каждого раздела настроек.

Share post
AdBlock has stolen the banner, but banners are not teeth — they will be back

More
Ads

Comments 0

Only users with full accounts can post comments. Log in, please.