Equivalente a UserSettings/ApplicationSettings en WPF dotnet core

 C Programming >> Programación C >  >> Tags >> WPF
Equivalente a UserSettings/ApplicationSettings en WPF dotnet core

Puede agregar el mismo archivo de configuración bueno anterior, p. haciendo clic con el botón derecho en Propiedades -> Agregar -> Nuevo elemento y busque "Configuración". El archivo se puede editar en el diseñador de configuraciones y usarse como en los proyectos de .net framework anteriores (ConfigurationManager, Settings.Default.Upgrade(), Settings.Default.Save, etc. funcionan).

Agregue también el archivo app.config a la carpeta raíz del proyecto (de la misma manera a través de Agregar -> Nuevo elemento), guarde la configuración una vez más, compile el proyecto y encontrará un archivo .dll.config en la carpeta de salida. Ahora puede cambiar los valores predeterminados de la aplicación como antes.

Probado con Visual Studio 1.16.3.5 y un proyecto WPF .net core 3.0.


Como se señaló en las publicaciones a las que hizo referencia, Microsoft.Extensions.Configuration API está pensada como una configuración única para su aplicación, o al menos para ser de solo lectura. Si su objetivo principal es mantener la configuración del usuario fácil/rápido/simple, podría implementar algo usted mismo. Almacenamiento de la configuración en el ApplicationData carpeta, similar a la antigua API.

public class SettingsManager<T> where T : class
{
    private readonly string _filePath;

    public SettingsManager(string fileName)
    {
        _filePath = GetLocalFilePath(fileName);
    }

    private string GetLocalFilePath(string fileName)
    {
        string appData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
        return Path.Combine(appData, fileName);
    }

    public T LoadSettings() =>
        File.Exists(_filePath) ?
        JsonConvert.DeserializeObject<T>(File.ReadAllText(_filePath)) :
        null;

    public void SaveSettings(T settings)
    {
        string json = JsonConvert.SerializeObject(settings);
        File.WriteAllText(_filePath, json);
    }
}

Una demostración usando lo más básico de UserSettings

public class UserSettings
{
    public string Name { get; set; }
}

No voy a proporcionar un ejemplo completo de MVVM, aún así tendríamos una instancia en la memoria, ref _userSettings . Una vez que cargue la configuración, la demostración tendrá anuladas sus propiedades predeterminadas. En producción, por supuesto, no proporcionaría valores predeterminados al inicio. Es solo con fines ilustrativos.

public partial class MainWindow : Window
{
    private readonly SettingsManager<UserSettings> _settingsManager;
    private UserSettings _userSettings;

    public MainWindow()
    {
        InitializeComponent();

        _userSettings = new UserSettings() { Name = "Funk" };
        _settingsManager = new SettingsManager<UserSettings>("UserSettings.json");
    }

    private void Button_FromMemory(object sender, RoutedEventArgs e)
    {
        Apply(_userSettings);
    }

    private void Button_LoadSettings(object sender, RoutedEventArgs e)
    {
        _userSettings = _settingsManager.LoadSettings();
        Apply(_userSettings);
    }

    private void Button_SaveSettings(object sender, RoutedEventArgs e)
    {
        _userSettings.Name = textBox.Text;
        _settingsManager.SaveSettings(_userSettings);
    }

    private void Apply(UserSettings userSettings)
    {
        textBox.Text = userSettings?.Name ?? "No settings found";
    }
}

XAML

<Window x:Class="WpfApp.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WpfApp"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <Window.Resources>
        <Style TargetType="Button">
            <Setter Property="Margin" Value="10"/>
        </Style> 
    </Window.Resources>
    <Grid Margin="10">
        <Grid.RowDefinitions>
            <RowDefinition/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>
        <TextBox Grid.Row="0" x:Name="textBox" Width="150" HorizontalAlignment="Center" VerticalAlignment="Center"/>
        <Button Grid.Row="1" Click="Button_FromMemory">From Memory</Button>
        <Button Grid.Row="2" Click="Button_LoadSettings">Load Settings</Button>
        <Button Grid.Row="3" Click="Button_SaveSettings">Save Settings</Button>
    </Grid>
</Window>

Puede usar un paquete Nuget System.Configuration.ConfigurationManager. Es compatible con .Net Standard 2.0, por lo que debería poder utilizarse en la aplicación .Net Core.

No hay un diseñador para esto, pero por lo demás funciona igual que la versión .Net, y debería poder simplemente copiar el código de su Settings.Designer.cs . Además, puede anular OnPropertyChanged , por lo que no es necesario llamar a Save .

Aquí hay un ejemplo, del proyecto .Net Standard en funcionamiento:

public class WatchConfig: ApplicationSettingsBase
{
    static WatchConfig _defaultInstance = (WatchConfig)Synchronized(new WatchConfig());

    public static WatchConfig Default { get => _defaultInstance; }

    protected override void OnPropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        Save();
        base.OnPropertyChanged(sender, e);
    }

    [UserScopedSetting]
    [global::System.Configuration.DefaultSettingValueAttribute(
    @"<?xml    version=""1.0"" encoding=""utf-16""?>
    <ArrayOfString>
      <string>C:\temp</string>
     <string>..\otherdir</string>
     </ArrayOfString>")]
    public StringCollection Directories
    {
        get { return (StringCollection)this[nameof(Directories)]; }
        set { this[nameof(Directories)] = value; }
    }
}