DEV Community: Ahmed Fouad

5 Reasons to Use AsyncFlow in Your Next Backend

Ahmed Fouad — Wed, 06 Sep 2023 00:44:38 +0000

Modern backend systems increasingly rely on asynchronous operations to manage long-running tasks efficiently. With numerous solutions available, why should you consider using AsyncFlow for your next .NET application? Here are five compelling reasons!

1. Seamless Asynchronous Job Invocation:
Starting long-running jobs should be smooth and intuitive. With AsyncFlow, once a user calls an invoke API, they receive a job ID immediately, streamlining the initiation of asynchronous tasks.

2. Integrated Status Tracking:

Keep your users informed. Rather than leaving them wondering about the status of their tasks, AsyncFlow allows them to easily track their job's progress. Whether it's still processing, completed, or has encountered an error, your users stay in the loop.

3. Flexible Result Retrieval:

The beauty of AsyncFlow lies in its flexibility. Once a job is finished, users can retrieve the results at their convenience, ensuring that they have access to data when they need it.

4. Robust Integration with Hangfire:

Leverage the power of Hangfire, a leading background processing library in the .NET ecosystem. AsyncFlow's seamless integration with Hangfire ensures efficient job execution without the hassles of setting up complex processes.

5. Extensible Cache Options:

Whether you prefer in-memory storage or a distributed cache, AsyncFlow has got you covered. Store job results based on your application's needs, ensuring optimal performance and resource management.

Asynchronous operations are the backbone of efficient backends. AsyncFlow offers an intuitive and powerful approach to managing asynchronous job flows in .NET applications. Dive into this tool and elevate your backend systems!

The Journey from Problem to Solution: Introducing AsyncFlow

Ahmed Fouad — Tue, 15 Aug 2023 03:24:40 +0000

It was a typical Tuesday afternoon when Ahmed, an astute developer, faced a daunting challenge. The request-response paradigm that he had always relied on was suddenly insufficient. With a growing user base and an expanding application, long-running tasks became the bane of his existence.

Frequent timeouts, aggravated users, and sleepless nights were all Ahmed seemed to know. The pressure of scaling without compromising user experience was weighing him down.

One evening, Ahmed stumbled upon the Job-based Asynchronous Processing Pattern. This was a game-changer! This pattern could handle time-consuming tasks in the background, and users could check the task's status or retrieve the results at their leisure. It was the perfect solution Ahmed had been searching for.

However, implementing it was no walk in the park. He needed something that would simplify this pattern's integration into his application.

Enter AsyncFlow.

Ahmed found AsyncFlow, a library that brought the power of this pattern right into the .NET ecosystem. Built atop Hangfire's robust infrastructure, AsyncFlow made it a breeze for him to implement asynchronous task processing.

Setting it up was a walk in the park:

builder.Services.AddHangfire(x => x.UseMemoryStorage());
builder.Services.AddHangfireServer();
builder.Services.AddMemoryCache();
builder.Services.AddAsyncFlow(options => options.UseMemoryCache());

Ahmed just had to write his business logic, implement the IAsyncFlow interface, and voila, his endpoints were up and running:

builder.Services.AddTransient<GenerateDataJob>();
app.MapFlow<GenerateDataJob, GenerateDataRequest, GenerateDataResponse>("dataGeneration");

It didn't stop there. Ahmed was also able to leverage Hangfire's capabilities, including its insightful dashboard and exceptional load balancing.

Elated with his discovery, Ahmed felt the need to share this gem with the world. If you're facing challenges like Ahmed and seeking a seamless way to implement the Job-based Asynchronous Processing Pattern in .NET, give AsyncFlow a glance. And if it helps you as much as it did Ahmed, consider giving it a star!

7 ways to improve code quality in c# using option type

Ahmed Fouad — Sat, 18 Apr 2020 21:56:03 +0000

