Ajout de la classe de paramètres à une application UWP

Question

Je développe une application de la plate-forme Windows universelle, mais il n'y a pas de modèle de paramètres dans Visual Studio.

Comment puis-je implémenter une classe facile, fortement typée et observable qui stocke mes paramètres dans LocalSettings ou RoamingSettings?

Answer 1

1. Créer une nouvelle classe héritant de ObservableSettings.
2. Appel au constructeur de classe de base de manière à indiquer si vous souhaitez enregistrer les paramètres dans LocalSettings ou dans RoamingSettings.
3. Ajouter tous vos propriétés de l'appel de la classe de base des membres de la Définir et Obtenir dans le getter et le setter. Pas besoin de passer le nom de la propriété ou de l'utilisation nameof() l'opérateur de!
4. Optionnellement, vous pouvez définir une valeur par défaut de la décoration de la propriété avec DefaultSettingValue attribut.

Voici un exemple d'une classe settings:

namespace Test
{
    public class Settings : ObservableSettings
    {
        private static Settings settings = new Settings();
        public static Settings Default
        {
            get { return settings; }
        }

        public Settings()
            : base(ApplicationData.Current.LocalSettings)
        {
        }

        [DefaultSettingValue(Value = 115200)]
        public int Bauds
        {
            get { return Get<int>(); }
            set { Set(value); }
        }

        [DefaultSettingValue(Value = "Jose")]
        public string Name
        {
            get { return Get<string>(); }
            set { Set(value); }
        }

    }
}

et voici comment ajouter une instance de votre application.xaml:

<Application
    x:Class="Test.App"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:Test"
    RequestedTheme="Light">
    <Application.Resources>
        <local:Settings x:Key="settings"/>
    </Application.Resources>
</Application>

L'accès et modifier les valeurs dans un MVVM de la mode:

<Page
    x:Class="Test.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:Test"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    DataContext="{StaticResource settings}">

    <StackPanel Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
        <TextBlock Text="Bauds"/>
        <TextBox Text="{Binding Default.Bauds, Mode=TwoWay}"/>
        <TextBlock Text="Name"/>
        <TextBox Text="{Binding Default.Name, Mode=TwoWay}"/>
    </StackPanel>
</Page>

Tout sera stocké correctement dans vos paramètres de dépôt.

Ici vous disposez de la mise en œuvre de DefaultSettingValue et ObservableSettings:

using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Reflection;
using System.ComponentModel;
using Windows.Storage;


[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
public sealed class DefaultSettingValueAttribute : Attribute
{
    public DefaultSettingValueAttribute()
    {
    }

    public DefaultSettingValueAttribute(object value)
    {
        Value = value;
    }

    public object Value { get; set; }
}

public class ObservableSettings : INotifyPropertyChanged
{
    private readonly ApplicationDataContainer settings;

    public ObservableSettings(ApplicationDataContainer settings)
    {
        this.settings = settings;
    }

    public event PropertyChangedEventHandler PropertyChanged;

    protected bool Set<T>(T value, [CallerMemberName] string propertyName = null)
    {
        if (settings.Values.ContainsKey(propertyName))
        {
            var currentValue = (T)settings.Values[propertyName];
            if (EqualityComparer<T>.Default.Equals(currentValue, value))
                return false;
        }

        settings.Values[propertyName] = value;
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        return true;
    }

    protected T Get<T>([CallerMemberName] string propertyName = null)
    {
        if (settings.Values.ContainsKey(propertyName))
            return (T)settings.Values[propertyName];

        var attributes = GetType().GetTypeInfo().GetDeclaredProperty(propertyName).CustomAttributes.Where(ca => ca.AttributeType == typeof(DefaultSettingValueAttribute)).ToList();
        if (attributes.Count == 1)
            return (T)attributes[0].NamedArguments[0].TypedValue.Value;

        return default(T);
    }

Vous pouvez télécharger une solution avec une fonctionnelle exemple à partir de la logithèque, j'ai créé dans GitHub.