Comment lier des propriétés booléennes inverses dans WPF?

Ce que j'ai, c'est un objet qui a une IsReadOnlypropriété. Si cette propriété est vraie, je voudrais définir la IsEnabledpropriété d'un bouton (par exemple) sur false.

Je voudrais croire que je peux le faire aussi facilement que cela, IsEnabled="{Binding Path=!IsReadOnly}"mais cela ne fonctionne pas avec WPF.

Suis-je relégué à devoir passer par tous les paramètres de style? Cela semble trop verbeux pour quelque chose d'aussi simple que de mettre un booléen à l'inverse d'un autre booléen.

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

Vous pouvez utiliser un ValueConverter qui inverse une propriété booléenne pour vous.

XAML:

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

Convertisseur:

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

Avez-vous envisagé une IsNotReadOnlypropriété? Si l'objet lié est un ViewModel dans un domaine MVVM, la propriété supplémentaire est parfaitement logique. S'il s'agit d'un modèle d'entité direct, vous pouvez envisager la composition et la présentation d'un ViewModel spécialisé de votre entité au formulaire.

Avec la reliure standard, vous devez utiliser des convertisseurs qui semblent peu venteux. Donc, je vous recommande de regarder mon projet CalcBinding , qui a été développé spécialement pour résoudre ce problème et quelques autres. Avec la liaison avancée, vous pouvez écrire des expressions avec de nombreuses propriétés source directement dans xaml. Dites, vous pouvez écrire quelque chose comme:

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

où A, B, C, IsChecked - propriétés de viewModel et cela fonctionnera correctement

Je recommanderais d'utiliser https://quickconverter.codeplex.com/

Inverser un booléen est alors aussi simple que: <Button IsEnabled="{qc:Binding '!$P', P={Binding IsReadOnly}}" />

Cela accélère le temps normalement nécessaire pour écrire des convertisseurs.

Je voulais que mon XAML reste aussi élégant que possible, j'ai donc créé une classe pour envelopper le bool qui réside dans l'une de mes bibliothèques partagées, les opérateurs implicites permettent à la classe d'être utilisée comme bool dans le code-behind de manière transparente

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

}

Les seules modifications nécessaires à votre projet sont de faire en sorte que la propriété que vous souhaitez inverser renvoie ceci au lieu de bool

    public InvertableBool IsActive 
    { 
        get 
        { 
            return true; 
        } 
    }

Et dans le suffixe XAML, la liaison avec Value ou Invert

IsEnabled="{Binding IsActive.Value}"

IsEnabled="{Binding IsActive.Invert}"

Celui-ci fonctionne également pour les bools nullables.

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

Ajoutez une propriété de plus dans votre modèle de vue, qui renverra la valeur inverse. Et liez ça au bouton. Comme;

en vue modèle:

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

en xaml:

IsEnabled="{Binding IsNotReadOnly"}

Je ne sais pas si cela est pertinent pour XAML, mais dans ma simple application Windows, j'ai créé la liaison manuellement et ajouté un gestionnaire d'événements 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;
}

J'ai eu un problème d'inversion, mais une bonne solution.

La motivation était que le concepteur XAML afficherait un contrôle vide, par exemple lorsqu'il n'y avait pas de datacontext / no MyValues(itemssource).

Code initial: masquer le contrôle lorsqu'il MyValuesest vide. Code amélioré: affichez le contrôle quand il MyValuesn'est PAS nul ou vide.

Bien entendu, le problème est de savoir comment exprimer «1 ou plusieurs éléments», ce qui est l'opposé de 0 élément.

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

Je l'ai résolu en ajoutant:

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

Ergo définissant la valeur par défaut pour la liaison. Bien sûr, cela ne fonctionne pas pour toutes sortes de problèmes inverses, mais cela m'a aidé avec du code propre.

💡 .Net Core Solution 💡

Gère une situation nulle et ne renvoie pas d'exception, mais retourne truesi aucune valeur n'est présentée; sinon prend le booléen entré et l'inverse.

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 J'aime mettre toutes mes statistiques de convertisseur dans le fichier app.xaml donc je n'ai pas à les redéclarer dans les fenêtres / pages / contrôles du projet.

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

Pour être clair, converters:c'est l'espace de noms de l'implémentation de classe réelle ( xmlns:converters="clr-namespace:ProvingGround.Converters").

Suite à la réponse de @ Paul, j'ai écrit ce qui suit dans le ViewModel:

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

J'espère qu'avoir un extrait ici aidera quelqu'un, probablement un débutant comme moi.
Et s'il y a une erreur, faites-le moi savoir!

BTW, je suis également d'accord avec le commentaire de @heltonbiker - c'est certainement l'approche correcte uniquement si vous n'avez pas à l'utiliser plus de 3 fois ...

J'ai fait quelque chose de très similaire. J'ai créé ma propriété dans les coulisses qui a permis la sélection d'une zone de liste déroulante UNIQUEMENT si elle avait fini de rechercher des données. Lorsque ma fenêtre apparaît pour la première fois, elle lance une commande chargée asynchrone mais je ne veux pas que l'utilisateur clique sur la zone de liste déroulante pendant le chargement des données (serait vide, puis renseignée). Donc, par défaut, la propriété est fausse, je renvoie donc l'inverse dans le getter. Ensuite, lorsque je recherche, je définis la propriété sur true et de nouveau sur false une fois terminé.

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

Ensuite, pour la zone de liste déroulante, je peux le lier directement à IsSearching:

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

J'utilise une approche similaire comme @Ofaim

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

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

public bool EnableSaveButton => !jobSaved;