In my last post I wrote about writing a TCP server using the Reactive Extensions library. It was not a Silverlight related post, but it simply introduces the server side component that I will use in this post to show you how to use the same library to consume the incoming data and present it in Silverlight. The interesting part is to understand how rx can simplify the programming model when dealing with asynchronicity both in Silverlight and in server side full .NET programming.

The server I presented was a very simple socket listener that waits for connections and then, when the channel has been established, it push to the client a continuous stream of data that represent the current state of the CPU and memory of the server. With this huge amount of informations incoming we can create a little application that is able to show a chart and some gauges, updated almost in realtime.

The application, developed following the MVVM pattern, is made of a simple view containing the controls used to present the informations. These controls are feeded by a couple of properties in the ViewModel that are updated with the incoming data. So the most of the work is done by the ViewModel that is responsible of connecting to the socket and read the information stream to update the properties. In a real world solution probably you will have some kind of layer between the ViewModel and the socket, but for the sake of the post we will keep it simple as much as we need to understand how it works.

Consuming a socket in Silverlight means using an instance of the Socket class that represents the connection and a SocketAsyncEventArgs that is used when you call the methods of the connection to make the requests and receive responses. So, as an example, when you have to establish the connection you have to create the instance of the Socket class and the call the ConnectAsync method providing the SocketAsyncEventArgs initialized with the address of the endpoint to connect to. When the connection has been established the SocketAsyncEventArgs class will raise a Completed event that notify about the result of the operation. Doing it with Reactive Extensions mean something like this:

   1: protected void Connect()

   2: {

   3:     this.Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

   4:  

   5:     SocketAsyncEventArgs arguments = new SocketAsyncEventArgs();

   6:     arguments.RemoteEndPoint = new DnsEndPoint(Application.Current.Host.Source.DnsSafeHost, 4530);

   7:  

   8:     var socketAsObservable = from args in Observable.FromEvent<SocketAsyncEventArgs>(

   9:                                  ev => arguments.Completed += ev,

  10:                                  ev => arguments.Completed -= ev)

  11:                              select args.EventArgs;

  12:  

  13:     socketAsObservable

  14:         .Where(args => args.LastOperation == SocketAsyncOperation.Connect)

  15:         .Subscribe(

  16:         args =>

  17:         {

  18:             args.Dispose();

  19:             this.Receive();

  20:         });

  21:  

  22:     this.Socket.ConnectAsync(arguments);

  23: }

In the line #3 it is created the Socket with the common parameter that is used in Silverlight for a TCP channel. Then an instance of the SocketAsyncEventArgs is initialized and its property RemoteEndPoint is provided with and instance of DnsEndPoint that represente the address of the server to connect to. The port is 4530 like we defined in the previour article.

At this point it is created a stream, called socketAsObservable, from the Completed event of the SocketAsyncEventArgs. the stream filter the LastOperation to be "Connect", as we expect and in the Subscribe method disposes the SocketAsyncEventArgs instance and starts to receive data. The SocketAsyncEventArgs instance can be used only once so we have to carefully dispose it to avoid memory leaks.

Once the connection has successfully established you have to put your socket in Receive. When incoming data is detected you will be notified and you can fetch it from the SocketAsyncEventArgs and put again the socket in Receive. Here is how it appear with Reactive Extensions:

   1: protected void Receive()

   2: {

   3:     SocketAsyncEventArgs arguments = new SocketAsyncEventArgs();

   4:     arguments.SetBuffer(new byte[1024], 0, 1024);

   5:  

   6:     var socketAsObservable = from args in Observable.FromEvent<SocketAsyncEventArgs>(

   7:                                  ev => arguments.Completed += ev,

   8:                                  ev => arguments.Completed -= ev)

   9:                              select args.EventArgs;

  10:  

  11:     socketAsObservable

  12:         .Where(args => args.LastOperation == SocketAsyncOperation.Receive)

  13:         .Throttle(TimeSpan.FromMilliseconds(500))

  14:         .ObserveOnDispatcher()

  15:         .Subscribe(OnReceive);

  16:  

  17:     if (this.Socket.Connected)

  18:         this.Socket.ReceiveAsync(arguments);

  19: }

Once again we create the instance of the SocketAsyncEventArgs. It is now initialized with a SetBuffer that allocates a buffer of 1 KByte that is used by the socket to compy the incoming data. Then the socketAsObservable is created using the FromEvent; This method is important because it is in charge of attaching and detaching the Completed event so we avoid to have unwanted delegates around. Again the socketAsObservable is filtered selecting only when LastOperation equals to Receive and we also apply a Throttling of about 500 milliseconds. It is made to discart updated when they are too fast. One update every half a second suffice to say that the UI is up to date with the server.

