Como vincular propriedades booleanas inversas no WPF?

O que tenho é um objeto que possui uma IsReadOnlypropriedade. Se essa propriedade for verdadeira, eu gostaria de definir a IsEnabledpropriedade em um Button (por exemplo) como false.

Eu gostaria de acreditar que posso fazê-lo tão facilmente quanto IsEnabled="{Binding Path=!IsReadOnly}"isso, mas isso não ocorre com o WPF.

Estou relegado a ter que passar por todas as configurações de estilo? Apenas parece muito prolixo para algo tão simples quanto definir um bool para o inverso de outro 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>

Você pode usar um ValueConverter que inverte uma propriedade bool para você.

XAML:

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

Conversor:

[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
    }

Você já considerou uma IsNotReadOnlypropriedade? Se o objeto que está sendo vinculado for um ViewModel em um domínio MVVM, a propriedade adicional fará todo sentido. Se for um modelo direto de entidade, considere a composição e a apresentação de um ViewModel especializado da sua entidade no formulário.

Com a ligação padrão, você precisa usar conversores com um pouco de vento. Portanto, recomendo que você analise meu projeto CalcBinding , desenvolvido especialmente para resolver esse problema e outros. Com a ligação avançada, você pode escrever expressões com muitas propriedades de origem diretamente no xaml. Digamos, você pode escrever algo como:

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

ou

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

ou

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

ou

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

onde A, B, C, IsChecked - propriedades do viewModel e ele funcionará corretamente

Eu recomendaria usar https://quickconverter.codeplex.com/

A inversão de um booleano é tão simples quanto: <Button IsEnabled="{qc:Binding '!$P', P={Binding IsReadOnly}}" />

Isso acelera o tempo normalmente necessário para gravar conversores.

Eu queria que meu XAML permanecesse o mais elegante possível, então criei uma classe para agrupar o bool que reside em uma das minhas bibliotecas compartilhadas, os operadores implícitos permitem que a classe seja usada como um bool no code-behind sem problemas

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;
    }

}

As únicas alterações necessárias ao seu projeto são fazer com que a propriedade que você deseja inverter retorne isso em vez de bool

    public InvertableBool IsActive 
    { 
        get 
        { 
            return true; 
        } 
    }

E no XAML postfix a ligação com Value ou Invert

IsEnabled="{Binding IsActive.Value}"

IsEnabled="{Binding IsActive.Invert}"

Este também funciona para bools anuláveis.

 [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
}

Adicione mais uma propriedade no seu modelo de exibição, que retornará valor reverso. E ligue isso ao botão. Gostar;

no modelo de exibição:

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

no xaml:

IsEnabled="{Binding IsNotReadOnly"}

Não sei se isso é relevante para o XAML, mas no meu aplicativo Windows simples, criei a ligação manualmente e adicionei um manipulador de eventos 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;
}

Eu tive um problema de inversão, mas uma solução pura.

A motivação foi que o designer XAML mostraria um controle vazio, por exemplo, quando não havia datacontext / no MyValues(itemssource).

Código inicial: oculta o controle quando MyValuesestá vazio. Código aprimorado: mostre o controle quando MyValuesNÃO for nulo ou vazio.

Obviamente, o problema é como expressar '1 ou mais itens', que é o oposto de 0 itens.

<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>

Eu o resolvi adicionando:

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

Ergo definindo o padrão para a encadernação. Claro que isso não funciona para todos os tipos de problemas inversos, mas me ajudou com um código limpo.

Solution .Net Core Solution 💡

Lida com a situação nula e não lança uma exceção, mas retorna truese nenhum valor for apresentado; caso contrário, pega o booleano inserido e o 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 Gosto de colocar todas as estatísticas do meu conversor no arquivo app.xaml para não precisar redeclará-las nas janelas / páginas / controles do projeto.

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

Para ser claro, converters:é o espaço para nome da implementação real da classe ( xmlns:converters="clr-namespace:ProvingGround.Converters").

Após a resposta de @ Paul, escrevi o seguinte no ViewModel:

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

Espero que ter um trecho aqui ajude alguém, provavelmente novato como eu.
E se houver algum erro, avise-me!

BTW, eu também concordo com o comentário @heltonbiker - é definitivamente a abordagem correta apenas se você não precisar usá-la mais de três vezes ...

Eu fiz algo muito parecido. Criei minha propriedade nos bastidores que permitia a seleção de uma caixa de combinação SOMENTE se ela terminasse de pesquisar dados. Quando minha janela aparece pela primeira vez, ele lança um comando carregado assíncrono, mas não quero que o usuário clique na caixa de combinação enquanto ainda carrega dados (estaria vazio e preenchido). Então, por padrão, a propriedade é false, então eu retorno o inverso no getter. Então, quando estou pesquisando, defino a propriedade como true e retorne para false quando concluir.

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;
}

Em seguida, para a caixa de combinação, posso vinculá-lo diretamente ao IsSearching:

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

Eu uso uma abordagem semelhante como @Ofaim

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

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

public bool EnableSaveButton => !jobSaved;