Option is relatively new for imperative programming (c#, java, …) developers also it is now a primitive type in some of these multiparadigm languages like java it is not yet natively supported in C#.

I think the biggest misunderstanding regarding option type came from it is similarity was the nullable type. you will find a lot of online articles presenting Option type as a safer alternative to the nullable type or as a final solution to NullReferenceException while other material defends Nullable and say that option type is not the way to go as it simply replaces NullReferenceException with MissingValueException.

Here we will show you how to use Option Type Correctly and how it will improve your code dramatically and prevent some potential bugs.

Optional 4.0.0

1- Force you to handle the missing value case

Option type will force you to deal with the missing case when you actually need to get the value.

public string GetEmail(string id)
{
    var user= GetUser("id");
    return user.SomeNotNull()
         .Select(context=>context.Email)
         .ValueOr("Not found");
}

Here you have the GetUser Method which fitch the user that matches the provided id from the database and in case there no user with that Id it will return null.

This is one of the classics problems in all kinds of applications where the developer starts his code like that

var user= GetUser("id");
return user.Email;

and then when some NullReferenceExceptions Happens you can see something like this

var user= GetUser("id");
return user?.Email;

and then the NullRefrenceException will occur at the consumer of this method.

using the Option where you have to think about what to do when there is no value will have you to not to fall in the null propagation trap.

you can also you .ValueOrDefault() or .ValueOrFailure() if you want but it is not recommended unless you really wanna do that.

2- You define when it is none and when it is some

private static string GetEmail(string id)
        {
            var user = GetUser(id);
            var email = user.SomeNotNull()
                .Where(context=> IsEmail(context.Email))
                .Select(context => context.Email)
                .ValueOr("Not Found");
            return email;
        }

In some cases, you wanna ensure that the returned value satisfy some condition for example here if you have a case where some of the emails in the database are not incorrect format or not verified or anything else that you do not want to return.

you can write the previous code instead of something ugly like this

var user= GetUser("id");
return IsEmail(user?.Email)??NotFound;

In some cases, even this code could fail if the IsEmail do not accept null parameters so you could end up with something like

var user= GetUser("id");
return var user= GetUser("id");
return !string.IsNulOrEmpty(User?.Email)&&IsEmail(user?.Email)??NotFound;

wherein the option version it will be

private static string GetEmail(string id)
        {
            var user = GetUser(id);
            var email = user.SomeNotNull()
               .Select(context => context.Email)
               .Where(email=>!string.IsNullOrEmpty(email))
               .Where(email=> IsEmail(email))
               .ValueOr(string.Empty);
            return email;
        }

3- Execute Only When Value Exist

public static void NotifyUser(string id)
       {

        var user = GetUser(id)
                  .SomeNotNull()
                  .Where(context=>context.IsActive)
                  .Where(context=>!context.NoDeleted)
                  .Where(context=>context.AllowNotification);

        user
            .Where(context => !string.IsNullOrEmpty(context.Email))
            .Where(context => IsEmail(context.Email))            
            .Where(context=>context.SubscribedToEmailNotification)
            .MatchSome(SendNotificationEmail);

        user    
         .Where(context=>!string.IsNullOrEmpty(context.PhoneNumber))
         .Where(context=>context.SubscribedToPhoneNotification)
         .MatchSome(SendNotificationSMS);

          }
        private static void SendNotificationSMS(User context)
        {

        }
        private static void SendNotificationEmail(User context)
        {

        }

this code explains himself send an email notification if the email exists and send an SMS if the phone number exists.

vau user =GetUser(id);

if(user==null || !user.IsActive || !user.IsDeleted || !user.AllowNotification)
   return;

if(!string.IsNullOrEmpty(user.Email)
    &&IsEmail(user.Email)
    && user.SubscribedToEmailNotification)
            sendNotificationEmail(user);

if(!string.IsNullOrEmpty(user.PhoneNumber))
   &&user.SubscribedToSMSNotification)
    SendNotificationSMS(user);

I am sure it will take less time from you to understand the first code snipped with optional.

While both of them have the same number of conditions and checks but When we are using Where we are defining a rule so when we say “

var user = GetUser(id)
                  .SomeNotNull()
                  .Where(context=>context.IsActive)
                  .Where(context=>!context.NoDeleted)
                  .Where(context=>context.AllowNotification);

we are defining a contract no more than that with no actions so our user only exists if he satisfies the conditions and later on when needed we will do actions depend on he exists or not.

but with if conditions we are actually forcing an execution path with contains the condition and the action normally these are harder to understand and force upfront work which could not be needed.

I am sure you are familiar with this Joke

A programmer is going to the grocery store and his wife tells him, “Buy a gallon of milk, and if there are eggs, buy a dozen.” So the programmer goes, buys everything, and drives back to his house. Upon arrival, his wife angrily asks him, “Why did you get 13 gallons of milk?” The programmer says, “There were eggs!”

I am sure he never heard of functional programming and his code is full of if-else bulls***t that is why he used the if condition to build an action set while normal humans use the requirements to build rules like that.

var milikGallon=store.GetMilikGallon().SomeNotNull();
milikGallon.MatchSome(Buy);

var egges=store.GetEggs().SomeNotNull().Select(eggs=>eggs.Take(13));
egges.MatchSome(Buy);

4- Async Support

public static async Task NotifyUser(string id)
        {
            var user = GetUser(id)
                .SomeNotNull()
                .Where(context => context.IsActive)
                .Where(context => !context.NoDeleted)
                .Where(context => context.AllowNotification);

var sendEmailTask=
           user
            .Where(context =>context.SubscribedToEmailNotification)
            .Where(context => !string.IsNullOrEmpty(context.Email))
            .Where(context => IsEmail(context.Email))
            .Select(SendNotificationEmail)
            .ValueOr(Task.CompletedTask);

 var sendSmsTask=
           user
            .Where(context => context.SubscribedToSMSNotification)
            .Where(context   
                     =>!string.IsNullOrEmpty(context.PhoneNumber))
             .Select(SendNotificationSMS)
             .ValueOr(Task.CompletedTask);

      await Task.WhenAll(sendEmailTask, sendSmsTask);

        }

private static Task SendNotificationSMS(User context)
        {
            return Task.CompletedTask;

        }

private static Task SendNotificationEmail(User context)
        {
            return Task.CompletedTask;

        }

When it comes to async programming all we need is to select the task instead of invoking a method and if we are using the Task.CompletedTask as a replacement value for the none condition.

var sendEmailTask=
           user
            .Where(context =>context.SubscribedToEmailNotification)
            .Where(context => !string.IsNullOrEmpty(context.Email))
            .Where(context => IsEmail(context.Email))
            .Select(SendNotificationEmail)
            .ValueOr(Task.CompletedTask);

will return a completed Task (Task.CompletedTask) when the user does not exist or is not subscribed to email notification or does not have a valid email otherwise, it returns the SendNotificationEmail task.

and with Task.WhenAll we manage to run and wait for the tasks in parallel and here is the edge of functional programming when we changed the methods to async we were pushed too to run them in parallel but in the other alternative it will be

vau user =GetUser(id);

if(user==null || !user.IsActive || !user.IsDeleted || !user.AllowNotification)
   return;

if(!string.IsNullOrEmpty(user.Email)
    &&IsEmail(user.Email)
    && user.SubscribedToEmailNotification)
          await sendNotificationEmail(user);

