Bnaya Eshet : Beginner, SELA

T 4 beginners – part 4

bnaya — Sat, 22 May 2010 12:02:33 GMT

T 4 beginners – part 4

this is the 4rd post on this series.

in this post we will focus on T4 Class feature control blocks.

you can download the code for this post here.

the series TOC is available here.

What is class feature control block?

class feature control block is one of the T4 extension mechanism that enable reuse of

T4 sections.

using class feature control block you can defines helper properties or methods,

that can be used from different T4 templates.

The syntax of class feature control block

class feature control block is having the following syntax <#+ ... #>

Code Snippet
 <#+   // Start of class feature block
private int Square(int i)
{
    return i*i;
}
#>
 

this extension can be use within control block or expression control block, as demonstrate:

 // This is hello number <#= i+1 #>, square <#= Square(i+1) #>
 

as you can the second expression block is using the Square (class feature method).

Where class feature control block can be define?

class feature control block can be both inline (which mean inside the T4 template)

or external (external helper file), which is more appropriate.

How to define external class feature control block?

to define class feature control block in external file, you should:

1. add text file into your project

(I'm changing the text file extension to *.tt.extension, but you can use whatever extension you like).

update: it is better to name the file extension *ttinclude

2. the class feature control block should be added into the extension file.

How to include external class feature control block?

if you want to use external class feature control block you should add

include directive to the T4 as demonstrate below:

<#@ include file="ClassFeatureBlock.tt.extension" #>

Summary

class feature control block is one of the strength, you can simplify the T4 template

by using predefine reusable methods.

Code sample available here.

T 4 beginners – part 3

bnaya — Sat, 22 May 2010 01:43:14 GMT

T 4 beginners – part 3

this is the 3rd post on this series.

in this post we will focus on basics T4 Control blocks.

you can download the code sample from here.

the series TOC is available here.

T4 Control blocks is where dynamic text is added into the template output,

this is the heart of T4 concept

(C# is the default language but you can change it to VB).

Standard control blocks

A standard control block is a section of program code that generates part of the output.

You can mix any number of text blocks and standard control blocks in a template file.

However, you cannot place one control block inside another.

Each standard control block is delimited by the symbols <# ... #>.

Code Snippet
 /*
*  generate on <# WriteLine(DateTime.Now.DayOfWeek.ToString()); #>
*/
 

the above snippet include control block that write the current day of week.

this is the code it generate:

Code Snippet
 /*
*  generate on Friday
*/
 

Expression control blocks

An expression control block evaluates an expression and converts it to a string and insert it into the output file.

the syntax of expression control blocks is using the <#= … #> syntax instead of <# … #> .

Code Snippet
 /*
*  generate on <#= DateTime.Now.DayOfWeek.ToString() #>
*/
 

both the WriteLine and the ; were omit.

the following snippets is using expression control block combine with standard control block which

use for iterations:

Code Snippet
  <#
for(int i = 0; i < 4; i++)
{
 #>
     // This is hello number <#= i+1 #>: Hello!
 <#
 } 
 #>
 

lines 1-3, start the iterations.

line 5, write text block which embedded expression control block that write the current iteration count.

lines 6-8, close the iterations.

the output will look like:

Code Snippet
 // This is hello number 1: Hello!
// This is hello number 2: Hello!
// This is hello number 3: Hello!
// This is hello number 4: Hello!
 

Summary

the control block is what T4 is doing, create dynamic section

T 4 beginners – part 2

bnaya — Thu, 20 May 2010 02:09:46 GMT

T 4 beginners – part 2

this is the second post on this series.

in this post we will focus on basics T4 Directives.

you can use the code sample of the previous post here.

the series TOC is available here.

Directive syntax:

any of the directives is using the following syntax:

<#@ DirectiveName [ParameterName = "ParameterValue"] #>

it start with <#@ follow with the directive name,

includes zero or more name value parameters and

end with #>

All parameter values must be surrounded by double quotation marks.

If the value itself contains quotation marks, they must be escaped with the \ character.

For example: <#@ DirectiveName Parameter=" \" quote \" " #>

T4 provide the following Directives:

Output

 <#@ output extension=".cs" encoding="UNICODE" #>
 

the output directive define the encoding and extension of the generated file.

Template

The template directive allow the following parameters (all the parameters are optional):

 <#@ template debug="true" language="C#" #>
 

language: the language define the programming language of the Control blocks within the T4
(this is the language that used to process the T4 and it has nothing to do with the T4 output).
example: language ="C#" or language="VB"
debug: indicate whether the template can be debug
(we will cover debugging on later post)
inherits: is one of the possible ways to extend T4
(we will discuss the inherit parameter in further post).

Assembly

The assembly directive define the T4 dependencies.

for example the following T4 Control block:

 <#= System.DateTime.Now.ToString() #>
 

will result with exception unless the following assembly directive will be define:

 <#@ Assembly Name="System.Core.dll" #>
 

The assembly name should be one of the following:

The file name of the assembly, if it is located in the same directory as the text template
The absolute path of the assembly
The relative path of the assembly (with respect to the directory in which the text template is located)
The strong name of the assembly, as in the GAC.
You can use the $(variableName) syntax to reference Visual Studio or MSBuild variables, and %VariableName% to reference environment variables.

Import

the import directive behave as using statement for the T4 control block.

as the case with other directive it add nothing to the T4 output.

using the following import directive:

 <#@ import namespace="System" #>
 

you can replace the following full path control block:

 <#= System.DateTime.Now.ToString() #>
 

with the following control block:

 <#= DateTime.Now.ToString() #>
 

Summary

the T4 directive is fairly intuitive and simple to use.

Resources

http://msdn.microsoft.com/en-us/library/bb126421.aspx

http://www.codeproject.com/KB/codegen/T4CustGtc.aspx

T 4 beginners – TOC

bnaya — Thu, 20 May 2010 02:02:00 GMT

T 4 beginners – TOC

The current available posts on the T 4 beginner series (T4 template) are:

T 4 beginners – part 1

bnaya — Wed, 19 May 2010 01:47:13 GMT

T 4 beginners – part 1

this is the first post of a series that will focus on T4 template.

this post discuss the T4 in general while the following pose will focus on the T4 practice.

the code for this post can be found here.

the series TOC is available here.

What is T4 template?

T4 is sanding for Text Template Transformation Toolkit.

T4 is all about automating code or content generation.

the usual extension for T4 files is the *.tt

When to use T4?

whenever you identify repeatable pattern of code or content, that can be

infer from other item within the project (like the case of code that is

generate from a designer, or entity framework self tracking entities),

you should consider to automate it by using T4,

instead of writing it over and over again.

What are the benefits?

T4 can bring the following benefits:

speed-up the development process.
increase the code consistency.
make is easier to apply best practice.
it is easy to start with prototype then modify it's dynamic sections.
T4 is very powerful concept because it is using C# or VB.net as it script language,
therefore it is lower the learning curve.

The T4 structure

T4 are composed of the following parts:

Directives - elements that control how the template is processed.
<#@ output extension=".txt" #>
Text blocks - content that is copied directly to the output.
Control blocks - program code that inserts variable values into the text,
and controls conditional or repeated parts of the text.
<#= System.DateTime.Now.ToString() #>

The syntax

T4 syntax resemble old ASP 3 syntax, it is an hybrid of text and <# control blocks #>

Code Snippet
 <#@ template debug="true" hostSpecific="true" #>
<#@ output extension=".cs" #>
<#@ Assembly Name="System.Core.dll" #>
<#@ Assembly Name="mscorlib.dll" #>
<#@ import namespace="System" #>
<#@ import namespace="System.Security.Principal" #>
 
using System;
//using System.Security.Principal;
namespace Bnaya.Samples
{
    // Last update on <#= System.DateTime.Now.ToString() #>
    public static class Utils
    {
        public static void GenerateBy ()
        {
            Console.WriteLine ("The code was generate on <#= Environment.MachineName #>");
            Console.WriteLine (@"by <#= WindowsIdentity.GetCurrent().Name #>");
        }
    }
}
 

we will discuss each T4 command in the following part of the series, but in general:

lines 1-6: are directives.

Line 12 and lines 17,18: has control blocks.

any thing else is just text blocks.

the project will look as follow:

the generated HelloWorld.cs will look as follow:

Code Snippet
 using System;
//using System.Security.Principal;
namespace Bnaya.Samples
{
    // Last update on 5/18/2010 7:29:10
    public static class Utils
    {
        public static void GenerateBy ()
        {
            Console.WriteLine ("The code was generate on BNAYA-PC");
            Console.WriteLine (@"by Bnaya-PC\Bnaya");
        }
    }
}
 

notice that the date at line 5 and part of the text at lines 10, 11 was generate by the T4.

What do you need to get it operating?

T4 is part of Visual Studio 2010, which mean that you can add T4 template to any of

your project (just by adding item and selecting one of the T4 item template).

what's missing is the IntelliSense and syntax coloring capability.

you can add the syntax coloring and IntelliSense by installing the following VS extension gallery:

http://visualstudiogallery.msdn.microsoft.com/en-us/60297607-5fd4-4da4-97e1-3715e90c1a23

Summary

T4 can boost your coding productivity by automating repeatable patterns.

MEF for Beginner (Deployment Catalog) - part 12

bnaya — Fri, 02 Apr 2010 01:20:55 GMT

MEF for Beginner (Deployment Catalog) - part 12

this is the 12th post of the MEF for Beginner series, the series TOC is available here.

this post will focus on Deployment Catalog.

the code sample for this post can be found here.

What is MEF Deployment Catalogs?

the deployment catalog is actually a redesign of the older package catalog.

it enable to load parts from xap packages a-synchronically.

Code sample

the following code sample depend on 2 assembly that should be added to the project:

System.ComponentModel.Composition
System.ComponentModel.Composition.Initialization

at the startup (app.xaml)

Code Snippet
 private void Application_Startup(object sender,StartupEventArgs e)
{
    InitializeContainer();
    this.RootVisual = new MainPage();
}
 
private void InitializeContainer()
{
    var catalogs = new AggregateCatalog();
 
    var catalog = new TypeCatalog(typeof(PlugIns));
    catalogs.Catalogs.Add(catalog);
 
    // Create deployment catalog
    var deployCatalog = new DeploymentCatalog("PlugIns.xap");
    deployCatalog.DownloadCompleted += OnDownloadCompletedHandler;
    deployCatalog.DownloadProgressChanged += OnDownloadProgressChangedHandler;
    deployCatalog.DownloadAsync();
 
    catalogs.Catalogs.Add(deployCatalog);
 
    // initialize the main application composition host (container)
    CompositionHost.Initialize(catalogs);
}
 

line 3, initialize MEF before the creation of any windows that depend on MEF.

line 9, define aggregate catalog (this is basically a catalog collection).

lines 11-12, create type catalog for plug-ins within the main xap (plug-in within the main xap

can be assess directly) and add the catalog to the aggregate catalog.

line 15, create deployment catalog (it get the xap relative path as parameter).

lines 16-17, register for xap download process events (optional).

line 18, start downloading the xap.

line 20, add the deployment catalog to the aggregate catalog.

line 23, initialize the composition host with the aggregate catalog (so

latter using CompositionInitializer.SatisfyImports will operate against the aggregate catalog).

at the MainPage.xaml the code will look as follow:

Code Snippet
 public partial class MainPage:UserControl,INotifyPropertyChanged
{
    public MainPage()
    {
        InitializeComponent();
        this.DataContext = this;
        CompositionInitializer.SatisfyImports(this);
    }
 
    private IEnumerable<string> _plugIns;
    [ImportMany(AllowRecomposition = true)]
    public IEnumerable<string> PlugIns
    {
        get
        {
            return _plugIns;
        }
        set
        {
            _plugIns = value;
            if(PropertyChanged != null)
                PropertyChanged(this,new PropertyChangedEventArgs("PlugIns"));
        }
    }
 
    public event PropertyChangedEventHandler PropertyChanged;
}
 

line 7, asking MEF to satisfy any import of the current instance (in our case the PlugIns property).

lines 11, decorate the PlugIns property for being assigned by the MEF composition.

notice that the decoration define AllowRecomposition = true, this is very important

because the deployment catalog is a-synchronic, therefore we do not control the exact time of the assignment.

Summary

deployment catalog is the current way for delay composition from xap packages.

it is a-synchronic and it will notify the catalog upon the download completion.

the code sample for this post can be found here.

Learn more

Rx - for beginners (part 13): Publish (broadcast to many subscribers)

bnaya — Thu, 01 Apr 2010 00:04:28 GMT

Rx - for beginners (part 13): Publish (broadcast to many subscribers)

this post is the 13th in a series of posts about the new Reactive Framework (Rx).

the series TOC can found here.

in this post we will focus on the Publish operator.

the code for this post available here.

let guess how many times the select statement will be invoke for the following code,

the underline stream will produce 2 value (0, 1)?

Code Snippet
 IObservable<long> observableRoot = Observable.Interval(TimeSpan.FromSeconds(1));
 
var producer = from item in observableRoot
               where item < 2
               select item;
 
producer.Subscribe(value => Console.WriteLine("A: " + value));
producer.Subscribe(value => Console.WriteLine("B: " + value));
 

the answer is 4 times, actually the select statement will be invoked for each of the subscription (in this sample we having 2 on lines 7-8),

each time that the producer (observable) will produced value.

in order to emphasis the problem I did some minor changes to the Linq query:

Code Snippet
 IObservable<long> observableRoot = Observable.Interval(TimeSpan.FromSeconds(1));
 
var producer = observableRoot.Where(item => item < 2);
producer = producer.Select(item =>
               {
                   Console.WriteLine("X");
                   return item;
               });
 
producer.Subscribe(value => Console.WriteLine("A: " + value));
producer.Subscribe(value => Console.WriteLine("B: " + value));
 

as you can see at line 3, we doing the where part,

and at lines 4-8 we doing the select part + writing X to the console each time that the select occurs.

the output for this code will look as follow:

So we do have a problem!

in lot of cases we would like to broadcast the same value for any of the registered subscriber without

recalculating different value for each of the subscription.

How can we do it using the Rx framework?

the solution is to separate the subscriber from the underline producer stream?

the separation is done in 2 steps:

step one, isolating from the underline stream, it is done by using the Publish operator.

the publish operator return non active IConnectableObservable which mean that

subscribers can subscribe to this producer isolation, but the producer isolation

does not yet listening to the underline stream.

step two, connecting to the underline stream by using Connect operator.

the code will look as follow:

Code Snippet
 IObservable<long> observableRoot = Observable.Interval(TimeSpan.FromSeconds(1));
 
var producer = observableRoot.Where(item => item < 2);
producer = producer.Select(item =>
               {
                   Console.WriteLine("X");
                   return item;
               });
 
IConnectableObservable<long> producerAbstraction = producer.Publish();
 
producerAbstraction.Subscribe(value => Console.WriteLine("A: " + value));
producerAbstraction.Subscribe(value => Console.WriteLine("B: " + value));
 
producerAbstraction.Connect();
 

nothing changed till line 10.

line 10, creation of IConnectableObservable abstraction (producerAbstraction) (which is not active yet).

lines 12-13, is similar to the previous subscription, but now the subscription is for the abstraction layer.

of producerAbstraction (instead of subscribing to the underline stream).

line 15, connect the producerAbstraction to the underline producer stream (only at this point values will start

flowing into the subscribers callbacks).

the output will be:

as you can see, no duplicate select occurs.

Summary

you should be aware of the subscription behavior, and apply the right pattern that

match your needs.

the code for this post available here.

Rx - for beginners (part 12): RxJs

bnaya — Tue, 30 Mar 2010 16:43:20 GMT

this post is the 11th in a series of posts about the new Reactive Framework (Rx).

the series TOC can found here.

in this post we will focus on Rx for JavaScript.

the recently the Rx team release JavaScript library that capable to

get observable stream from events.

for example the syntax for mouse move event will be:

 var mouseMove = Rx.Observable.FromJQueryEvent($(document), "mousemove");
 

all you have to do in order of using this library is to rx.js which is less than 7Kb (GZipped).

 <script src="rx.js" type="text/javascript"></script>
 

you can download the installation from here.

the installation include sample code that demonstrate old good JavaScript trick of

attacking sting tail to the mouse move event.

to see the effect move the mouse on the gray panel.

Rx on javascriptRx on javascriptRx on javascript

the full code for this trick is:

Code Snippet
 <html xmlns="http://www.w3.org/1999/xhtml" >
    <head>
        <title>Rx for JavaScript Rocks!</title>   
            <script src="http://code.jquery.com/jquery-latest.js"></script>
            <script src="rx.js" type="text/javascript"></script>
            <script type="text/javascript">
        $(document).ready(function() 
            { 
                var mouseMove = Rx.Observable.FromJQueryEvent($(document), "mousemove");
 
                var text = "time flies like an arrow";
                var container = $("#container");
                for (var i = 0; i < text.length; i++)
                {
                    (function(i)
                    {
                        var s = $(document.createElement("span"));
                        s.html(text.charAt(i));
                        s.css({ position: "absolute" });
                        s.appendTo(container);
 
                        mouseMove.Delay(i * 100).Subscribe(function(mouseEvent)
                        {
                            s.css({ top: mouseEvent.clientY + "px", 
                                    left: mouseEvent.clientX + i * 10 + 15 + "px"});
    
                        });
                    })(i);
                }
            });
        </script>
    </head>
 
    <body style="font-family: Consolas, monospace; overflow: hidden">
        <div id="container"></div>
    </body>
</html>
 

line 9, getting observable stream.

line 13, iterate for each of the character of the text.

lines 22-27, subscribe to the event stream (for each of the character).

Summary

the Rx framework is now available for web developers.

Learn More

MEF for Beginner (Import from Xaml) - part 11

bnaya — Sat, 20 Mar 2010 21:28:23 GMT

MEF for Beginner (Import from Xaml) - part 11

this is the 11th post of the MEF for Beginner series, the series TOC is available here.

this post will focus on Importing mef parts directly from the Xaml.

the code sample for this post is available here.

assuming that we have the following exports:

Code Snippet
 class DemoStrings
{
    [Export("MyTag")]
    public string Text1 { get { return "Hello world"; } }
    [Export("MyTag")]
    public string Text2 { get { return "export using custom attribute"; } }
    [Export("NotMyTag")]
    public string Text3 { get { return "not included (Not My Tag contract)"; } }
    [Export("MyTag")]
    public string Text4 { get { return "Wpf markup extension"; } }
    [Export]
    public string Text5 { get { return "not included (have no contract)"; } }
}
 

we may want to have it import into the Xaml as follow:

Code Snippet
 <Window x:Class="Bnaya.Samples.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:mef="clr-namespace:Bnaya.Samples"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
        <ListBox
                 DataContext="{mef:ImportManyStrings MyTag}" 
                 ItemsSource="{Binding}"/>
    </Grid>
</Window>
 

as you can see at line 8 the data context is using special definition for importing all exported strings that
define the their contract as MyTag (looking at the exports it will import the exports at lines 4,6,10).

what should we have in order to achieve that functionality?

actually very little, all we have to do is to define a markup extension that return the exported parts.

the following code is how the markup extension should be define:

Code Snippet
 [MarkupExtensionReturnType(typeof(IEnumerable<string>))]
public class ImportManyStringsExtension : MarkupExtension
{
    private readonly IEnumerable<string> _dataSource;
    public ImportManyStringsExtension(string contract)
    {
        _dataSource = CompositionHost.Provider.GetExportedValues<string>(contract);
    }
 
    public override object ProvideValue(IServiceProvider serviceProvider)
    {
        return _dataSource;
    }   
}
 

line 1, decorate that our markup extension for returning IEnumerable<string>.

line 2, derive from MarkupExtension.

line 7, at the construction time, dynamically ask mef for any discoverable parts that follow the contract.

the CompositionHost is a very small helper class that was taken from the MEF Silverlight implementation

with some very minor enhancements.

lines 10-13, returning the discoverable parts to the Xaml.

One last thing

we should remove the StartupUri from the App.Xaml and using the OnStartup override instead:

Code Snippet
 protected override void OnStartup(StartupEventArgs e)
{
    base.OnStartup(e);
 
    if (!Utils.IsInDesignTool)
    {
        var asmCatalog = new AssemblyCatalog(typeof(App).Assembly);
        var catalogs = new AggregateCatalog(asmCatalog);
        var container = new CompositionContainer(catalogs);
        CompositionHost.Initialize(container);
        container.Compose(new CompositionBatch());
        
        var root = new MainWindow(); 
        root.ShowDialog();
    }
}
 

line 5, preventing MEF operation during design time.

lines 7-9, setting the MEF container.

line 10, setting the MEF container as the main container of the application

(this way it can be reachable anywhere).

line 11, do the composition,

IMPOERANT: the composition should happens before the window instantiation,

because that when the markup extension will be invoke.

the exported part should be available at this time.

lines 13-14, starting the application.

Summary

we can extend the Xaml very easily in order to get better Xaml->Mef experience.

the code sample for this post is available here.

תגים של Technorati:‏ Import,ImportMany,MEF,composition,CLR 4

Rx - for beginners (part 10): Concat expression

bnaya — Tue, 16 Mar 2010 21:49:53 GMT

Rx - for beginners (part 10): Concat expression

this post is the 10th in a series of posts about the new Reactive Framework (Rx).

the series TOC can found here.

in this post we will focus on the Concat expression.

the code for this post can be download from here.

What does it do?

the Concat expression is used to concatenate one Observable stream

into the end of another Observable stream.

once the first Observable stream is completed the the concat stream will be immediate subscribed.

the marble diagrams of Concat expression will look as follow:

the result observable stream will subscribe to the yStream after the xStream is completed,

therefore any values on the yStream before the subscription will be ignored.

in case of exception on any of the Concat Observable streams the marble diagrams will look as follow:

Code sample

the code for this post can be download from here.

Helper method for creating interval stream (based on System.Timers.Timer event):

Code Snippet
 static System.Timers.Timer s_timer = new System.Timers.Timer(1000);
 
private static IObservable<string> CreateObservable(string prefix,TimeSpan stopAt)
{
    var eventStream = Observable.FromEvent<ElapsedEventArgs>(s_timer,"Elapsed");
 
    var startTime = DateTime.Now;
    var stopTime = startTime + stopAt;
 
    Func<IEvent<ElapsedEventArgs>,bool> stopPredicate =
        value => value.EventArgs.SignalTime < stopTime;
    Func<IEvent<ElapsedEventArgs>,string> selectFormatter =
        value => prefix + (value.EventArgs.SignalTime - startTime).TotalSeconds.ToString("N0");
    
    var obs = eventStream.TakeWhile(stopPredicate).Select(selectFormatter);
 
    return obs;
}
 

Line 1, create instance of the timer.

Line 3, the method get 2 parameters:

prefix: which is used to format the stream output (line 13).
stop at: which will define the stream lifetime duration.

line 5, create observable stream out of the timer elapsed event (we can use this technique on any .NET event).

lines 10-11, is the stop predicate which is used by the TakeWhile at line 15.

lines 12-13, is the output formatting which is used by the Select at line 15.

the main method is look as follow:

Code Snippet
 static void Main(string[] args)
{
    var xs = CreateObservable("X", TimeSpan.FromSeconds(3.5));
    var ys = CreateObservable("  Y", TimeSpan.FromSeconds(10));
 
    xs.Subscribe (value => {/* do nothing */},
        () =>
        {
            Console.ForegroundColor = ConsoleColor.Gray;
            Console.WriteLine("xs Completed");
            Console.ForegroundColor = ConsoleColor.White;
        });
 
    var combineLatestStream = xs.Concat(ys);
 
    Console.ForegroundColor = ConsoleColor.White;
    combineLatestStream.Subscribe(value => Console.WriteLine(value),() => Console.WriteLine("Completed"));
    s_timer.Start();
    Console.ReadKey();
}
 

line 3, create observable stream with lifetime period of 3.5 seconds.

lime 4, create observable stream with lifetime period of 10 seconds.

lines 6-12, subscribing the the complete event of the xs stream.

line 14, Concat the streams.

line 17, subscribe to to concat output stream.

line 18, start the timer so the streams will start to produce values.

the output will look as follow:

you may notice that Y4 value is missing.

the reason for it is that the complete event occur at the 4th timer elapse event,

and only then the subscription to the ys stream was taking place so nobody was yet listening

to the ys stream when the 4th timer elapsed.

Summary

Concat can join 2 observable stream, but unlike Merge

it doesn't listen on both streams simultaneously.

תגים של Technorati:‏ Rx,IObservable,IObserver

Rx - for beginners (part 8): Combine Latest expression

bnaya — Wed, 10 Mar 2010 23:32:27 GMT

Rx - for beginners (part 8): Combine Latest expression

this post is the 8th in a series of posts about the new Reactive Framework (Rx).

the series TOC can found here.

in this post we will focus on the Combine Latest expression.

the code for this post can be download from here.

What does it do?

like the zip expression the Combine Latest expression is used to synchronize

2 IObservable streams into single IObservable stream.

unlike the zip expression the Combine Latest doesn't using queue,

as it name suggest it only remember the latest value of each stream.

What is the combination strategy?

the strategy used by the Combine Latest is to observe both stream, and each time

it new value observed on either of the stream it combine it with the latest value observed on the other stream.

the marble diagrams of Combine Latest expression will look as follow:

we can see that when the y stream observed the b value, the result stream

combine it with the latest value observed on x stream (3) and latter the same value

will be combine into the result stream when the x stream will observed the 4 value.

When does it halt?

the Combine Latest processing will come to end either when one of the stream

will complete or throw exception.

Code sample

the code for this post can be download from here.

Helper method for creating interval stream:

Code Snippet
 private static IObservable<string> CreateObservable(
    string prefix,int stopAt, double secondsInterval)
{
    var inteval = TimeSpan.FromSeconds(secondsInterval);
    var eventStream = Observable.Interval(inteval).
        TakeWhile(value => value < stopAt).
        Select(value => prefix + value.ToString());
 
    return eventStream;
}
 

the method parameters include (line 2):

prefix: just so we can distinguish values that was created by one stream from
values created on the other (see line 7).
stop at: define how many values will be produce by the stream before complete (see line 6).
seconds interval: define the frequency that the stream produce values (see lines 4,5)

The main method is looking as follow:

Code Snippet
 static void Main(string[] args)
{
    var xs = CreateObservable("X",15, 0.5);
    var ys = CreateObservable("Y",2, 2);
 
    var combineLatestStream = xs.CombineLatest(ys, (x,y) => x + " : " + y);
    combineLatestStream.Subscribe(value => Console.WriteLine(value),() => Console.WriteLine("Completed"));
    Console.ReadKey();
}
 

line 3, create stream which will produce 15 values before completion at frequency of 0.5 seconds.

line 4, create stream which will produce 2 values before completion at frequency of 2 seconds.

line 6, is combine both streams, the Lamda is using to concatenate both stream's values.

The result will look as follow:

Summary

Combine Latest expression can be used to synchronize 2 streams,

while the output stream will get notified when ever either of the stream produce new value.

תגים של Technorati:‏ Rx,IObservable,IObserver

Rx - for beginners (part 7): Zip expression

bnaya — Fri, 05 Mar 2010 06:43:23 GMT

Rx - for beginners (part 7): Zip expression

this post is the 7th in a series of posts about the new Reactive Framework (Rx).

the series TOC can found here.

in this post we will focus on the Zip expression.

the code for this post can be download from here.

What does it do?

the zip expression is used to synchronize 2 IObservable streams into single IObservable stream.

How does it do it?

it is taking the first observed value on either of the stream and wait for value from the other stream.

after both stream produce a value, the zip will project the value combination,

then it will wait for the next couple.

What happens when the stream frequency is not equals?

if one of the stream produce values more frequently than the other, those values will be queue in memory

and each time that the slower stream will produce a value, a single value will be fetched out of the fast stream's queue,

and combined with the slower stream's value.

that mean that you should be aware for possibly side effects, in terms of memory usages.

the marble diagrams of zip expression will look as follow:

When does it halt?

the zip processing will come to end either when one of the stream

will complete or when either of the stream will throw exception.

…..

actually it is a bit more complex,

when one of the stream complete, and still having value within the queued,

the complete notification will be put into the queue.

which mean that the actual complete will take place only the queue become dry

or when the other stream will notify completion.

the marble diagram for this scenario will look as follow:

if either of the stream is throwing exception the exception will immediately

project into the result stream and halt the zip operation.

Code sample

the code for this post can be download from here.

Helper method for creating interval stream:

Code Snippet
 private static IObservable<string> CreateObservable(
    string prefix,int stopAt, double secondsInterval)
{
    var inteval = TimeSpan.FromSeconds(secondsInterval);
    var eventStream = Observable.Interval(inteval).
        TakeWhile(value => value < stopAt).
        Select(value => prefix + value.ToString());
 
    return eventStream;
}
 

the method parameters include (line 2):

prefix: just so we can distinguish values that was created by one stream from
values created on the other (see line 7).
stop at: define how many values will be produce by the stream before complete (see line 6).
seconds interval: define the frequency that the stream produce values (see lines 4,5)

The main method is looking as follow:

Code Snippet
 static void Main(string[] args)
{
    var xs = CreateObservable("X",5, 0.1);
    var ys = CreateObservable("   Y",3, 1);
 
    var zippedStream = xs.Zip (ys, (x, y) => x + " : " + y);
    zippedStream.Subscribe(value => Console.WriteLine(value),() => Console.WriteLine("Complete"));
    Console.ReadKey();
}
 

line 3, create stream which will produce 5 values before completion at frequency of 0.1 seconds.

line 4, create stream which will produce 3 values before completion at frequency of 1 seconds.

line 6, is zipping both streams, the Lamda is using to concatenate both stream's values.

The result will look as follow:

Summary

Zip expression can be used to synchronize 2 streams,

but we should be carful of possible memory side effects.

תגים של Technorati:‏ Rx,IObservable,IObserver

Rx - for beginners (part 6): Merge expression

bnaya — Wed, 03 Mar 2010 02:46:41 GMT

Rx - for beginners (part 6): Merge expression

this post is the 6th in a series of posts about the new Reactive Framework (Rx).

the series TOC can found here.

in this post we will focus on the Merge expression.

What does it do?

the merge expression is used to merge multiple IObservable streams into single IObservable streams.

the marble diagrams of merge expression will look as follow:

each value on the source streams is project into the result stream until all

the source streams complete.

if one of the stream raise exception the error will be project into the result stream

and dispose the subscriptions (the result stream will stop listening to any of the streams).

the marble diagram for this case will look as follow:

Code Sample

the code sample can be download from here.

the sample for this post is merging 3 streams that is running on different time interval

into one stream.

Code Snippet
 private static IObservable<string> CreateObservable(
            string prefix,int stopAt, double secondsInterval)
        {
            var inteval = TimeSpan.FromSeconds(secondsInterval);
            var eventStream = Observable.Interval(inteval).
                TakeWhile(value => value < stopAt).
                Select(value => prefix + value.ToString());
 
            return eventStream;
        }
 

the code is using the CreateObservable method in order to create each of the source stream.

line 5, Observable.Interval is creating stream with increasing value for each interval.

line 6, is stopping the after stopAt iterations.

line 7, formatting the value of the stream to string with prefix and the interval value.

the main method is looking as follow:

Code Snippet
 static void Main(string[] args)
        {
            var xs = CreateObservable("X",5, 0.3);
            var ys = CreateObservable("   Y",2, 1);
            var zs = CreateObservable("      Z",7, 0.6);
 
            //var mergedStream = xs.Merge(ys).Merge(zs);
            var mergedStream = Observable.Merge(xs,ys,zs);
            mergedStream.Subscribe(value => Console.WriteLine(value));
            Console.ReadKey();
        }
 

Lines 3-5, creating source streams.

line 8, creating the merged stream.

line9, subscribe to the merged stream.

the following is the output:

Summary

Merge is exactly what we expected, any value of the source streams will be project

into the result stream unless exception occurs.

תגים של Technorati:‏ Rx,IObservable,IObserver

Rx - for beginners (part 5): marble diagrams, select and where

bnaya — Mon, 01 Mar 2010 02:24:40 GMT

Rx - for beginners (part 5): marble diagrams, select and where

this post is the 5th in a series of posts about the new Reactive Framework (Rx).

the series TOC can found here.

this post will focus on marble diagrams which is used for visualizing IObservable stream.

on this post we will visualize the select and where clause, while in the

upcoming posts we will discuss other operations that can be

used to upon IObservable streams.

the code sample for this post is available here.

What should we visualize?

the event stream should visualize the following:

on next
on error
on complete

How should we read the diagram?

marble diagram can have one or more horizontal line.

each horizontal line present the timeline of single IObservable stream.
the ellipse present single occurrence of new value event (on next).
the vertical line present the end of the stream sequence (on complete).
the X sign present exception (on error).

The hidden assumption used by the Rx framework is that the IObservable stream

should stop either on complete or on error.

How can we draw select clause using the marble diagram?

Code Snippet
 // Create IObservable that has increasing long value each second 
var timeStream = Observable.Interval(TimeSpan.FromSeconds(1));
 
// invert the timeStream stream using Linq statement
var negativeTimeStream = from value in timeStream
                         select -value;
 
negativeTimeStream.Subscribe(value => Console.WriteLine(value));
 

line 2, creating IObservable stream that increment the projected value each second.

line 5, is using Linq statement to convert the stream into negative value.

line 8, subscribe to the stream and write it to the console.

the result is shown in the following image.

the marble diagrams for the above snippet will look like the following diagram:

the marble diagrams show the construction of new IObservable stream using the select operation.

the vertical arrow present the transition from the source stream into the destination stream.

as the case with IEnumerable the select statement is extension method which

can be used on any IObservable stream, we will get same result for the following code:

Code Snippet
 var negativeTimeStream = timeStream.Select(value => -value);
 

Where clause marble diagram?

the where clause of the following snippet:

Code Snippet
 // taking only even values
//var evenTimeStream = timeStream.Where(value => value % 2 == 0);
var evenTimeStream = from value in timeStream
                     where value % 2 == 0
                     select value;
 

will be present:

Summary

marble diagrams is how stream manipulation can be visualize.

we already surveyed the select and where operations, and we will continue

with other operation in the upcoming posts.

Code Samples

the code sample for this post is available here.

תגים של Technorati:‏ Rx,IObservable,IObserver

Rx - for beginners (part 4): anonymous observer handler

bnaya — Fri, 26 Feb 2010 21:04:12 GMT

Rx - for beginners (part 4): anonymous observer handler

this post is the 4th in a series of posts about the new Reactive Framework (Rx).

the series TOC can found here.

this post will focus on anonymous observer handler.

the code sample for this post can be download from here.

Anonymous Observer

as we mention on the previous posts, IObserver is used as a callback interface

which can be subscribe to the IObservable,

but this is a bit of overkill, when what we subscribe is relatively small (like Console.Write).

wouldn't it be nice to use Lamda expression instead?

doesn't we want to have something similar to button1.Click += (s,e)=>Console.WriteLine(…); .

IObservable extensions

using Lamda expression syntax in order to subscribe delegate into the IObservable is

available because IObservable got the following extension options for its Subscribe method

(under the hood we are speaking about extension methods).

Action<TSource> onNext
Action<TSource> onNext, Action onCompleted
Action<TSource> onNext, Action<Exception> onError
Action<TSource> onNext, Action<Exception> onError, Action onCompleted

so assuming we got IObservable instance called foo, the following code is perfectly OK:

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

for simple subscription only for the on next callback.

subscribing both for on next and on error will look as follow:

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

what is actually happens is that under the hood the subscribe method creating

instance of IObserver, attaching the delegate, and hand it to the IObservable subscribe method.

Code Sample

I took the previous post's sample, which look as follow:

Code Snippet
 class Program
{
    static void Main(string[] args)
    {
        var obs = new Observer();
        var observable = new FakeObservableFeeder();
        IDisposable unsubscribe = observable.Subscribe(obs);
        Console.ReadKey();
        unsubscribe.Dispose();
    }
    private class Observer : IObserver<int>
    {
        void IObserver<int>.OnCompleted()
        {
            Console.WriteLine("Done");
        }
        void IObserver<int>.OnError(Exception exception)
        {
            Console.WriteLine("Error: " + exception.Message);
        }
        void IObserver<int>.OnNext(int value)
        {
            Console.WriteLine(value);               
        }
    }
}
 

you can see at line 11, that we implementing IObserver with code one line

for each methods (Console.WriteLine ).

and at line 7, we subscribing this observer into the IObservable instance.

Code Sample using anonymous observer

this can be match simpler using anonymous observer, as shown in the following snippet:

Code Snippet
 class Program
{
    static void Main(string[] args)
    {
        var observable = new FakeObservableFeeder();
        // subscribing handlers (Anonymous observer)
        IDisposable unsubscribe = observable.Subscribe(
            value => Console.WriteLine(value),
            exc => Console.WriteLine(exc),
            () => Console.WriteLine("Done"));
        Console.ReadKey();
        unsubscribe.Dispose();
    }
}
 

definitely less code was written.

you can see the subscription at line 7.

line 8, is handling the on next action.
line 9, is handling the on error action.
line 10, is handling the on complete action.

Summary

what we have seen is that simple action can be subscribed using anonymous observer handlers.

תגים של Technorati:‏ IObservable,IObserver,Rx