Come associare le proprietà booleane inverse in WPF?

Quello che ho è un oggetto che ha una IsReadOnlyproprietà. Se questa proprietà è vera, vorrei impostare la IsEnabledproprietà su un pulsante, (ad esempio), su false.

Vorrei credere che posso farlo con la stessa facilità IsEnabled="{Binding Path=!IsReadOnly}"ma che non vola con WPF.

Sono relegato a dover passare attraverso tutte le impostazioni di stile? Sembra troppo prolisso per qualcosa di così semplice come impostare un bool sull'inverso di un altro bool.

<Button.Style>
    <Style TargetType="{x:Type Button}">
        <Style.Triggers>
            <DataTrigger Binding="{Binding Path=IsReadOnly}" Value="True">
                <Setter Property="IsEnabled" Value="False" />
            </DataTrigger>
            <DataTrigger Binding="{Binding Path=IsReadOnly}" Value="False">
                <Setter Property="IsEnabled" Value="True" />
            </DataTrigger>
        </Style.Triggers>
    </Style>
</Button.Style>

È possibile utilizzare un ValueConverter che inverte una proprietà bool per te.

XAML:

IsEnabled="{Binding Path=IsReadOnly, Converter={StaticResource InverseBooleanConverter}}"

Converter:

[ValueConversion(typeof(bool), typeof(bool))]
    public class InverseBooleanConverter: IValueConverter
    {
        #region IValueConverter Members

        public object Convert(object value, Type targetType, object parameter,
            System.Globalization.CultureInfo culture)
        {
            if (targetType != typeof(bool))
                throw new InvalidOperationException("The target must be a boolean");

            return !(bool)value;
        }

        public object ConvertBack(object value, Type targetType, object parameter,
            System.Globalization.CultureInfo culture)
        {
            throw new NotSupportedException();
        }

        #endregion
    }

Hai considerato una IsNotReadOnlyproprietà? Se l'oggetto da associare è un ViewModel in un dominio MVVM, la proprietà aggiuntiva ha perfettamente senso. Se si tratta di un modello Entity diretto, è possibile prendere in considerazione la composizione e la presentazione al modulo di un ViewModel specializzato della propria entità.

Con la rilegatura standard devi usare convertitori che sembrano poco ventosi. Quindi, ti consiglio di guardare il mio progetto CalcBinding , che è stato sviluppato appositamente per risolvere questo problema e alcuni altri. Con il bind avanzato puoi scrivere espressioni con molte proprietà sorgente direttamente in xaml. Dì, puoi scrivere qualcosa del tipo:

<Button IsEnabled="{c:Binding Path=!IsReadOnly}" />

o

<Button Content="{c:Binding ElementName=grid, Path=ActualWidth+Height}"/>

o

<Label Content="{c:Binding A+B+C }" />

o

<Button Visibility="{c:Binding IsChecked, FalseToVisibility=Hidden}" />

dove A, B, C, IsChecked - proprietà di viewModel e funzionerà correttamente

Consiglierei di utilizzare https://quickconverter.codeplex.com/

Invertire un valore booleano è quindi semplice come: <Button IsEnabled="{qc:Binding '!$P', P={Binding IsReadOnly}}" />

Ciò accelera il tempo normalmente necessario per scrivere i convertitori.

Volevo che il mio XAML rimanesse il più elegante possibile, quindi ho creato una classe per avvolgere il bool che risiede in una delle mie librerie condivise, gli operatori impliciti consentono alla classe di essere usata come bool nel code-behind senza problemi

public class InvertableBool
{
    private bool value = false;

    public bool Value { get { return value; } }
    public bool Invert { get { return !value; } }

    public InvertableBool(bool b)
    {
        value = b;
    }

    public static implicit operator InvertableBool(bool b)
    {
        return new InvertableBool(b);
    }

    public static implicit operator bool(InvertableBool b)
    {
        return b.value;
    }

}

Le uniche modifiche necessarie al tuo progetto sono di rendere la proprietà che vuoi invertire restituire questo invece di bool

    public InvertableBool IsActive 
    { 
        get 
        { 
            return true; 
        } 
    }

E nel postfix XAML l'associazione con Valore o Inverti

IsEnabled="{Binding IsActive.Value}"

IsEnabled="{Binding IsActive.Invert}"

Questo funziona anche per bool null.

 [ValueConversion(typeof(bool?), typeof(bool))]
public class InverseBooleanConverter : IValueConverter
{
    #region IValueConverter Members

    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (targetType != typeof(bool?))
        {
            throw new InvalidOperationException("The target must be a nullable boolean");
        }
        bool? b = (bool?)value;
        return b.HasValue && !b.Value;
    }

    public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        return !(value as bool?);
    }

    #endregion
}

Aggiungi un'altra proprietà nel tuo modello di visualizzazione, che restituirà un valore inverso. E legalo al bottone. Piace;

in vista modello:

public bool IsNotReadOnly{get{return !IsReadOnly;}}

in xaml:

IsEnabled="{Binding IsNotReadOnly"}

