What's new in Visual Studio 2012 General

© Copyright SELA software & Education Labs Ltd. 14-18 Baruch Hirsch St.Bnei Brak 51202 Israel
www.sela.co.il

Parallel programming
(API, Performance and Debugging)
using VS 2012, C# 5
and .NET 4.5

• Task represents a metadata of work unit
• Task.Run(…)
• Task.Factory.StartNew(…)
• Task<T> represents a metadata of work unit + return value.

Action a = () => Console.WriteLine("Hello World");
Task t1 = Task.Run(a);

Func<DateTime> f = () => DateTime.Now;
Task<DateTime> t2 = Task.Run(f);
…
DateTime x = t2.Result;

6

• A task encapsulates the work item data
– Execution status Work Unit Context
– State Delegate
– Result State = 123
– Exception Status= Created
– Wait Status= WaitingToRun
– Cancellation (covered later) Status= Running
Status= RanToCompletion Scheduling
– Continuation (covered later)
Result
Status= Faulted
Exception

Task t = new Task ((state) => Console.WriteLine(“”), 123);
t.Start();
7


• Continuations chain tasks one after another

var tsk = Task.Factory.StartNew(s => …);

Task taskAlways = tsk.ContinueWith(sourceTask =>);

Task taskError = tsk.ContinueWith(sourceTask => …,
TaskContinuationOptions.OnlyOnFaulted);

© Copyright SELA software & Education Labs Ltd. 14-18 Baruch Hirsch St.Bnei Brak 51202 Israel 8

Retargeting to .NET 4.5 will improve performance dramatically.
For example, the code below will run 3-4 times faster.

private static void Test(Task t)
{
for (int i = 0; i < 1000000; i++)
{
t = t.ContinueWith(tmp => 1);
}
}


• Task.Run • Task.Delay
– Quickly schedule new task – Schedule task with a
delay
• Task.FromResult • Task.ContinueWith
– Create task from value – More overloads

• Task.Yield • Task.WhenAll / WhenAny
– Like DoEvents but better – Continueation of
WaitAll / WaitAny


• Less operations fall back to running sequentially.

intArray.AsParallel()
.Select(x => Foo(x))
.TakeWhile(x => Filter(x))
.ToArray();


Operators that may cause sequential fallback in both .NET 4 and
.NET 4.5 are marked in blue, and operators that may cause fallback
in .NET 4 but no longer in .NET 4.5 are marked in orange.


• Improve concurrent collections and synchronization.
• ConcurrentDictionary is using finer grain synchronization.
• After upgrading to .NET 4.5, it can run 15% faster.

var cd = new ConcurrentDictionary<int, int>();
cd.TryAdd(42, 0);
for (int i = 1; i < 10000000; i++)
cd.TryUpdate(42, i, i – 1);


• ThreadLocal<T> reduce Values.

var resources = new ThreadLocal<int>(trackAllValues: true);
Parallel.For (0, 100000, i =>
resources.Value += i);

Int total = resources.Values.Sum();

resource.Dispose();


• Define cancellation with timeout.

var ct = new CancellationTokenSource(TimeSpan.FromSeconds(30));

// or

var ct = new CancellationTokenSource();
ct.CancelAfter(TimeSpan.FromSeconds(30));


What is the output of the following Code?

var cts = new CancellationTokenSource (TimeSpan.FromSeconds(1));
Task a = Task.Run(() =>
{
Thread.Sleep(3000);
Console.WriteLine("A");
});
Task b = a.ContinueWith( t => Console.WriteLine("B"), cts.Token);
Task c = b.ContinueWith( t => Console.WriteLine("C"));


• Lazy cancellation will Ignore the cancellation until the
completion of the previous task.

Task a = Task.Run(…);

Task b = a.ContinueWith(…, cancellationToken,
TaskContinuationOptions.LazyCancellation,
TaskScheduler.Default);

Task c = b.ContinueWith(…);


• New overload that allow to pass object state into continuations

var t = Task<string>.Run(() => "123");
t.ContinueWith((tsk, state) => state + tsk.Result, "Some state");


• TaskCreationOptions and TaskContinuationOptions:
• DenyChildAttach
• HideScheduler.
• 3rd Party interaction.
• Task.Run specifies DenyChildAttach and TaskScheduler.Default (ignore
current)


Will the UI responsiveness be affected by this code?

