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.