Fially we marshal the stream to the UI Thread using the ObserveOnDispatcher and the received events are forwarded to the OnReceive method that is responsible of parsing the received data and updating the UI.

   1: protected void OnReceive(SocketAsyncEventArgs args)

   2: {

   3:     string data = Encoding.UTF8.GetString(args.Buffer, 0, args.BytesTransferred);

   4:  

   5:     IEnumerable<Sample> samples = this.GetSamples(ref data);

   6:  

   7:     Array.Clear(args.Buffer, 0, 1024);

   8:  

   9:     if (data.Length > 0)

  10:     {

  11:         byte[] bytes = Encoding.UTF8.GetBytes(data);

  12:         Array.Copy(bytes, args.Buffer, bytes.Length);

  13:         args.SetBuffer(bytes.Length, 1024 - bytes.Length);

  14:     }

  15:     else

  16:         args.SetBuffer(0, 1024);

  17:  

  18:     if (this.Socket.Connected)

  19:         this.Socket.ReceiveAsync(args);

  20:  

  21:     this.Update(samples);

  22: }

The method peek up the received data and then calls again the ReceiveAsync method of the connection to make again the channel ready to receive other informations. Then the Update method is called to update the properties binded to the view.

The code is simple and obviously it need some additional check, as an example it needs to verify the communication errors that here are swallowed. I hope it shows, once again, how reactive extension can help you to simplify the consumption of asynchronous streams.

One interesting feature of Reactive Extensions is the combining of Observables. There are a number of extension methods made to combine two or more streams; Amb, Concat, SelectMany, Merge, Zip, CombineLatest, all these methods are made to take, multiple and non necessarily omogeneous, streams and combine them in a unique resulting stream based on different rules. Here a brief resume of the rules applied from every method

Understanding the meaning of each method is really difficult if you do not make some simple experiment, but this is out of the scope of this post. Now I would like to show the meaning of "combining two streams" with a real example that show how a little change in the previous mouse trail example can give a great difference in terms of functions.

In my last example I used the TrailWithCount and TrailWithTime methods to catch MouseMove events to draw a polyline on the plugin that il the trail of the mouse pointer. In the example you have seen the trail shortens while the mouse was moving but when the mouse stops also the trail stops. Now I want to change the example to let the trail shorten to zero length when the mouse stops moving.

To achieve this result I need to have a timer that continues to record the current position for the mouse when it stops. For this purpose I can use the static method Obsevable.Interval(timespan) that is able to generate a stream of events at the given interval of time. Here is the two lines I have to add to the previous example.

   1: Observable.FromEvent<MouseEventHandler, MouseEventArgs>(

   2:     ev => new MouseEventHandler(ev),

   3:     ev => this.LayoutRoot.MouseMove += ev,

   4:     ev => this.LayoutRoot.MouseMove -= ev)

   5:     .CombineLatest(Observable.Interval(TimeSpan.FromMilliseconds(25)), (a, b) => a)

   6:     .ObserveOnDispatcher()

   7:     .Select(o => o.EventArgs.GetPosition(this.LayoutRoot))

   8:     .TrailWithCount(100)

   9:     .Subscribe(DrawLine);

the CombineLatest method gets events from the mouse and from the time interval (this regularly every 25 milliseconds) and using the selector lambda it takes from the combined stream only the mouse events. Every time an interval expire the combined value will contain an integer (the number of intervals from the start) and the latest mouse event. When the mouse stops moving the stream from the MouseMove also stops to provide values but the CombineLatest method will replicate the latest value taken for every interval elapsed. So the trail will be feeded with the latest position and the visual effect will be the shorten of the trail until it reaches the current position of the mouse pointer.

The ObserveOnDispatched method is required because the Observable.Interval method implies the use of a separate thread so when we get the values we are in this thread and we need to marshall back to the UI thread. This method does the trick. Here is the result:

Today @saldoukhov pointed me to an alternative (and possibly regular) way to implement TrailWithCount, different from the version I introduced yesterday in my latest post. This tecnique invole the use of a bunch of methods from the Reactive Extensions and, at first sight may result more simple and straightforward. Also if @saldoukhov pointed to the sole count version it is also possibile to write a TrailWithTime this way. Here is the new implementation of these methods:

   1: // BE AWARE THAT THESE METHODS HAVE HUGE PERFORMANCE IMPACT

   2:  

   3: public static IObservable<IEnumerable<T>> TrailWithCount<T>(this IObservable<T> observable, int count)

   4: {

   5:     return observable.Scan(

   6:         Enumerable.Empty<T>(),

   7:         (a, b) => a.StartWith(b).Take(count));

   8: }

   9:  

  10: public static IObservable<IEnumerable<T>> TrailWithTime<T>(this IObservable<T> observable, TimeSpan timeSpan)

  11: {

  12:     return observable

  13:         .Select(o => new Timestamped<T>(o, DateTime.Now))

  14:         .Scan(

  15:             Enumerable.Empty<Timestamped<T>>(), (a, b) =>

  16:                 a.StartWith(b).TakeWhile(o => (DateTime.Now - o.Timestamp).TotalMilliseconds <= timeSpan.TotalMilliseconds))

  17:         .Select(k => k.Select(o3 => o3.Value));

  18: }

Both the methods work the same way with the sole difference that the TrailWithTime wraps the Point in a Timestamped instance and then unwraps it just before returning to the caller. Here the Scan method is an aggregation function that forward every occurrence from the stream and populate a resulting aggregation. So the StartWith method let the aggregation grow and then the Take method extract the "counted" instances we really need.

