Entity Framework | Giorgi Dalakishvili | Personal Website

EntityFramework.Exceptions 3.1.1 - Support for Entity Framework Core 3 and Improved API

Thu, 12 Mar 2020 07:35:16 +0000

In the previous article I introduced EntityFramework.Exceptions, a library which simplifies handling exceptions in Entity Framework Core but the library had one important limitation: In order to use it you had to inherit your custom DbContext from ExceptionProcessorContextBase class. This means that if you wanted to use some other base class for your DbContext you were out of luck. The latest version of the library solves this issue by replacing one of the internal services used by entity framework core with a custom implementation and also adds support for Entity Framework Core 3.1.1

The service that needs to be replaced is IStateManager and is used by the ChangeTracker. The custom implementation of IStateManager interface inherits from the built in StateManager class and overrides SaveChanges and SaveChangesAsync methods. Let’s see how it works:

public abstract class ExceptionProcessorStateManager<T> : StateManager where T : DbException
{
private static readonly Dictionary<DatabaseError, Func<DbUpdateException, Exception>> ExceptionMapping = new Dictionary<DatabaseError, Func<DbUpdateException, Exception>>
{
{DatabaseError.MaxLength, exception => new MaxLengthExceededException("Maximum length exceeded", exception.InnerException) },
{DatabaseError.UniqueConstraint, exception => new UniqueConstraintException("Unique constraint violation", exception.InnerException) },
{DatabaseError.CannotInsertNull, exception => new CannotInsertNullException("Cannot insert null", exception.InnerException) },
{DatabaseError.NumericOverflow, exception => new NumericOverflowException("Numeric overflow", exception.InnerException) },
{DatabaseError.ReferenceConstraint, exception => new ReferenceConstraintException("Reference constraint violation", exception.InnerException) }
};
protected ExceptionProcessorStateManager(StateManagerDependencies dependencies) : base(dependencies)
{
}
public override int SaveChanges(bool acceptAllChangesOnSuccess)
{
try
{
return base.SaveChanges(acceptAllChangesOnSuccess);
}
catch (DbUpdateException originalException)
{
var exception = GetException(originalException);
if (exception != null)
{
throw exception;
}
throw;
}
}
public override async Task<int> SaveChangesAsync(bool acceptAllChangesOnSuccess, CancellationToken cancellationToken = new CancellationToken())
{
try
{
var result = await base.SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken);
return result;
}
catch (DbUpdateException originalException)
{
var exception = GetException(originalException);
if (exception != null)
{
throw exception;
}
throw;
}
}
private Exception GetException(DbUpdateException ex)
{
if (ex.GetBaseException() is T dbException && GetDatabaseError(dbException) is DatabaseError error && ExceptionMapping.TryGetValue(error, out var ctor))
{
return ctor(ex);
}
return null;
}
protected abstract DatabaseError? GetDatabaseError(T dbException);
}

The abstract ExceptionProcessorStateManager class catches any database exception thrown during SaveChanges call and tries to translate it into one of the supported exception instances. If it succeeds it throws the new exception and if it doesn’t it simply rethrows the original exception. The GetDatabaseError is overriden in database specific projects and returns DatabaseError based on the specific DbException that was thrown:

class SqlServerExceptionProcessorStateManager: ExceptionProcessorStateManager<SqlException>
{
public SqlServerExceptionProcessorStateManager(StateManagerDependencies dependencies) : base(dependencies)
{
}
private const int ReferenceConstraint = 547;
private const int CannotInsertNull = 515;
private const int CannotInsertDuplicateKeyUniqueIndex = 2601;
private const int CannotInsertDuplicateKeyUniqueConstraint = 2627;
private const int ArithmeticOverflow = 8115;
private const int StringOrBinaryDataWouldBeTruncated = 8152;
protected override DatabaseError? GetDatabaseError(SqlException dbException)
{
switch (dbException.Number)
{
case ReferenceConstraint:
return DatabaseError.ReferenceConstraint;
case CannotInsertNull:
return DatabaseError.CannotInsertNull;
case CannotInsertDuplicateKeyUniqueIndex:
case CannotInsertDuplicateKeyUniqueConstraint:
return DatabaseError.UniqueConstraint;
case ArithmeticOverflow:
return DatabaseError.NumericOverflow;
case StringOrBinaryDataWouldBeTruncated:
return DatabaseError.MaxLength;
default:
return null;
}
}
}

In order to actually replace IStateManager with the custom implementation you need to install either SQL Server, PostgreSQL or MySQL nuget package and call UseExceptionProcessor method of the ExceptionProcessorExtensions from the database specific package:

class DemoContext : DbContext, IDemoContext
{
public DbSet<Product> Products { get; set; }
public DbSet<ProductSale> ProductSale { get; set; }
protected override void OnModelCreating(ModelBuilder builder)
{
builder.Entity<Product>().Property(b => b.Price).HasColumnType("decimal(5,2)").IsRequired();
builder.Entity<Product>().Property(b => b.Name).IsRequired().HasMaxLength(15);
builder.Entity<Product>().HasIndex(u => u.Name).IsUnique();
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseSqlServer(@"Data Source=(localdb)\ProjectsV13;Initial Catalog=Test;Integrated Security=True;Connect Timeout=30;")
.UseExceptionProcessor();
}
}

The UseExceptionProcessor method is very simple and all it does is a call to DbContextOptionsBuilder.ReplaceService<TService,TImplementation> method:

