public static void GetFinalError(SavingResult res, Exception ex)
{
res.ExecutionResult = eExecutionResult.ErrorWhileExecuting;
res.Exception = ex;
while (res.Exception != null && res.Exception.Message == "An error occurred while updating the entries. See the inner exception for details.")
{
res.Exception = res.Exception.InnerException;
}
if (ex.GetType() == typeof(System.Data.Entity.Validation.DbEntityValidationException))
{
res.ValidationError = "dbEntity Validation Errors : \r\n\r\n";
System.Data.Entity.Validation.DbEntityValidationException ValidationException = (System.Data.Entity.Validation.DbEntityValidationException)ex;
foreach (System.Data.Entity.Validation.DbEntityValidationResult ValidRes in ValidationException.EntityValidationErrors)
{
foreach (System.Data.Entity.Validation.DbValidationError ValidError in ValidRes.ValidationErrors)
{
res.ValidationError += ValidError.PropertyName + " = " + ValidError.ErrorMessage + "\r\n";
}
res.ValidationError += "\r\n";
}
res.Exception = new Exception(res.ValidationError);
}
}
public void DbEntityValidationException_parameterless_constructor()
{
var exception = new DbEntityValidationException();
Assert.Equal(Strings.DbEntityValidationException_ValidationFailed, exception.Message);
Assert.False(exception.EntityValidationErrors.Any());
}
/// <summary>
/// 设置异常数据
/// </summary>
private void SetExceptionDatas( DbEntityValidationException exception ) {
foreach ( var errors in exception.EntityValidationErrors ) {
foreach ( var error in errors.ValidationErrors ) {
Data.Add( string.Format( "{0}属性验证失败", error.PropertyName ), error.ErrorMessage );
}
}
}
protected void addErrorMessage(DbEntityValidationException exception)
{
if (exception != null)
{
if (exception.EntityValidationErrors != null && exception.EntityValidationErrors.Count() > 0)
{
foreach (DbEntityValidationResult result in exception.EntityValidationErrors)
{
if (result.ValidationErrors != null)
{
foreach (var error in result.ValidationErrors)
{
addErrorMessage(error.ErrorMessage);
}
}
}
}
else
{
if (!String.IsNullOrWhiteSpace(exception.Message))
{
addErrorMessage(exception.Message);
}
}
}
}
//public static int
public static string CreateComplexMessage(this System.Data.Entity.Validation.DbEntityValidationException exception, string glueBefore = " - ", string glueAfter = ";\r\n")
{
var error = "";
var parts = new List <string>();
foreach (var _error in exception.EntityValidationErrors)
{
if (!_error.IsValid)
{
foreach (var __error in _error.ValidationErrors)
{
var errorMessage = glueBefore + __error.ErrorMessage;
if (!string.IsNullOrEmpty(glueAfter))
{
if (!errorMessage.Last().In('.', ',', ';', '!', '?'))
{
errorMessage += glueAfter;
}
}
parts.Add(errorMessage);
}
}
}
error = string.Join("", parts);
return(error);
}
public void Append(DbEntityValidationException exception)
{
foreach (var validationError in exception.EntityValidationErrors.SelectMany(entityValidationError => entityValidationError.ValidationErrors))
{
Errors.Add(new PropertyMessagePair { PropertyName = validationError.PropertyName, Message = validationError.ErrorMessage });
}
}
/// <summary>
/// Recopila todas las validación falladas de una DbEntityValidationException y las convierte a string.
/// </summary>
/// <param name="ex"></param>
/// <returns></returns>
public static string ParseDbEntityValidationException(DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
return string.Join("<br/>", errorMessages);
}
public static string AnotarEntityValidationException(DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors.SelectMany(x => x.ValidationErrors).Select(x => x.ErrorMessage);
string fullErrorMessage = string.Join("; ", errorMessages);
string exceptionMessage = string.Concat(ex.Message, " The validation errors are: ", fullErrorMessage);
_log.Error(exceptionMessage);
return exceptionMessage;
}
public static string ExceptionMessage(DbEntityValidationException ex)
{
var errorMessage = ex.EntityValidationErrors.SelectMany(x => x.ValidationErrors).Select(x => x.ErrorMessage);
var fullErrorMessage = String.Join("; ", errorMessage);
var exceptionMessage = string.Concat(ex.Message, " The validation errors are: ", fullErrorMessage);
DbEntityValidationException e = new DbEntityValidationException(exceptionMessage, ex.EntityValidationErrors);
return e.Message;
}
public void GetValidationDescription_HandlesValidationErrors(DbEntityValidationException ex, string expected)
{
// Act
string actual = EntityUtils.GetValidationDescription(ex);
// Assert
Assert.Equal(expected, actual);
}
private IEnumerable<DataValidationResult> GetErrors(DbEntityValidationException validationException)
{
foreach (var dbEntityValidationResult in validationException.EntityValidationErrors)
{
EntityEntry entry = new EntityEntry(dbEntityValidationResult.Entry);
IEnumerable<ValidationError> entryErrors = GetEntryErrors(dbEntityValidationResult.ValidationErrors);
yield return new DataValidationResult(entry, entryErrors);
}
}
private void HandleException(DbEntityValidationException ex)
{
var details = from DbValidationError error in ex.EntityValidationErrors.First().ValidationErrors
select new
{
Error = error.ErrorMessage
};
ShowExceptions(details, STR_TEXT_ValidationErrors, STR_TITLE_ValidationErrors, STR_TITLE_ICON_warning, STR_PANEL_danger);
}
public static void Write(DbEntityValidationException exception)
{
Debug.WriteLine(exception.Message);
foreach (var validationError in exception.EntityValidationErrors)
{
Debug.WriteLine(validationError.Entry.Entity.GetType().Name);
}
}
public static void GetDbErrorState(DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
Trace.TraceInformation("Property: {0} Error: {1} Entity: {2}", validationError.PropertyName, validationError.ErrorMessage, validationErrors.Entry.Entity.GetType().FullName);
}
}
}
public static void CheckDbEntityValidationException(DbEntityValidationException e)
{
foreach (DbEntityValidationResult result in e.EntityValidationErrors)
{
foreach (DbValidationError ve in result.ValidationErrors)
{
Console.WriteLine("invalid property: {0}", ve.PropertyName);
}
}
}
public void RegistraErros(DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
foreach (var ve in eve.ValidationErrors)
{
ModelState.AddModelError(ve.PropertyName, ve.ErrorMessage);
}
}
}
public static void MergeValidationErrors(ModelStateDictionary state, DbEntityValidationException errors)
{
foreach (var entity in errors.EntityValidationErrors)
{
foreach (var error in entity.ValidationErrors)
{
state.AddModelError(error.PropertyName, error.ErrorMessage);
}
}
}
public void logDbContextException(DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
logger.Error("Entity of type \"" + eve.Entry.Entity.GetType().Name + "\" in state \"" + eve.Entry.State + "\" has the following validation errors:",e);
foreach (var ve in eve.ValidationErrors)
{
logger.Error("- Property: \"" + ve.PropertyName + "\", Error: \"" + ve.ErrorMessage + "\"",e);
}
}
}
internal static string GetErrorMessage(DbEntityValidationException validationException)
{
StringBuilder messageBuilder = new StringBuilder("Validation Errors").AppendLine();
var messages = from validationResult in validationException.EntityValidationErrors
select GetErrorMessage(validationResult);
messages.ToList<string>().ForEach(m => messageBuilder.AppendLine(m));
return messageBuilder.ToString();
}
public static void LogValidationErrors(DbEntityValidationException ex)
{
foreach (var eve in ex.EntityValidationErrors)
{
var s = string.Format("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
//Logging.PushString(s);
s = eve.ValidationErrors.Aggregate(s, (current, ve) => current + string.Format("- Property: \"{0}\", Error: \"{1}\"", ve.PropertyName, ve.ErrorMessage));
Logging.PutError("DbEntityValidationException EFValidation: " + s, ex);
}
}
public static IEnumerable<ValidatorError> ConvertToValidatorErrorList(DbEntityValidationException exception)
{
var errorMessages = new List<string>();
foreach (DbEntityValidationResult validationResult in exception.EntityValidationErrors)
{
//string entityName = validationResult.Entry.Entity.GetType().Name;
foreach (DbValidationError error in validationResult.ValidationErrors)
{
yield return new ValidatorError(error.ErrorMessage, error.PropertyName);
}
}
}
private static string GetError(DbEntityValidationException ex)
{
StringBuilder builder = new StringBuilder();
foreach (var validationErrors in ex.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
builder.AppendLine(validationError.ErrorMessage);
}
}
return builder.ToString();
}
static string GetErrorMessage(DbEntityValidationException dbEntityValidationException)
{
var stringBuilder = new StringBuilder();
stringBuilder.AppendLine("Validation failed for one or more entities.");
foreach (var dbEntityValidationResult in dbEntityValidationException.EntityValidationErrors)
{
AppendErrorMessages(dbEntityValidationResult, stringBuilder);
}
return stringBuilder.ToString();
}
public static void DisplayValidationErrors(DbEntityValidationException e)
{
string errorFormat = @"Validation failed for entity [{0}]. Validation errors:" + Environment.NewLine + @"{1}";
var errorList = new List<String>();
foreach (var entityValidationError in e.EntityValidationErrors)
{
var entityName = entityValidationError.Entry.Entity.GetType().Name;
var errors = String.Join(Environment.NewLine, entityValidationError.ValidationErrors.Select(a => a.PropertyName + ": " + a.ErrorMessage));
errorList.Add(String.Format(errorFormat, entityName, errors));
}
throw new Exception(String.Join(Environment.NewLine + Environment.NewLine, errorList) + Environment.NewLine, e);
}
public void HandleDbEntityValidationException(DbEntityValidationException e)
{
var message = new StringBuilder();
foreach (var err in e.EntityValidationErrors)
{
foreach (var inner in err.ValidationErrors)
{
message.AppendLine(inner.ErrorMessage);
}
}
throw new Exception(message.ToString());
}
protected string GetFullErrorText(System.Data.Entity.Validation.DbEntityValidationException exc)
{
var msg = string.Empty;
foreach (var validationErrors in exc.EntityValidationErrors)
{
foreach (var error in validationErrors.ValidationErrors)
{
msg += string.Format("Property: {0} Error: {1}", error.PropertyName, error.ErrorMessage) + Environment.NewLine;
}
}
return(msg);
}
public string ComposeErrorMessage(DbEntityValidationException e)
{
var message = new StringBuilder();
foreach (var err in e.EntityValidationErrors)
{
foreach (var inner in err.ValidationErrors)
{
message.AppendLine(inner.ErrorMessage);
}
}
return message.ToString();
}
private static HttpResponseMessage CreateResponseMessage(HttpRequestMessage request, DbEntityValidationException dbEntityValidationException)
{
List<object> validationErrors = new List<object>();
foreach (DbEntityValidationResult error in dbEntityValidationException.EntityValidationErrors) {
validationErrors.Add(new {
entityType = error.Entry.Entity.GetType(),
errors = error.ValidationErrors
});
}
return request.CreateResponse(HttpStatusCode.BadRequest, validationErrors);
}
public static string ValidationExceptionToString(DbEntityValidationException ex)
{
string msg = "";
foreach (DbEntityValidationResult vr in ex.EntityValidationErrors)
{
foreach (DbValidationError ve in vr.ValidationErrors)
{
msg += String.Format("'{0}': {1}\n", ve.PropertyName, ve.ErrorMessage);
}
}
return msg;
}
public static string EvaluateEFException(DbEntityValidationException dbEx)
{
var sb = new StringBuilder();
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
sb.AppendFormat("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:", validationErrors.Entry.Entity.GetType().Name, validationErrors.Entry.State);
foreach (var validationError in validationErrors.ValidationErrors)
{
sb.AppendFormat("Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage);
}
}
return sb.ToString();
}
public static Dictionary <string, IList <string> > GetAllErrorMessages(this DbEntityValidationException dbEntityValidationException)
{
var data = new Dictionary <string, IList <string> >();
foreach (var item in dbEntityValidationException.EntityValidationErrors.SelectMany(x => x.ValidationErrors))
{
data.Add(item.PropertyName, new List <string>()
{
item.ErrorMessage
});
}
return(data);
}
/// <summary>
/// Converts System.Data.Entity.Validation.DbEntityValidationException exception to database-independent DbException exception used in Data Layer and View Model Layer.
/// </summary>
/// <param name="exception">Exception to convert.</param>
public static DbException Convert(DbEntityValidationException exception)
{
StringBuilder stringBuilder = new StringBuilder();
foreach (DbEntityValidationResult validationResult in exception.EntityValidationErrors)
{
foreach (DbValidationError error in validationResult.ValidationErrors)
{
if (stringBuilder.Length > 0)
stringBuilder.AppendLine();
stringBuilder.Append(error.PropertyName + ": " + error.ErrorMessage);
}
}
return new DbException(stringBuilder.ToString(), CommonResources.Exception_ValidationErrorCaption, exception);
}
public static void ThrowDetailedEntityValidationErrors(DbEntityValidationException e)
{
// Retrieve the error messages as a list of strings.
var errorMessages = e.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
// Join the list to a single string.
var fullErrorMessage = string.Join("; ", errorMessages);
// Combine the original exception message with the new one.
var exceptionMessage = string.Concat(e.Message, " The validation errors are: ", fullErrorMessage);
// Throw a new DbEntityValidationException with the improved exception message.
throw new DbEntityValidationException(exceptionMessage, e.EntityValidationErrors);
}
public static void ViewEntityValidationException(DbEntityValidationException dbEx)
{
try
{
Trace.TraceInformation("■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■{0}", Environment.NewLine);
Trace.TraceInformation("Detallando 'DbEntityValidationException'{0}", Environment.NewLine);
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
Trace.TraceInformation(">>> Property: {0} Error: {1}{2}", validationError.PropertyName, validationError.ErrorMessage, Environment.NewLine);
}
}
Trace.TraceInformation("■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■{0}", Environment.NewLine);
}
catch (Exception exc)
{
Trace.TraceInformation("Error intentando detallar 'DbEntityValidationException'. {0}", exc.Message);
}
}
public Exception HandleException(Exception exception, Guid handlingInstanceId)
{
System.Data.Entity.Validation.DbEntityValidationException excepcionValidacion = exception as System.Data.Entity.Validation.DbEntityValidationException;
string Mensaje = "";
foreach (System.Data.Entity.Validation.DbEntityValidationResult validacion in excepcionValidacion.EntityValidationErrors)
{
foreach (DbValidationError errorvalidacion in validacion.ValidationErrors)
{
Mensaje += $"•{errorvalidacion.ErrorMessage}\r\n";
//this.Controls[0].DataBindings.Add()
}
}
//Se notifica al usuario a través de MessageBox
System.Windows.Forms.MessageBox.Show(Mensaje, "Errores de validacion");
return(excepcionValidacion);
}
protected Tuple <string, IEnumerable <DbEntityValidationResult> > parseEntityValidationException(System.Data.Entity.Validation.DbEntityValidationException ex)
{
// Retrieve the error messages as a list of strings.
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.PropertyName + ": " + x.ErrorMessage);
// Join the list to a single string.
var fullErrorMessage = string.Join(" ", errorMessages);
// Combine the original exception message with the new one.
var exceptionMessage = string.Concat(ex.Message, " ", fullErrorMessage);
// Pass the details for a new DbEntityValidationException with the improved exception message.
return(new Tuple <string, IEnumerable <DbEntityValidationResult> >(exceptionMessage, ex.EntityValidationErrors));
}
//
// Summary:
// Initializes a new instance of DbEntityValidationException.
public DbEntityValidationExceptionBase()
{
_dbEntityValidationException = new DbEntityValidationException();
}
//
// Summary:
// Initializes a new instance of DbEntityValidationException.
//
// Parameters:
// message:
// The exception message.
public DbEntityValidationExceptionBase(string message)
{
_dbEntityValidationException = new DbEntityValidationException();
}
public DbEntityValidationExceptionBase(Exception exception)
{
_dbEntityValidationException = exception as DbEntityValidationException;
}
//
// Summary:
// Initializes a new instance of DbEntityValidationException.
//
// Parameters:
// message:
// The exception message.
//
// innerException:
// The inner exception.
public DbEntityValidationExceptionBase(string message, Exception innerException)
{
_dbEntityValidationException = new DbEntityValidationException(message, innerException);
}