The problem here is that if you try to run this method on a very large number of items (e.g. 1000) you will see a huge performance impact that leave the start of the trail far from the mouse pointer. The effect is so far more evident if you try to use the TrailWithTime with a long timeout (e.g. 5/10 sec).

As far as I understood these methods have an huge payload in terms of iterations and of garbage they produce. Every time you get an event on the stream a new instance of the array is created and it is crawled to create the result. The TrailWithTime has the worst performances because it produces a great number of Timestamped<> instances. I'm not aware of the inner working of the Scan, StartWith and Take methods but the resulting effect is really clear

If you try to run my previous version with a similar interval you will see a very tiny performance impact. Internally I use a queue and the sole payload are the collection of the Dequeued items (but they would have been collected the same if there is not the trail) and the iteration along the resulting collection to create a PointCollection. This is an interesting demonstration of how the use of LINQ may affect drammatically the performances of an application and I suggest you to double check when you use them.

By the way, thanks to @saldoukhov for his suggestion that I had not considered when I wrote for the first time my Trail methods.

In my most recent post I've show a new way to write methods to call network resources like feeds, WCF methods and so on. I've proposed two solution that take advantage of Reactive Extension to call operations that follow the Begin-End pattern and also operation that use an event driven pattern. Today I would like to make another step forward to make the event driven side of the problem more reliable. Most of the times when you call the network you deal with this pattern instead of the Begin-End. Calling WCF and WebClient follow this pattern and we need to accurately handle the errors when we get the result from the calls.

The problem is that when you call a network resource this way you eventually get exceptions as a value of a property of the result instead of having them thrown as you may expect. This is obviously understandable due to the asynchronous nature of the calls. Also if the runtime will throw exceptions you would not be able to catch them because they are generated in another thread so the sole way to get them is that the runtime catch every exception and forward it using the Error property of the result. So here is how you commony handle the errors in network calls:

   1: public void client_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)

   2: {

   3:     if (e.Error != null)

   4:     {

   5:         // there is an exception

   6:         MessageBox.Show(e.Error.Message);

   7:     }

   8:     else

   9:     {

  10:         // no error occured: do what you want with the result

  11:     }

  12: }

Using my Reactive Extensions way to the asynchronicity this issue may be a big problem because, since the Subscribe method is able to catch exceptions along the execution of the event, it does not understand about the Error resulting from an asynchronous network call. In my last example I showed this code:

   1: IObservable<SyndicationFeed> result = Observable.FromEvent<DownloadStringCompletedEventHandler, DownloadStringCompletedEventArgs>(

   2:     ev => new DownloadStringCompletedEventHandler(ev),

   3:     ev => client.DownloadStringCompleted += ev,

   4:     ev => client.DownloadStringCompleted -= ev)

   5:     .Select(o => o.EventArgs.Result)

   6:     .ConvertToFeed();

Unfortunately it works perfectly when the network call returns a valid response but it is unable to catch an exception if something goes wrong. To solve this problem I wrote an extension method that can collect possible exceptions and rethrow them. The trick is made using a base class named "AsyncCompletedEventArgs" that is used by every EventArgs returned by a network call. Having this common base class is key to write a single method to handle a lot of cases. Here is the code from the ThrowIfError() method:

   1: public static IObservable<IEvent<T>> ThrowIfError<T>(this IObservable<IEvent<T>> observable)

   2:     where T : AsyncCompletedEventArgs

   3: {

   4:     return observable.SelectMany(

   5:         o =>

   6:         {

   7:             if (o.EventArgs.Error != null)

   8:                 throw o.EventArgs.Error;

   9:  

  10:             return Observable.Return(o);

  11:         });

  12: }

