DataTrigger in cui il valore NON è null?

So che posso creare un setter che controlla se un valore è NULL e fa qualcosa. Esempio:

<TextBlock>
  <TextBlock.Style>
    <Style>
      <Style.Triggers>
        <DataTrigger Binding="{Binding SomeField}" Value="{x:Null}">
          <Setter Property="TextBlock.Text" Value="It's NULL Baby!" />
        </DataTrigger>
      </Style.Triggers>
    </Style>
  </TextBlock.Style>
</TextBlock>

Ma come posso verificare un valore "non" ... come in "NOT NULL" o "NOT = 3"? È possibile in XAML?

Risultati: Grazie per le tue risposte ... Sapevo di poter fare un convertitore di valore (il che significa che avrei dovuto inserire il codice e che non sarebbe stato XAML puro come speravo). Tuttavia, questo risponde alla domanda che effettivamente "no" non è possibile farlo in XAML puro. La risposta selezionata, tuttavia, mostra probabilmente il modo migliore per creare quel tipo di funzionalità. Buona scoperta.

Mi sono imbattuto in una limitazione simile con DataTriggers e sembrerebbe che tu possa solo verificare la parità. La cosa più vicina che ho visto che potrebbe aiutarti è una tecnica per fare altri tipi di confronti diversi dall'uguaglianza.

Questo post sul blog descrive come eseguire confronti come LT, GT, ecc. In un DataTrigger.

Questa limitazione di DataTrigger può essere aggirata in una certa misura usando un convertitore per massaggiare i dati in un valore speciale che è quindi possibile confrontare, come suggerito nella risposta di Robert Macnee.

Per questo puoi usare un IValueConverter:

<TextBlock>
    <TextBlock.Resources>
        <conv:IsNullConverter x:Key="isNullConverter"/>
    </TextBlock.Resources>
    <TextBlock.Style>
        <Style>
            <Style.Triggers>
                <DataTrigger Binding="{Binding SomeField, Converter={StaticResource isNullConverter}}" Value="False">
                    <Setter Property="TextBlock.Text" Value="It's NOT NULL Baby!"/>
                </DataTrigger>
            </Style.Triggers>
        </Style>
    </TextBlock.Style>
</TextBlock>

Dove IsNullConverter è definito altrove (e conv è impostato per fare riferimento al suo spazio dei nomi):

public class IsNullConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return (value == null);
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        throw new InvalidOperationException("IsNullConverter can only be used OneWay.");
    }
}

Una soluzione più generale sarebbe quella di implementare un IValueConverter che controlla l'uguaglianza con ConverterParameter, in modo da poter verificare qualsiasi cosa, e non solo null.

Questo è un po 'un trucco, ma ho appena impostato uno stile predefinito e quindi lo ho annullato usando un DataTrigger se il valore è null ...

  <Style> 
      <!-- Highlight for Reviewed (Default) -->
      <Setter Property="Control.Background" Value="PaleGreen" /> 
      <Style.Triggers>
        <!-- Highlight for Not Reviewed -->
        <DataTrigger Binding="{Binding Path=REVIEWEDBY}" Value="{x:Null}">
          <Setter Property="Control.Background" Value="LightIndianRed" />
        </DataTrigger>
      </Style.Triggers>
  </Style>

Confronta con null (Come diceva Michael Noonan):

<Style>
    <Style.Triggers>
       <DataTrigger Binding="{Binding SomeProperty}" Value="{x:Null}">
           <Setter Property="Visibility" Value="Collapsed" />
        </DataTrigger>
     </Style.Triggers>
</Style>

Confronta con not null (senza convertitore):

<Style>
    <Setter Property="Visibility" Value="Collapsed" />
    <Style.Triggers>
       <DataTrigger Binding="{Binding SomeProperty}" Value="{x:Null}">
           <Setter Property="Visibility" Value="Visible" />
        </DataTrigger>
     </Style.Triggers>
</Style>

Sto usando questo per abilitare un pulsante solo se è selezionato un elemento listview (cioè non null):

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

È possibile utilizzare la DataTriggerclasse in Microsoft.Expression.Interactions.dll fornita con Expression Blend .

Esempio di codice:

<i:Interaction.Triggers>
    <i:DataTrigger Binding="{Binding YourProperty}" Value="{x:Null}" Comparison="NotEqual">
       <ie:ChangePropertyAction PropertyName="YourTargetPropertyName" Value="{Binding YourValue}"/>
    </i:DataTrigger
</i:Interaction.Triggers>

Usando questo metodo è possibile attivare contro GreaterThane LessThananche. Per utilizzare questo codice è necessario fare riferimento a due dll:

