DEV Community: Karim Fahmy

build dynamic query predicate in Linq

Karim Fahmy — Thu, 25 May 2023 14:41:29 +0000

I've created a nuget package Linq.Extension.PredicateBuilder helps you to solve complexity in filter collection by apply filtering on combination of properties.

Overview

To make the scenario concrete, let's assume that our object is declared as follows:

public class Post
  {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Description { get; set; }
        public bool IsPublished { get; set; }
        public DateTime PublishedAt { get; set; }
        public int TotalViews { get; set; }
        public int TotalComments { get; set; }
  }

Now suppose we have a collection of Posts like this (this is just for explanation purposes, in real life you would get a much bigger collection from database

var posts = new List<Post>
            {
                new Post {Id = 1, Name = "post1" , Description = "post1 description", IsPublished = true, PublishedAt = DateTime.Now, TotalViews = 50, TotalComments = 4},
                new Post {Id = 2, Name = "post2" , Description = "post2 description", IsPublished = false, PublishedAt = DateTime.Now.AddDays(-3), TotalViews = 10, TotalComments = 1},
                new Post {Id = 3, Name = "post3" , Description = "post3 description", IsPublished = true, PublishedAt = DateTime.Now.AddDays(-8), TotalViews = 120, TotalComments = 8},
                new Post {Id = 4, Name = "post4" , Description = "post4 description", IsPublished = true, PublishedAt = DateTime.Now.AddDays(-1), TotalViews = 40, TotalComments = 5},
                new Post {Id = 5, Name = "post5" , Description = "post5 description", IsPublished = true, PublishedAt = DateTime.Now, TotalViews = 0, TotalComments = 0},
                new Post {Id = 6, Name = "post6" , Description = "post6 description", IsPublished = true, PublishedAt = DateTime.Now.AddDays(-10), TotalViews = 150, TotalComments = 10},
                new Post {Id = 7, Name = "post7" , Description = "post7 description", IsPublished = false, PublishedAt = DateTime.Now, TotalViews = 0, TotalComments = 0},
                new Post {Id = 8, Name = "post8" , Description = "post8 description", IsPublished = true, PublishedAt = DateTime.Now.AddDays(-20), TotalViews = 250, TotalComments = 15},

            };

Suppose we want to allow the user to filter the collection on any property or any combination of properties, one way would be to have a function for each property and each combination of properties, something like:

public IList<Post> FilterByName(string  name)
{
    return  posts.Where(p => p.Name == name).ToList();
}

public  IList<posts> FilterByDescription(string  description)
{
    return  posts.Where(p => p.Description.Contains(description)).ToList();
}

public  IList<posts> FilterByTotalViewsGreaterOrEqual(int totalViews)
{
    return  posts.Where(p => p.TotalViews >= totalViews).ToList();
}

As you can see, this becomes a very tedious job since the number of functions to cover all possible combinations is quite big.

The other way to filter the collection, which is much more convenient and tidier is to build an expression tree dynamically and pass it to the where clause for filtering so Linq.Extension.PredicateBuilder comes

Installation

dotnet add package Linq.Extension.PredicateBuilder

Usage

using Linq.Extension.PredicateBuilder;

internal class Program
    {
        static void Main(string[] args)
        {
            var predicate = new PostViewComponentModel
            {
                Search = new List<Search>
                {
                    new Search
                    {
                        Field = new Field{ Value = "PublishedAt" },
                        Operator = new Operator { Value = OperatorComparer.Between},
                        Value = new Value{ value =  "07/08/2023" , value2 = "07/18/2023"}
                    },
                    new Search
                    {
                        Field = new Field{ Value = "Name" },
                        Operator = new Operator { Value = OperatorComparer.BeginsWith },
                        Value = new Value{ value = "p" }
                    },
                    new Search
                    {
                        Field = new Field{ Value = "Status" },
                        Operator = new Operator { Value = OperatorComparer.In },
                        Value = new Value{ value = "0,2" }
                    }
                },
                PageNumber = 1,
                PageSize = 20

            }; 
            var result = new Post().GetPosts().BuildQuery(predicate.PredicateBuilderFilterRule
                , new PredicateBuilderOptions() { CultureInfo = CultureInfo.CurrentCulture }).ToPaged(predicate);
        }
    }

    public enum Status
    {
        New,
        Pending,
        Completed
    }


    public class PostViewComponentModel : PredicateBuilderInvokerBase<Post>
    {
    }

    public class Post
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Description { get; set; }
        public bool IsPublished { get; set; }
        public DateTime PublishedAt { get; set; }
        public int TotalViews { get; set; }
        public int TotalComments { get; set; }
        public Status Status { get; set; }

        public IQueryable<Post> GetPosts()
        {
            var posts = new List<Post>
            {
                new Post {Id = 1, Name = "POST1" , Description = "post1 description", IsPublished = true, 
                    PublishedAt = DateTime.Now.AddMinutes(-3), TotalViews = 50, TotalComments = 4 , Status = 0},

                new Post {Id = 2, Name = "POST2" , Description = "post2 description", IsPublished = false,
                    PublishedAt = DateTime.Now.AddDays(-1), TotalViews = 10, TotalComments = 1 , Status = (Status)1},

                new Post {Id = 3, Name = "POST3" , Description = "post3 description", IsPublished = true,
                    PublishedAt = DateTime.Now.AddDays(-8), TotalViews = 120, TotalComments = 8, Status = (Status)2},

                new Post {Id = 4, Name = "POST4" , Description = "post4 description", IsPublished = true,
                    PublishedAt = DateTime.Now.AddDays(-1), TotalViews = 40, TotalComments = 5, Status = (Status)1},

                new Post {Id = 5, Name = "POST5" , Description = "post5 description", IsPublished = true,
                    PublishedAt = DateTime.Now, TotalViews = 0, TotalComments = 0 , Status = (Status)2},

                new Post {Id = 6, Name = "POST6" , Description = "post6 description", IsPublished = true,
                    PublishedAt = DateTime.Now.AddDays(-10), TotalViews = 150, TotalComments = 10, Status = (Status)2},

                new Post {Id = 7, Name = "POST7" , Description = "post7 description", IsPublished = false,
                    PublishedAt = DateTime.Now, TotalViews = 0, TotalComments = 0, Status = (Status)2},

                new Post {Id = 8, Name = "POST8" , Description = "post8 description", IsPublished = true,
                    PublishedAt = DateTime.Now.AddDays(-20), TotalViews = 250, TotalComments = 15, Status = 0},

            };

            return posts.AsQueryable();
        }
    }

