Benchmark using EF Linq Queries

Introduction

The benchmark is to test the performance of your code. It means using more optimized practice and avoiding any repetition of code or refining your code in a better way to improve performance.

For this purpose, we are going to use the BenchmarkDotNet Nuget package which is a lightweight, open-source, and powerful .Net library that can transform your methods into benchmarks, track those methods, and then provide insights into the performance data captured. It is easy to write BenchmarkDotNet benchmarks and the results of the benchmarking process are user-friendly as well.

Installation of BenchmarkDotNet Nuget Package

Install-Package BenchmarkDotNet

Creating A Benchmark class in .NET Core

public class ServiceManager
    {
        [Benchmark(Baseline = true)]
        public List<AuthorDTO> GetAuthors()
        {
             using var dbContext = new AppDatabaseContext();
            var authors = dbContext.Authors
                .Include(author => author.Books)
                .Select(x => new AuthorDTO
                {
                    FirstName = x.FirstName,
                    LastName = x.LastName,
                    UserName = x.UserName,
                    Email = x.Email,
                    Age = x.Age,
                    Country = x.Country,
                    AllBooks = x.Books.Select(x => new BookDTO
                    {
                        BookTitle = x.BookTitle,
                        PublishedYear = x.PublishedYear
                    }).ToList(),
                }).OrderByDescending(x => x.AllBooks.Count()).ToList();

            return authors;

        }

        [Benchmark]
        public List<AuthorDTO> OptimizedCompileQuery()
        {
            using var dbContext = new AppDatabaseContext();
            var authors = CompileQuery(dbContext).OrderByDescending(x => x.AllBooks.Count()).ToList();
            return authors;
        }

        private static readonly Func<AppDatabaseContext, IEnumerable<AuthorDTO>> CompileQuery =
            EF.CompileQuery((AppDatabaseContext context) => context.Authors.Select(x => new AuthorDTO
            {
                FirstName = x.FirstName,
                LastName = x.LastName,
                UserName = x.UserName,
                Email = x.Email,
                Age = x.Age,
                Country = x.Country,
                AllBooks = x.Books.Select(x => new BookDTO
                {
                    BookTitle = x.BookTitle,
                    PublishedYear = x.PublishedYear
                }).ToList(),

            }));
    }

In the above class, I have added two methods. The GetAuthors() method gets the author list and books a using straightforward LINQ query. The other method named OptimizedCompileQuery() uses compile query to get the authors list along with books. Once these methods are defined you can call these in your main class shown below.

static void Main(string[] args)
{
   var summary = BenchmarkRunner.Run<ServiceManager>();
}

Once you start your application you are likely to face this issue. But you can resolve it by building your application in release mode.

To resolve this you need to right-click your solution and select release from the dropdown list. When benchmarking you should always ensure that you run your project in release mode.

Now, you are all set to go and test your code. Run the application and check whether you wrote an optimized code or not. Your result will look like this. shown in the below image.

You can see that there is almost a 100% difference between a normal LINQ query and a compiled EF Core query.

Summary

We can use benchmarks to run some tests to check the benchmark of our code as we know there is always room for improvement. The benchmark implementation is very simple and easy.

Thank you so much for reading and listening. If you found this helpful hit that clap button. Any suggestions and improvements are warmly welcome. Happy coding …..##coding #learning #selfimprovement