// <summary>
// Validates a property or an entity.
// </summary>
// <param name="entityValidationContext"> Validation context. Never null. </param>
// <param name="property"> Property to validate. Null for entity validation. Not null for property validation. </param>
// <returns>
// Validation errors as <see cref="IEnumerable{DbValidationError}" /> . Empty if no errors, never null.
// </returns>
public virtual IEnumerable<DbValidationError> Validate(
EntityValidationContext entityValidationContext, InternalMemberEntry property)
{
DebugCheck.NotNull(entityValidationContext);
var validationContext = entityValidationContext.ExternalValidationContext;
validationContext.SetDisplayName(property, _displayAttribute);
var objectToValidate = property == null
? entityValidationContext.InternalEntity.Entity
: property.CurrentValue;
ValidationResult validationResult = null;
try
{
validationResult = _validationAttribute.GetValidationResult(objectToValidate, validationContext);
}
catch (Exception ex)
{
throw new DbUnexpectedValidationException(
Strings.DbUnexpectedValidationException_ValidationAttribute(
validationContext.DisplayName, _validationAttribute.GetType()),
ex);
}
return validationResult != ValidationResult.Success
? DbHelpers.SplitValidationResults(validationContext.MemberName, new[] { validationResult })
: Enumerable.Empty<DbValidationError>();
}
/// <summary>
/// Contract for IValidator.Validate method.
/// </summary>
/// <param name = "entityValidationContext">Validation context.</param>
/// <param name = "property">Property.</param>
/// <returns>Nothing - always throws.</returns>
IEnumerable<DbValidationError> IValidator.Validate(
EntityValidationContext entityValidationContext, InternalMemberEntry property)
{
Contract.Requires(entityValidationContext != null);
Contract.Ensures(Contract.Result<IEnumerable<DbValidationError>>() != null);
throw new NotImplementedException();
}
/// <summary>
/// Validates an entity.
/// </summary>
/// <param name = "entityValidationContext">Entity validation context. Must not be null.</param>
/// <returns><see cref = "DbEntityValidationResult" /> instance. Never null.</returns>
public DbEntityValidationResult Validate(EntityValidationContext entityValidationContext)
{
Contract.Requires(entityValidationContext != null);
Contract.Assert(entityValidationContext.InternalEntity != null);
var validationErrors = Validate(entityValidationContext, null);
return new DbEntityValidationResult(entityValidationContext.InternalEntity, validationErrors);
}
/// <summary>
/// Validates an entity.
/// </summary>
/// <param name="entityValidationContext"> Entity validation context. Must not be null. </param>
/// <returns>
/// <see cref="DbEntityValidationResult" /> instance. Never null.
/// </returns>
public DbEntityValidationResult Validate(EntityValidationContext entityValidationContext)
{
DebugCheck.NotNull(entityValidationContext);
Debug.Assert(entityValidationContext.InternalEntity != null);
var validationErrors = Validate(entityValidationContext, null);
return new DbEntityValidationResult(entityValidationContext.InternalEntity, validationErrors);
}
/// <summary>
/// Validates type properties. Any validation errors will be added to <paramref name = "validationErrors" />
/// collection.
/// </summary>
/// <param name = "entityValidationContext">
/// Validation context. Must not be null.
/// </param>
/// <param name = "validationErrors">
/// Collection of validation errors. Any validation errors will be added to it.
/// </param>
/// <param name = "parentProperty">The entry for the complex property. Null if validating an entity.</param>
/// <remarks>
/// Note that <paramref name = "validationErrors" /> will be modified by this method. Errors should be only added,
/// never removed or changed. Taking a collection as a modifiable parameter saves a couple of memory allocations
/// and a merge of validation error lists per entity.
/// </remarks>
protected override void ValidateProperties(
EntityValidationContext entityValidationContext, InternalPropertyEntry parentProperty,
List<DbValidationError> validationErrors)
{
var entityEntry = entityValidationContext.InternalEntity;
foreach (var validator in PropertyValidators)
{
validationErrors.AddRange(
validator.Validate(entityValidationContext, entityEntry.Member(validator.PropertyName)));
}
}
/// <summary>
/// Validates type properties. Any validation errors will be added to <paramref name = "validationErrors" />
/// collection.
/// </summary>
/// <param name = "entityValidationContext">
/// Validation context. Must not be null.
/// </param>
/// <param name = "validationErrors">
/// Collection of validation errors. Any validation errors will be added to it.
/// </param>
/// <param name = "parentProperty">The entry for the complex property. Null if validating an entity.</param>
/// <remarks>
/// Note that <paramref name = "validationErrors" /> will be modified by this method. Errors should be only added,
/// never removed or changed. Taking a collection as a modifiable parameter saves a couple of memory allocations
/// and a merge of validation error lists per entity.
/// </remarks>
protected override void ValidateProperties(
EntityValidationContext entityValidationContext, InternalPropertyEntry parentProperty,
List<DbValidationError> validationErrors)
{
Contract.Assert(parentProperty.EntryMetadata.IsComplex, "A complex type expected.");
Contract.Assert(parentProperty.CurrentValue != null);
foreach (var validator in PropertyValidators)
{
var complexProperty = parentProperty.Property(validator.PropertyName);
validationErrors.AddRange(validator.Validate(entityValidationContext, complexProperty));
}
}
/// <summary>
/// Validates a property.
/// </summary>
/// <param name = "entityValidationContext">Validation context. Never null.</param>
/// <param name = "property">Property to validate. Never null.</param>
/// <returns>Validation errors as <see cref = "IEnumerable{DbValidationError}" />. Empty if no errors. Never null.
/// </returns>
public virtual IEnumerable<DbValidationError> Validate(
EntityValidationContext entityValidationContext, InternalMemberEntry property)
{
//Contract.Requires(entityValidationContext != null);
//Contract.Requires(property != null);
var validationErrors = new List<DbValidationError>();
foreach (var validator in _propertyValidators)
{
validationErrors.AddRange(validator.Validate(entityValidationContext, property));
}
return validationErrors;
}
/// <summary>
/// Validates a property.
/// </summary>
/// <param name="entityValidationContext"> Validation context. Never null. </param>
/// <param name="property"> Property to validate. Never null. </param>
/// <returns>
/// Validation errors as <see cref="IEnumerable{DbValidationError}" /> . Empty if no errors. Never null.
/// </returns>
public virtual IEnumerable<DbValidationError> Validate(
EntityValidationContext entityValidationContext, InternalMemberEntry property)
{
DebugCheck.NotNull(entityValidationContext);
DebugCheck.NotNull(property);
var validationErrors = new List<DbValidationError>();
foreach (var validator in _propertyValidators)
{
validationErrors.AddRange(validator.Validate(entityValidationContext, property));
}
return validationErrors;
}
/// <summary>
/// Validates an instance.
/// </summary>
/// <param name = "entityValidationContext">Entity validation context. Must not be null.</param>
/// <param name = "property">The entry for the complex property. Null if validating an entity.</param>
/// <returns><see cref = "DbEntityValidationResult" /> instance. Never null.</returns>
/// <remarks>
/// Protected so it doesn't appear on EntityValidator.
/// </remarks>
protected IEnumerable<DbValidationError> Validate(
EntityValidationContext entityValidationContext, InternalPropertyEntry property)
{
var validationErrors = new List<DbValidationError>();
ValidateProperties(entityValidationContext, property, validationErrors);
// only run type level validation if all properties were validated successfully
if (!validationErrors.Any())
{
foreach (var typeLevelValidator in _typeLevelValidators)
{
validationErrors.AddRange(typeLevelValidator.Validate(entityValidationContext, property));
}
}
return validationErrors;
}
/// <summary>
/// Validates a complex property.
/// </summary>
/// <param name="entityValidationContext"> Validation context. Never null. </param>
/// <param name="property"> Property to validate. Never null. </param>
/// <returns> Validation errors as <see cref="IEnumerable{DbValidationError}" /> . Empty if no errors. Never null. </returns>
public override IEnumerable<DbValidationError> Validate(
EntityValidationContext entityValidationContext, InternalMemberEntry property)
{
Contract.Assert(property is InternalPropertyEntry);
var validationErrors = new List<DbValidationError>();
validationErrors.AddRange(base.Validate(entityValidationContext, property));
// don't drill into complex types if there were errors or the complex property has not been initialized at all
if (!validationErrors.Any() && property.CurrentValue != null
&&
_complexTypeValidator != null)
{
validationErrors.AddRange(
_complexTypeValidator.Validate(entityValidationContext, (InternalPropertyEntry)property));
}
return validationErrors;
}
/// <summary>
/// Validates an entity or a complex type implementing IValidatableObject interface.
/// This method is virtual to allow mocking.
/// </summary>
/// <param name="entityValidationContext"> Validation context. Never null. </param>
/// <param name="property"> Property to validate. Null if this is the entity that will be validated. Never null if this is the complex type that will be validated. </param>
/// <returns>
/// Validation error as <see cref="IEnumerable{DbValidationError}" /> . Empty if no errors. Never null.
/// </returns>
/// <remarks>
/// Note that <paramref name="property" /> is used to figure out what needs to be validated. If it not null the complex
/// type will be validated otherwise the entity will be validated.
/// Also if this is an IValidatableObject complex type but the instance (.CurrentValue) is null we won't validate
/// anything and will not return any errors. The reason for this is that Validation is supposed to validate using
/// information the user provided and not some additional implicit rules. (ObjectContext will throw for operations
/// that involve null complex properties).
/// </remarks>
public virtual IEnumerable<DbValidationError> Validate(
EntityValidationContext entityValidationContext, InternalMemberEntry property)
{
DebugCheck.NotNull(entityValidationContext);
Debug.Assert(
(property == null && entityValidationContext.InternalEntity.Entity is IValidatableObject) ||
(property != null && (property.CurrentValue == null || property.CurrentValue is IValidatableObject)),
"Neither entity nor complex type implements IValidatableObject.");
if (property != null
&& property.CurrentValue == null)
{
return Enumerable.Empty<DbValidationError>();
}
var validationContext = entityValidationContext.ExternalValidationContext;
validationContext.SetDisplayName(property, _displayAttribute);
var validatableObject = (IValidatableObject)(property == null
? entityValidationContext.InternalEntity.Entity
: property.CurrentValue);
IEnumerable<ValidationResult> validationResults = null;
try
{
validationResults = validatableObject.Validate(validationContext);
}
catch (Exception ex)
{
throw new DbUnexpectedValidationException(
Strings.DbUnexpectedValidationException_IValidatableObject(
validationContext.DisplayName, ObjectContextTypeCache.GetObjectType(validatableObject.GetType())),
ex);
}
return DbHelpers.SplitValidationResults(
validationContext.MemberName,
validationResults ?? Enumerable.Empty<ValidationResult>());
}
// <summary>
// Validates a complex property.
// </summary>
// <param name="entityValidationContext"> Validation context. Never null. </param>
// <param name="property"> Property to validate. Never null. </param>
// <returns>
// Validation errors as <see cref="IEnumerable{DbValidationError}" /> . Empty if no errors. Never null.
// </returns>
public override IEnumerable <DbValidationError> Validate(
EntityValidationContext entityValidationContext, InternalMemberEntry property)
{
Debug.Assert(property is InternalPropertyEntry);
var validationErrors = new List <DbValidationError>();
validationErrors.AddRange(base.Validate(entityValidationContext, property));
// don't drill into complex types if there were errors or the complex property has not been initialized at all
if (!validationErrors.Any() &&
property.CurrentValue != null
&&
_complexTypeValidator != null)
{
validationErrors.AddRange(
_complexTypeValidator.Validate(entityValidationContext, (InternalPropertyEntry)property));
}
return(validationErrors);
}
public virtual IEnumerable <DbValidationError> Validate(
EntityValidationContext entityValidationContext,
InternalMemberEntry property)
{
if (property != null && property.CurrentValue == null)
{
return(Enumerable.Empty <DbValidationError>());
}
ValidationContext validationContext = entityValidationContext.ExternalValidationContext;
validationContext.SetDisplayName(property, this._displayAttribute);
IValidatableObject validatableObject = property == null ? (IValidatableObject)entityValidationContext.InternalEntity.Entity : (IValidatableObject)property.CurrentValue;
IEnumerable <ValidationResult> validationResults;
try
{
validationResults = validatableObject.Validate(validationContext);
}
catch (Exception ex)
{
throw new DbUnexpectedValidationException(Strings.DbUnexpectedValidationException_IValidatableObject((object)validationContext.DisplayName, (object)ObjectContextTypeCache.GetObjectType(validatableObject.GetType())), ex);
}
return(DbHelpers.SplitValidationResults(validationContext.MemberName, validationResults ?? Enumerable.Empty <ValidationResult>()));
}
// <summary>
// Validates a property or an entity.
// </summary>
// <param name="entityValidationContext"> Validation context. Never null. </param>
// <param name="property"> Property to validate. Null for entity validation. Not null for property validation. </param>
// <returns>
// Validation errors as <see cref="IEnumerable{DbValidationError}" /> . Empty if no errors, never null.
// </returns>
public virtual IEnumerable <DbValidationError> Validate(
EntityValidationContext entityValidationContext, InternalMemberEntry property)
{
DebugCheck.NotNull(entityValidationContext);
if (!AttributeApplicable(entityValidationContext, property))
{
return(Enumerable.Empty <DbValidationError>());
}
var validationContext = entityValidationContext.ExternalValidationContext;
validationContext.SetDisplayName(property, _displayAttribute);
var objectToValidate = property == null
? entityValidationContext.InternalEntity.Entity
: property.CurrentValue;
ValidationResult validationResult = null;
try
{
validationResult = _validationAttribute.GetValidationResult(objectToValidate, validationContext);
}
catch (Exception ex)
{
throw new DbUnexpectedValidationException(
Strings.DbUnexpectedValidationException_ValidationAttribute(
validationContext.DisplayName, _validationAttribute.GetType()),
ex);
}
return(validationResult != ValidationResult.Success
? DbHelpers.SplitValidationResults(validationContext.MemberName, new[] { validationResult })
: Enumerable.Empty <DbValidationError>());
}
protected override void ValidateProperties(
EntityValidationContext entityValidationContext, InternalPropertyEntry parentProperty,
List<DbValidationError> validationErrors)
{
//Contract.Requires(entityValidationContext != null);
//Contract.Requires(validationErrors != null);
}
// <summary>
// Validates type properties. Any validation errors will be added to <paramref name="validationErrors" />
// collection.
// </summary>
// <param name="entityValidationContext"> Validation context. Must not be null. </param>
// <param name="parentProperty"> The entry for the complex property. Null if validating an entity. </param>
// <param name="validationErrors"> Collection of validation errors. Any validation errors will be added to it. </param>
// <remarks>
// Note that <paramref name="validationErrors" /> will be modified by this method. Errors should be only added,
// never removed or changed. Taking a collection as a modifiable parameter saves a couple of memory allocations
// and a merge of validation error lists per entity.
// </remarks>
protected abstract void ValidateProperties(
EntityValidationContext entityValidationContext, InternalPropertyEntry parentProperty,
List <DbValidationError> validationErrors);
/// <summary>
/// Validates an instance.
/// </summary>
/// <param name="entityValidationContext"> Entity validation context. Must not be null. </param>
/// <param name="property"> The entry for the complex property. Null if validating an entity. </param>
/// <returns>
/// <see cref="DbEntityValidationResult" /> instance. Never null.
/// </returns>
public new IEnumerable <DbValidationError> Validate(
EntityValidationContext entityValidationContext, InternalPropertyEntry property)
{
return(base.Validate(entityValidationContext, property));
}
/// <summary>
/// Validates an instance.
/// </summary>
/// <param name = "entityValidationContext">Entity validation context. Must not be null.</param>
/// <param name = "property">The entry for the complex property. Null if validating an entity.</param>
/// <returns><see cref = "DbEntityValidationResult" /> instance. Never null.</returns>
public new IEnumerable<DbValidationError> Validate(
EntityValidationContext entityValidationContext, InternalPropertyEntry property)
{
return base.Validate(entityValidationContext, property);
}
/// <summary>
/// Validates type properties. Any validation errors will be added to <paramref name = "validationErrors" />
/// collection.
/// </summary>
/// <param name = "entityValidationContext">
/// Validation context. Must not be null.
/// </param>
/// <param name = "validationErrors">
/// Collection of validation errors. Any validation errors will be added to it.
/// </param>
/// <param name = "parentProperty">The entry for the complex property. Null if validating an entity.</param>
/// <remarks>
/// Note that <paramref name = "validationErrors" /> will be modified by this method. Errors should be only added,
/// never removed or changed. Taking a collection as a modifiable parameter saves a couple of memory allocations
/// and a merge of validation error lists per entity.
/// </remarks>
protected abstract void ValidateProperties(
EntityValidationContext entityValidationContext, InternalPropertyEntry parentProperty,
List<DbValidationError> validationErrors);
// <summary>
// Determines if the attribute should be enforced given the context of the validation request.
// </summary>
// <param name="entityValidationContext"> Validation context. Never null. </param>
// <param name="property"> Property to validate. Null for entity validation. Not null for property validation. </param>
// <returns> True if the attribute should be enforced; otherwise false. </returns>
protected virtual bool AttributeApplicable(
EntityValidationContext entityValidationContext, InternalMemberEntry property)
{
// Do not apply RequiredAttrbiute to existing entities when the property is
// a navigation property and it has not been loaded.
var internalNavigationProperty = property as InternalNavigationEntry;
if (_validationAttribute is RequiredAttribute &&
property != null && property.InternalEntityEntry != null &&
property.InternalEntityEntry.State != EntityState.Added && property.InternalEntityEntry.State != EntityState.Detached &&
internalNavigationProperty != null && !internalNavigationProperty.IsLoaded)
{
return false;
}
return true;
}