var scd = TaskScheduler.FromCurrentSynchronizationContext();
var tsk = Task.Factory.StartNew (() => ...);
tsk.ContinueWith (t =>
{
// TODO: modify UI component

Task.Factory.StartNew ( () => Thread.Sleep(10000) );
}, scd);


• TaskScheduler provides:
• ConcurrentScheduler
• ExclusiveScheduler
• asynchronous equivalent of a reader/writer lock
• Writer take priority over reader


WCF template support TAP
The proxy default does generate TAP methods for each operation.
At the service side WCF know how to translate methods that return
Task<T>

[ServiceContract]
public interface IService1
{
[OperationContract]
Task<string> GetData(int value);
}


async / await

.NET 4.5
TPL Dataflow
Linq .NET 4
TPL (TAP), IObservable
.NET 3.5
Extension Method
XxxSlim
.NET 3
yield return
.NET 2
delegate Generics
.NET 1
Thread, ThreadPool,
(APM, EAP)
IEnumerable 37

async / await

.NET 4.5
TPL Dataflow
.NET 4
TPL
.NET 3.5
XxxSlim
.NET 3

.NET 2

.NET 1
Thread, ThreadPool,
(APM, EAP)
38

• async – mark the method as a-sync
• await – delegate the execution to a call back thread

marker
static async Task Execute()
{ delegate the
execution to a
Console.WriteLine(“run on calling thread”);
call back thread
await Task.Factory.StartNew(() => Thread.Sleep(1000));

Console.WriteLine(“run on callback thread”);
}


• async – mark the method as a-sync
• await – delegate the execution to a call back thread

{ delegate the
execution to a
Console.WriteLine(“run on calling thread”); Thread Id = 1
call back thread
await Task.Factory.StartNew(() => Thread.Sleep(1000)); Thread Id = 2

Console.WriteLine(“run on callback thread”); Thread Id = 3
}


{
await Task.Factory.StartNew(() => Thread.Sleep(1000));
}

static Task Execute()
{
Task t = Task.Factory.StartNew(() => Thread.Sleep(1000));
return t.ContinueWith (tsk =>
{
});
}


Thread Id = 1
{
await Task.Factory.StartNew(() => Thread.Sleep(1000)); Thread Id = 2
} Thread Id = 3

{
Thread Id = 1
Task t = Task.Factory.StartNew(() => Thread.Sleep(1000)); Thread Id = 2
{
Console.WriteLine(“run on callback thread”); Thread Id = 3
});
}


{
DateTime result = await Task.Factory.StartNew(() => DateTime.Now );
Console.WriteLine(result );
}

static Task Execute()
{
Task<DateTime> t = Task.Factory.StartNew(() => DateTime.Now);
{ DateTime result = tsk.Result;
Console.WriteLine(result );
});
}


• How do we handle Exception in Tpl?
static void Execute()
{

Console.WriteLine("run on calling thread");
…
var tsk = Task.Factory.StartNew(() => …);

}


{
try {
…

}
catch (Exception ex) { … }
}


{
try {
…

} What about
async
catch (Exception ex) { … }
operations
}
Handle synchronous code


{
try {
…
var tsk = Task.Factory.StartNew(() => {});
tsk.ContinueWith(t => Logger.Write(t.Exception),
TaskContinuationOptions.OnlyOnFaulted );
}
catch (Exception ex) { Logger.Write(ex); }
}


• How do we handle Exception using Async?
{
try
{

await Task.Run(() => …); // working on other thread

}
catch (Exception ex) {…}
}


how long does it take to execute the method?

private static async Task Execute()
{
var sw = Stopwatch.StartNew();

await Task.Delay(1000);

Console.WriteLine("Async: {0:N3}", sw.Elapsed.TotalSeconds);
}