That set #HappyCoding 😉

ShortId Factory

Karim Fahmy — Mon, 06 Mar 2023 08:42:38 +0000

ShortIdFactory

A library that generates unique random identifiers by set characters length. Identifiers generated can be used as primary keys for databases and unique identifiers.

Install ShortIdFactory with Nuget

dotnet add package ShortIdFactory

Usage
var shortId = new ShortIdFactory(characterCount: 11).Generate(); // _6ulErifjS0

Source code

enjoy

Introduce IdentityCore.Adapter.AspNetMembership

Karim Fahmy — Wed, 11 Jan 2023 09:47:53 +0000

IdentityCore.Adapter.AspNetMembership

Is a Adapter library that enables you to use Microsoft Identity with existing code base using AspNetMembership user management
to have several new features like Two-Factor Authentication, Account Lockout, Account Confirmation, Password Reset, Security Stamp (Sign-Out Everywhere) and external login with existing Facebook, Google, Twitter or Live login.

Before, these features had to be coded,

so now developers can focus more on main business while using tested and standardized method to manage users.

Required

.Net 6 Framework

Installation

Install by Nuget

  dotnet add package IdentityCore.Adapter.AspNetMembership

Usage

if you are using the default schema of AspNetMemberShip without any customization

as well you can include identity options.

services.AddIdentityAdapter(SqlConnectionString);