The method is able to intercept and IObservable<IEvent<T>> that is the interface resulting from Observable.FromEvent() method. Once it receive the interface it examine the content and if it detects an error simple throw it. This make the runtime catch the exception and forward it to the OnError method of the Observer<T> that is the second parameter of a Subscribe method. If there is not any error the method simply returns the observable itself so the chain of method can be continued seamless. I use the SelectMany method to flatten the results from IObservable<IObservable<IEvent<T>>> (it's not a joke) to IObservable<IEvent<T>>. So now we can use the method everywhere we have to place a network call:

   1: public static IObservable<SyndicationFeed> DownloadFeedWebClient(Uri uri)

   2: {

   3:     WebClient client = new WebClient();

   4:  

   5:     IObservable<SyndicationFeed> result = Observable.FromEvent<DownloadStringCompletedEventHandler, DownloadStringCompletedEventArgs>(

   6:         ev => new DownloadStringCompletedEventHandler(ev),

   7:         ev => client.DownloadStringCompleted += ev,

   8:         ev => client.DownloadStringCompleted -= ev)

   9:         .ThrowIfError()

  10:         .Select(o => o.EventArgs.Result)

  11:         .ConvertToFeed();

  12:  

  13:     client.DownloadStringAsync(uri);

  14:  

  15:     return result;

  16: }

This does not change anything to the way you can call the DownloadFeedWebClient method because it returns always an IObservable<T> so you can simply Subscribe to it and specify and handler for the OnError part of the Observer<T>. To view an example please visit my previous article.

Continuing of my series about IApplicationServices I would like to propose a base class I've created to easily develop Application Services that runs a thread. There are lot of cases when you implement IApplicationService to run a parallel task that accomplish some kind of background tasks. I've collected all the redundant code inside a class I called ThreadedService. Extending this class you have a thread automatically started and stopped according with the application lifetime. Here is the class:

public abstract class ThreadedService : IDisposable, IApplicationService, IApplicationLifetimeAware

{

    /// <summary>

    /// Gets or sets the exit event.

    /// </summary>

    /// <value>The exit event.</value>

    private ManualResetEvent ExitEvent { get; set; }

    /// <summary>

    /// Gets or sets the wait handles.

    /// </summary>

    /// <value>The wait handles.</value>

    protected WaitHandle[] ExitHandles { get; set; }

    /// <summary>

    /// Initializes a new instance of the <see cref="ThreadedObject"/> class.

    /// </summary>

    public ThreadedService()

    {

        this.ExitEvent = new ManualResetEvent(false);

        this.ExitHandles = new WaitHandle[] { this.ExitEvent };

    }

    /// <summary>

    /// The main thread body

    /// </summary>

    protected abstract void ThreadProc();

    #region IDisposable Members

    /// <summary>

    /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

    /// </summary>

    public virtual void Dispose()

    {

        this.StopService();

    }

    #endregion

    #region IApplicationLifetimeAware

    public virtual void Starting()

    { }

    public virtual void Started()

    {

        ThreadStart listenThreadStart = new ThreadStart(ThreadProc);

        Thread thread = new Thread(listenThreadStart);

        thread.Start();

    }

    public virtual void Exiting()

    {

        this.ExitEvent.Set();

    }

    public virtual void Exited()

    { }

    #endregion

    #region IApplicationService

    public virtual void StartService(ApplicationServiceContext context)

    { }

    public virtual void StopService()

    { }

    #endregion

}

As already said the class is able to manage the background thread automatically but require a little level of collaboration when you develop the body of the thread. Infact after overriding the ThreadProc method you have to listen for the ExitEvent to be raised. When this event is set you have to exit from the service as soon as possible.

Saying we have to poll the newtork once every minute you can implement the ThreadProc the way I show it in the figure.

protected override void ThreadProc()

{

    this.Update();

    while (WaitHandle.WaitAny(this.ExitHandles, 5000) == WaitHandle.WaitTimeout)

        this.Update();

}

The procedure wait for the ExitEvent for a timeout. During this time the runtime is able to do something else but once the event is set the process is immediately exited. Something very simple but effective.

In my last post about injection of ApplicationServices with MEF I've presented a simple solution that allows people to adds instances of ApplicationServices, without the need of adding the markup to the App.xaml file. The solution was interesting as a demonstration of how MEF works, but after some tests and some feedbacks I had I realized it is not applicable in a real world solution because of a subtle problem.

The problem is given by a conflict in the lifetime of the application between the Application_Start event and the StartService method. If you put the code to inizialize the CompositionContainer inside of the Application_Start event you may get an error stating that the composition has already initialized, just because when the StartService method call the CompositionInitializer method, to compose the services, the container is implicitly initialized. Unfortunately the Application_Start method is called after the StartService so here is the reason of the error you get.

For a long while I've thinked this may remain only a beautiful example because I do not discovered a valid solution, but today I convinced myself that a correction to this problem is possible and that it also add the ability of supporting recomposition to the HostService. As far as I know there is not any concern in calling the methods of the service with a delay respect the runtime raises the corrisponding method, almost until the method is not one of the Exit flavour. During the exit we have to free resources, stop threads, and so on and it is important to make these actions as soon as possible to let the runtime able to close the application faster. But the initialization phase may start in a later time, with the sole constraint that the sequence of the methods should be the same.

So this morning I've worked in this direction and in the following box you can see the resulting solution:

   1: public class HostService : IApplicationService, IApplicationLifetimeAware, IPartImportsSatisfiedNotification

   2: {

   3:     /// <summary>

   4:     /// Gets or sets the context.

   5:     /// </summary>

   6:     /// <value>The context.</value>

   7:     public ApplicationServiceContext Context { get; set; }

   8:     /// <summary>

   9:     /// Gets or sets the current.

  10:     /// </summary>

  11:     /// <value>The current.</value>

  12:     public static HostService Current { get; private set; }

  13:  

  14:     /// <summary>

  15:     /// Gets or sets the initialized.

  16:     /// </summary>

  17:     /// <value>The initialized.</value>

  18:     private List<IApplicationService> Initialized { get; set; }

  19:  

  20:     /// <summary>

  21:     /// Gets or sets the services.

  22:     /// </summary>

  23:     /// <value>The services.</value>

  24:     [ImportMany(AllowRecomposition = true, RequiredCreationPolicy = CreationPolicy.Shared)]

  25:     public List<IApplicationService> Services { get; set; }

  26:  

  27:     /// <summary>

  28:     /// Initializes a new instance of the <see cref="HostService"/> class.

  29:     /// </summary>

  30:     public HostService()

  31:     {

  32:         if (HostService.Current != null)

  33:             throw new InvalidOperationException("Service already exists");

  34:  

  35:         HostService.Current = this;

  36:         this.Initialized = new List<IApplicationService>();

  37:     }

  38:  

  39:     /// <summary>

  40:     /// Called by an application immediately after the <see cref="E:System.Windows.Application.Exit"/> event occurs.

  41:     /// </summary>

  42:     public void Exited()

  43:     {

  44:         foreach (IApplicationLifetimeAware service in this.Services.OfType<IApplicationLifetimeAware>())

  45:             service.Exited();

  46:     }

  47:  

  48:     /// <summary>

  49:     /// Called by an application immediately before the <see cref="E:System.Windows.Application.Exit"/> event occurs.

  50:     /// </summary>

  51:     public void Exiting()

  52:     {

  53:         foreach (IApplicationLifetimeAware service in this.Services.OfType<IApplicationLifetimeAware>())

  54:             service.Exiting();

  55:     }

  56:  

  57:     /// <summary>

  58:     /// Called by an application immediately after the <see cref="E:System.Windows.Application.Startup"/> event occurs.

  59:     /// </summary>

  60:     public void Started()

  61:     {

  62:         CompositionInitializer.SatisfyImports(this);

  63:     }

  64:  

  65:     /// <summary>

  66:     /// Called by an application immediately before the <see cref="E:System.Windows.Application.Startup"/> event occurs.

  67:     /// </summary>

  68:     public void Starting()

  69:     {

  70:     }

  71:  

  72:     /// <summary>

  73:     /// Called by an application in order to initialize the application extension service.

  74:     /// </summary>

  75:     /// <param name="context">Provides information about the application state.</param>

  76:     public void StartService(ApplicationServiceContext context)

  77:     {

  78:         this.Context = context;

  79:     }

  80:  

  81:     /// <summary>

  82:     /// Called by an application in order to stop the application extension service.

  83:     /// </summary>

  84:     public void StopService()

  85:     {

  86:         foreach (IApplicationService service in this.Services)

  87:             service.StopService();

  88:     }

  89:  

  90:     /// <summary>

  91:     /// Called when a part's imports have been satisfied and it is safe to use.

  92:     /// </summary>

  93:     public void OnImportsSatisfied()

  94:     {

  95:         // buffer for services that raises exception during initialization

  96:         List<IApplicationService> errors = new List<IApplicationService>();

  97:  

  98:         // call StartService

  99:         foreach (IApplicationService service in this.Services.OfType<IApplicationService>().Except(this.Initialized))

 100:         {

 101:             try

 102:             {

 103:                 service.StartService(this.Context);

 104:             }

 105:             catch

 106:             {

 107:                 errors.Add(service);

 108:             }

 109:         }

 110:  

 111:         // call Starting

 112:         foreach (IApplicationLifetimeAware service in 

 113:             this.Services.OfType<IApplicationLifetimeAware>()

 114:             .Except(this.Initialized.OfType<IApplicationLifetimeAware>())

 115:             .Except(errors.OfType<IApplicationLifetimeAware>()))

 116:         {

 117:             try

 118:             {

 119:                 service.Starting();

 120:             }

 121:             catch

 122:             {

 123:                 errors.Add((IApplicationService)service);

 124:             }

 125:         }

 126:  

 127:         // call Started

 128:         foreach (IApplicationLifetimeAware service in 

 129:             this.Services.OfType<IApplicationLifetimeAware>()

 130:             .Except(this.Initialized.OfType<IApplicationLifetimeAware>())

 131:             .Except(errors.OfType<IApplicationLifetimeAware>()))

 132:         {

 133:             try

 134:             {

 135:                 service.Started();

 136:             }

 137:             catch

 138:             {

 139:                 errors.Add((IApplicationService)service);

 140:             }

 141:         }

 142:  

 143:         // register ad Initialized to avoid duplicated initialization in case of recomposition

 144:         foreach (IApplicationService service in 

 145:             this.Services.OfType<IApplicationService>()

 146:             .Except(this.Initialized)

 147:             .Except(errors))

 148:             this.Initialized.Add(service);

 149:  

 150:         // remove services that raised exceptions

 151:         foreach (IApplicationService service in errors)

 152:             this.Services.Remove(service);

 153:     }

 154: }

As you can see the structure of the service remains the same, and also the management of the Exit, Exited and StopService is not changed. The very important change is in the Started method, that is called after the Application_Start event. In this method I only perform the composition. Then, in the OnImportsSatisfied method I start a sequence to emulate the startup of the service, repeating the flow that an ApplicationService usually follow during it initialization. I've also added some code to manage exceptions raised during the initialization. In these cases the services that raised the errors do not follow the remaining parts of the initialization and finally are removed from the Services collection.

In the service I maintain a collection of Initialized services because if the recomposition happen I must not repeat the inizialization of services that were already initialized previously. This is also the reason that make me asking a Shared CreationPolicy, because when the composition container compose the Services property does not have to create new instances but only have to add the new services coming from the recomposition.

I hope this solution to be more reliable than the previous one. As usual I will be glad to have feedback from you to continue improving the code..

My last post has opened to some unexpected questions about what may seems a strangeness in my code. I was surprised about this questions, just because I believed it was a known pattern, so I decided to give an explanation to ones that does not know the reason I wrote some lines of code in the constructor

   1: public class SampleService : IApplicationService

   2: {

   3:     public static SampleService Current { get; private set; }

   4:  

   5:     /// <summary>

   6:     /// Initializes a new instance of the <see cref="ServiceHost"/> class.

   7:     /// </summary>

   8:     public SampleService()

   9:     {

  10:         if (SampleService.Current != null)

  11:             throw new InvalidOperationException("Service already exists");

  12:  

  13:         SampleService.Current = this;

  14:     }

  15:  

  16:     // omissis...

  17: }

The problem here is that sometimes it is not useful (and sometimes it is definitely bad) to have more than an instance of an ApplicationService running behind the scenes. Given that none can limit the number of instances in the ApplicationLifetimeObjects collection I use a pattern to avoid this problem.

First of all I expose a static property "Current". This property is useful to interact with the running service from any part of the code. Since after the beta there is not an indexer to access the running service this is the most common pattern used for this purpose.

Then in the constructor I check the property "Current" to be null. If I found a value it means someone is trying to put two instances of the service in the markup, so I raise an exception stating that only one instance is allowed. In the case "Current" is empty I save myself to this property using "this".

So nothing is wrong in my previous example. Only few lines of code to implement a Singleton pattern for IApplicationService, with a tecnique that is widely used also inside the framework classes.

About two weeks ago I started a series of articles about the Windows Phone 7 hosted by the well knows site SilverlightShow. In the very first rows of the opening article I wrote: "Starting with this article we will follow a path to discover one by one all the aspects of this device". The intent of the series is infact to give a walkthrough, starting from scratch, about the brand new device that is born in the previous months.

Now we are at the third number of the series and after having explained the most simple but not always obvious details of the UI, now it is time to go forward to explore the navigation paradigm that permeates you phone. This number will introduce to the problems of application lyfecycle and tombstoning that will be the argument of the fourth part I'm about to write.

If you have lost the previous number here is the links:

Windows Phone 7 Part #1: Getting Started

Windows Phone 7 Part #2: Your first app

Windows Phone 7 Part #3: Understanding navigation

As usual, if you have feedback or requests, you have only to write me or to Silverlightshow and we will fast answer to your needs.

Have a good reading

Recently I'm working hard with Expression Blend to create some interfaces starting from some Illustrator mockups, made by a designer and also creating the user interface of some Windows Phone 7 applications I developed. One thing I've found annoying is that once you create a shape and you rotate it in the designer, Blend uses a CompositeTransform to render the shape in the XAML markup. If you are creating lot of elements (in my case they were the ticks of a gauge) you can get lot of transformations that the plugin or the phone have to render. And to me (particularly from my developer side), this is no a good thing since many times a rotated rectangle might be represented as a Path instead of using the CompositeTransform.

After realizing that creating the shape by hand is not an option I searched hard the options in the menu items because in my mind it was obvious to have a "Make transform static" option. But it simply does not exists (or at least I was unable to find it). So for a long time I decided to close my eyes and accept the Transformations. This until I found a tricky way to convince Blend to perform this operation as a side effect of a sequence of common operations. Here is the process I found:

First of all create the Shape. In this example I will use a Rectangle:

Then I apply the Transformation I need. For this example I simply rotate the shape with the mouse of an amout of degrees:

Now select the shape and find the option in the context menu (or in the Objects Tree) to make the shape a Path (Path -> Convert To Path). Obviously, to remove the transformation, you have to make the rectangle a Path. Once you have done this you will have this in the Object tree:

As now Blend have performed the conversion but the CompositeTrasform is still in place. To convince Blend we have another couple of steps. Now Draw another shape (a rectangle) over the shape to convert. See in figure the result:

Then Convert also this Rectangle to a Path. After this step the Objects Tree will show two paths one on top of the other. In the figure I've named the upper Shape to "Mask":

Finally, and it is the tricky thing you have to deselect both the Paths (e.g. selecting the LayoutRoot element) then select again them starting from "Mask" then (using CTRL) the shape to convert. It is important to be aware that in the conversion the order matter. If you select the shapes in the inverse order you will not reach the required result. Then finally from the context menu select Combine -> Intersect. The resulting shape is this:

The type of selection makes evident that now the Shape ha no rotation but we can see at the markup and the result is reported here:

   1: <Grid x:Name="LayoutRoot" Background="White">

   2:     <Path x:Name="Mask" 

   3:         Data="M29.362633,1.5 L101.14476,29.362633 L73.282127,101.14476 L1.5,73.282127 z" 

   4:         Fill="#FFFFD200" 

   5:         Margin="228.678,148.678,308.678,228.678" 

   6:         Stretch="Fill" Stroke="Black" StrokeThickness="3" UseLayoutRounding="False"/>

   7: </Grid>

Now you are ready to put the shape wherever you need it. I've experimented the trick in many ways and until today I never found a case where it does not works. The sole things you have to keep in mind is the right order of the steps, and that you can convert only a single shape at a time. So for my Gauge I had to make the conversion many times.

As a suggestion I think it would be beautiful to have an additional menu item that does the trick automatically... If someone knows a better way please feel free to write me and I will be very grateful.

After a huge timeframe I return to my writing activity starting a series of articles about Windows Phone 7 for SilverlightShow website. During this time I've find the time to develop many samples for this device to prepare some speeches and I've created two applications for the marketplace.

The intent of the new series is to collect a number of articles, starting from scratch up to the very complicated subjects and I've started today with the very first and basic article about how to get started. In this article explain the architecture of the phone, and how to startup the development environment to be ready to write your own applications and deploy to the marketplace. Here is the planned table of contents of the series, but keep in mind that if you believe I miss something you can let me know and I manage to extend the series:

Windows Phone 7 Part #1: Getting Started (19/1/2011)
 
Windows Phone 7 Part #2: Your first app
 
Windows Phone 7 Part #3: Understanding navigation
 
Windows Phone 7 Part #4: The application lifecycle
 
Windows Phone 7 Part #5: Panorama and Pivot controls
 
Windows Phone 7 Part #6: Advanced interaction
 
Windows Phone 7 Part #7: Understanding Push Notifications
 
Windows Phone 7 Part #8: Using Sensors

As you can see the road is long, since many arguments are covered by the series. I hope you will enjoy reading them but as I've already said if you think there is something to change contact me or the SilverlightShow website and we evaluate your proposals.

If you evere tryied to localize a Silverlight application, you have found for sure that it is not a straighforward task. Like all the other .NET tecnologies the Silverlight projects has resource files and you can create satellite assemblies to contains culture specific strings. But the problem is that it is not so easy to bring this string to the interface.

When you create a resx file Visual Studio generates a code file with a class ready to be used to read the strings. You can also choose to make this class public, so it is possible to use it across different projects. Unfortunately this class has an internal constructon so there is no way to add an instance to the App.xaml resources and use DataBinding to reference the strings in the user interface.

Someone suggest to manually change the ctor of the class but to me it is very frustrating to correct this simple bug every time I add a new resource. So it is required to create a proxy class, that wraps the static one. Every property will call the correspondent static property and then the proxy class will be used for the DataBinding. When you are developing a simple application this is a simple task, but what about when you have an huge number of strings?

With this in mind I've worked to a T4 template that it is able to read a resx file and automatically produces the proxy class. If you do not know it, the T4 template is a very powerful tool that exists since Visual Studio 2008. With it you can write code to generate code inside Visual Studio, and it is exactly what I'm searching for.

Here is the template:

   1: <#@ template debug="false" hostspecific="true" language="C#" #>

   2: <#@ output extension=".cs"  encoding="UTF8" #>

   3: <#@ assembly name="System.Core" #>

   4: <#@ assembly name="System.Xml" #>

   5: <#@ assembly name="System.Xml.Linq" #>

   6: <#@ import namespace="System.IO" #>

   7: <#@ import namespace="System.Text.RegularExpressions" #>

   8: <#@ import namespace="System.Linq" #>

   9: <#@ import namespace="System.Xml" #>

  10: <#@ import namespace="System.Xml.Linq" #>

  11: //------------------------------------------------------------------------------

  12: // <auto-generated>

  13: //     This code was generated by a tool.

  14: //

  15: //     Changes to this file may cause incorrect behavior and will be lost if

  16: //     the code is regenerated.

  17: // </auto-generated>

  18: //------------------------------------------------------------------------------

  19:  

  20: <#

  21: string appName = "ResXProxy Generator Template";

  22: string version = "1.0.3977.0";

  23: string ns = (string)System.Runtime.Remoting.Messaging.CallContext.LogicalGetData("NamespaceHint");

  24: string resxFileName = Path.ChangeExtension(Host.TemplateFile, ".resx");

  25: string resxClassName = Path.GetFileNameWithoutExtension(Host.TemplateFile);

  26: string proxyClassName = string.Format("{0}ResourceProxy", resxClassName);

  27: XDocument document = XDocument.Parse(File.ReadAllText(resxFileName));

  28: #>

  29: namespace <#=ns#>

  30: {

  31:     using System.Globalization;

  32:     using System.Windows.Markup;

  33:  

  34:     /// <summary>

  35:     /// Represent a proxy class for "<#= resxClassName #>" resources

  36:     /// </summary>

  37:     [System.Diagnostics.DebuggerStepThroughAttribute()]

  38:     [System.CodeDom.Compiler.GeneratedCode("<#= appName #>", "<#= version #>")]

  39:     public class <#= proxyClassName #>

  40:     {

  41:         /// <summary>

  42:         /// Initializes the "<#= proxyClassName #>" class

  43:         /// </summary>

  44:         public <#= proxyClassName #>()

  45:         {}

  46:     

  47:         /// <summary>

  48:         /// Gets the current culture

  49:         /// </summary>

  50:         [System.CodeDom.Compiler.GeneratedCode("<#= appName #>", "<#= version #>")]

  51:         public CultureInfo CurrentCulture 

  52:         { 

  53:             get { return CultureInfo.CurrentCulture; } 

  54:         }

  55:  

  56:         /// <summary>

  57:         /// Gets the current UI Culture

  58:         /// </summary>

  59:         [System.CodeDom.Compiler.GeneratedCode("<#= appName #>", "<#= version #>")]

  60:         public CultureInfo CurrentUICulture 

  61:         {

  62:             get { return CultureInfo.CurrentUICulture; } 

  63:         }

  64:         

  65:         /// <summary>

  66:         /// Gets the current Xml Language property

  67:         /// </summary>

  68:         [System.CodeDom.Compiler.GeneratedCode("<#= appName #>", "<#= version #>")]

  69:         public XmlLanguage Language 

  70:         { 

  71:             get { return XmlLanguage.GetLanguage(CultureInfo.CurrentUICulture.Name); } 

  72:         }

  73: <# foreach(var item in document.Element("root").Elements("data")) 

  74:    { 

  75:         string name = EscapeName(item);

  76:     

  77:         if (item.Attributes("type").Count() == 0)

  78:         {

  79: #>

  80:  

  81:         /// <summary>

  82: <# if (item.Elements("comment").Count() == 1) { #>

  83:         /// <remarks><#= item.Element("comment").Value #></remarks>

  84: <# } #>

  85:         /// Gets the "<#= name #>" Property

  86:         /// </summary>

  87:         [System.CodeDom.Compiler.GeneratedCode("<#= appName #>", "<#= version #>")]

  88:         public string <#= name #> 

  89:         { 

  90:             get { return <#= resxClassName + "." + name #>; } 

  91:         }

  92: <# 

  93:         }

  94: }

  95: #>

  96:     }

  97: }<#+

  98: public string EscapeName(XElement item)

  99: {

 100:     string name = item.Attribute("name").Value;

 101:     return Regex.Replace(name, "[^a-zA-Z0-9_]{1,1}", "_");

 102: }

 103: #>

Using the template is really easy. First of all you have to configure the Silverlight application to be localizable (here you can find how to do)  and then create the required resx files. Finally you have to add the template using the same name of the main resource file but using the .tt extension. E.g. if your resx is called AppString.resx you have to call the template AppStrings.tt. Nothing else. Once you have added the template it automatically generates a class called AppStringResourceProxy you can easily reference from a XAML file and bind to the UI. Remember that every time you change the resx file you have to select "Run custom tool" from the context menu of the T4 template to generate the code again.

The generated class does not contains only the string properties but also expose a Language property. You can bind this property to the corresponding Language property of the page (the UserControl) and override the default culture that is usually set to "en-US". Doing this you will have also the Dates and numeric values converted to the right culture.

   1: <UserControl Language="{Binding Language, Source={StaticResource AppString}}" />

The tamplate works fine for Silverlight and Windows Phone. I've never tryied but I think it works also with WPF. Hope this helps.

There is not any doubt, the words I read today in this article and the complete lack of Silverlight during the PDC 2010 has been for me an hard blow. I put a great part of my work in this technology, I immediately recognized as my best friend for fast and reliable developing of applications. And I'm still convinced about this argument, also after the fashion of HTML5 has taken the scene few months ago and now that it has been promoted to a primary actor of the most important conference of Microsoft. This does not mean I really believe that Silverlight has been put in the trashcan and HTML5 has been suddenly put in its place. This will be a story about whom we will know in the next months and I'm confident that what appear to be real now will be demonstrated false soon.

I say these words not as a fanboy, but simply thinking at the reasons that moved me away from the HTML and Javascript world where I was really active. I remember the days when I spent my time trying to make HTML pages similar across four browser. I remember the days when I filled my code with message boxes just to try to understand why my javascript code did not work. I remember the frustrating hours I wasted to try to make good layouts with a technology that is not born to develop applications but only to display rich hypertexts. Yes, all we have to remember that HTML is not for applications. And it is not cross-platform. Developers makes it so. 

I started my story in Silverlight with the very first beta of the version 1.0 and I still have in my ears the voices of people saying: "puah... you have to develop with Javascript... you are crazy!". And they were right, Silverlight 1.0 was ugly because it did not resolved the main problem of the developers, the need of having reliable code that is something Javascript cannot give us. And even Javascript libraries like jQuery can't. I would like to know where are the people that write testable code, the ones that use dependency containers, design patterns, or simply the most effective coding tecniques that have its main reason in protecting the code from errors (expecially runtime errors) and give it maintainability and flexibility. While Silverlight enforces all these tecniques, Javascript doesn't. So the question I asked myself today was: is it what the people really wants?

And my answer is no. I'm confident people like to have effective applications that they can develop in less of half the time they have to use with other technologies. HTML5 will be for sure an interesting thing, but none has to confuse it with a development platform. HTML is the sole language that can be used for websites, where search engines make the difference, but when someone seriously wants to develop "applications", it is an insane choice. Now, and watching at the story behind HTML probably forever. I want to remembers, closing this post, that HTML5 now is far to be final. Just during the demo at the PDC they showed how differently it behave on different browsers and to me none can seriously believe that the actors in the scene will not try to catch HTML5 and make it a weapon to kill the other competitors. This is already happening.