if(!string.IsNullOrEmpty(user.PhoneNumber))
   &&user.SubscribedToSMSNotification)
   await SendNotificationSMS(user);

which of course can be refactored to run the 2 tasks in parallel but it is not part of the natural refactor path when we refactored sendNotificationEmail and SendNotificationSMS to be async.

5- Exception Handling

The get user method may throw an exception if there is a DB error or something like that, our previous code does not handle this in anyways while the normal try-catch block can work perfectly with our functional programming code Option type give us a better way for exception handling.

I will start by writing an extension method that wraps our GetUser method to return OptionWithException instead of T.

public static Option<T, Exception> ToOption<P,T>(this Func<P,T> context,P parameter)
        {

                try
                {
                    var result = context.Invoke(parameter);
                   return result.SomeNotNull(
() =>
(Exception) new NullReferenceException($"{context.Method.Name} returned null"));
                }
                catch (Exception e)
                {
                    return Option.None<T, Exception>(e);
                }
        }

and then we could use it like that

private static string GetEmail(string id)
  {
    var userFactory=new Func<string,User>(GetUser);

    var user = userFactory.ToOption(id);
    var email= 
     user.Filter(context =>!string.IsNullOrEmpty(context.Email,
                () =>new ConditionNotMatchedException("Emptyemail"))

          .Filter(context => IsEmail(context.Email), 
             () => new ConditionNotMatchedException("InvalidEmail"))

          .Select(context => context.Email);

     return email.ValueOr("Not found");
        }

This new code will be doing the same as the older one will return the email or not found.

but as you have noticed we replaced the Where(T=>bool) with Filter(T=>bool , ()=>Exception). That is because we will use the exception now as a reason when the value not existing so we can know why there is no email if we want and to do we must do an additional simple change

public struct EmailResult
   {
       public string Email { get; set; }
       public string Error { get; set; }

}
private static EmailResult GetEmail(string id)
   {
     var userFactory=new Func<string,User>(GetUser);

     var user = userFactory.ToOption(id);
     var emailResult = 
         user.Filter(context =>!string.IsNullOrEmpty(context.Email),   
              () => new ConditionNotMatchedException("Emptyemail"))

             .Filter(context => IsEmail(context.Email),
            () => new ConditionNotMatchedException("InvalidEmail"))

             .Select(context => context.Email)
             .MapException(ex=>new EmailResult(){Error =ex.Message})
             .Map(email=>new EmailResult(){Email = email});

     return emailResult.ValueOrException();
        }

As we need to know the reason in case of not finding the email so we will return a ResultObject in which we will map the result and the exception using

.MapException(ex=>new EmailResult(){Error =ex.Message})
.Map(email=>new EmailResult(){Email = email});

6- Integration With Other contracts Frameworks like Shoudly

Shouldly 3.0.2

Shoudly is an assertion framework and normally assertion frameworks are used for testing but here I would use it for filtering my value

private static EmailResult GetEmail(string id)
 {
   var userFactory=new Func<string,User>(GetUser);

   var user = userFactory.ToOption(id);
   var emailResult = user
         .Filter(context=>context.Email.ShouldNotBeNullOrEmpty())            
         .Filter(context=>context.Email.ShouldMatch(Patterns.Email))
         .Select(context => context.Email)
         .MapException(ex=>new EmailResult(){Error = ex})
         .Map(email=>new EmailResult(){Email = email});

   return emailResult.ValueOrException();
 }

but it requires me to implement a simple overload for filter

public static Option<T, Exception> Filter< T>(this Option<T, Exception> context,Action<T> condition)
        {
            try
            {
                if (!context.HasValue)
                    return context;
                condition.Invoke(context.ValueOrFailure());
                 return context;
            }
            catch (Exception e)
            {
                return Option.None<T, Exception>(e);
            }
        }

I believe this syntax is the most readable one you can achieve

var emailResult = user
         .Filter(context=>context.Email.ShouldNotBeNullOrEmpty())            
         .Filter(context=>context.Email.ShouldMatch(Patterns.Email))
         .Select(context => context.Email)

7- It can be your entry to functional Programming

Here I have to tell you that option type is one of the building blocks of functional programming and by using it as we mentioned in the previous 6 sections you are actually writing functional Programming cold.

So welcome on board, now I would suggest that you follow me on twitter and medium for more articles.

Ahmed Fouad

And you can buy me one coffee it will help me write more articles

Buy AhmedFouad a Coffee. ko-fi.com/ahmedfouad

And I would really recommend you to read Functional Programming in C#: How to write better C# code as it is one of few books that introduce functional programming thinking to c# developers read it and you will notice dramatic improvements in how you think and a strong boost in your code quality.

Building your First async fluent API using interface extension methods pattern

Ahmed Fouad — Sat, 11 Apr 2020 20:22:45 +0000

Fluent Interface is an advanced API design that really on extension methods and methods chaining. When of the most famous examples of fluent API is the linq extension methods for IEnumerable.

var passed=Students.Where(s=>s.Passed).Select(s=>s.Name).ToList();

In the asynchronous Programming, async/await, fluent APIs are kind of limited due to the nature of the Task object that it is hot build default, in this article, we will overcome this problem and will build a small library that allows fluent extension methods.

as an example,

var data=await GetDataAsync()
         .AsRepeatable(TimeSpan.FromSeconds(10))
         .FirstOrDefaultAsync(data=>data.Any());

another example could be

var data=await GetNewsAsync()
         .Where(newsList=>newsList.Date>=DateTime.Today)
         .SelectMany(newsList=>newsList.NewsItems)
         .ToList();

Just to give you an idea of how this code could be written using Imperative approach

 var newsList=await GetNewsAsync();
 if(newsList.Date>=DateTime.Today)
    {
       return newsList.Select(news=>news.NewsItems).ToList();
    }
else
       return new List<NewsItem>();

It is up to you to choose which code fashion you would like, if you like the second one, you can stop reading this article as in the rest of the article we will extend the c sharp language to make the first one applicable.

Good you decided to continue that show that you are a very elegant software engineer so please grape your coffee and you can invite me on as well using

Buy AhmedFouad a Coffee. ko-fi.com/ahmedfouad

Step 1: Convert your async Task to Task>

This will help us to get rid of the NullReferenceExceptions and concentrate only on the extension methods.

public static Func<Task<Option<T>>> ToOption<T>(this Func<Task<T>> context)
{
     return new Func<Task<Option<T>>>(async () =>{
     try
       {
          var result = await context.Invoke();
          return result.SomeNotNull();
       }
     catch (Exception e)
       {
          return Option.None<T>();
       }});

}

This method simply invokes the async method and return Option.None when the value is null or exception happened or the value as some when there is a value.

we will need to install the option type nugget package

Optional 4.0.0

Step 2: Build a Wrapper class in which we will implement our extension methods

public class ExtendedTask<T>
    {
        private readonly Func<Task<Option<T>>> \_taskOption;
        public ExtendedTask(Func<Task<T>> task)
        {
            \_taskOption = task.ToOption();
        }
        public ExtendedTask(Func<Task<Option<T>>> task)
        {
            \_taskOption = task;
        }
    }

form here it is very easy to implement our extension methods, we will just delegate the implementation to the option type.

public ExtendedTask<T> Where(Func<T,bool> condition)
        {
            var conditionedTask = \_taskOption.Select(func => new Func<Task<Option<T>>>(async () =>
            {
                var result = await func.Invoke();
                return result.Where(condition);
            }));

            return new ExtendedTask<T>(conditionedTask);
        }

It will return the new ExtendedTask of value when the condition is meet and ExtendedTask of None otherwise.

Now we will implement the select method and select async method using the same strategy.

public ExtendedTask<TP> Select<TP>(Func<T,TP> selector)
        {
            var conditionedTask = \_taskOption.Select(func => new 
            Func<Task<Option<TP>>>(async () =>
            {
                var result = await func.Invoke();

                return result.Select(selector);
            }));

          return new ExtendedTask<TP>(conditionedTask);
        }

public ExtendedTask<TP> SelectAsync<TP>(Func<T, Task<TP>> selector)
        {
            var conditionedTask = \_taskOption.Select(func => new  
            Func<Task<Option<TP>>>(async () =>
            {
                var result = await func.Invoke();

                var [@select](http://twitter.com/select) = await result.Select(selector.Invoke)
                 .ValueOr(()=>Task.FromResult(default(TP)));

                return [@select](http://twitter.com/select).SomeWhen(p =>
                {
                    var b = p.Equals(default(TP));
                    return !b;
                });
            }));

Step 3: Implement the AsTask() method

public async Task<T> AsTask()
        {
            return (await \_taskOption.Select(async task => await 
                    task())).ValueOrDefault();
        }

This method simply returns a new task that executes the decorated task and will simply return the default of T when the value is None.

Step4: Implement AsRepeatable() method

As the repeatable method is a transformation method that transforms a scalar Task to a Vector IAsyncEnumerable

public IAsyncEnumerable<T> AsRepeatable()
        {
            return new TaskAsyncEnumerable<T>( \_taskOption);
        }
        public IAsyncEnumerable<T> AsRepeatable(TimeSpan timeSpan)
        {
            return new TaskAsyncEnumerable<T>(\_taskOption ,timeSpan);
        }

And here is the Implementation of TaskAsyncEnumerable

It is quite straight forward The enumerator will keep executing the task on iterating and will only stop when the Iterating stop or when the value becomes null.

Step 5: Let’s try it

var getDataAsync = new ExtendedTask<News>(GetDataAsync);
var data = await getDataAsync
                .AsRepeatable(TimeSpan.FromSeconds(1))
                .FirstOrDefaultAsync(data => data.Items.Any());

Step 6

If you like the article please share it, follow me on medium and on twitter to get my upcoming

Ahmed Fouad

and pay me the coffee at

Buy AhmedFouad a Coffee. ko-fi.com/ahmedfouad

Send Push Notification from a webhook endpoint using Azure notification hub

Ahmed Fouad — Sat, 04 Apr 2020 21:43:55 +0000

Webhooks are user-defined HTTP callbacks where the provider calls the client's web service to notify him when a new event occurred by contrast to the API where the client calls the provider to GET some information or POST new data.

For example if you are building a continuous integration system and you want to build and create an app package every time a commit is done to the Master branch.

So your build tool must get notified when a new commit is made and this can only happen using webhooks, your build server will register his endpoint in the git server and the git server will call your build server registered endpoint and therefore your build server will pull the new code and create a build.

Another example and it is the one that we will do together in this article, you know that I use ko-fi.com to gather donations to keep this blog running and buy tools to enhance the article quality, now I wanna receive a push notification on my mobile when a new donation is made so how I will do this.

Step1: Create an Azure Lambda Function to be used as a webhook endpoint.

This is a very straight forward open visual studio and create new Azure Lambda Function project.

it is very straight forward I just receive the post request body, decode it and parse it to get the payload according to ko-fi.com documentation.

Next, I use the azure notification hub to send an FCM notification with the message content.

please remember to install the azure notification hub nugget package

Microsoft.Azure.NotificationHubs 3.3.0

var notificationHubClient = new NotificationHubClient(connectionString, hubName);

the notification hub constructor takes 2 parameters connection string and hub name, we will see how we get them in step 2.

var notificationResult = await notificationHubClient.SendNotificationAsync(

new FcmNotification("{\"data\":{\"message\":\"" + payload.Message + "\"}}"));

we create and send the FcmNotification with a JSON payload, please check the FCM documentation for more.

Step2: Create Azure Notification Hub

using Azure Portal, create a new Notification Hub resource, then go to the resource page and navigate to Acess Policies to get the connection string.

The DefaultFullSharedAccessSignature is the first parameter in the NotificationHubClient constructor and the second parameter is just the resource name which is the hub name.

var notificationHubClient = new NotificationHubClient("Endpoint=sb://xxx.servicebus.windows.net/;SharedAccessKeyName=DefaultFullSharedAccessSignature;SharedAccessKey=53Mxxxx=", "kofihub");

var notificationResult =

await notificationHubClient.SendNotificationAsync(

new FcmNotification("{\"data\":{\"message\":\"" + payload.Message + "\"}}"));

Now you can publish your azure lambda function from the visual studio by right-clicking on it then click publish.

Step 3 Create a Firebase project

I think to create a new project on firebase.google.com is very straightforward and no need to put screenshots for it.

just remember after the project is created go to the settings page and trap the web API key and put it in the azure notification hub fcm settings

Step 4 Add fcm push notification support to your xamarin app

you can follow Microsoft excellent documentation to do this

Add push notifications to your Xamarin.Forms app - Azure Mobile Apps

Step 5 Register your azure function endpoint as a webhook callback

In Azure Portal Go to your FunctionApp resource and navigate your function then click “Get Function URL “

now provide the URL to your 3rd party provider, in my case it is ko-fi.com

and now we are done.

I would like to recommend you the Practical Azure Functions: A Guide to Web, Mobile, and IoT Applications book, it is really one of the best books that will show you the power of lambda functions.

And please if you like this article, you can support me on ko-fi.com it will only cost you 3 USD but it will help me publishing new content and using more professional tools to create better quality articles, I am sure that 3 USD is not a lot.

Buy AhmedFouad a Coffee. ko-fi.com/ahmedfouad

Generator Pattern using CSharp and Linq

Ahmed Fouad — Sat, 28 Mar 2020 23:10:12 +0000

Reactive Programming

The Generator Pattern or the unbound list is a very old technique in functional programming (Haskell) that is possible due to the lazy execution technique.

IEnumerable<int> EvenNumbers=EnumerableEx.From(x=>2x);
Console.Writeline(EvenNumbers[2]);//4

The previous example demonstrated how the generator pattern could be used in CSharp.

When we defined our EvenNumbers=EnumerableEx.From(x=>2x), we only defined a strategy for calculation any element in the enumerable but the function will only get executed when you access one of it is elements.

List<int> EvenNumbers=EnumerableEx.From(x=>2x).Take(10).ToList();
Console.Writeline(EvenNumbers); //0,2,4,3,8,10,12,14,16,18

The conversation between the Inbounded list and the bounded list is simply achieved by adding bounds using linq Skip and Take operators.

Execution Control

In normal c# imperative code, the execution control is usually done by loops and conditions (the natural evolution of GoTo). The factory pattern unleashes the power of LINQ for execution control.

Parallel programming(PLINQ)

var evenNumbers=EnumerableEx.From(x=>2x).Take(10).AsParallel().ToList();
Console.Writeline(EvenNumbers);

Conditions for skipping and Taking

var evenNumbers=EnumerableEx.From(x=>2x);

var data = evenNumbers.Scan((0, 0), (tuple, i) => (i, tuple.Item2 + i))
.Skip(1)
.TakeWhile(i => i.Item2 <= 12)
.Select(tuple => tuple.Item1).ToList();

The previous method will return all the even numbers that their sum is less than or equal to 12 {0,2,4,6}.

you can find the scan method and more linq extensions in the LinqMore Library

https://morelinq.github.io/

Memorization

When dealing with lazy execution memorization is a very important concept as it prevents the recalculation of enumerable elements.

var evenNumbers=EnumerableEx.From(x=>2x);
var data1 =evenNumbers.Take(10).ToList();
var data2 =evenNumbers.Take(20).ToList();

the previous code problem is that it will calculate the first 10 elements in order to build the data1 list and then it will calculate the first 20 elements independently in order to build the data2 list. that means that the first 10 elements are calculated twice.

In order to resolve this, I will use the .Memorize() extension method from the LinqMore library.

var evenNumbers=EnumerableEx.From(x=>2x).Memorize();
var data1 =evenNumbers.Take(10).ToList();
var data2 =evenNumbers.Take(20).ToList();

Now the first 10 elements will get calculated and memorized when building the data1 list and they will get recalled when building the data2 so the elements from 10 to 20 will only get calculated.

Generator Pattern Implementation

Our implementation starts with the Generator Enmurable Which implements the IEnumerable Interface

it is very straight forward it receives the generator function as a parameter and every time the MoveNext method is called it generates the item using the generator function and increments the index.

and here the standard implementation of the IEnumerable

and finally the EnumerableEx helper class

public static class EnumerableEx

{

public static IEnumerable<T> From<T>( Func<int, T> generatorFunc)

{

return new Generator<T>(generatorFunc);

}

}

A Real-Life example

Personally I have used the generator pattern in a lot of projects that I cannot reveal here so it is kind of hard to give you a high-quality real-life example but I can ask you to build a xamarin mobile app that shows the user 2 numbers on the screen and ask him to sum it, if he do it correctly add one point to his score and if the wrong deducts one point. He wins only when his score is 10 and he loose when his score is -10.

if you like this article please share it on your social media and I appreciate if you would like to pay the coffee for me on

Buy AhmedFouad a Coffee. ko-fi.com/ahmedfouad

Introduction to OPTION type in CSharp

Ahmed Fouad — Sun, 23 Feb 2020 20:00:31 +0000

Option type is a polymorphic type introduced in Type theory and has been adopted in many programming languages most of them are functional languages like (F#, Haskell, typescript,…) but some are object-oriented too like java.

In CSharp there is no yet support for OPTION type as a native type but there is a very strong and robust 3rd party implementation using this NuGet.

Optional 4.0.0

What is Option Type?

Option type is a type that can have value or nothing, similar to nullable types that can be a value or null, but option type is not the value but a function of value.

if we try to express the difference between Nullabe and optional in a semi-formal notation it

Object X => X : Object||Null

Optional X => F(x):Object||Nothing

Real-World Example

public ReservationViewModel AddItemToReservation(string id,string itemId)

{

var reservation = \_restaurant.GetReservation(id);

if (reservation == null)

return null;

var item = \_inventory.GetItem(itemId);

if (item == null)

return null;

reservation.Items.Add(item);

return ReservationViewModel(reservation);

}

private ReservationViewModel MapReservationViewModel(Reservation reservation)

{

if (reservation == null)

return null;

var user = \_ClientsManger.GetUser(reservation.Id);

return new ReservationViewModel()

{

From = reservation.From,

User = user != null ? $"{user.FirstName} {user.SecondName}" : "Not a client",

Id = reservation.Id,

Name = reservation.Name,

To = reservation.To

};

}

The previous method gets a user reservation from a database and query for an inventory item and adds the inventory item to the reservation than call “MapReservationViewModel” to map the result to a reservation view model.

It is clear that we need to keep checking for null values and propagate nulls to prevent crashing so the first method check if the reservation is not Null and the Inventory Item is not null and the if so it just returns null and the second method has to ensure that the reservation it gets is not null otherwise it has to return null. And so on every method that will be in the chain should handle the null cases.

While you could imagine that it will be an easy task and that you can handle it with the help of the null propagation feature in c# or by manually checking, I would assure you that in complex cases you would end up with a lot of null reference exceptions.

The Functional Programming solution

I would start by doing a small refactor in the GetReservation, GetInventory, GetUserMethods to return option instead of nullable

public Optional.Option<Reservation> GetReservation(string id)

{

\_reservations.TryGetValue(id, out Reservation result);

return result.SomeNotNull();

}

Then in my AddItemToReservation method, I will join the result of GetReservation and GetInventoryItem

public Option<ReservationViewModel> AddItemToReservation(string id, string itemId)

{

var reservationOptinal = \_restaurant.GetReservation(id);

var itemOptional = \_inventory.GetItem(itemId);

var result= reservationOptinal.Intersect(itemOptional)

The intersection of 2 optional will return an optional tuple of both iff both has values and Nothing if any of them has nothing. ( AND in logic operators).

now I will start to apply my value transformations using the select operator

public Option<ReservationViewModel> AddItemToReservation(string id, string itemId)

{
var result= reservationOptinal.Intersect(itemOptional)

.Select(AddItemFunc);

Reservation AddItemFunc(( Reservation , Item ) tuple)

{

var (reservation, item) = tuple;

reservation.Items.Add(item);

return reservation;

}
}

AddItemFunc is an inner function that receives a value tuple of (reservation, item) and adds the item to the reservation and returns the reservation.

now we will only need to build another optional value type by making a union of reservation and OptionalUser and that can be done easily using the select operator

.Select(reservation => (reservation, \_ClientsManger.GetUser(reservation.UserId)))

Now the full method will be :

I think it is readability is acceptable and it is very computational efficient as at any time if the option becomes Nothing due to any transformation the method will directly return Nothing without continuing the computation.

Final note the Intersect method is not yet included in the Optional library so you can find it here :

https://gist.github.com/TheFo2sh/121c208a6e1bb235df32e43d51b89c68

The power of Reactive Programming and CancellationTokens

Ahmed Fouad — Sun, 09 Feb 2020 22:54:19 +0000

One of the most common scenarios that a mobile developer could encounter is to have an async method that depends on a platform capability like Internet connectivity, Bluetooth, Camera,…

While checking for the capability availability sound straight forward and a method like this one can do the job

public async Task<string> GetDataAsync()

{

if (Connectivity.NetworkAccess != NetworkAccess.Internet

||Connectivity.ConnectionProfiles.All(x=>x!=ConnectionProfile.WiFi))

return null;

HttpResponseMessage response;

using (var httpClient = new HttpClient())

{

response = await httpClient.GetAsync("https://medium.com/feed/@Medium");

}

response.EnsureSuccessStatusCode();

return await response.Content.ReadAsStringAsync();

}

What if after the checking pass or while downloading the internet connection gets interrupted, In this case, you could get an HttpException may be in this case it can handle the exception but what the connection type changed from wifi to cellular for example, now you will download the data from the user cellular data.

The good news is that HttpClient.GetAsync has an overload that takes a CancellationToken as a parameter, so now all that we need is to use this overlead and pass to it a CancellationToken that gets canceled when the internet connection changed.

but here one challenged the xamarin essential expose a ConnectivityChanged event and implementing a CancellationTokenSource based on events is a bit tricky and can introduce more bugs to your code.

In this article, I will provide you with a reusable method that you can use to convert any .net event to a CancellationTokenSource.

We first will convert our Event to an Observableusing C# reactive extension

Observable

.FromEventPattern<Xamarin.Essentials.ConnectivityChangedEventArgs>(

handler => Xamarin.Essentials.Connectivity.ConnectivityChanged += handler, handler => Xamarin.Essentials.Connectivity.ConnectivityChanged -= handler)

.FirstAsync(x=>x.EventArgs.NetworkAccess!=NetworkAccess.Internet)

and then will convert the observableto a custom implementation of CancellationTokenSource

our ObservableCancellationTokenSource is just an adapter that takes IObservavle As a parameter subscribe on it and just call the cancellation method when the observable publish a new value.

The dispose method takes care of disposing of the CanellationTokenSourceand the subscription so no memory leaks will get introduced.

now the modified version of our GetDataAsync method should look like that

public static async Task<string> GetDataAsync(CancellationToken cancellationToken)

{

if (cancellationToken.IsCancellationRequested)

return null;

HttpResponseMessage response;

using (var httpClient = new HttpClient())

{

response = await httpClient.GetAsync("https://medium.com/feed/@Medium", cancellationToken);

}

response.EnsureSuccessStatusCode();

return await response.Content.ReadAsStringAsync();

}

and the caller will look like

var cancellationTokenSource = Observable

.FromEventPattern<ConnectivityChangedEventArgs>(

handler => Connectivity.ConnectivityChanged += handler,

handler => Connectivity.ConnectivityChanged -= handler)

.FirstAsync(x => x.EventArgs.NetworkAccess != NetworkAccess.Internet

||Connectivity.ConnectionProfiles.All(connectionProfile => connectionProfile != ConnectionProfile.WiFi))

.ToCancellationTokenSource();

using (cancellationTokenSource)

{

var result = await FullState.GetDataAsync(cancellationTokenSource.Token);

}

Rx Bonus (combine events)

as we are using RX observable, we have the opportunity of combining multiple events to a single CancellationToken.

Func<EventPattern<ConnectivityChangedEventArgs>, bool> connectivityPredicate = x => x.EventArgs.NetworkAccess != NetworkAccess.Internet

||Connectivity.ConnectionProfiles.All(connectionProfile => connectionProfile != ConnectionProfile.WiFi);

Func<EventPattern<EnergySaverStatusChangedEventArgs>, bool> batteryPredicate = x => x.EventArgs.EnergySaverStatus == EnergySaverStatus.On;

var connectivityObservable = Observable

.FromEventPattern<ConnectivityChangedEventArgs>(

handler => Connectivity.ConnectivityChanged += handler,

handler => Connectivity.ConnectivityChanged -= handler);

var batteryObservable = Observable

.FromEventPattern<EnergySaverStatusChangedEventArgs>(

handler => Battery.EnergySaverStatusChanged += handler,

handler => Battery.EnergySaverStatusChanged -= handler);

var cancellationTokenSource = connectivityObservable

.CombineLatest(batteryObservable,(connectivityArgs, batteryArgs) => (connectivityArgs, batteryArgs))

.FirstAsync(x=>connectivityPredicate(x.connectivityArgs)|| batteryPredicate(x.batteryArgs))

.ToCancellationTokenSource();

similar behavior can be achieved using CancellationTokenSource.CreateLinkedTokenSource but I prefer the observable approach.

How you can use Artifical Intelligence in your xamarin apps (a real-world example)

Ahmed Fouad — Sun, 01 Dec 2019 15:26:31 +0000

For most of the mobile/web developers, AI is not an option while some have studied it in the university or have tried to read about it. They keep staking with the problem of applicability “How and what to apply”

In this article, we will use make a News App and we will make use of the K-means algorithm to group our news. If you like the article and wanna more of AI topics for xamarin or mobile development please clap it, share it everywhere so I can see that more people want this topic.

Our app in a news app that shows some articles from newsapi.org and we need to group these articles by date in a way that makes sense to the user.

A way that makes sense means that depending on the data itself we will generate the groups and the groups.

We will use the K-means algorithm to do this, let me explain first how it works but anyways it is already implemented in Accord.net framework so we will not implement it but ourselves.

1- Pick random centroids which will be the centers of your groups

2- measure the distance of each element and the centroid.

3- recalculate the centroids so the distance is minimized

4- keep doing this for a number of iteration or until the distance within each group reaches a threshold that you already defined.

the nuggets packages that we will need to implement our app are

https://www.nuget.org/packages/Accord.MachineLearning

for AI

public async void Init()

{

var news=await GetNews().ToArrayAsync();

var points = news.Select(x => new double[] {x.PublishedAt.ToUnixTimeSeconds()}).ToArray();

var kmeans = new KMeans(5);

var clusters = kmeans.Learn(points);

var labels = clusters.Decide(points);

Articles = news.Select((value, index) => (value, clusters[labels[index]]))

.OrderByDescending(x => x.Item2.Centroid[0])

.Select(x => new ArticleViewModel()

{

Title = x.value.Title,

Description = x.value.Description,

Image = x.value.UrlToImage?.ToString(),

Group = DateTimeOffset.FromUnixTimeSeconds((long) x.Item2.Centroid[0]).Humanize()

}).ToList();

}

so at first, I get all the news articles in an array and I mapped every news item to an array of a single double which represents the publishing date.

var kmeans = new KMeans(5);

create a kmeans object that will cluster our points in 5 clusters (you can change 5 to anything you want).

var clusters = kmeans.Learn(points);

will generate the 5 centroids for our date.

var labels = clusters.Decide(points);

will group the data in the previously generated clusters.

Articles = news.Select((value, index) => (value, clusters[labels[index]]))

will return a list of value tuples that contain (Article, Centroid in Unix millisecond)

.Select(x => new ArticleViewModel()

{

Title = x.value.Title,

Description = x.value.Description,

Image = x.value.UrlToImage?.ToString(),

Group = DateTimeOffset.FromUnixTimeSeconds((long) x.Item2.Centroid[0]).Humanize()

}).ToList();

we create a view model for each article that contains the Title, Description, Image and the humanized form of it is centroid using Humanizer.

The full view model

using System;

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.ComponentModel;

using System.Diagnostics;

using System.Linq;

using System.Net.Http;

using System.Runtime.CompilerServices;

using System.Text;

using System.Threading.Tasks;

using Accord.MachineLearning;

using App9.Annotations;

using Dasync.Collections;

using Humanizer;

using Newtonsoft.Json;

using QuickType;

using Xamarin.Forms;

namespace App9

{

public class ArticleViewModel

{

public string Group { get; set; }

public string Title { get; set; }

public string Image { get; set; }

public ImageSource ImageSource => Image != null ? ImageSource.FromUri(new Uri(Image,UriKind.RelativeOrAbsolute)) : null;

public string Description { get; set; }

}

class MainPageViewModel:INotifyPropertyChanged

{

private List<ArticleViewModel> \_articles;

public List<ArticleViewModel> Articles

{

get => \_articles;

set

{

\_articles = value;

OnPropertyChanged();

}

}

public async void Init()

{

var news=await GetNews().ToArrayAsync();

var points = news.Select(x => new double[] {x.PublishedAt.ToUnixTimeSeconds()}).ToArray();

var kmeans = new KMeans(5);

var clusters = kmeans.Learn(points);

var labels = clusters.Decide(points);

Articles = news.Select((value, index) => (value, clusters[labels[index]]))

.OrderByDescending(x => x.Item2.Centroid[0])

.Select(x => new ArticleViewModel()

{

Title = x.value.Title,

Description = x.value.Description,

Image = x.value.UrlToImage?.ToString(),

Group = DateTimeOffset.FromUnixTimeSeconds((long) x.Item2.Centroid[0]).Humanize()

}).ToList();

}

private async IAsyncEnumerable<Article> GetNews()

{

using (var httpClient = new HttpClient())

{

var rawResponse = await httpClient.GetStringAsync(

"https://newsapi.org/v2/top-headlines?sortBy=popularity&pageSize=100&country=us&apiKey=dd652e7605d54451a4179d0b28d3f928");

var response = JsonConvert.DeserializeObject<Response>(rawResponse);

foreach(var article in response.Articles)

{

yield return article;

}

}

}

public event PropertyChangedEventHandler PropertyChanged;

[NotifyPropertyChangedInvocator]

protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)

{

PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));

}

}

}

The view

<?xml version="1.0" encoding="utf-8" ?>

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"

xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"

xmlns:d="http://xamarin.com/schemas/2014/forms/design"

xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

mc:Ignorable="d"

xmlns:syncfusion="clr-namespace:Syncfusion.ListView.XForms;assembly=Syncfusion.SfListView.XForms"

xmlns:data="clr-namespace:Syncfusion.DataSource;assembly=Syncfusion.DataSource.Portable"

x:Class="App9.MainPage">

<StackLayout>

<syncfusion:SfListView ItemSize="100" ItemSpacing="20" ItemsSource="{Binding Articles}" >

<syncfusion:SfListView.DataSource>

<data:DataSource>

<data:DataSource.GroupDescriptors>

<data:GroupDescriptor PropertyName="Group"/>

</data:DataSource.GroupDescriptors>

</data:DataSource>

</syncfusion:SfListView.DataSource>

<syncfusion:SfListView.ItemTemplate>

<DataTemplate>

<Grid ColumnSpacing="5">

<Grid.ColumnDefinitions>

<ColumnDefinition Width="3\*"></ColumnDefinition>

<ColumnDefinition Width="7\*"></ColumnDefinition>

</Grid.ColumnDefinitions>

<Image Source="{Binding ImageSource}" VerticalOptions="Start" Grid.Column="0"/>

<StackLayout Grid.Column="1" Spacing="10">

<Label Text="{Binding Title}" FontSize="Title" MaxLines="1" />

<Label Text="{Binding Description}" FontSize="Body" MaxLines="3" />

</StackLayout>

</Grid>

</DataTemplate>

</syncfusion:SfListView.ItemTemplate>

</syncfusion:SfListView>

</StackLayout>

</ContentPage>

How to use CanellationToken With ICommand A Solid Implementation of ICommand

Ahmed Fouad — Fri, 15 Nov 2019 00:10:37 +0000

This article can be considered a part 2 of Async Command A Modern Implementation of ICommand in which we were addressing the async problem in ICommand by blocking the CanExecuteStatus to false in case the previous task was not yet completed.

In this article, we will address the same problem using a different way we will use CancellationToken to cancel the pending task and execute the new one, imagine you have a news app where the user should click on one title in a listview the app will download the news article and will show it, what happens when the user clicks on a title and before the download complete he clicks on another one.

And you can use it in your ViewModel like this

CommandAsync<Uri> commandAsync = new CommandAsync<Uri>(async (uri,cancellationToken)=>await client.GetAsync(uri,cancellationToken));

or can be simplified to this

CommandAsync<Uri> commandAsync = new CommandAsync<Uri>(httpclient.GetAsync);