//or

services.AddIdentityAdapter(SqlConnection, opts =>
            {
                opts.Password.RequiredLength = 8;
                opts.Password.RequireNonAlphanumeric = true;
                opts.Password.RequireLowercase = false;
                opts.Password.RequireUppercase = true;
                opts.Password.RequireDigit = true;
            });

if you are using the customize schema of AspNetMemberShip create your own CustomUserStore.cs and CustomRoleStore.cs to adapted your customization

services.AddIdentityAdapter(SqlConnection, opts =>
            {
                opts.Password.RequiredLength = 8;
                opts.Password.RequireNonAlphanumeric = true;
                opts.Password.RequireLowercase = false;
                opts.Password.RequireUppercase = true;
                opts.Password.RequireDigit = true;
            }).AddUserStore<CustomUserStore>()
              .AddRoleStore<CustomRoleStore>();

🔗 Links

ASP.NET Core - Why asynchronous is useful

Karim Fahmy — Tue, 04 Oct 2022 05:12:34 +0000

Did you ever wonder why you should use async and await in your ASP.NET Core applications? Most probable you heard something about performance. And there is some truth to it, but not in the way you might think.

Have a look at the following asynchronous controller code:

[HttpGet]
public async Task<IActionResult> GetByIdAsync(int id)
{
    var entity = await repository.GetByIdAsync(id).ConfigureAwait(false);
    return Ok(entity);
}

And here the "sync" version of it:

[HttpGet]
public IActionResult GetById(int id)
{
    var entity = repository.GetById(id);
    return Ok(entity);
}

They look pretty much the same, so Why should I prefer the async version here ?

The answer is not performance, as in it runs faster. The answer is: It scales better. Let's dissect the synchronous version for a moment. When we hit repository.GetById(...)

the current worker thread stops and has to wait until the job is done. Most likely you have a SQL Server which does the real work. And these are not even local, they are on a different machine, so your server is literally idling until the answer comes back. Once this happens your controller returns.

Now let's check the async version:
Here we also have to wait for the repository to finish its stuff, but there is a key difference. The await keyword allows the current worker thread to "detach" from the program and go back to the thread pool. Once GetByIdAsync is done,

.NET will take another thread from the pool and continue the work. Now the runtime will be the same. Obvious it could even be that the async version is slightly (in the sense of measurable but not important) slower. But we return the thread to the thread pool and pick it up once the async stuff is finished. This is important for one thing: Scalability.

You see everytime you make a request against your server, a new worker thread will process your stuff. When you return the thread, when it just idles around, you can utilize that thread to make process another request. That is why async and await are powerful in combination with ASP.NET Core.

Another small example: Imagine you have a server which only has 1 available worker thread in the pool. Also two requests are coming in shortly one after another.

In the synchronous version only the first request can be dealt with as there are no free threads available anymore. In the asynchronous version the second request can be immediately handled once the first request reached to the await repository.GetByIdAsync(...)line.

The second request also encounters this line and returns that one thread back to the pool, which immediately gets picked up by request 1 to return the answer. Later we can then return the answer for request 2.

Sure this is a made up scenario, which I hope you don't run into it, but it also shows the power of async and await. Instead of not being able to serve all request, we are not able to even though it might take a bit longer.

Conclusion

Asynchronous programming in ASP.NET Core is a super efficient way of scaling your web application. You can fully utilize your server and system resources are not just idling around!

System Design| Business Rules Implementation

Karim Fahmy — Wed, 10 Aug 2022 14:39:00 +0000

let's assume having to support some legacy code that has a lot of conditional logic and poor quality.

as well it's ongoing development on the system so It can be quite hard to integrate new rules as the code can be difficult to understand and to digest what is going on.

This sort of code often has comments explaining what the different pieces of conditional logic are doing.

The problems only gets worse as you have to add more conditions over time.

You can get a better understanding of how the Rules Pattern works by checking out the code in my github repo.

the example we have about e-commerce store that has discount criteria feature

