Change la Couleur de Fond pour WPF zone de texte dans changé à l'état d'

Il suffit d'utiliser un MultiBinding avec la même propriété deux fois, mais ont Mode=OneTime sur l'une des liaisons. Comme ceci:

Public Class MVCBackground
    Implements IMultiValueConverter

    Public Function Convert(ByVal values() As Object, ByVal targetType As System.Type, ByVal parameter As Object, ByVal culture As System.Globalization.CultureInfo) As Object Implements System.Windows.Data.IMultiValueConverter.Convert
        Static unchanged As Brush = Brushes.Blue
        Static changed As Brush = Brushes.Red

        If values.Count = 2 Then
            If values(0).Equals(values(1)) Then
                Return unchanged
            Else
                Return changed
            End If
        Else
            Return unchanged
        End If
    End Function

    Public Function ConvertBack(ByVal value As Object, ByVal targetTypes() As System.Type, ByVal parameter As Object, ByVal culture As System.Globalization.CultureInfo) As Object() Implements System.Windows.Data.IMultiValueConverter.ConvertBack
        Throw New NotImplementedException()
    End Function
End Class

Et dans le code xaml:

<TextBox Text="{Binding TestText}">
    <TextBox.Background>
        <MultiBinding Converter="{StaticResource BackgroundConverter}">
            <Binding Path="TestText"    />
            <Binding Path="TestText" Mode="OneTime" />
        </MultiBinding>
    </TextBox.Background>
</TextBox>

Pas de propriétés supplémentaires ou de logique, nécessaire et vous pourriez probablement envelopper le tout dans votre propre extension de balisage. Espérons que cela aide.

Si vous utilisez le MVVM paradigme, vous devriez envisager de le Viewmodel comme ayant le rôle d'adaptateur entre le Modèle et la Vue.

Il n'est pas prévu de le ViewModel pour être complètement agnostique de l'existence d'une INTERFACE utilisateur dans tous les sens, mais pour être agnostique de toute spécifiques de l'INTERFACE utilisateur.

Donc, le ViewModel peut (et doit) avoir la fonctionnalité de Convertisseurs de nombreux que possible. L'exemple pratique ici serait celui-ci:

Serait une INTERFACE utilisateur nécessitent de savoir si un texte est égal à une chaîne par défaut?

Si la réponse est oui, c'est une raison suffisante pour mettre en œuvre un IsDefaultString propriété sur un ViewModel.

public class TextViewModel : ViewModelBase
{
    private string theText;

    public string TheText
    {
        get { return theText; }
        set
        {
            if (value != theText)
            {
                theText = value;
                OnPropertyChanged("TheText");
                OnPropertyChanged("IsTextDefault");
            }
        }
    }

    public bool IsTextDefault
    {
        get
        {
            return GetIsTextDefault(theText);
        }
    }

    private bool GetIsTextDefault(string text)
    {
        //implement here
    }
}

Puis de lier la TextBox comme ceci:

<TextBox x:Name="textBox" Background="White" Text="{Binding Path=TheText, UpdateSourceTrigger=LostFocus}">
    <TextBox.Resources>
        <Style TargetType="TextBox">
            <Style.Triggers>
                <DataTrigger Binding="{Binding IsTextDefault}" Value="False">
                    <Setter Property="TextBox.Background" Value="Red"/>
                </DataTrigger>
            </Style.Triggers>
        </Style>
    </TextBox.Resources>
</TextBox>

Que cela se propage texte vers le ViewModel sur TextBox perdre le focus, ce qui entraîne un nouveau calcul de la IsTextDefault. Si vous avez besoin pour ce faire d'un grand nombre de fois, ou pour de nombreuses propriétés, vous pouvez même cuire jusqu'à quelques de la classe de base comme DefaultManagerViewModel.

Complète diferent façon serait de ne pas implémenter INotifyPropertyChanged et, au lieu de descendre de DependencyObject ou UIElement

Ils mettent en œuvre la liaison à l'aide de DependencyProperty
Vous pouvez utiliser un seul gestionnaire d'événement et de l'utilisateur e.Propriété à trouver la droite de zone de texte

Je suis sûr que l'e.NewValue != e.OldValue vérification est inutile parce que la liaison ne devrait pas avoir changé. J'ai aussi beleive il y a peut être une façon de mettre en œuvre la liaison pour le dependecyObject est la zone de texte et pas votre objet...

Modifier si vous avez déjà hériter de toute WPF classe (comme le contrôle ou le contrôle usercontrol) vous êtes probablement ok et vous n'avez pas besoin de changer de UIElement comme la plupart de WPF héritent de cette classe

Alors vous pouvez avoir:

using System.Windows;
namespace YourNameSpace
{
class PersonViewer:UIElement
{

    //DependencyProperty FirstName
    public static readonly DependencyProperty FirstNameProperty =
        DependencyProperty.Register("FirstName", typeof (string), typeof (PersonViewer),
                                    new FrameworkPropertyMetadata("DefaultPersonName", FirstNameChangedCallback));

    public string FirstName {
        set { SetValue(FirstNameProperty, value); }
        get { return (string) GetValue(FirstNameProperty); }
    }

    private static void FirstNameChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e) {

        PersonViewer owner = d as PersonViewer;
        if (owner != null) {
            if(e.NewValue != e.OldValue && e.NewValue != "DefaultPersonName" ) {

                //Set Textbox to changed state here

            }
        }

    }

    public void AcceptPersonChanges() {

        //Set Textbox to not changed here

    }

 }
}