Übergabe des Status von WPF ValidationRule zum Anzeigen von Modell in MVVM

Question

Ich stecke in einer anscheinend gemeinsamen Anforderung fest. Ich habe eine WPF Prism (für MVVM) -Anwendung. Mein Modell implementiert IDataErrorInfo zur Validierung. Die IDataErrorInfo funktioniert hervorragend für nicht numerische Eigenschaften. Wenn der Benutzer jedoch bei numerischen Eigenschaften ungültige Zeichen eingibt (die nicht numerisch sind), erreichen die Daten das Modell nicht einmal, weil wpf es nicht in einen numerischen Typ konvertieren kann.

Also musste ich WPF ValidationRule verwenden, um dem Benutzer eine sinnvolle Nachricht für ungültige numerische Einträge zu geben. Alle Schaltflächen in der Ansicht sind an DelegateCommand von prism (im Ansichtsmodell) gebunden und das Aktivieren/Deaktivieren von Schaltflächen erfolgt in View Model selbst.

Wenn nun eine wpf ValidationRule für einige TextBox fehlschlägt, wie gebe ich diese Informationen an View Model weiter, damit die Schaltflächen in der Ansicht entsprechend deaktiviert werden können?

Answer 1

Nirvan

Der einfachste Weg, um dieses besondere Problem zu lösen, ist eine numerische Textbox, zu verwenden, die von dem Benutzer verhindert Geben Sie einen ungültigen Wert ein (Sie können dies entweder über einen Drittanbieter tun oder eine Open-Source-Lösung finden, z. B. eine von Textbox abgeleitete Klasse, die nicht numerische Eingaben unterdrückt).

Die zweite Möglichkeit, dies in MVVM ohne das oben beschriebene zu behandeln, besteht darin, ein anderes Feld in Ihrem ViewModel zu definieren, das eine Zeichenfolge ist, und dieses Feld an Ihr Textfeld zu binden. Dann können Sie im Setzer Ihres Zeichenkettenfelds die Ganzzahl einstellen und Ihrem numerischen Feld einen Wert zuweisen:

Hier ist ein grobes Beispiel: (Ich habe es nicht getestet, aber es sollte Ihnen die Idee geben)

Answer 2

Wenn Sie eine benutzerdefinierte Implementierung bereitstellen, können Sie den erhaltenen Wert speichern und das letzte Ergebnis speichern. Pseudo-Code:

public class IsInteger : ValidationRule 
{ 
    private int parsedValue; 

    public IsInteger() { } 

    public string LastValue{ get; private set; } 

    public bool LastParseSuccesfull{ get; private set; } 

    public int ParsedValue{ get{ return parsedValue; } } 

    public override ValidationResult Validate(object value, CultureInfo cultureInfo) 
    { 
    LastValue = (string) value; 
    LastParseSuccesfull = Int32.TryParse(LastValue, cultureInfo, ref parsedValue); 
    return new ValidationResult(LastParseSuccesfull, LastParseSuccesfull ? "not a valid number" : null); 
    } 
} 

Answer 3

Jemand hier gelöst ist (leider sein in VB) durch eine Abhängigkeitseigenschaft HasError in der VM zu schaffen, die an der Validation.HasError gebunden zu sein scheint. Ich weiß nicht ganz es noch verstehen, aber es kann Ihnen helfen:

http://wpfglue.wordpress.com/2009/12/03/forwarding-the-result-of-wpf-validation-in-mvvm/

Answer 4

Für MVVM bevorzuge ich Attached Properties für diese Art von Sache, weil sie wiederverwendbar sind und es hält die Ansicht Modelle sauber.

Um die Validation.HasError-Eigenschaft an Ihr Ansichtsmodell zu binden, müssen Sie eine angefügte Eigenschaft erstellen, die über CoerceValueCallback den Wert der angefügten Eigenschaft mit der Validation.HasError-Eigenschaft des Steuerelements, das Sie validieren, synchronisiert Eingabe an.

This Artikel erläutert, wie diese Technik verwendet wird, um das Problem zu beheben, das Ansichtsmodell von WPF ValidationRule-Fehlern zu melden. Der Code war in VB, also portierte ich ihn auf C#, wenn Sie keine VB-Person sind.

Die angefügte Eigenschaft

public static class ValidationBehavior 
{ 
    #region Attached Properties 

