Jak powiązać odwrotne właściwości boolowskie w WPF?

Mam obiekt, który ma IsReadOnlywłaściwość. Jeśli ta właściwość jest prawdziwa, chciałbym ustawić IsEnabledwłaściwość przycisku (na przykład) na false.

Chciałbym wierzyć, że mogę to zrobić tak łatwo, IsEnabled="{Binding Path=!IsReadOnly}"ale to nie działa z WPF.

Czy jestem zmuszony przejść przez wszystkie ustawienia stylu? Wydaje się po prostu zbyt pracowity dla czegoś tak prostego, jak ustawienie jednego bool na odwrotność innego 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>

Możesz użyć ValueConverter, który odwraca dla ciebie właściwość bool.

XAML:

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

Przetwornik:

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

Czy rozważałeś IsNotReadOnlynieruchomość? Jeśli powiązanym obiektem jest ViewModel w domenie MVVM, wówczas dodatkowa właściwość ma idealny sens. Jeśli jest to bezpośredni model encji, możesz rozważyć kompozycję i zaprezentowanie w formularzu specjalistycznego modelu ViewModel swojej encji.

W przypadku standardowych wiązań należy używać konwerterów, które wyglądają na nieco wietrzne. Polecam więc przyjrzeć się mojemu projektowi CalcBinding , który został opracowany specjalnie w celu rozwiązania tego problemu i kilku innych. Dzięki zaawansowanemu wiązaniu możesz pisać wyrażenia o wielu właściwościach źródłowych bezpośrednio w xaml. Powiedz, możesz napisać coś takiego:

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

lub

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

lub

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

lub

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

gdzie A, B, C, IsChecked - właściwości viewModel i będzie działać poprawnie

Polecam korzystanie z https://quickconverter.codeplex.com/

Odwracanie wartości logicznej jest wtedy tak proste, jak: <Button IsEnabled="{qc:Binding '!$P', P={Binding IsReadOnly}}" />

To przyspiesza czas potrzebny na napisanie konwerterów.

Chciałem, aby moja XAML pozostała tak elegancka, jak to możliwe, dlatego stworzyłem klasę do zawijania bool, który znajduje się w jednej z moich bibliotek współdzielonych, niejawne operatory pozwalają na użycie klasy jako bool w kodowaniu bezproblemowo

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

}

Jedyne zmiany potrzebne w projekcie to spowodowanie, że właściwość, którą chcesz odwrócić, zwraca to zamiast bool

    public InvertableBool IsActive 
    { 
        get 
        { 
            return true; 
        } 
    }

A w postfiksie XAML powiązanie z wartością lub odwróceniem

IsEnabled="{Binding IsActive.Value}"

IsEnabled="{Binding IsActive.Invert}"

Ten działa również dla zerowalnych boolów.

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

Dodaj jeszcze jedną właściwość do modelu widoku, która zwróci wartość odwrotną. I przywiąż to do przycisku. Lubić;

w widoku modelu:

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

w xaml:

IsEnabled="{Binding IsNotReadOnly"}

Nie wiem, czy dotyczy to XAML, ale w mojej prostej aplikacji Windows utworzyłem powiązanie ręcznie i dodałem moduł obsługi zdarzeń formatu.

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

Miałem problem z inwersją, ale dobre rozwiązanie.

Motywacją było to, że projektant XAML pokazywałby pustą kontrolkę, np. Gdy nie istniał żaden MyValuestekst / brak (itemsource).

Kod początkowy: ukryj kontrolę, gdy MyValuesjest pusty. Ulepszony kod: pokaż kontrolę, gdy MyValuesNIE jest pusta lub pusta.

Oczywiście problemem jest sposób wyrażenia „1 lub więcej przedmiotów”, co jest przeciwieństwem 0 przedmiotów.

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

Rozwiązałem to, dodając:

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

Ergo ustawia wartość domyślną dla wiązania. Oczywiście to nie działa na wszystkie rodzaje odwrotnych problemów, ale pomogło mi z czystym kodem.

💡 .Net Rdzeń Rozwiązanie 💡

Obsługuje sytuację zerową i nie zgłasza wyjątku, ale zwraca wartość, truejeśli nie zostanie podana żadna wartość; w przeciwnym razie pobiera wprowadzony Boolean i odwraca go.

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 Lubię umieszczać całą moją statystykę konwertera w pliku app.xaml, więc nie muszę ich ponownie konfigurować w oknach / stronach / kontrolkach projektu.

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

Dla jasności converters:jest to przestrzeń nazw rzeczywistej implementacji klasy ( xmlns:converters="clr-namespace:ProvingGround.Converters").

Po odpowiedzi @ Paula napisałem w ViewModel:

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

Mam nadzieję, że posiadanie fragmentu kodu pomoże komuś, prawdopodobnie nowicjuszowi, tak jak ja.
A jeśli popełnisz błąd, daj mi znać!

BTW, zgadzam się również z komentarzem @heltonbiker - to zdecydowanie poprawne podejście tylko wtedy , gdy nie musisz go używać więcej niż 3 razy ...

Zrobiłem coś bardzo podobnego. Swoją własność utworzyłem za scenami, które umożliwiały wybór skrzynki TYLKO, jeśli zakończy wyszukiwanie danych. Kiedy moje okno pojawia się po raz pierwszy, uruchamia komendę asynchronicznie ładowaną, ale nie chcę, aby użytkownik klikał kombinację podczas ładowania danych (byłby pusty, a następnie zostałby zapełniony). Więc domyślnie właściwość jest fałszywa, więc zwracam odwrotność w getterze. Następnie podczas wyszukiwania ustawiam właściwość na true, a po zakończeniu ponownie ustawiam na 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;
}

Następnie dla combobox mogę go powiązać bezpośrednio z IsSearching:

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

Używam podobnego podejścia, jak @Ofaim

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

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

public bool EnableSaveButton => !jobSaved;