Is it possible to write new attached property like Validation.Errors, say MyValidation.XYZ

Alexander Landa 0

Hello,

I would like to use some set of my own different attached properties not defined in Validation.cs.

Actually I've tried all known possible ways including AddValueChanged for existing public Validation.<DependencyProperty>, but no have no luck - I get only a default value of new property and has no chance to get an actualization event fired.

Thank you for assistance.

1 answer

Hui Liu-MSFT 48,566 Microsoft Vendor

Hi,@Alexander Landa. Welcome to Microsoft Q&A. It is possible to create your own attached properties in WPF, similar to Validation.Errors, for various purposes such as custom validation, behavior addition, or data binding facilitation.

Here's an example of create a custom attached property MyValidation.XYZ:

<StackPanel>

    <TextBox Width="100" Height="60" Text="{Binding MyValue}" local:MyValidation.XYZ="{Binding MyValue}" />

</StackPanel>

Codebehind:

public partial class MainWindow : Window,INotifyPropertyChanged
{
    public MainWindow()
    {
        InitializeComponent();
        DataContext = this;
    }
    private string myValue;

    public string MyValue
    {
        get { return myValue; }
        set { myValue = value; OnPropertyChanged(); }
    }
    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged([CallerMemberName] string name = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
    }

}
public static class MyValidation
{
    public static readonly DependencyProperty XYZProperty =
        DependencyProperty.RegisterAttached("XYZ", typeof(string), typeof(MyValidation),
            new PropertyMetadata(null, OnXYZPropertyChanged));

    public static string GetXYZ(DependencyObject obj)
    {
        return (string)obj.GetValue(XYZProperty);
    }

    public static void SetXYZ(DependencyObject obj, string value)
    {
        obj.SetValue(XYZProperty, value);
    }

    private static void OnXYZPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        // This method will be called whenever the value of XYZ property changes
        // You can perform any necessary actions here
        string newValue = (string)e.NewValue;
        string oldValue = (string)e.OldValue;

        // Example: Logging the change
        System.Diagnostics.Debug.WriteLine($"XYZ property changed from '{oldValue}' to '{newValue}'");
    }
}

The result:

When MyValue changes, a meesage is displayed in the output window.

XYZ property changed from '' to 'FFF' XYZ property changed from 'FFF' to 'DDD'

If the answer is the right solution, please click "Accept Answer" and kindly upvote it. If you have extra questions about this answer, please click "Comment".

Note: Please follow the steps in our documentation to enable e-mail notifications if you want to receive the related email notification for this thread.

Alexander Landa 0 Reputation points

2024-03-26T08:47:24.0766667+00:00

Thank you.

My goal is slightly different. The validation is done (and in some cases can only be done) by a ViewModel, not by attached Rules inside WPF/XAML. The elements in the View have no Binding to such attached property. Moreover, I would like to define a Style, where the new attached property acts like a trigger property. So, at some time, at some point this should be a notification change for this property. Because of the huge amount of ViewModel's I like to separate the business logic, the validation logic and so on, and should not have the tight couple with new visual validation property Validation.XYZ inside classes.

Hui Liu-MSFT 48,566 Microsoft Vendor

Hi,@Alexander Landa. If your goal is to have validation logic handled by the ViewModel and have a way to trigger UI updates based on the validation state, you can achieve this without directly binding to an attached property in XAML.

Instead, you could use the INotifyDataErrorInfo interface along with data validation techniques in WPF.

  <Window.Resources>
      <local:BoolToVisibilityConverter x:Key="BoolToVisibilityConverter"/>
  </Window.Resources>
  <Window.DataContext>
      <local:MainViewModel/>
  </Window.DataContext>
  <Grid>
      <StackPanel>
          <TextBox Width="100" Height="60" Text="{Binding MyValue, UpdateSourceTrigger=PropertyChanged}" />
          <TextBlock Text="Validation Error:" Visibility="{Binding HasErrors, Converter={StaticResource BoolToVisibilityConverter}}"/>
      </StackPanel>
  </Grid>

Codebedhind:


  public class MainViewModel : INotifyPropertyChanged, INotifyDataErrorInfo
  {
      private string _myValue ="value";
      private Dictionary<string, List<string>> _errors = new Dictionary<string, List<string>>();

      public string MyValue
      {
          get => _myValue;
          set
          {
              _myValue = value;
              ValidateProperty(value, nameof(MyValue));
              OnPropertyChanged();
              OnPropertyChanged(nameof(HasErrors));
          }
      }

      public bool HasErrors => _errors.Count > 0;

      public event PropertyChangedEventHandler PropertyChanged;
      public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;

      protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
      {
          PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
      }

      public IEnumerable GetErrors(string propertyName)
      {
          if (_errors.ContainsKey(propertyName))
          {
              return _errors[propertyName];
          }
          return null;
      }

      public bool HasErrorsForProperty(string propertyName)
      {
          return _errors.ContainsKey(propertyName);
      }

      private void ValidateProperty(object value, [CallerMemberName] string propertyName = "")
      {
            // Perform validation logic here and add errors to the _errors dictionary
        // assume we're validating MyValue is not empty
          if (string.IsNullOrWhiteSpace((string)value))
          {
           AddError(propertyName, "Value cannot be empty.");
          }
          else
          {
              RemoveError(propertyName);
          }
      }

      private void AddError(string propertyName, string error)
      {
          if (!_errors.ContainsKey(propertyName))
          {
              _errors[propertyName] = new List<string>();
          }
          if (!_errors[propertyName].Contains(error))
          {
              _errors[propertyName].Add(error);
              OnErrorsChanged(propertyName);
          }
      }

      private void RemoveError(string propertyName)
      {
          if (_errors.ContainsKey(propertyName))
          {
              _errors.Remove(propertyName);
              OnErrorsChanged(propertyName);
          }
      }

      private void OnErrorsChanged(string propertyName)
      {
          ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
      }
  }

  public class BoolToVisibilityConverter : IValueConverter
  {
      public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
      {
          if (value is bool boolValue)
          {
              if (boolValue)
                  return Visibility.Visible;
              else
                  return Visibility.Collapsed; // or Visibility.Hidden based on your requirement
          }

     
          return Visibility.Collapsed;
      }

      public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
      {
          throw new NotImplementedException();
      }
  }


```If the problem exists, please feel free to let me know. You could show a minimal, reproducible example without private information so I can reproduce the issue. If your question is more complete and clear, you may get a more accurate solution.

Share via

Is it possible to write new attached property like Validation.Errors, say MyValidation.XYZ

1 answer

Your answer