tpl demo

using System ;

using System.Collections.Concurrent ;

using System.Threading ;

using System.Threading.Tasks ;

using System.Threading.Tasks.Dataflow ;

 

namespace TDFDemo

{

class Program

{

static void Main ( string [] args )

{

new Program (). Run ();

}

 

private async void Run ()

{

var bus = new Bus ();

 

// Inline handler

var s1 = bus . Subscribe < Message >( message => Console . WriteLine ( "Inline Handler 1: {0}" , message . Content ));

 

// Inline handler factory

var s2 = bus . Subscribe < Message >(() => new MessageHandler (). Handle );

 

// Automatic handler subscription

var s3 = bus . Subscribe < Message , MessageHandler >();

 

for ( int i = 0 ; i < 10 ; i ++)

{

await bus . SendAsync ( new Message ( "Message " + i ));

}

 

// Unsubscribe the second handler

bus . Unsubscribe ( s2 );

 

Thread . Sleep ( 1000 );

 

// Cancellation support

 

Console . WriteLine ( "\nSecond Burst:" );

var tokenSource = new CancellationTokenSource ();

var token = tokenSource . Token ;

 

for ( int i = 0 ; i < 10 ; i ++)

{

await bus . SendAsync ( new Message ( "Message " + i ), token );

 

if ( i == 5 )

{

tokenSource . Cancel ();

break ;

}

}

 

Console . ReadLine ();

}

}

 

public class Message

{

public DateTime TimeStamp { get ; private set ; }

public string Content { get ; private set ; }

 

public Message ( string content )

{

Content = content ;

TimeStamp = DateTime . UtcNow ;

}

}

 

public interface IHandle < TMessage >

{

void Handle ( TMessage message );

}

 

public class MessageHandler : IHandle < Message >

{

public void Handle ( Message message )

{

Console . WriteLine ( "Message Handler Received: {0}" , message . Content );

}

}

 

public class Bus

{

private readonly BroadcastBlock < object > broadcast =

new BroadcastBlock < object >( message => message );

 

private readonly ConcurrentDictionary < Guid , IDisposable > subscriptions

= new ConcurrentDictionary < Guid , IDisposable >();

 

public Task < bool > SendAsync < TMessage >( TMessage message , CancellationToken cancellationToken )

{

return broadcast . SendAsync ( message , cancellationToken );

}

 

public Guid Subscribe < TMessage >( Action < TMessage > handlerAction )

{

var handler = new ActionBlock < object >(

message => handlerAction (( TMessage ) message ),

new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = 2 }

);

 

var subscription = broadcast . LinkTo (

handler ,

new DataflowLinkOptions { PropagateCompletion = true },

message => message is TMessage

);

 

return AddSubscription ( subscription );

}

 

public void Unsubscribe ( Guid subscriptionId )

{

IDisposable subscription ;

if ( subscriptions . TryRemove ( subscriptionId , out subscription ))

{

subscription . Dispose ();

}

}

 

private Guid AddSubscription ( IDisposable subscription )

{

var subscriptionId = Guid . NewGuid ();

subscriptions . TryAdd ( subscriptionId , subscription );

return subscriptionId ;

}

}

 

public static class BusExtensions

{

public static Task < bool > SendAsync < TMessage >( this Bus bus , TMessage message )

{

return bus . SendAsync < TMessage >( message , CancellationToken . None );

}

 

public static Guid Subscribe < TMessage >( this Bus bus , Func < Action < TMessage >> handlerActionFactory )

{

return bus . Subscribe < TMessage >( message => handlerActionFactory (). Invoke ( message ));

}

 

public static Guid Subscribe < TMessage , THandler >( this Bus bus ) where THandler : IHandle < TMessage >, new ()

{

return bus . Subscribe < TMessage >( message => new THandler (). Handle ( message ));

}

}

}