Task t = Task.Delay(1000);
t.ContinueWith (t1 =>
{
Task t2 = Task.Delay(1000);
t2.ContinueWith (t4 => …);
}


how long does it take to execute the method?

{

await t1;
await t2;

}


http://blogs.msdn.com/b/pfxteam/archive/2011/09/28/10217876.aspx

{

await Task.WhenAll(t1, t2);

}


await Task.WhenAll (t1, t2);

Task[] arr = new Task[]{t1, t2};
Task.Factory.ContinueWhenAll (arr, tsks => {…});


private static async Task Execute()
{

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

}


private static async Task Execute( int n )
{

for (int i = 0; i < n; i++)
{
}

}


• Using a-sync syntax from UI thread will execute the operation on
other thread and sync back to the UI thread after the await
keyword.

public partial class MainWindow : Window
{
private async Task GetData()
{
Data = "Waiting"; // update the property on the UI thread

string text = await Task.Factory.StartNew(() =>
{
Thread.Sleep(5000);
return "Hellow world";
});
Data = text; // update the property on the UI thread
}

public string Data { get; set; } // bound to UI element
}


Using a-sync syntax from UI thread will execute the operation on
keyword.

{
private async Task GetData() UI Thread
{

{
Thread.Sleep(5000);
});
}

}


Using a-sync syntax from UI thread will execute the operation on
keyword.

{
{

string text = await Task.Factory.StartNew(() => Thread Pool
{
Thread.Sleep(5000);
});
}

}


• Using a-sync syntax from UI thread will execute the operation on
keyword.

{
{

{
Thread.Sleep(5000);
UI Thread return "Hellow world";
});
}

}


• Code review

using (var scope = new MyDisposable())
{
…
Task.Run(() => scope.Execute());
…
}


• the Dispose will be call on the completion thread.

{
…
await Task. Run(() => scope.Execute());
…
}


• Await can apply Lambda expression