public class DiscountCalculator
{
    public decimal CalculateDiscountPercentage(Customer customer)
    {
        decimal discount = 0;
        if (customer.DateOfBirth < DateTime.Now.AddYears(-65))
        {
            // senior discount 5%
            discount = .05m;
        }

        if (customer.DateOfBirth.Day == DateTime.Today.Day &&
            customer.DateOfBirth.Month == DateTime.Today.Month)
        {
            // birthday 10%
            discount = Math.Max(discount, .10m);
        }

        if (customer.DateOfFirstPurchase.HasValue)
        {
            if (customer.DateOfFirstPurchase.Value < DateTime.Now.AddYears(-1))
            {
                // after 1 year, loyal customers get 10%
                discount = Math.Max(discount, .10m);
                if (customer.DateOfFirstPurchase.Value < DateTime.Now.AddYears(-5))
                {
                    // after 5 years, 12%
                    discount = Math.Max(discount, .12m);
                    if (customer.DateOfFirstPurchase.Value < DateTime.Now.AddYears(-10))
                    {
                        // after 10 years, 20%
                        discount = Math.Max(discount, .2m);
                    }
                }

                if (customer.DateOfBirth.Day == DateTime.Today.Day &&
                    customer.DateOfBirth.Month == DateTime.Today.Month)
                {
                    // birthday additional 10%
                    discount += .10m;
                }
            }
        }
        else
        {
            // first time purchase discount of 15%
            discount = Math.Max(discount, .15m);
        }
        return discount;
    }
}

The Rules Design Pattern
the fact that this complexity will increase as more rules are added.

I was looking around for a design pattern that might address those things and came across the Rules Pattern

The Rules Pattern works by separating out the rules from the rules processing logic applying the Single Responsibility Principle.

This makes it easy to add new rules without changing the rest of the system applying the Open/Closed Principle.

this image of new design

illustration of the above image:

IRule : contains all methods of rule flow such ClearConditions() , Initialize() , IsValid() , Apply() , OnRuleViolated() as well you can add OnRuleCompleted()
IRule implemented by abstract class BaseRule<T> that use dependency of ICondition that has expression of rule requirement
RulesEngine.cs has ApplyRule() which the execution path of rule
the rules classes itself inherit base rule and override the method body

BirthdayDiscountRule example:

public class BirthdayDiscountRule : BaseRule<Customer>
    {
        public override void Initialize(Customer obj)
        {
            Conditions.Add(new ConditionExtension(CustomerExtensions.IsBirthday(obj)));
        }

        public override Customer Apply(Customer obj)
        {
            obj.Discount += .10m;
            return obj;
        }
        public override void OnRuleViolated(Customer obj)
        {
            Console.WriteLine($"{this.GetType().Name}  Violated");
        }
    }

this code snipped of final result

class Program
    {
        static void Main(string[] args)
        {
            var productA = new Product { Price = 100, Name = "Apple Watch" };
            var productB = new Product { Price = 50, Name = "Samsung Watch" };

            var customer = new Customer
            {
                Products = new List<Product> { productA, productB, productA, productA },
                DateOfFirstPurchase = DateTime.Now.AddYears(-2),
                DateOfBirth = DateTime.Now.AddYears(-5),
            };
            customer.TotalValue = customer.Products.Sum(p => p.Price);

            var ruleManager = new CustomerRuleManager(customer);
            var result = ruleManager.Run();
        }
    }
    public class CustomerRuleManager
    {
        private readonly Customer _customer;

        public CustomerRuleManager(Customer customer)
        {
            _customer = customer;
        }

        public Customer Run()
        {
            _customer
                .ApplyRule(new BirthdayDiscountRule())
                .ApplyRule(new BuyThreeGetThirdFree("Apple Watch"))
                .ApplyRule(new FreeShipping())
                .ApplyRule(new LoyalCustomerRule(5, 0.12m))
                .ApplyRule(new NewCustomerRule())
                .ApplyRule(new RetiredDiscountRule());

            return _customer;
        }
    }