Skip to main content

What are the base async patterns in .NET world

In momentul de fata exista diferite paternuri care sunt folosite pentru apeluri asyncrone. Am observat ca destul de multa lume incurca aceste paternuri si se face un mix intre acestea.
Din cate am observat pana acuma exista 3 paternuri principale care sunt folosite in general in .NET (mai putin 4.5, despre care o sa vorbim separat).
EAP (Event based Asynchronous Pattern) - in acest patern orice schimbare de stare (actiune se termina de executat, apare o eroare, progresul) sunt notificate prin intermediul unor evenimente.
public class FooEAP
{   
    public void CalculateAsync(int value1, int value2)
{
    int sum = value1 + value2;
    OnCalculateComplete(sum);
}
public event CalculateCompleteEventHandler CalculateComplete;
private void OnCalculateComplete(int result)
{
    if( CalculateComplete != null )
    {
        CalculateComplete(this, new FooCalculateEventArgs(result));
    }
}
}
APM (Asynchronous Programming Model) - paternul este destul de usor de recunoscut prin formatul BeginXXX si EndXXX. In momentul in care un utilizator apeleaza BeginXXX, task-ul incepe sa se execute. Aceasta metoda o sa returneze o implementare a interfetei IAsyncResult care are urmatoarea forma:
public interface IAsyncResult
{
WaitHandle AsyncWaitHandle { get; }
Boolean    IsCompleted     { get; }
Object     AsyncState      { get; }
Boolean    CompletedSynchronously { get; }
}
Aceasta interfata se poate folosii pentru a verifica in ce stare se afla actiunea noastra sau sa vedem progresul. Acest patern este destul de intalnit in WCF.
public class FooAPM
{
    IAsyncResult calculateAsyncResult;
    public IAsyncResult BeginCalculate(int value1, int value2)
{
    ...   
}
    public void EndInvoke()
{
    // Wait the task to finish
}
}
TPL (Task Parallel Library) - se bazeaza pe task-uri care au fost introduse cu .NET 4.0. Nu reprezinta un patern in sine, dar din .NET 4.5 mai ales o sa fim nevoiti sa le folosim din ce in ce mai des. In general acestea se foloseste cand lucram cu API care se bazeaza pe task-uri. TPL simplifica foarte mult paternul asyncron. Folosind TPL ne este mult mai usor sa scriem si sa folosim cod asyncron.
public class FooTPL
{
    public Task<int> Calculate(int value1, int value2)
{
    return new Task<int>(() => { return value1 + value2; });
}
}
Task-urile sunt destul de complexe din puct de vedere a API-ului. Sunt extrem de usor de folosit, dar trebuie folosite cu cap deoarece pot sa faca mai mult rau decat bine.
Odata cu .NET 4.5 au aparut async si await, iar orice apel poate sa fie executat asyncron fara sa mai scrim nici o linie de cod. In spate ele se bazeaza pe task-uri si fac parte din TPL si vin in ajutor programatorului. Folosinf aceste doua chei ne este multi mai usor sa scriem si sa facem apeluri asyncrone. In general aceste metode sunt denumite sub forma XXXAsync.
public class FooTPL
{
    public async Task<int> CalculateAsync(int value1, int value2)
{   
    int sum = await CalculateHelper.SumAsync(value1, value2);
return sum;
}
}
Despre cum functioneaza await, o sa revin intr-un post viitor.
Sper ca dupa citirea acestui post va este putin mai clar fiecare din aceste "paternuri". Toate fac acelasi lucru, doar ca in diferite moduri.

Comments

Popular posts from this blog

How to check in AngularJS if a service was register or not

There are cases when you need to check in a service or a controller was register in AngularJS.
For example a valid use case is when you have the same implementation running on multiple application. In this case, you may want to intercept the HTTP provider and add a custom step there. This step don’t needs to run on all the application, only in the one where the service exist and register.
A solution for this case would be to have a flag in the configuration that specify this. In the core you would have an IF that would check the value of this flag.
Another solution is to check if a specific service was register in AngularJS or not. If the service was register that you would execute your own logic.
To check if a service was register or not in AngularJS container you need to call the ‘has’ method of ‘inhector’. It will return TRUE if the service was register.
if ($injector.has('httpInterceptorService')) { $httpProvider.interceptors.push('httpInterceptorService&#…

ADO.NET provider with invariant name 'System.Data.SqlClient' could not be loaded

Today blog post will be started with the following error when running DB tests on the CI machine:
threw exception: System.InvalidOperationException: The Entity Framework provider type 'System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer' registered in the application config file for the ADO.NET provider with invariant name 'System.Data.SqlClient' could not be loaded. Make sure that the assembly-qualified name is used and that the assembly is available to the running application. See http://go.microsoft.com/fwlink/?LinkId=260882 for more information. at System.Data.Entity.Infrastructure.DependencyResolution.ProviderServicesFactory.GetInstance(String providerTypeName, String providerInvariantName) This error happened only on the Continuous Integration machine. On the devs machines, everything has fine. The classic problem – on my machine it’s working. The CI has the following configuration:

TeamCity.NET 4.51EF 6.0.2VS2013
It seems that there …

Run native .NET application in Docker (.NET Framework 4.6.2)

Scope
The main scope of this post is to see how we can run a legacy application written in .NET Framework in Docker.

Context
First of all, let’s define what is a legacy application in our context. By a legacy application we understand an application that runs .NET Framework 3.5 or higher in a production environment where we don’t have any more the people or documentation that would help us to understand what is happening behind the scene.
In this scenarios, you might want to migrate the current solution from a standard environment to Docker. There are many advantages for such a migration, like:

Continuous DeploymentTestingIsolationSecurity at container levelVersioning ControlEnvironment Standardization
Until now, we didn’t had the possibility to run a .NET application in Docker. With .NET Core, there was support for .NET Core in Docker, but migration from a full .NET framework to .NET Core can be costly and even impossible. Not only because of lack of features, but also because once you…