public static class ExceptionProcessorExtensions
{
public static DbContextOptionsBuilder UseExceptionProcessor(this DbContextOptionsBuilder self)
{
self.ReplaceService<IStateManager, SqlServerExceptionProcessorStateManager>();
return self;
}
public static DbContextOptionsBuilder<TContext> UseExceptionProcessor<TContext>(this DbContextOptionsBuilder<TContext> self) where TContext : DbContext
{
self.ReplaceService<IStateManager, SqlServerExceptionProcessorStateManager>();
return self;
}
}

Once you have done it you will start getting database specific exceptions instead of DbUpdateException:

using (var demoContext = new DemoContext())
{
demoContext.Products.Add(new Product
{
Name = "Moon Lamp",
Price = 1
});
demoContext.Products.Add(new Product
{
Name = "Moon Lamp",
Price = 10
});
try
{
demoContext.SaveChanges();
}
catch (UniqueConstraintException e)
{
//Unique index was violated. Show corresponding error message to user.
 }
}

The full source code of the library is available on GitHub: EntityFramework.Exceptions If you have questions or suggestions feel free to leave a comment, create an issue and star the repository.

Introducing EntityFramework.Exceptions

Tue, 11 Dec 2018 07:35:16 +0000

When using Entity Framework Core for data access all database exceptions are wrapped in DbUpdateException. If you need to know whether the exception was caused by a unique constraint, value being too long or value missing for a required column you need to dig into the concrete DbException subclass instance and check the error number to determine the exact cause.

EntityFramework.Exceptions simplifies this by handling all the database specific details and throwing different exceptions for different cases. All you have to do is

inherit your DbContext from ExceptionProcessorContext and handle the exception(s) (such as UniqueConstraintException, CannotInsertNullException, MaxLengthExceededException, NumericOverflowException) you need.

The Problem with Entity Framework Exceptions

Let’s say we have a Product table which has Name column with a unique index and Price column. Entity Framework context will look like this:

class DemoContext : DbContext
{
public DbSet<Product> Products { get; set; }
protected override void OnModelCreating(ModelBuilder builder)
{
builder.Entity<Product>().Property(b => b.Price).HasColumnType("decimal(5,2)").IsRequired();
builder.Entity<Product>().Property(b => b.Name).IsRequired().HasMaxLength(15);
builder.Entity<Product>().HasIndex(u => u.Name).IsUnique();
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseSqlServer(@"Data Source=localhost;Initial Catalog=Test;Integrated Security=True;Connect Timeout=30;");
}
}

If we try to insert two records with the same name we will get DbUpdateException. As we have already mentioned DbUpdateException is thrown every time when saving changes to the database fails. In order to check that the exception was caused by the unique index we need to get the specific database DbException subclass instance and check the error number. In case of SQL Server we can do it like this:

using (var demoContext = new DemoContext())
{
demoContext.Products.Add(new Product
{
Name = "Moon Lamp",
Price = 1
});
demoContext.Products.Add(new Product
{
Name = "Moon Lamp",
Price = 10
});
try
{
demoContext.SaveChanges();
}
catch (DbUpdateException e)
{
var sqlException = e.GetBaseException() as SqlException;
//2601 is error number of unique index violation
 if (sqlException != null && sqlException.Number == 2601)
{
//Unique index was violated. Show corresponding error message to user.
 }
}
}

While this works it has several disadvantages. First of all it is repetitive to write this code every time we try to save changes to database. Secondly, there are other database errors to handle such as trying to insert null in non-null column or trying to insert longer value than the column allows. Finally, the error numbers are different for different database servers.

To avoid these issues I have created a library EntityFramework.Exceptions which handles database specific errors and throws different exceptions for different database errors.

EntityFramework.Exceptions – Easy Way to Handle Exceptions

With EntityFramework.Exceptions we can rewrite the above code like this:

using (var demoContext = new DemoContext())
{
demoContext.Products.Add(new Product
{
Name = "Moon Lamp",
Price = 1
});
demoContext.Products.Add(new Product
{
Name = "Moon Lamp",
Price = 10
});
try
{
demoContext.SaveChanges();
}
catch (UniqueConstraintException e)
{
//Unique index was violated. Show corresponding error message to user.
 }
}

As you can see we no longer have to deal with database specific exception and error numbers. Instead UniqueConstraintException is thrown when either a unique index or unique constraint is violated. As a result our code is cleaner, shorter and easier to understand. What’s more the library provides other exceptions such as CannotInsertNullException, MaxLengthExceededException, NumericOverflowException. For example if we try insert a product with Name longer than 15 characters we will get MaxLengthExceededException exception:

using (var demoContext = new DemoContext())
{
demoContext.Products.Add(new Product
{
Name = "Moon Lamp Change 3 Colors",
Price = 1
});
try
{
demoContext.SaveChanges();
}
catch (MaxLengthExceededException e)
{
//Max length of Name column exceeded. Show corresponding error message to user.
 }
}

Apart from this EntityFrameworkCore.Exceptions supports other database servers such as PostgreSQL and MySQL so if you ever switch to different database server your exception handling code will stay the same.

To get started with EntityFramework.Exceptions all you need to do is install either SQL Server, PostgreSQL or MySQL nuget package and inherit your DbContext from ExceptionProcessorContext:

class DemoContext : ExceptionProcessorContext
{
public DbSet<Product> Products { get; set; }
}

How Does EntityFramework.Exceptions Work ?

The implementation is pretty straightforward. There is an ExceptionProcessorContextBase class in EntityFramework.Exceptions.Common project which inherits from DbContext, overrides SaveChanges and handles any exception that occurs. It gets the database specific exception instance and asks derived classes to tell which exception it should throw for the DbException that occurred. For more details please check the GitHub repository. If you find the library useful don’t forget to Star the repository. If you have any questions or suggestions you are welcome to submit an issue or send a PR.