    public static readonly DependencyProperty HasErrorProperty = DependencyProperty.RegisterAttached(
     "HasError", 
     typeof(bool), 
     typeof(ValidationBehavior), 
     new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, null, CoerceHasError)); 

    private static readonly DependencyProperty HasErrorDescriptorProperty = DependencyProperty.RegisterAttached(
     "HasErrorDescriptor", 
     typeof(DependencyPropertyDescriptor), 
     typeof(ValidationBehavior)); 

    #endregion 

    private static DependencyPropertyDescriptor GetHasErrorDescriptor(DependencyObject d) 
    { 
     return (DependencyPropertyDescriptor)d.GetValue(HasErrorDescriptorProperty); 
    } 

    private static void SetHasErrorDescriptor(DependencyObject d, DependencyPropertyDescriptor value) 
    { 
     d.SetValue(HasErrorDescriptorProperty, value); 
    } 

    #region Attached Property Getters and setters 

    public static bool GetHasError(DependencyObject d) 
    { 
     return (bool)d.GetValue(HasErrorProperty); 
    } 

    public static void SetHasError(DependencyObject d, bool value) 
    { 
     d.SetValue(HasErrorProperty, value); 
    } 

    #endregion 

    #region CallBacks 

    private static object CoerceHasError(DependencyObject d, object baseValue) 
    { 
     var result = (bool)baseValue; 
     if (BindingOperations.IsDataBound(d, HasErrorProperty)) 
     { 
      if (GetHasErrorDescriptor(d) == null) 
      { 
       var desc = DependencyPropertyDescriptor.FromProperty(System.Windows.Controls.Validation.HasErrorProperty, d.GetType()); 
       desc.AddValueChanged(d, OnHasErrorChanged); 
       SetHasErrorDescriptor(d, desc); 
       result = System.Windows.Controls.Validation.GetHasError(d); 
      } 
     } 
     else 
     { 
      if (GetHasErrorDescriptor(d) != null) 
      { 
       var desc = GetHasErrorDescriptor(d); 
       desc.RemoveValueChanged(d, OnHasErrorChanged); 
       SetHasErrorDescriptor(d, null); 
      } 
     } 
     return result; 
    } 
    private static void OnHasErrorChanged(object sender, EventArgs e) 
    { 
     var d = sender as DependencyObject; 
     if (d != null) 
     { 
      d.SetValue(HasErrorProperty, d.GetValue(System.Windows.Controls.Validation.HasErrorProperty)); 
     } 
    } 

    #endregion 
} 

mit dem beiliegenden Eigentum in XAML

<Window 
    x:Class="MySolution.MyProject.MainWindow" 
    xmlns:v="clr-namespace:MyNamespace;assembly=MyAssembly"> 
    <TextBox 
     v:ValidationBehavior.HasError="{Binding MyPropertyOnMyViewModel}"> 
     <TextBox.Text> 
     <Binding 
      Path="ValidationText" 
      UpdateSourceTrigger="PropertyChanged"> 
      <Binding.ValidationRules> 
      <v:SomeValidationRuleInMyNamespace/> 
      </Binding.ValidationRules> 
     </Binding> 
    </TextBox.Text> 
    </TextBox> 
</ Window > 

Nun ist die Eigenschaft auf Ihrer Ansicht Modell wird mit Validation.HasError auf Textbox synchronisiert werden.

Answer 5

Sie müssen abhängig von der Bindungstypeigenschaft custome user control angeben. Zum Beispiel, wenn Ihre Eigenschaft int-Typ ist, müssen Sie Steuerelement, das nicht anderen Wert als interenger Typ zulassen.

Die Logik, die Sie in PreviewTextInput = "NumberValidationTextBox" einfügen können.

private void NumberValidationTextBox(object sender, TextCompositionEventArgs e) 
    { 
     Regex regex = new Regex("[^0-9]+"); 
     e.Handled = regex.IsMatch(e.Text); 
    } 

Geben Sie einfach Ihre Logik ein oder legen Sie die Kontrolle über Ihre Kunden ein und Sie sind fertig.

Defend muss auch mvvm Validierung implementieren.

Answer 6

1. Implementieren Sie IDataErrorInfo in Ihrem Modell oder Viewmodel abhängig Logik der Bindungseigenschaft. Sie können in beiden Klassen implementieren.

2. Implementieren Sie dies auch in Ihrer Basisvalidierungsklasse. Hier wird die Validierung ausgelöst, wenn IDataErrorInfo nicht funktioniert.

   public virtual bool HasError 
   { 
       get { return _hasError; } 
       set 
       { 
        // if (value.Equals(_hasError)) return; 
        _hasError = value; 
        RaisePropertyChanged(() => HasError); 
       } 
   } 
   

