/// <summary>
/// Obtient une concaténation des messages d'erreur pour le nom du champ spécifié.
/// </summary>
public virtual string this[string columnName]
{
get
{
// L'objet n'a pas encore été validé
if (_validationResults == null)
{
return(string.Empty);
}
ValidationResults filteredResults = new ValidationResults();
filteredResults.AddAllResults(_validationResults.Where(vr => vr.Key == columnName));
if (!filteredResults.IsValid)
{
//On renvoie la concaténation de toutes les erreurs sur la propriété "columnName"
IEnumerable <string> messages = filteredResults
.Flatten(vr => vr.NestedValidationResults)
.Where(vr => vr.NestedValidationResults == null || !vr.NestedValidationResults.Any())//on prend seulement les feuilles de l'arbre
.Select(vr => vr.Message);
return(string.Join("|", messages));
}
return(string.Empty);
}
}
public static string GetColumnValidationMessage(string columnName, ValidationResults validationResults)
{
if (validationResults == null)
{
return(null);
}
if (String.IsNullOrEmpty(columnName))
{
return(null);
}
IEnumerable <ValidationResult> columnValidationResults = validationResults.Where(vr => vr.Key.Equals(columnName));
if (columnValidationResults.Count() == 0)
{
return(null);
}
string validationMessage = String.Empty;
string newLine = String.Empty;
foreach (var r in columnValidationResults)
{
validationMessage += newLine + r.Message;
newLine = "\n";
}
return(validationMessage);
}
///<summary>
/// Validates a property of the entity and returns the information about invalid values.
///</summary>
///<param name="entityInstance"></param>
///<param name="property"></param>
///<returns></returns>
public IList <IInvalidValueInfo> Validate(object entityInstance, string property)
{
ValidationResults vapResults = DoValidation(entityInstance);
var resultsForProperty = vapResults.Where(v => v.Key == property);
return(ConvertErrors(resultsForProperty));
}
public string this[string propertyName]
{
get
{
currentResults = (Rulesets == null || Rulesets.Length == 0)
? Validation.Validate(this, Ruleset.DEFAULT)
: Validation.Validate(this, Rulesets);
return string.Join(
Environment.NewLine,
currentResults.Where(r => r.Key == propertyName).Select(r => r.Message));
}
}
/// <summary>
/// Valide l'état du model de façon synchrone
/// </summary>
void InternalUpdateValidationState()
{
IsValidating = true;
try
{
bool?wasValid = null;
// Stocke les propriétés qui étaient en erreur
IList <string> invalidKeys = null;
// Récupère les propriétés qui étaient en erreur
if (_validationResults != null)
{
invalidKeys = _validationResults.Select(vr => vr.Key).ToList();
if (!invalidKeys.Any())
{
invalidKeys = null;
}
wasValid = _validationResults.IsValid;
}
// Valide l'objet
_validationResults = _validator.Validate(this);
if (invalidKeys != null)
{
// Parcourt les propriétés qui étaient en erreur auparavant
foreach (string key in invalidKeys)
{
// S'il y a eu un changement d'état, il faut en prévenir les bindings
if (!_validationResults.Any(vr => vr.Key == key))
{
OnPropertyChanged(key, false);
}
}
}
if (!_validationResults.IsValid)
{
// Parcourt des propriétés qui sont en erreur
foreach (var result in _validationResults.Where(vr => vr.Target == this))
{
OnPropertyChanged(result.Key, false);
}
}
// Si l'objet change d'état de validité, on prévient les bindings
if (!wasValid.HasValue || wasValid.Value != _validationResults.IsValid)
{
OnIsValidChanged();
}
if (!(invalidKeys == null && _validationResults.IsValid))
{
OnPropertyChanged(nameof(Error), false);
OnPropertyChanged(nameof(Errors), false);
}
}
finally
{
IsValidating = false;
}
}