Func<Task> f = async () =>
{
Console.WriteLine(“Synchronously");
Console.WriteLine(“Parallel callback");
};

f();


• await cannot be declare in:
– constructor
– lock
– catch or finally
– unsafe block


async / await

.NET 4.5
TPL Dataflow
.NET 4
TPL (TAP), IObservable
.NET 3.5
XxxSlim
.NET 3

.NET 2
Generics
.NET 1
Thread, ThreadPool,
(APM, EAP)
IEnumerable 85

Rx (Reactive Extension) is a library for composing
asynchronous and event-based programs
using observable.

Rx = Push standard over Producer / Consumer (Pub /Sub) Pattern.

Handling the continuation of event stream
86

Rx (Reactive Extension) is a library for composing
asynchronous and event-based programs
using observable.


Subscribe

Observable Observer
(Producer) (Consumer)

87

Does it sound familiar? event EventHandler Click;
Click += (s,e) => {…};


Subscribe

Observable Observer
(Producer) (Consumer)

88

Rx = Linq to Events stream.
- Event can't be composed into LINQ query.
- Event can't be stored in variables and data structures.
- Event can't be pass as parameter.

from dress in producer
where color == blue &&
IsReasonable(dress.price)
select dress

89

• Concept
• Where to use
• How to use

90

GPS
Accelerometer Stock Tickers

Social Media

Server Management

UI
OData

Next

Thread 1 Thread 2 Value
Next 1
Next 2
Current Current 2


How can we reduce the Azure request cost
for Search (send request only if the user
input is idle for 0.5 seconds)


• Google “Rx msdn”
http://msdn.microsoft.com/en-us/data/gg577609
https://rx.codeplex.com
• Platform:
– NET 3.5 SP1
– .NET 4
– .NET 4.5
– WinRT / WinStore
– Silverlight 3, 4
– Windows Phone
– XBox and Zune via XNA
– JavaScript


• Google “Rx msdn”
http://msdn.microsoft.com/en-us/data/gg577609
https://rx.codeplex.com
• NuGet
– Rx-Main
– Rx-Wpf
– Rx-Testing
– Rx-Silverlight
– Rx-Xaml
– Rx-WinForms
– Rx-Providers


Producer

public interface IObservable <T>
{
IDisposable Subscribe (IObserver<T> observer);
}
IEnumerable<out T>
{
Consumer IEnumerator<T> GetEnumerator();
}

IEnumerator<out T> : IDisposable, IEnumerator
public interface IObserver<T> {
{ bool MoveNext();
void OnCompleted (); T Current { get; }
void OnError (Exception exception); void Reset();
void OnNext (T value); }
}


Producer

{
}
IEnumerable<out T>
{
}

IEnumerator<out T> : IDisposable, IEnumerator
public interface IObserver<T> {
{ bool MoveNext();
void OnError (Exception exception); void Reset();
void OnNext (T value); }
}


Producer

{
}

IEnumerable<out T>
{
}

public interface IObserver<T> IEnumerator<out T> Complete / Error
: IDisposable, IEnumerator
{
{
bool MoveNext(); // throw exception
void OnError (Exception exception); }
void OnNext (T value);
}


Producer

{
}

IEnumerable<out T>
{
}

public interface IObserver<T> IEnumerator<out T> : IDisposable, IEnumerator
{
{
bool MoveNext();
}


Producer

{
}

IEnumerable<out T>
{
}

{
{
bool MoveNext();
}


How do you unsubscribe from:
Producer this.Click += (s,e) => {…};

{
}

IEnumerable<out T>
{
}

{
{
bool MoveNext();
}


static void Main(string[] args)
{
IObserver<int> c1 = new Consumer(0);

IObservable<int> p = new Producer();

IDisposable c1Unsubscribe = p.Subscribe(c1);

Thread.Sleep(2000);

Thread.Sleep(1000);
c1Unsubscribe.Dispose(); // unsubscribe

Console.ReadKey();
}


IDisposable unsubscribe = foo.Subscribe (value =>
Console.WriteLine(value));

The following extension method is available for subscription:
• Action<TSource> onNext
• Action<TSource> onNext, Action onCompleted
• Action<TSource> onNext, Action<Exception> onError
• Action<TSource> onNext, Action<Exception> onError, Action onCompleted

IDisposable unsubscribe = foo.Subscribe(
value => Console.WriteLine(value),
exc => Console.WriteLine(exc.Message));

static void Main(string[] args)
{

IObservable<int> p = new Producer();

IDisposable c1Unsubscribe =
p.Subscribe(item => Console.WriteLine(item));


Thread.Sleep(1000);
c1Unsubscribe.Dispose(); // unsubscribe
}


• The marble diagram is the formal way of presenting the
observable stream

on next on next on next complete

on next on next on error


• The marble diagram is the formal way of presenting the
observable stream


var timeStream = Observable.Interval (TimeSpan.FromSeconds(1));
var negativeTimeStream =
from value in timeStream select -value;

1 2 3

value => -value

-1 -2 -3


var evenTimeStream = from value in timeStream
where value % 2 == 0
select value;

1 2 3 4 5 6

2 4 6


1 Sec 1 Sec 1 Sec 1 Sec
• Create time base stream
– Observable.Interval(…);
– Observable.Timer(…);

2 Sec 1 Sec 1 Sec
• Create immediate values
– Observable.Range(…);
– Observable.Return(..);

• Create custom
– Observable.Create(…)
– Observable.Generate(…)


• Visual Rx is a free open source tool, which enable
monitoring a real-time Rx datum stream.
• http://visualrx.codeplex.com/


• Retry: re-subscribe on error
• Catch: subscribe fallback stream on error
• Finally: finalization action


If a tree falls in a forest and no one is around to hear it,
does it make a sound?
if it did make a sound when nobody observed it,
we should mark it as hot,
otherwise it should be marked as cold.


Hot observable streams are streams that are active regardless of
whether or not
they are being observed.
such stream are the Sensors (accelerometer) ,Stock Exchange or
Mouse move event, .

Cold observable streams are streams that are activated upon
subscription
(in most cases a new stream will be activated for each
subscription).
for example Read resources (File, Network).


Subject is great for propagation strategy
Can merge multiple subscribers into single stream
Very useful for custom channeling operators
Hot stream.

ISubject<in TSource, out TResult>
:IObserver<TSource>, IObservable<TResult>

IObserver IObservable
Subject

12
8

class Program { class Program {
event Action<int> E; ISubject<int> S = new Subject<int>();

static void Main() { static void Main() {
var p = new Program(); var p = new Program();

p.E += i => p.S.Subscribe(i =>
Console.Write(i); Console.Write(i));

p.E(1); p.S.OnNext(1);
} }
} }





} }
} }


Can’t pass as a parameter Separation of Concerns:
or store in a data-structure can be split into
IObservable / IObserver

static void Main() {
Support extension static void Main() {
var p = new Program(); query
method and linq var p = new Program();
Can be disposed
Support concurrency
through scheduler

} }
} }


• Different strategies for combining the result of multiple streams
together


the merge combinator is used to merge multiple IObservable streams into single
IObservable streams

T1 T2 T3

B1 B2 B3

T1 B1 B2 T2 B3 T3


the merge combinator is used to merge multiple IObservable streams into single
IObservable streams

