Entity Framework Core – Custom Functions (Using HasDbFunction)

In the previous post (Custom Functions - using IMethodCallTranslator) we looked at the more flexible approach that requires some boilerplate code. For the usage of a custom function in a project, especially if there are no plans to make the function public then the sacrifice of some (not required) flexibility to reduce the amount of code is fully acceptable.

In this article:

pg
Pawel Gerr is architect consultant at Thinktecture. He focuses on backends with .NET Core and knows Entity Framework inside out.
  1. Entity Framework Core: ROW_NUMBER Support

  2. Entity Framework Core: Custom Functions (using IMethodCallTranslator)
  3. Entity Framework Core: Custom Functions (using HasDbFunction)

As in the previos post we will use the extension method RowVersion with the ORDER BY part only as an example. The actual code can be found on Azure DevOps: Thinktecture.EntityFrameworkCore

Create a static method "RowNumber"

For this approach the method RowNumber must a static method containing the ORDER BY parameters only, i.e. the method cannot be an extension method for DbFunctions like before.

				
					public static class DbFunctionsExtensions
{
   // will throw at runtime because EF tries to translate DbFunctions as well
   public static long RowNumber(this DbFunctions _, object orderBy)
   {
      throw new InvalidOperationException("...");
   }

   // works as expected
   public static long RowNumber(object orderBy)
   {
      throw new InvalidOperationException("This method is for use with Entity Framework Core only and has no in-memory implementation.");
   }
}
				
			

Due to new method signature of RowNumber the usage is slightly different as well.

				
					...
  .Select(i => new
             {
                ...,
                RowNumber = DbFunctionsExtensions.RowNumber(i.ProductId)
             })
				
			

Introduction of custom function to EF

In the previous approach we had to implement IMethodCallTranslatorIMethodCallTranslatorPlugin and IDbContextOptionsExtension to introduce a new function to EF during the configuration of the (SqlServer)DbContextOptionsBuilder. This time we will skip the IMethodCallTranslator and use the ModelBuilder during OnModelCreating.

The configuration of a new function is encapsulated in an extension method AddRowNumberSupport.

				
					public class DemoDbContext : DbContext
{
   ...

   protected override void OnModelCreating(ModelBuilder modelBuilder)
   {
      ...

      modelBuilder.AddRowNumberSupport();
   }
}
				
			

I was not totally honest with you at the beginning. It is true that we don’t need custom implementation of IMethodCallTranslator (SqlServerRowNumberTranslator) but we need some code from it. I will pretend that the SqlServerRowNumberTranslator does not exist and copy the required code to the extension method AddRowNumberSupport

Like before we fetch a MethodInfo of the method RowNumber first.

				
					public static class ModelBuilderExtensions
{
   private static readonly MethodInfo _rowNumberMethod 
            = typeof(DbFunctionsExtensions)
              .GetMethod(nameof(DbFunctionsExtensions.RowNumber), 
                         new[] { typeof(object) });
				
			

Then we use HasDbFunction and HasTranslation to introduce the function to EF. Inside of HasTranslation we (re)use the RowNumberExpression from the previous post.

				
					public static ModelBuilder AddRowNumberSupport(this ModelBuilder modelBuilder)
   {
      modelBuilder.HasDbFunction(_rowNumberMethod)
                  .HasTranslation(expressions =>
                               {
                                  var orderByParams = ExtractParams(expressions.First());

                                  return new RowNumberExpression(orderByParams);
                               });

      return modelBuilder;
   }
				
			

The method ExtractParams is the same as in the SqlServerRowNumberTranslator.

				
					private static ReadOnlyCollection<Expression> ExtractParams(Expression parameter)
   {
      if (parameter is ConstantExpression constant
          && constant.Value is IEnumerable<Expression> enumerable)
      {
         return enumerable.ToList().AsReadOnly();
      }

      return new List<Expression> { parameter }.AsReadOnly();
   }
				
			

Summary

This approach is easier to grasp and the difference in the amout of code is not that big to base a decision on that alone. Use the approach you like the best because the change from one approach to another is easy and requires very litte time.

Free
Newsletter

Current articles, screencasts and interviews by our experts

Don’t miss any content on Angular, .NET Core, Blazor, Azure, and Kubernetes and sign up for our free monthly dev newsletter.

EN Newsletter Anmeldung (#7)
Related Articles
AI
sg
One of the more pragmatic ways to get going on the current AI hype, and to get some value out of it, is by leveraging semantic search. This is, in itself, a relatively simple concept: You have a bunch of documents and want to find the correct one based on a given query. The semantic part now allows you to find the correct document based on the meaning of its contents, in contrast to simply finding words or parts of words in it like we usually do with lexical search. In our last projects, we gathered some experience with search bots, and with this article, I'd love to share our insights with you.
17.05.2024
Angular
SL-rund
If you previously wanted to integrate view transitions into your Angular application, this was only possible in a very cumbersome way that needed a lot of detailed knowledge about Angular internals. Now, Angular 17 introduced a feature to integrate the View Transition API with the router. In this two-part series, we will look at how to leverage the feature for route transitions and how we could use it for single-page animations.
15.04.2024
.NET
KP-round
.NET 8 brings Native AOT to ASP.NET Core, but many frameworks and libraries rely on unbound reflection internally and thus cannot support this scenario yet. This is true for ORMs, too: EF Core and Dapper will only bring full support for Native AOT in later releases. In this post, we will implement a database access layer with Sessions using the Humble Object pattern to get a similar developer experience. We will use Npgsql as a plain ADO.NET provider targeting PostgreSQL.
15.11.2023