3. Als Nächstes fügen globale Klasse

   public class ProtocolSettingsLayout 
   { 
       public static readonly DependencyProperty MVVMHasErrorProperty = DependencyProperty.RegisterAttached("MVVMHasError", typeof(bool), typeof(ProtocolSettingsLayout), new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, null, CoerceMVVMHasError)); 
   
       public static bool GetMVVMHasError(DependencyObject d) 
       { 
        return (bool)d.GetValue(MVVMHasErrorProperty); 
       } 
   
       public static void SetMVVMHasError(DependencyObject d, bool value) 
       { 
        d.SetValue(MVVMHasErrorProperty, value); 
       } 
   
       private static object CoerceMVVMHasError(DependencyObject d, Object baseValue) 
       { 
        bool ret = (bool)baseValue; 
   
        if (BindingOperations.IsDataBound(d, MVVMHasErrorProperty)) 
        { 
         if (GetHasErrorDescriptor(d) == null) 
         { 
          DependencyPropertyDescriptor desc = DependencyPropertyDescriptor.FromProperty(Validation.HasErrorProperty, d.GetType()); 
          desc.AddValueChanged(d, OnHasErrorChanged); 
          SetHasErrorDescriptor(d, desc); 
          ret = System.Windows.Controls.Validation.GetHasError(d); 
         } 
        } 
        else 
        { 
         if (GetHasErrorDescriptor(d) != null) 
         { 
          DependencyPropertyDescriptor desc = GetHasErrorDescriptor(d); 
          desc.RemoveValueChanged(d, OnHasErrorChanged); 
          SetHasErrorDescriptor(d, null); 
         } 
        } 
        return ret; 
       } 
   
       private static readonly DependencyProperty HasErrorDescriptorProperty = DependencyProperty.RegisterAttached("HasErrorDescriptor", 
                         typeof(DependencyPropertyDescriptor), 
                         typeof(ProtocolSettingsLayout)); 
   
       private static DependencyPropertyDescriptor GetHasErrorDescriptor(DependencyObject d) 
       { 
        var ret = d.GetValue(HasErrorDescriptorProperty); 
        return ret as DependencyPropertyDescriptor; 
       } 
   
       private static void OnHasErrorChanged(object sender, EventArgs e) 
       { 
        DependencyObject d = sender as DependencyObject; 
   
        if (d != null) 
        { 
         d.SetValue(MVVMHasErrorProperty, d.GetValue(Validation.HasErrorProperty)); 
        } 
       } 
   
       private static void SetHasErrorDescriptor(DependencyObject d, DependencyPropertyDescriptor value) 
       { 
        var ret = d.GetValue(HasErrorDescriptorProperty); 
        d.SetValue(HasErrorDescriptorProperty, value); 
       } 
   } 
   

4. XAML

   <TextBox PreviewTextInput="NumValidationTextBox" Text="{Binding ESec, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=true, NotifyOnValidationError=true, ValidatesOnExceptions=True, NotifyOnSourceUpdated=True, NotifyOnTargetUpdated=True, TargetNullValue='0', FallbackValue='0' }" Validation.ErrorTemplate="{StaticResource validationTemplate}" viewmodels:ProtocolSettingsLayout.MVVMHasError="{Binding Path=HasError}" />  
   

Answer 7

Seit .NET 4.5, ValidationRule eine Überlastung der Validate-Methode hat:

public ValidationResult Validate(object value, CultureInfo cultureInfo, 
    BindingExpressionBase owner) 

Sie können es außer Kraft setzen und das View-Modell auf diese Weise erhalten:

public override ValidationResult Validate(object value, 
    CultureInfo cultureInfo, BindingExpressionBase owner) 
{ 
    ValidationResult result = base.Validate(value, cultureInfo, owner); 
    var vm = (YourViewModel)((BindingExpression)owner).DataItem; 
    // ... 
    return result; 
} 

Answer 8

traf ich das gleiche Problem und löste es mit einem Trick. Siehe Konverter unter:

public class IntValidationConverter : IValueConverter 
{ 
    static string[] AllValuse = new string[100000]; 
    static int index = 1; 
    public static int StartOfErrorCodeIndex = -2000000000; 
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture) 
    { 
     if (value == null) return null; 
     if (value.ToString() == "") return null; 

     int iValue = (int)(value); 

     if (iValue == int.MinValue) return null; 

     if (iValue >= StartOfErrorCodeIndex) return value; 
     if ((iValue < IntValidationConverter.StartOfErrorCodeIndex) && (iValue > int.MinValue)) return AllValuse[StartOfErrorCodeIndex - iValue]; 

     return null; 
    } 

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) 
    { 
     if (value == null) return int.MinValue; 
     if (value.ToString() == "") return int.MinValue; 

     int result; 
     bool success = int.TryParse(value.ToString(), out result); 
     if (success) return result; 

     index++; 
     AllValuse[index] = value.ToString(); 
     return StartOfErrorCodeIndex - index; 
    } 
} 

Answer 9

ich das gleiche Problem mit Ihnen zu haben, aber ich in einer anderen Art und Weise zu lösen, benutze ich den Trigger die Taste zu deaktivieren, wenn die Eingabe ungültig ist. Unterdessen sollte die Textbox Bindung verwenden ValidatesOnExceptions=true

<Style TargetType="{x:Type Button}"> 
<Style.Triggers> 
    <DataTrigger Binding="{Binding ElementName=tbInput1, Path=(Validation.HasError)}" Value="True"> 
     <Setter Property="IsEnabled" Value="False"></Setter> 
    </DataTrigger> 

    <DataTrigger Binding="{Binding ElementName=tbInput2, Path=(Validation.HasError)}" Value="True"> 
     <Setter Property="IsEnabled" Value="False"></Setter> 
    </DataTrigger> 
</Style.Triggers>