12

In the msdn page for InotifyDataErrorInfo.GetErrors it says that GetErrors method is called with a parameter which can be either:

  • The name of the property we want to retrieve error info for
  • Null
  • String.Empty

The documentation doesn't say when this method is called with null vs String.Empty. I've seen both cases in my app and I need to understand when I can expect one or the other.

Clarification: I'm not asking about how I should implement GetErrors method (I simply test for both null and empty). The question is more to understand why the WPF framework tries to call this method sometimes with null and sometimes with an empty string (I encountered both cases in my app). If the intent is to ask for errors that are not tied to a specific property, why use two different values for the call when only one is enough?

Improve this question
1
  • Do I get your question right, that you're asking, why you should distinguish between null and string.Empty? Commented Jan 25, 2016 at 15:39

4 Answers 4

Reset to default
2

You have to expect both null and string.Empty when the caller wants to know not the error for a specific parameter but the errors for all parameters of the entity. So you should not make a difference between null and string.Empty.

So something in this way:

if(string.IsNullOrEmpty(propertyName))
{
    // return all errors
}
else
{
    // return the error for the parameter 'propertyName'
}
Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

The answer in short: you should not care.
I wouldn't search for a pattern when it is called with null and when it is called with string.Empty, as the interface description allows both. So I belive some microsoft developers used null and the others used string.Empty. So you will find which group implemented the calling class. But that will not help you to write your application or something similar.
I disagree with. If there's a reason behind this behavior that is not documented in msdn I would like to know about it and understand what's the difference between the two cases. If there's no difference then there's something wrong with the framework
You should implement against the interface, not the implementation behind it. As both 'null' and 'string.Empty' are allowed for asking for all errors both variants will be used. I don't see why something should be wrong with the framework. Maybe the Interface is not designed very well. It maybe would have been better to use two functions and disallow 'null' and 'string.Empty' as a value of this function.
I got stuck with this error for quite some time until I came across this answer that fixed the problem. I had implemented the INotifyDataErrorInfo.GetErrors but completly didn't think of evaluating for string.IsNullOrEmpty(propertyName) and GetErrors kept on throwing ArgumentException that a key for propertyName in the dictionary used for storing the errors is "" or null.
2

WPF calls InotifyDataErrorInfo.GetErrors(null/string.Empty) to get errors of "entire view model". All controls that have data context or binding to view model with "entire view model errors" will be rendered with error template. For example you have view model Credentials with two properties: UserName, Password. You may implement something like this:

IEnumerable InotifyDataErrorInfo.GetErrors(string propertyName)
    {
        if (UserNames.Length == 0)
        {
            if (string.IsNullOrEmpty(propertyName))
            {
                return "Some credentials component is wrong.";
            }
            else if (propertyName == "UserNames")
            {
                return "User name is required field.";
           }
        }
    }

However in most cases you may return null when string.IsNullOrEmpty(propertyName).

Improve this answer

Comments

2

You get the null argument when the binding refers to no property, as with the default Path:

DataContext="{Binding ValidatesOnNotifyDataErrors=True}"
DataContext="{Binding Path=., ValidatesOnNotifyDataErrors=True}"

This can be avoided by specifying an actual property in the Path. It can, of course, be a property in the view-model, including one that just returns "this".

Tag="{Binding Path=DataContext, RelativeSource={RelativeSource Self}, ValidatesOnNotifyDataErrors=True}"

As for string.Emtpy, that is explicit in the framework for the internal BindingExpression.UpdateNotifyDataErrors method:

List<object> propertyErrors = GetDataErrors(indei, propertyName);
List<object> valueErrors = GetDataErrors(dataErrorValue, String.Empty);
List<object> errors = MergeErrors(propertyErrors, valueErrors);

Warning: notice the aggregation operation above, so if you use string.IsNullOrEmpty to verify that the framework is asking for entity-level errors and return the same errors regardless of "null" vs. string.Emtpy, you might end up with duplicate messages in the UI (one for "null" and another for string.Empty). At least in today's .NET framework releases.

Improve this answer

Comments

0

When is INotifyDataErrorInfo.GetErrors called with null vs String.empty?

If you want to validate single property, you will call 

RaiseEvent ErrorsChanged(Me, New DataErrorsChangedEventArgs("PropertyName"))

from setter of that property.

If you want to validate entire entity, you will call 

RaiseEvent ErrorsChanged(Me, New DataErrorsChangedEventArgs(String.Empty))

from some "central" place, like Save button click, or Window closing.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.