Associazione della visibilità di un pulsante a un valore bool in ViewModel

Come associo la visibilità di un pulsante a un valore bool nel mio ViewModel?

<Button Height="50" Width="50" Style="{StaticResource MyButtonStyle}"
    Command="{Binding SmallDisp}" CommandParameter="{Binding}" Cursor="Hand"
    Visibility="{Binding Path=AdvancedFormat}" />

Supponendo che AdvancedFormatsia a bool, è necessario dichiarare e utilizzare a BooleanToVisibilityConverter:

<!-- In your resources section of the XAML -->
<BooleanToVisibilityConverter x:Key="BoolToVis" />

<!-- In your Button declaration -->
<Button
 Height="50" Width="50"
 Style="{StaticResource MyButtonStyle}"
 Command="{Binding SmallDisp}" CommandParameter="{Binding}" 
Cursor="Hand" Visibility="{Binding Path=AdvancedFormat, Converter={StaticResource BoolToVis}}"/>

Notare l'aggiunta Converter={StaticResource BoolToVis}.

Questo è un modello molto comune quando si lavora con MVVM. In teoria si potrebbe fare la conversione da soli sulla proprietà ViewModel (vale a dire solo fare immobiliare di tipo Visibility) anche se io preferirei non farlo, dal momento che ora si sta scherzi con la separazione degli interessi. La visibilità di un oggetto dovrebbe davvero essere all'altezza della vista.

C'è un terzo modo che non richiede un convertitore o una modifica al modello di visualizzazione: usa uno stile:

<Style TargetType="Button">
   <Setter Property="Visibility" Value="Collapsed"/>
   <Style.Triggers>
      <DataTrigger Binding="{Binding IsVisible}" Value="True">
         <Setter Property="Visibility" Value="Visible"/>
      </DataTrigger>
   </Style.Triggers>
</Style>

Tendo a preferire questa tecnica perché la uso in molti casi in cui ciò a cui mi sto legando è associo non booleano, ad esempio la visualizzazione di un elemento solo se DataContextnon è nullo o l'implementazione di display a più stati in cui compaiono layout diversi in base al impostazione di un enum nel modello di visualizzazione.

Conversione bidirezionale in c # da booleano a visibilità

using System;
using System.Windows;
using System.Windows.Data;

namespace FaceTheWall.converters
{
    class BooleanToVisibilityConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            if (value is Boolean && (bool)value)
            {
                return Visibility.Visible;
            }
            return Visibility.Collapsed;
        }

        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            if (value is Visibility && (Visibility)value == Visibility.Visible)
            {
                return true;
            }
            return false;
        }
    }
}

In genere ci sono due modi per farlo, una classe convertitore o una proprietà nel Viewmodel che essenzialmente converte il valore per te.

Tendo a utilizzare l'approccio della proprietà se si tratta di una conversione una tantum. Se vuoi riutilizzarlo, usa il convertitore. Di seguito, trova un esempio del convertitore:

<ValueConversion(GetType(Boolean), GetType(Visibility))> _
Public Class BoolToVisibilityConverter
    Implements IValueConverter

    Public Function Convert(ByVal value As Object, ByVal targetType As System.Type, ByVal parameter As Object, ByVal culture As System.Globalization.CultureInfo) As Object Implements System.Windows.Data.IValueConverter.Convert

        If value IsNot Nothing Then
            If value = True Then 
                Return Visibility.Visible
            Else
                Return Visibility.Collapsed
            End If
        Else
            Return Visibility.Collapsed
        End If
    End Function

    Public Function ConvertBack(ByVal value As Object, ByVal targetType As System.Type, ByVal parameter As Object, ByVal culture As System.Globalization.CultureInfo) As Object Implements System.Windows.Data.IValueConverter.ConvertBack
        Throw New NotImplementedException
    End Function
End Class

Un metodo di proprietà ViewModel controllerebbe semplicemente il valore della proprietà booleana e restituirebbe una visibilità basata su quello. Assicurati di implementare INotifyPropertyChanged e di chiamarlo sulle proprietà Boolean e Visibility per aggiornarlo correttamente.

Ciò può essere ottenuto in un modo molto semplice 1. Scrivilo nella vista.

<Button HorizontalAlignment="Center" VerticalAlignment="Center" Width="50" Height="30">
<Button.Style>
        <Style TargetType="Button">
                <Setter Property="Visibility" Value="Collapsed"/>
                        <Style.Triggers>
                                <DataTrigger Binding="{Binding IsHide}" Value="True">
                                        <Setter Property="Visibility" Value="Visible"/>
                                    </DataTrigger>
                            </Style.Triggers>
            </Style>
    </Button.Style>

2. La seguente è la proprietà booleana che contiene il valore vero / falso. Di seguito è riportato lo snippet di codice. Nel mio esempio questa proprietà è nella classe UserNote.

   public bool _isHide = false;
   
   public bool IsHide
   {
   
   get { return _isHide; }
   
   set
       {
           _isHide = value;
               OnPropertyChanged("IsHide");
       }
   } 

3. Questo è il modo in cui la proprietà IsHide ottiene il valore.

   userNote.IsHide = userNote.IsNoteDeleted;

In vista:

<Button
 Height="50" Width="50"
 Style="{StaticResource MyButtonStyle}"
 Command="{Binding SmallDisp}" CommandParameter="{Binding}" 
Cursor="Hand" Visibility="{Binding Path=AdvancedFormat}"/>

Modello in vista:

public _advancedFormat = Visibility.visible (whatever you start with)

public Visibility AdvancedFormat
{
 get{return _advancedFormat;}
 set{
   _advancedFormat = value;
   //raise property changed here
}

Avrai bisogno di un evento di modifica della proprietà

 protected virtual void OnPropertyChanged(PropertyChangedEventArgs e) 
    { 
        PropertyChanged.Raise(this, e); 
    } 

    protected void OnPropertyChanged(string propertyName) 
    { 
        OnPropertyChanged(new PropertyChangedEventArgs(propertyName)); 
    } 

Questo è il modo in cui usano Model-view-viewmodel

Ma poiché vuoi che sia legato a un booleano, avrai bisogno di un convertitore. Un altro modo è impostare un valore booleano esterno e quando si fa clic su quel pulsante, impostare property_advancedFormat sulla visibilità desiderata.

Da Windows 10 15063 in poi

A partire dalla build 15063 di Windows 10, è disponibile una nuova funzionalità chiamata "Conversione della visibilità implicita" che associa Visibility al valore bool in modo nativo: non è più necessario utilizzare un convertitore.

(vedere https://social.technet.microsoft.com/wiki/contents/articles/34846.uwp-compiled-binding-windows-10-anniversary-update.aspx#Implicit_Visibility_conversion ).

Il mio codice (che suppone che venga utilizzato MVVM e anche il modello 10):

<!-- In XAML -->
<StackPanel x:Name="Msg_StackPanel" Visibility="{x:Bind ViewModel.ShowInlineHelp}" Orientation="Horizontal" Margin="0,24,0,0">
    <TextBlock Text="Frosty the snowman was a jolly happy soul" Margin="0,0,8,0"/>
    <SymbolIcon Symbol="OutlineStar "/>
    <TextBlock Text="With a corncob pipe and a button nose" Margin="8,0,0,0"/>
</StackPanel>

<!-- in companion View-Model -->
public bool ShowInlineHelp // using T10 SettingsService
{ 
    get { return (_settings.ShowInlineHelp); }
    set { _settings.ShowInlineHelp = !value; base.RaisePropertyChanged(); }
}