Non so se questo è rilevante per XAML, ma nella mia semplice app di Windows ho creato manualmente l'associazione e aggiunto un gestore di eventi Format.

public FormMain() {
  InitializeComponent();

  Binding argBinding = new Binding("Enabled", uxCheckBoxArgsNull, "Checked", false, DataSourceUpdateMode.OnPropertyChanged);
  argBinding.Format += new ConvertEventHandler(Binding_Format_BooleanInverse);
  uxTextBoxArgs.DataBindings.Add(argBinding);
}

void Binding_Format_BooleanInverse(object sender, ConvertEventArgs e) {
  bool boolValue = (bool)e.Value;
  e.Value = !boolValue;
}

Ho avuto un problema di inversione, ma una soluzione chiara.

La motivazione era che il designer XAML avrebbe mostrato un controllo vuoto, ad es. Quando non c'era datacontext / no MyValues(itemssource).

Codice iniziale: nasconde il controllo quando MyValuesè vuoto. Codice migliorato: mostra il controllo quando MyValuesNON è nullo o vuoto.

Ovviamente il problema è come esprimere "1 o più elementi", che è l'opposto di 0 elementi.

<ListBox ItemsSource={Binding MyValues}">
  <ListBox.Style x:Uid="F404D7B2-B7D3-11E7-A5A7-97680265A416">
    <Style TargetType="{x:Type ListBox}">
      <Style.Triggers>
        <DataTrigger Binding="{Binding MyValues.Count}">
          <Setter Property="Visibility" Value="Collapsed"/>
        </DataTrigger>
      </Style.Triggers>
    </Style>
  </ListBox.Style>
</ListBox>

L'ho risolto aggiungendo:

<DataTrigger Binding="{Binding MyValues.Count, FallbackValue=0, TargetNullValue=0}">

Ergo impostando il valore predefinito per l'associazione. Naturalmente questo non funziona per tutti i tipi di problemi inversi, ma mi ha aiutato con un codice pulito.

💡 .Net Core Solution 💡

Gestisce la situazione nulla e non genera un'eccezione, ma restituisce truese non viene presentato alcun valore; altrimenti prende il booleano immesso e lo inverte.

public class BooleanToReverseConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
     => !(bool?) value ?? true;

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
     => !(value as bool?);
}

xaml

IsEnabled="{Binding IsSuccess Converter={StaticResource BooleanToReverseConverter}}"

App.Xaml Mi piace mettere tutte le statistiche dei miei convertitori nel file app.xaml in modo da non doverle dichiarare nuovamente nelle finestre / pagine / controlli del progetto.

<Application.Resources>
    <converters:BooleanToReverseConverter x:Key="BooleanToReverseConverter"/>
    <local:FauxVM x:Key="VM" />
</Application.Resources>

Per essere chiari converters:è lo spazio dei nomi per l'implementazione effettiva della classe ( xmlns:converters="clr-namespace:ProvingGround.Converters").

Seguendo la risposta di @ Paul, ho scritto quanto segue nel ViewModel:

public bool ShowAtView { get; set; }
public bool InvShowAtView { get { return !ShowAtView; } }

Spero che avere uno snippet qui aiuti qualcuno, probabilmente un principiante come me.
E se c'è un errore, per favore fatemi sapere!

A proposito, sono anche d'accordo con il commento di @heltonbiker - è sicuramente l'approccio corretto solo se non devi usarlo più di 3 volte ...

Ho fatto qualcosa di molto simile. Ho creato la mia proprietà dietro le quinte che ha consentito la selezione di una casella combinata SOLO se avesse terminato la ricerca di dati. Quando viene visualizzata per la prima volta la mia finestra, avvia un comando caricato asincrono ma non voglio che l'utente faccia clic sulla casella combinata mentre sta ancora caricando i dati (sarebbe vuoto, quindi sarebbe popolato). Quindi, per impostazione predefinita, la proprietà è falsa, quindi restituisco l'inverso nel getter. Quindi, quando cerco, imposto la proprietà su true e al termine su false.

private bool _isSearching;
public bool IsSearching
{
    get { return !_isSearching; }
    set
    {
        if(_isSearching != value)
        {
            _isSearching = value;
            OnPropertyChanged("IsSearching");
        }
    }
}

public CityViewModel()
{
    LoadedCommand = new DelegateCommandAsync(LoadCity, LoadCanExecute);
}

private async Task LoadCity(object pArg)
{
    IsSearching = true;

    //**Do your searching task here**

    IsSearching = false;
}

private bool LoadCanExecute(object pArg)
{
    return IsSearching;
}

Quindi per la casella combinata posso collegarlo direttamente a IsSearching:

<ComboBox ItemsSource="{Binding Cities}" IsEnabled="{Binding IsSearching}" DisplayMemberPath="City" />

Uso un approccio simile come @Ofaim

private bool jobSaved = true;
private bool JobSaved    
{ 
    get => jobSaved; 
    set
    {
        if (value == jobSaved) return;
        jobSaved = value;

        OnPropertyChanged();
        OnPropertyChanged("EnableSaveButton");
    }
}

public bool EnableSaveButton => !jobSaved;