var xs = Observable.Interval(TimeSpan.FromSeconds(1));
var ys = Observable.Interval(TimeSpan.FromSeconds(0.2));
var zs = Observable.Merge(xs, ys);
T1 T2 T3
zs.Subscribe(item => Console.Write(item));

B1 B2 B3

T1 B1 B2 T2 B3 T3


the zip combinator is used to synchronize 2 IObservable streams into a single
IObservable stream

S1 S2 S3

P1 P2 P3

S1 + P1 S2 + P2 S3 + P3


the zip combinator is used to synchronize 2 IObservable streams into a single
IObservable stream
var xs = Observable.Interval(TimeSpan.FromSeconds(1));
var ys = Observable.Interval(TimeSpan.FromSeconds(1));
var zs = xs.Zip(ys, (x, y) => x + y));

S1 S2 S3
zs.Subscribe(item => Console.Write(item));

P1 P2 P3

S1 + P1 S2 + P2 S3 + P3


the zip combinator may not be the right choice for non-synchronized stream.

S1 S2 S3 S4 S5 S6 S7 S8

P1 P2 P3

S1 + P1 S2 + P2 S3 + P3


the buffer with time operator buffers values that occur within specific
time windows, and then publishs the buffered values whenever the time period
ends.

3 seconds 3 seconds
1 2 3 4 5 6 7 8 9

{1,2,3,4} {5,6,7,8}


the buffer with time operator buffers values that occur within specific
time windows, and then publishs the buffered values whenever the time period
ends.

3 seconds 3 seconds
1 2 3 4 5 6 7 8 9

IObservable<long> xs = ...;
{1,2,3,4} {5,6,7,8}
IObservable<IList<long>> xsBufferd =
xs.Buffer (TimeSpan.FromSeconds(1));


Day 1 Day 2

Credit: http://enumeratethis.com/2011/07/26/financial-charts-reactive-extensions/

Day 1 Day 2
High
H How does it affect the
program?
H GC Gen 2
Close
and Large object heap
Open C
O
O
L C
Low
L


the Window operator buffers values that occur within specific
time windows, and then publishes the buffered values whenever the time
period ends.

3 seconds 3 seconds
1 2 3 4 5 6 7

1 2 3 4

5 6 7


the Window operator buffers values that occur within specific
time windows, and then publishes the buffered values whenever the time
period ends.

3 seconds 3 seconds
1 2 3 4 5 6 7

1 2 3 4

5 6 7

IObservable<IObservable<long>> xsBufferd = xs.Window(4);


Day 1 Day 2

H

H

C
O
O
L C
L

IObservable<IObservable<long>> xsBufferd =
xs.Window(TimeSpan.FromDays(1));


• Drag & drop


Data (What)
• Scheduler
– Data
– Threads Time
– Time (Virtual Time) (when)
• Commit points

Thread
(How)

Observable.Interval(TimeSpan.FromSeconds(1), TaskPoolScheduler.Default);


• NewThreadScheduler: new thread execution.
• ThreadPoolScheduler: thread pool execution.
• TaskPoolScheduler: TPL execution
• Scheduler.Immediate: current thread execution.
• Scheduler.CurrentThread: current thread via queue execution.
• EventLoopScheduler: single thread execution.
• DispatcherScheduler: WPF thread
(System.Reactive.Windows.Threading.dll)
• ControlScheduler: WinForm thread
(System.Reactive.Windows.Forms.dll)


Forum activity, similar / overlapping Microsoft technologies

RX PLINQ / Parallel Extensions TPL DataFlow
Threads: 1,251 Threads: 793 Threads: 59
Messages: 7,787 Messages: 3,828 Messages: 264
Users: 665 Users: 1,004 Users: 44
General Discussions: 239 General Discussions: 39 General Discussions: 6

Microsoft Robotics CCR Async CTP Axum
Threads: 411 Threads: 325 Threads: 125
Messages: 1,858 Messages: 1,409 Messages: 490
Users: 590 Users: 366 Users: 104
General Discussions: 49 General Discussions: 27 General Discussions: 19

Friday, November 25, 2011


Rx is a powerful Linq-able dataflow extension
Rx applies to the producer / consumer (pub / sub)
pattern
Rx has lots of extension operators
Rx can compose different event streams into
combined stream functionality
Rx rely on the scheduler which can be mocked for
testing and replay purposes