System.Windows.Interactivity.dll

Microsoft.Expression.Interactions.dll

<StackPanel.Style>
  <Style>
    <Setter Property="StackPanel.Visibility" Value="Visible"></Setter>
    <Style.Triggers>
      <DataTrigger  Binding="{Binding ElementName=ProfileSelectorComboBox, Path=SelectedItem.Tag}" Value="{x:Null}">
          <Setter Property="StackPanel.Visibility" Value="Collapsed"></Setter>
      </DataTrigger>
    </Style.Triggers>
  </Style>
</StackPanel.Style>

Ho appena usato la logica inversa qui ... impostando il mio stackpanel su invisibile quando il mio comboitem non è popolato, funziona abbastanza bene!

Fermare! Nessun convertitore! Non voglio "vendere" la libreria di questo ragazzo, ma odiavo il fatto di fare il convertitore ogni volta che volevo confrontare cose in XAML.

Quindi con questa libreria: https://github.com/Alex141/CalcBinding

puoi farlo [e molto altro]:

Innanzitutto, nella dichiarazione di windows / userControl:

<Windows....
     xmlns:conv="clr-namespace:CalcBinding;assembly=CalcBinding"
>

quindi, nel blocco di testo

<TextBlock>
      <TextBlock.Style>
          <Style.Triggers>
          <DataTrigger Binding="{conv:Binding 'MyValue==null'}" Value="false">
             <Setter Property="Background" Value="#FF80C983"></Setter>
          </DataTrigger>
        </Style.Triggers>
      </TextBlock.Style>
    </TextBlock>

La parte magica è la conv: Binding 'MYValue == null' . In effetti, potresti impostare qualsiasi condizione tu voglia [guarda il documento].

nota che non sono un fan di terze parti. ma questa libreria è gratuita e di scarso impatto (basta aggiungere 2 dll al progetto).

La mia soluzione è nell'istanza DataContext (o ViewModel se si utilizza MVVM). Aggiungo una proprietà che restituisce true se viene soddisfatta la condizione Not Null che desidero.

    Public ReadOnly Property IsSomeFieldNull() As Boolean
        Get
            Return If(SomeField is Null, True, False)
        End Get
    End Property

e associare DataTrigger alla proprietà sopra. Nota: in VB.NET assicurarsi di utilizzare l'operatore If e NOT la funzione IIf, che non funziona con oggetti Null. Quindi XAML è:

    <DataTrigger Binding="{Binding IsSomeFieldNull}" Value="False">
      <Setter Property="TextBlock.Text" Value="It's NOT NULL Baby!" />
    </DataTrigger>

Se stai cercando una soluzione che non utilizza IValueConverter, puoi sempre andare con il meccanismo seguente

       <StackPanel>
            <TextBlock Text="Border = Red when null value" />
            <Border x:Name="border_objectForNullValueTrigger" HorizontalAlignment="Stretch" Height="20"> 
                <Border.Style>
                    <Style TargetType="Border">
                        <Setter Property="Background" Value="Black" />
                        <Style.Triggers>
                            <DataTrigger Binding="{Binding ObjectForNullValueTrigger}" Value="{x:Null}">
                                <Setter Property="Background" Value="Red" />
                            </DataTrigger>
                        </Style.Triggers>
                    </Style>
                </Border.Style>
            </Border>
            <TextBlock Text="Border = Green when not null value" />
            <Border HorizontalAlignment="Stretch" Height="20">
                <Border.Style>
                    <Style TargetType="Border">
                        <Setter Property="Background" Value="Green" />
                        <Style.Triggers>
                            <DataTrigger Binding="{Binding Background, ElementName=border_objectForNullValueTrigger}" Value="Red">
                                <Setter Property="Background" Value="Black" />
                            </DataTrigger>
                        </Style.Triggers>
                    </Style>
                </Border.Style>
            </Border>
            <Button Content="Invert Object state" Click="Button_Click_1"/>
        </StackPanel>

Converter:

public class NullableToVisibilityConverter: IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return value == null ? Visibility.Collapsed : Visibility.Visible;
    }
}

Rilegatura:

Visibility="{Binding PropertyToBind, Converter={StaticResource nullableToVisibilityConverter}}"

Puoi usare un convertitore o creare una nuova proprietà nel tuo ViewModel in questo modo:

public bool CanDoIt
{
    get
    {
        return !string.IsNullOrEmpty(SomeField);
    }
}

e usalo:

<DataTrigger Binding="{Binding SomeField}" Value="{Binding CanDoIt}">