¿Cómo unir propiedades booleanas inversas en WPF?

Lo que tengo es un objeto que tiene una IsReadOnlypropiedad. Si esta propiedad es verdadera, me gustaría establecer la IsEnabledpropiedad en un Botón, (por ejemplo), en falso.

Me gustaría creer que puedo hacerlo tan fácilmente como IsEnabled="{Binding Path=!IsReadOnly}"eso, pero eso no vuela con WPF.

¿Estoy relegado a tener que pasar por todas las configuraciones de estilo? Simplemente parece demasiado prolijo para algo tan simple como establecer un bool en el inverso de otro 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>

Puede usar un ValueConverter que invierta una propiedad bool por usted.

XAML:

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

Convertidor:

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

¿Has considerado una IsNotReadOnlypropiedad? Si el objeto que está vinculado es un ViewModel en un dominio MVVM, entonces la propiedad adicional tiene mucho sentido. Si se trata de un modelo de entidad directo, puede considerar la composición y presentar un ViewModel especializado de su entidad al formulario.

Con el enlace estándar necesita usar convertidores que parezcan poco ventosos. Por lo tanto, le recomiendo que mire mi proyecto CalcBinding , que fue desarrollado especialmente para resolver este problema y algunos otros. Con el enlace avanzado puede escribir expresiones con muchas propiedades de origen directamente en xaml. Digamos que puedes escribir algo como:

<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}" />

donde A, B, C, IsChecked - propiedades de viewModel y funcionará correctamente

Yo recomendaría usar https://quickconverter.codeplex.com/

Invertir un booleano es tan simple como: <Button IsEnabled="{qc:Binding '!$P', P={Binding IsReadOnly}}" />

Eso acelera el tiempo que normalmente se necesita para escribir convertidores.

Quería que mi XAML siguiera siendo lo más elegante posible, así que creé una clase para envolver el bool que reside en una de mis bibliotecas compartidas, los operadores implícitos permiten que la clase se use como un bool en código subyacente sin 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;
    }

}

Los únicos cambios necesarios para su proyecto son hacer que la propiedad que desea invertir devuelva esto en lugar de bool

    public InvertableBool IsActive 
    { 
        get 
        { 
            return true; 
        } 
    }

Y en el postfix XAML el enlace con Value o Invert

IsEnabled="{Binding IsActive.Value}"

IsEnabled="{Binding IsActive.Invert}"

Este también funciona para bools anulables.

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

Agregue una propiedad más en su modelo de vista, que devolverá el valor inverso. Y unir eso al botón. Me gusta;

a la vista modelo:

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

en xaml:

IsEnabled="{Binding IsNotReadOnly"}

No sé si esto es relevante para XAML, pero en mi aplicación simple de Windows creé el enlace manualmente y agregué un controlador de eventos de formato.

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

Tuve un problema de inversión, pero una solución ordenada.

La motivación era que el diseñador de XAML mostraría un control vacío, por ejemplo, cuando no había datacontext / no MyValues(itemssource).

Código inicial: oculta el control cuando MyValuesestá vacío. Código mejorado: muestra el control cuando MyValuesNO es nulo o está vacío.

Por supuesto, el problema es cómo expresar '1 o más elementos', que es lo opuesto a 0 elementos.

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

Lo resolví agregando:

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

Ergo establece el valor predeterminado para el enlace. Por supuesto, esto no funciona para todo tipo de problemas inversos, pero me ayudó con un código limpio.

💡 .Net Core Solution 💡

Maneja situaciones nulas y no arroja una excepción, pero regresa truesi no se presenta ningún valor; de lo contrario toma el booleano ingresado y lo invierte.

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 Me gusta poner todas mis estadísticas de convertidor en el archivo app.xaml para no tener que volver a declararlas en las ventanas / páginas / controles del proyecto.

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

Para que quede claro converters:es el espacio de nombres para la implementación real de la clase ( xmlns:converters="clr-namespace:ProvingGround.Converters").

Siguiendo la respuesta de @ Paul, escribí lo siguiente en ViewModel:

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

Espero que tener un fragmento aquí ayude a alguien, probablemente novato como soy.
Y si hay un error, ¡házmelo saber!

Por cierto, también estoy de acuerdo con el comentario de @heltonbiker: definitivamente es el enfoque correcto solo si no tiene que usarlo más de 3 veces ...

Hice algo muy similar Creé mi propiedad detrás de escena que permitía la selección de un cuadro combinado SOLO si había terminado de buscar datos. Cuando mi ventana aparece por primera vez, inicia un comando cargado asíncrono, pero no quiero que el usuario haga clic en el cuadro combinado mientras todavía está cargando datos (estaría vacío, luego se llenaría). Entonces, por defecto, la propiedad es falsa, así que devuelvo el inverso en el captador. Luego, cuando estoy buscando, configuro la propiedad en verdadero y de nuevo en falso cuando se completa.

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

Luego, para el cuadro combinado, puedo vincularlo directamente a IsSearching:

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

Yo uso un enfoque similar 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;