16
9

17
0

http://blogs.microsoft.co.il/blogs/bnaya/
Rx at DelLab: http://msdn.microsoft.com/en-
us/devlabs/ee794896
101 Rx Samples: http://rxwiki.wikidot.com/101samples
Lee Campbell –
http://leecampbell.blogspot.com/2010/05/intro-to-rx.html
http://leecampbell.blogspot.com/search/label/Rx

17
1

async / await

.NET 4.5
TPL Dataflow
.NET 4
TPL
.NET 3.5
XxxSlim
.NET 3

.NET 2

.NET 1
Thread, ThreadPool,
(APM, EAP)
173

• TPL Dataflow (TDF) is a higher-level abstraction over the TPL

• It provides common solutions for common parallel patterns

• Focuses on providing agent-based models, building blocks for
message passing and buffering parallelization


• TPL Dataflow (TDF) evolved from:
– AAL: Asynchronous Agents Library (native)
– Axum: agent-based language that builds upon the architecture of the
Web and principles of isolation
– CCR: (Microsoft Robotics) Concurrency and Coordination Runtime


• High-throughput / low-latency.
• Immense CPU and I/O traffic

• TDF’s Building blocks can be used:
– Standalone
– In composition with others (enabling complex dataflow networks)

• Efficient execution that avoids oversubscription.


• Download .NET 4.5
• Reference: System.Threading.Tasks.Dataflow.dll
– NuGet: Tpl Dataflow or TDF
• Main namespaces:
– System.Threading.Tasks.Dataflow
– System.Threading.Tasks


• DTF is based on 2 interfaces:
– ISourceBlock<T> // producer
– ITargetBlock<T> // consumer

Link To
ISourceBlock<T> ITargetBlock<T>

• Each node in the dataflow may either ISourceBlock<T>,
ITargetBlock<T> or both.


• OfferMessage:
• Accept or Deny the message
• Calls back to methods on the source block
• consumeToAccept – communication pattern direct vs. indirect consume

DataflowMessageStatus OfferMessage(
DataflowMessageHeader messageHeader,
TInput messageValue, // push
ISourceBlock<TInput> source, // pull
bool consumeToAccept); // false = push

18
3

OfferMessage communicates back to caller either by using the
source parameter or by the DataflowMessageStatus return value.
• Accepted: accepted the message and take ownership.
• Declined
• Postponed: postponed the message
for potential consumption at a later time.
The target may consume the message later by using the
source ConsumeMessage.
• NotAvailable: failed to consume the message
(the message is no longer available)
• DecliningPermanently: declined the message and
all future messages sent by the source.

• Data-pulling APIs.

interface IReceivableSourceBlock<TOutput>
: ISourceBlock<TOutput>
{
bool TryReceive(out TOutput item, Predicate<TOutput> filter);
bool TryReceiveAll(out IList<TOutput> items);
}

18
5

LinkTo -> OfferMessage

Push: LinkTo

ISourceBlock<T> ITargetBlock<T>
Pull: TryReceive

TryReceive

18
6

• TPL Dataflow provides built-in blocks for most common and
needed scenarios
• The built-in blocks fall into three categories:
– Pure Buffering blocks
– Execution blocks
– Grouping blocks

19

• A propagator which provides a buffer for storing instances of T
• Non broadcasting nature:
– Push via LinkTo will offer a message to each target in turn, allowing only
one to consume each
– Pull via Receives will remove the received element from the buffer


private BufferBlock<int> _buffer = new BufferBlock<int>();

private void Producer()
{
for (int i = 0; i < 10; i++) {
_buffer.Post(i);
}
}
private void Consumer()
{
while (true) {
int item = _buffer.Receive();
Console.WriteLine(item);
}
}


private BufferBlock<int> _buffer = new BufferBlock<int>();

{ Does it sound familiar?
for (int i = 0; i < 10; i++) {
_buffer.Post(i);
}
}
{
while (true) {
}
}


private BufferBlock<int> _buffer = new = new ConcurrentQueue<int>();
ConcurrentQueue<int> _buffer BufferBlock<int>();

{
for (int i = 0; i < 10; i++) {
_buffer.Enqueue(i);
_buffer.Post(i);
}
} What’s happens when the
queue is empty?
{
int item;
while (true) {
while (_buffer.TryDequeue(out item)) {
} }
}


private BlockingCollection<int>_buffer = new ConcurrentQueue<int>();
ConcurrentQueue<int> _buffer = new BlockingCollection<int>();

{
for (int i = 0; i < 10; i++) {
_buffer.Add(i);
_buffer.Enqueue(i);
} Which thread is running?
} Is it a thread pool’s thread?
{
foreach(int item in _buffer.GetConsumingEnumerable()) {
int item;
while (_buffer.TryDequeue(out item)) {
} Console.WriteLine(item);
} }
}


private BlockingCollection<int> _buffer = new BlockingCollection<int>();

{
for (int i = 0; i < 10; i++) { Watch your memory graph
_buffer.Add(i); when idle!!!
} Real-life story: Blocking
} Collection
{
foreach(int item in _buffer.GetConsumingEnumerable()) {
Parallel.ForEach(_buffer.GetConsumingEnumerable(), item => {
}
}


var abConsumer1 = new ActionBlock<int>(i => …));

var bufferBlock = new BufferBlock<int>();
bufferBlock.LinkTo (abConsumer1); /* target */

bufferBlock.Post(1);
bufferBlock.Post(2); ActionBlock
BufferBlock
ActionBlock


How does it different from Rx?

Rx = direct push (functional programming).
TDF = push via buffering (agent base).

In general it is a better together scenario.

Target Block

Buffe
r Task

• ISourceBlock<T>.AsObservable()
• ITargetBlock<T>.AsObserver()

var xs = from item in bufferBlock.AsObservable()
group item % 10 into g
select g;


var options = new ExecutionDataflowBlockOptions {BoundedCapacity = 1};

var abConsumer1 = new ActionBlock<int>(i => …, options ));
var abConsumer2 = new ActionBlock<int>(i => …, options ));


bufferBlock.Post(1); Target Block
bufferBlock.Post(2);

BoundedCapacity = 1

• A propagator which provides a buffer for storing instances of T
• Broadcasting nature:
– Always keep the last item
– All linked targets will be offered a copy of the data,
the block’s constructor gets a Func<T,T> for the cloning operation.



var broadcastBlock = new BroadcastBlock<int>(i => i.Clone());
broadcastBlock.LinkTo (abConsumer1); /* broadcast target */
broadcastBlock.LinkTo (abConsumer2); /* broadcast target */

broadcastBlock.Post(1);
broadcastBlock.Post(2);
TargetBlock
BroadcastBlock
TargetBlock


• How to avoid over subscription?
• How to tune the blocks execution?
• Why does the BroadcastBlock is having an input buffer?


• Blocks signature

var downloader = new ActionBlock<string>(async url =>
{
byte [] imageData = await DownloadAsync(url);
Process(imageData);
});

downloader.Post("http://msdn.com/concurrency ");
downloader.Post("http://blogs.msdn.com/pfxteam");

20
9

Action

Broadcast
4 3 2 1

Action


Action

Broadcast
4 3 2 1 1

Action


Action
1
Broadcast
4 3 2 2
1

Action
1


Action
2 1
Broadcast
4 3 3
2
3

Action
2 1


Action
3 2 1
Broadcast
4 4
3

Action
2 1


Action
4 3 2
Broadcast
4

Action
2 1


Action
4 3
Broadcast
4

Action
2 1


• Can we avoid Task starvation?

MaxMessagesPerTask


Action

Broadcast
4 3 2 1 1

Action


Action
1
Broadcast
4 3 2 2
1

Action
1


Action
2 1
Broadcast
4 3 2
3

Action
2 1


Google: Bnaya Export Web Crawler
http://blogs.microsoft.co.il/blogs/bnaya/archive/2012/01/28/
tpl-dataflow-walkthrough-part-5.aspx


22
2

High level abstraction.
Producer / Consumer = ISourceBlock / ITargetBlock
Greedy vs. Non-Greedy
Makes no built-in guarantees of isolation.

Introduction to TPL Dataflow by Stephen Toub,
Microsoft (part of the async CTP)

http://blogs.microsoft.co.il/blogs/bnaya/

22
3

What's new in Visual Studio 2012 General

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Andere mochten auch

Andere mochten auch (20)

Ähnlich wie What's new in Visual Studio 2012 General

Ähnlich wie What's new in Visual Studio 2012 General (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

What's new in Visual Studio 2012 General

Hinweis der Redaktion