outcoldman

How to use Moq and nUnit to write Unit Tests for Windows Runtime libraries

I love to use Moq library, it is the best mocking framework for me. Visual Studio provides Fakes framework, but my opinion is that it is for slightly different issues. Fakes is a framework for making fakes, not mokes. For example if you need to change how System.IO.File.Exist handles the path or if for some reason you need to change return value of System.DateTime.Now to test something related to time – this is good job for Fakes framework. If you need to make a Stubs or Mocks I prefer to use Moq, it is just simpler. And don't forget that they work together really well.

The problem which I met when I started to write gMusic is that Moq does not exist for Windows Store Apps (WinRT). It is because "winrt doesn't allow dynamic codegen". But I found a workaround. Instead of creating new Unit Test Class Library for Windows Store Apps I created simple Class Library with Target Framework 4.5 (I will call it Unit Test library). After this I added reference to Windows Runtime using this blog post Referencing the Windows Runtime from Desktop Apps. And the latest point is to include my code from Windows Store Apps library to this Unit Test library. I cannot reference it, because my libraries have different runtimes: Windows Store Apps library has runtime .NETCore (or WinRT, or Windows Runtime, so many names for this). And my Unit Test library has runtime .NETFramework 4.5. Visual Studio does not allow you to mix runtimes, except if they are Portable Libraries. The solution for this is to just include all my code which I want to test from Windows Store Apps library to Unit Test library as links to files Adding an Existing Item as a Link (you can just use drag'n'drop in Solution Explorer with pressed Shift+Ctrl to move some folder or files from one project to another and make it as links).

It is not a perfect solution, but works for me.

How to improve performance of your own Inversion of Control Framework?

I enjoy doing anything by myself instead of using well know frameworks. I am not saying that I am using only my own frameworks. It just gives me more knowledge about how these frameworks doing their job. Inversion of Control Framework it is one of these examples. I have a blog post on Russian about simple implementation of IoC container. You can look on it here Simple IoC Container (I used Microsoft Translator for this link). Actually right now is more than just one class, I have my own framework, which I use for some my applications, like gMusic (you can follow this project on GitHub – Framework).

Couple months ago I met an article IoC Container Benchmark - Performance comparison, where this guy compare different IoC containers (when I first time met this article it was only about performance). So I decided to check performance of my simple container. This is result (I have different count of iterations, so do not compare it to the original blog post):

In this list: "Outcold" – this is my current framework, "IoC A" – it is a class which I showed in this blog post Simple IoC Container (based on Activator.CreateInstance), "IoC E" – it is a different version of IoC class, but based on Expressions (I showed in in one of my comments here). "LightInject" – it is one of the faster frameworks from original blog post about IoC performance, "Unity" – it is one of the famous frameworks. As you can see that, the version of IoC class which is based on Expressions has the worst performance. The funny thing, that I used it everywhere, I really thought that it should be faster than Activator, somebody told me… and I did not verify that…. Anyway, after this article, I spent some time to improve performance of my IoC container, and this is how I did this.

The main problem of IoC container which I implemented is that I did not cache the compiled Expression. Each time when I ask IoC to resolve some object – it compiles expression and after this resolve it:

First optimization is simple. Just need to cache expression after first time somebody will ask to resolve object. However, first I need to change how I invoke constructor, because my expression expects constraints I need to change it to parameters, so each "resolving" can use it is own parameters:

Now I have Delegate, which can create for me a new object of specific type. The only one problem, that this delegate can have different set of parameters, so I cannot cast it to something like Func<Type1, … , TypeN, Result> and invoke it. I need to call DynamicInvoke, which is slow:

This is the result of this optimization (as you can see it is very good, but still variant with Activator works better):

The second step I made – I just changed Expression in such way, so it always takes just one parameter "array of objects". In expression I use this array to cast each item of this array to the parameter in constructor. This is how I do this:

This is the result:

It is faster than version with Activator! But it still slower than LightInject. I guess it is because LightInject used before System.Reflection.Emit instead of Expressions, or maybe they have better idea how to create this expression for type resolving.

Anyway, it was a good result for me.

Meet IntelliCommand (Visual Studio 2010/2012 extension)

How many shortcut keys you know in Visual Studio? Do you want to know all of them? I know how you can learn them very easy.

I'd like to introduce you a cool extension for Visual Studio 2010/2012 which I wrote with help of my colleagues Drake Campbell and Aditya Mandaleeka. Let me just copy-paste description from Visual Studio Gallery:

IntelliCommand - an extension for Visual Studio 2010 and 2012 which helps to find the short keys. It shows the help windows with all possible combinations when you press Ctrl or Shift or Alt or their combinations (hold it for about 2 seconds to see this window). Also it shows the list of possible combination when you press first combination of chord shortcut keys, like Ctrl+K, Ctrl+C (this combination comments selected text in editor).

Couple screenshots:

IntelliCommand shows all available shortcut keys for combination of Control + Shift after couple seconds:

Ctrl+K was pressed. Visual Studio waits for second combination:

Available options for Intelli Command. The delay of showing Intelli Command window. Customization of Intelli Command window look:

Download IntelliCommand from Visual Studio Gallery.

Feedback is welcome!

Moving site to the Windows Azure Web Sites

It was a year and half when last time I updated my web site. Sadly this is just one project I have where I can have some experience with web development. And because I really missed it, so I've put three things on my agenda:

Move domain from ru to com, so now my site is available on http://outcoldman.com.
Add support for mobile devices and make some minor changes.
Move site from masterhost to orcsweb. I have both of them for free, but second one gives better conditions, like more storage and better network bandwidth. And I like orcsweb, because these guys update their servers on next days after new .NET Framework ships.

But how you can understand from the topic I failed last task. Because orcsweb sets medium trust for shared sites – this is a huge pain for developers. For example I met problems with using AntiXSS.

Windows Azure Web Sites

Azure Web Sites is still in preview. Azure gives you up to 10 Shared Web Instances for free. But if you want to use custom domains you need move instance to Paid Shared Instance Model, which will cost you about 10-15$ per month. I'm not sure about this, I still cannot understand how this will work if my instance will use CPU only for 1 minute in an hour. I will need to pay for whole hour or just for one minute?

Couple days ago also I saw an information that Web Sites now support .NET Framework 4.5. And this was the latest argument for Web Sites instead of orcsweb. Particularly I dreamed also about to try cloud.

I don't want to tell you how it was easy for me to create a Web Site Instance in Azure. Azure portal has really good documentation and a lot of videos about how to do this. I just want to say – try it. If you don't have an account in Azure – you can try free trial, which will ask you about credit card, but don't worry. You can set limit to 0$, so you will not need to worry about what will be when trial period will come to end or what if you will use more resources than Azure gives you for free. Each free shared web instance on Web Sites has domain name like x.azurewebsites.net, so it is very easy to use them to try something or show your project to world.

And this is really cool that you don't need to think a lot about settings. I just downloaded Publish Profile, which I imported to the ASP.NET MVC 4 project in Visual Studio (right click on project in solution explorer and choose Publish…). And that is it.

Mobile Devices support

I thought that this requires a huge amount of work. Because I remembered from ASP.NET – you need to render your pages on server for mobile devices in special way if you want to support them. I was so surprised when I found that to do this you just need to add two things. Set viewport for mobile devices:

And set special css classes for case when width is less than some defined value:

The easiest way is to take a look how ASP.NET MVC 4.0 defines its classes for mobile devices. This is really good example.

Moving domain

At first I specified for both of my domains that they should redirect to azure web site instance. After this I set two special rules for Url Rewriter in web.config. Url Rewriter is installed on Web Sites by default.

After this I found that it is really easy to change domain in Google Web Master and Google Analytics services. As I understand to do the moving right – I will need also to find main referral pages in internet (Google Analytics can help me to do this) and change links on it (or ask owners to change them). And after this I can say good bye to my old domain.

What is next?

As I said I really missed web-development. So I have some plans to continue improving my web site. At first I want to refactor couple places in source code and publish it to GitHub. When I tried some new features, like Entity Framework and SQL Server CE I didn't try to do it well, I just tried it. And when I saw that it works – I published it with thoughts that I will refactor this code in future. Very common situation, right?

One thing which I still cannot understand – is how to analyzer log files from 0:/LogFiles/http/RawLogs/*.log. They have next format:

# date time s-sitename cs-method cs-uri-stem cs-uri-query s-port cs-username c-ip cs-host sc-status sc-substatus sc-win32-status sc-bytes cs-bytes time-taken

The best option which I found is to import them to excel.

Object Release Verification Framework

Computer Software can have bugs and some of these bugs are Memory Leaks. It is usual case that if your software is a Multi-Document application you need to pay more attention on memory leaks. The main question in these applications is how I can be sure that when user will close document I will release all instances and resources related to this document? What if you already found a Memory Leak and fixed it? How you can protect yourself to be sure that after some changes you will not have this memory leak again?

I had the same thought after one of my Memory Leak fix. Do we have any software or tools which can validate that after some interaction with my application all instances are released, which I want to be released? In native world there are should be a lot of different instruments / practices to do this (I'm not an expert, but pretty sure that this is true). In managed world there are a lot of tools with names Memory Profiler, but to make them work you need to run them separately, analyze your application and after that analyze the report to find memory leaks. This can work, but I'd like to have some instrument in my application which can in runtime check my application and find memory leaks. The solution which I found is pretty simple. I store the list of WeakReferences to objects which I want to check after some interaction that they are released. Based on this I wrote Object Release Verification Framework with couple classes and interfaces. This framework is published on nuget.org as a portable library.

Let's take a look on example. At first – we need to create a new WPF Application project (I will use Visual Studio 2012), after this we need to include nuget package ObjectReleaseVerification by invoking next command in Package Managed Console (or with help of NuGet UI):

PM> Install-Package ObjectReleaseVerification

After this we need to add some code to initialize Verification Framework. It is turned off by default, and it doesn't have any notifications about memory leaks by default. The cause of the latest: some restrictions of using portable library – it is hard to find something which will work on Windows Phone, Web and Desktop platforms at the same time. The initialization code can be next:

This code turns on Object Release Verification framework only when we compile bits in Debug configuration. Also we add one Handler for verification events, which actually is a part of verification framework TextOutputVefiricationHandler. This class expects just one parameter in constructor. The value of this parameter is a function which can write strings. In my case it is debug output window.

After this I will add some logic to the application. I will emulate work of multi-document application:

This code adds simple table control and couple buttons which can add and remove tabs to this control. The code behind:

Method AddTab creates and adds new tab item to the tab control, it uses DateTime.Now as a name for the tab, we will use as a "document name" (just want to remind that I'm going to emulate a multi-document application). Our window also contains the list of all tab items. We use it just to emulate memory leaks in future. The last code line adds the new tab item to the verification framework, so it can start to track it. We use "document name" as a context. Context is a unique name, which allows us to group instances in different lists, so we can just validate instances in special list, by special context.

Method RemoveTab removes active tab from the list of all tabs and from control. Last line of code in this method validates that all instances in current context are released. The context is a document name (tab header), which we generates in AddTab. In method Verify we use delay for 1 second to be sure that Verifier will do verification when runtime will go away from the RemoveTab method. We need to be sure that all variable instances like tabItem will be out of scope, so there are will be no references to these instances. Method Verify will invoke Collect method of Garbage Collection and after that do verification, like which objects are released and which of them not.

This is how it looks:

On this screenshot I added couple tabs and after this removed one of them. As you can see in output window – verification framework shows me which objects are released.

You can implement your own verification handler. For example verification handler in next sample just shows assert when verification fails (application has memory leaks):

After this we can also add it to the collection of verification handlers:

After this let's try to comment one line in RemoveTab, so with this line we will simulate memory leak:

After we will try the same steps which we made in previous run (add couple tabs and remove one of them) we will see assert and detail information in output window:

You can take a look on this sample at https://github.com/outcoldman/OutcoldSolutions-ObjectReleaseVerification-Sample. If you will have any suggestions or comments about this framework – I'd like to hear them.

Windows Phone: Safe work with tasks

When developers use task from namespace Microsoft.Phone.Tasks they can do two mistakes: a) do not put some logic about that application can go to the tombstone mode, it is when phone will save all states off pages and application somewhere and when user will come back to application – phone will restore these states to application and pages; b) developers don't known that method Show can throw exception InvalidOperationException, this can happends when application is in progress of navigation, which potentially can kill your application if you do not have some exception handler, and this means that when user will go back from task to application he will see the main page of phone instead of the application's page.

Ok, so let's look at simple example, my Windows Phone page will do next task: it will have some image control and button which can choose the image from library:

I have next code behind:

So, how much problems you see in this code?

Problem #1. Tombstone mode.

If you will have closer look on MSDN documentation, for example on PhotoChooserTask – you will see the Important Note which tells us about Tombstone Mode. This is big mistake to think that your application is not really huge and there are a little chance that phone can send your application to Tombsone Mode (especially when we got users with just 512Mb devices). It is very simple to test your application on how it can handle Tombstone Mode, you just need to set the checkbox in Debug setting of your project properties:

If you will try to use my example you will see that after you will choose the image – the application will do nothing. You will see this behavior because phone will kill all instances of pages and instance of application when task will be launched. And after user will come back to your application – the phone will recreate all instances of pages and instance of application. If you need to store some data between the time when it kills and restores the instances of the application and pages you can use the States of pages and application to store some data. Be careful, because all objects in states will be serialized and deserialized, so if you will try to save a very huge graph of objects – phone can throws exception. Also phone knows what task you've invoked on your page and when phone will navigate back to your page from tombstone mode it will also invokes the event of the task like Completed. So this is how we can solve problem with tombstone mode in my example:

Of course in most cases you will need to have some association between the image and data in your application model. For example you want to store the icon for some contact in application. So we need to get knowledge how to work with States: How to: Preserve and Restore Page State for Windows Phone. Actually the solution will be pretty simple: a) we need to save data in method OnNavigatedFrom b) and in method OnNavigatedTo we need to read from State this data and after that subscribe to Completed event of the task. You will need to have subscription exactly in an OnNavigatedTo method, because if you will still have a subscription in constructor – phone will invokes the handler when State will not be loaded yet. You can use State only after OnNavigatedTo will be invoked. So, I will need to change my example to this:

Problem #2. Method Show can throw exceptions.

The method Show can throw exception. It is very easy to reproduce this. Just double click on button from previous example. After you will do this – after you will choose the image the phone will show you main screen instead of your application's pages. This is because your application will not catch exception on second button's click, so on first click you will launch the task, and on second click method Show will throw exception "System.InvalidOperationException: Not allowed to call Show() multiple times before a Chooser returns". So you need always to have a try-catch blocks on top of Show invokes. I solved this problem for me very easy: I just wrote couple wrappers which do all work like catch exception. You can look on the code in my repository.

So, the previous example will be next (if we will not need the States to store something when Task will be launched):

And to invoke tasks which don't have ChooserTask as a base class (which just shows something and you do not expect to get some data from them) you will need to write the next code:

Let's do our windows phone application more stable! Example with my wrappers and all other my source code you can find at my repository.

Windows Phone 7 Silverlight: Behaviors for TextBox

I’ve submitted my first application for Windows Phone! It is very simple app. Marketplace has a good amount of similar apps: Planning Poker. Anyway, I’ve wrote couple own behaviors for TextBox and want to share this code with you.

If you are Silverlight/WPF developer and have already used Blend than you should know what are Behaviors and Interactions. If not or if you forget what it is I will remind you. You can find these libraries in directory “c:\Program Files (x86)\Microsoft SDKs\Expression\Blend\” (in case if you have Windows x86 than you should remove from path (x86)). And of course these libraries exist only in case if Blend has been installed. In this directory you can find packs of libraries for WPF/Silverlight and WindowsPhone. If you don’t know what are Behaviors and Interaction I suggest you to read Expression Blend SDK for Windows Phone on MSDN. In few words: this is approach to extend default control’s features, more than! this approach allows you to use MVVM pattern.

Let’s extend some features of default TextBox control.

FocusOnLoadedBehavior

If you will try to open phone contact’s item to edit on your device you’ll see that device will set focus on first TextBox. This is very good user experience: if you open something for edit than most likely you will put focus on TextBox to edit data in this TextBox. Otherwise it is good question what if this page will have more than one TextBox, should we place focus on first of them or not? Windows Phone does it, it places focus on first TextBox if you will open edit page of contact’s name.

I found that it will be good to do the same in some of my pages, so I wrote next behavior:

     /// <summary>

    /// UI Behavior to set focus to <see cref="AssociatedObject"/> on loaded event.

    /// </summary>

    public class FocusOnLoadedBehavior : Behavior<Control>

    {

        public static readonly DependencyProperty SetFocusOnLoadedProperty =

            DependencyProperty.Register("SetFocusOnLoaded", typeof(bool), typeof(FocusOnLoadedBehavior), new PropertyMetadata(true));

        /// <summary>

        /// Set focus to <see cref="AssociatedObject"/> on loaded event. By default <value>true</value>.

        /// </summary>

        public bool SetFocusOnLoaded

        {

            get { return (bool)GetValue(SetFocusOnLoadedProperty); }

            set { SetValue(SetFocusOnLoadedProperty, value); }

        }

        protected override void OnAttached()

        {

            base.OnAttached();

            AssociatedObject.Loaded += AssociatedObject_Loaded;

        }

        protected override void OnDetaching()

        {

            base.OnDetaching();

            AssociatedObject.Loaded -= AssociatedObject_Loaded;

        }

        void AssociatedObject_Loaded(object sender, RoutedEventArgs e)

        {

            AssociatedObject.Loaded -= AssociatedObject_Loaded;

            if (SetFocusOnLoaded)

            {

                AssociatedObject.Focus();

            }

        }

    }

It is easy to use it. Just place it for one of your TextBox like I will show below and this behavior will set focus on Loaded event (in most cases it will be the moment when user opens page with this control):

    <TextBox MaxLength="255" Text="{Binding Path=DisplayName, Mode=TwoWay}" 

         xmlns:interactivity="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"

         xmlns:oBehaviors="clr-namespace:outcold.Phone.Behaviors;assembly=outcold.Phone">

        <interactivity:Interaction.Behaviors>

            <oBehaviors:FocusOnLoadedBehavior />

        </interactivity:Interaction.Behaviors>

    </TextBox>

I’ve put namespace definitions “interactivity” and “oBehavior” to TextBox attributes just for example, you can move it on top level, for example you can add it to your page attributes.

This behavior has property SetFocusOnLoad. If you will need to manage when you need set this focus and when not – you can use this property. For example it can be the case when you have two TextBoxes and you need to decide which of them should get focus on page load.

TextBoxSelectOnFocusBehavior

This is second must have behavior. If user (or you) set focus to TextBox than in different cases user can expect different default position of cursor. For example if it is TextBox for edit some word than most likely user don’t want to add some letters to this word, in most cases he will delete this word to write new one (for example it can be dictionary), so it is good UX to select whole word on focus set event. To do so you can use next behavior:

    public enum TextBoxFocusSelectType

    {

        None = 0, 

        SelectAll = 1,

        SetCursorToTheEnd = 2

    }

    /// <summary>

    /// UI Behavior to set how to select text in TextBox on Focused.

    /// </summary>

    public class TextBoxSelectOnFocusBehavior : Behavior<TextBox>

    {

        public TextBoxSelectOnFocusBehavior()

        {

            Type = TextBoxFocusSelectType.None;

        }

        /// <summary>

        /// Set behavior of how to select text in <see cref="AssociatedObject"/>.

        /// By default <value>TextBoxFocusSelectType.None</value>.

        /// </summary>

        public TextBoxFocusSelectType Type

        {

            get;

            set;

        }

        protected override void OnAttached()

        {

            base.OnAttached();

            AssociatedObject.GotFocus += AssociatedObject_GotFocus;

        }

        protected override void OnDetaching()

        {

            base.OnDetaching();

            AssociatedObject.GotFocus -= AssociatedObject_GotFocus;

        }

        void AssociatedObject_GotFocus(object sender, RoutedEventArgs e)

        {

            if (Type == TextBoxFocusSelectType.SelectAll)

            {

                AssociatedObject.SelectAll();

            }

            else if (Type == TextBoxFocusSelectType.SetCursorToTheEnd)

            {

                AssociatedObject.Select(AssociatedObject.Text.Length, 0);

            }

        }

    }

To use it just add it to TextBox:

    <TextBox MaxLength="255" Text="{Binding Path=DisplayName, Mode=TwoWay}" 

         xmlns:interactivity="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"

         xmlns:oBehaviors="clr-namespace:outcold.Phone.Behaviors;assembly=outcold.Phone">

        <interactivity:Interaction.Behaviors>

            <oBehaviors:FocusOnLoadedBehavior />

            <oBehaviors:TextBoxSelectOnFocusBehavior Type="SetCursorToTheEnd" />

        </interactivity:Interaction.Behaviors>

    </TextBox>

TextBoxInputRegexFilterBehavior

The last behavior for today TextBoxInputRegexFilterBehavior, which allows you to filter input text. Actually this behavior can add some unobviousness behavior to your application: user sees some button, but when he presses it he doesn’t see any changes. So you should use it very careful. One place where I used it: I need to get integer values from user, but TextBox has minimum InputScope=”Number” which has digits and dot (or comma, it depends on your device language). I saw in one of the apps that one developer created his own keyboard to get rid of this problem. I didn’t like it, and of course I don’t want to use validators for Windows Phone applications, we have very small screen for validators. So I’ve wrote next behavior:

    /// <summary>

    /// UI behavior for <see cref="TextBox"/> to filter input text with special RegularExpression

    /// </summary>

    public class TextBoxInputRegexFilterBehavior : Behavior<TextBox>

    {

        private Regex _regex;

        private string _originalText;

        private int _originalSelectionStart;

        private int _originalSelectionLength;

        public string RegularExpression 

        {

            get { return _regex.ToString(); } 

            set 

            {

                if (string.IsNullOrEmpty(value))

                {

                    _regex = null;

                }

                else

                {

                    _regex = new Regex(value);

                }

            } 

        }

        protected override void OnAttached()

        {

            base.OnAttached();

            AssociatedObject.TextInputStart += AssociatedObject_TextInputStart;

            AssociatedObject.TextChanged += AssociatedObject_TextChanged;

        }

        protected override void OnDetaching()

        {

            base.OnDetaching();

            AssociatedObject.TextInputStart -= AssociatedObject_TextInputStart;

            AssociatedObject.TextChanged -= AssociatedObject_TextChanged;

        }

        void AssociatedObject_TextInputStart(object sender, TextCompositionEventArgs e)

        {

            if (_regex != null && e.Text != null && !(e.Text.Length == 1 && Char.IsControl(e.Text[0])))

            {

                if (!_regex.IsMatch(e.Text))

                {

                    _originalText = AssociatedObject.Text;

                    _originalSelectionStart = AssociatedObject.SelectionStart;

                    _originalSelectionLength = AssociatedObject.SelectionLength;

                }

            }

        }

        public void AssociatedObject_TextChanged(object sender, TextChangedEventArgs e)

        {

            if (_originalText != null)

            {

                string text = _originalText;

                _originalText = null;

                AssociatedObject.Text = text;

                AssociatedObject.Select(_originalSelectionStart, _originalSelectionLength);

            }

        }

    }

To use it:

    <TextBox Text="{Binding Path=Value, Mode=TwoWay}" MaxLength="3" Width="100" InputScope="Number" 

            xmlns:interactivity="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"

            xmlns:oBehaviors="clr-namespace:outcold.Phone.Behaviors;assembly=outcold.Phone">

        <interactivity:Interaction.Behaviors>

            <oBehaviors:TextBoxSelectOnFocusBehavior Type="SelectAll" />

            <oBehaviors:TextBoxInputRegexFilterBehavior RegularExpression="[0-9]+" />

        </interactivity:Interaction.Behaviors>

    </TextBox>

In next topics I will show you some other behaviors which I use for my Windows Phone applications. And don’t forget to read section Expression Blend SDK for Windows Phone on MSDN!

Silverlight 4 in Action

Silverlight 4 in Action (Manning, Pete Brown) – this is second book, which I read about Silverlight. First was Pro Silverlight 3 in C# (Apress, Matthew MacDonald), which helped me when I was need to very quickly know more about Silverlight after WPF. After reading Silverlight 4 in Action I think that this is best book about Silverlight. But maybe I should compare this book with Pro Business Applications with Silverlight.

I think that most of Silverlight and WPF developers know book’s author’s blog Pete Brown. Since 2009 author is Microsoft employee, since 2007 Silverlight became the main technology of development for him. You can think that Silverlight 4 in Action is second edition, because Manning has also Silverlight 2 in Action, which I didn’t read. But Silverlight 2 in Action has different authors than SL4 in Action. So talk about what’s new in Silverlight 4 in Action is no good, it is different book, written by another author. Looks like this is first book of Pete Brown, and it is written very good.

After buying paper book you will get also free e-book version (pdf), which you can read with Kindle device for example (only in album rotation). The book has about 800 pages, has 3 parts and 25 chapters.

First what was strange for me it was order of chapters. Chapters about creating own panels, custom controls (not UserControls), and about styles and resources located at the end of the book (with comparing with Pro Silverlight 3). Maybe for beginners it will be a problem, but for me all was very consecutive. And I think it is very logical that stuff which you will use not really often showed at the end of the book, like: Writable Bitmap, making own panels and controls. Most of us are developing applications for enterprise, so for us making animation not is usual stuff. About own controls and panels, really I remember only a few cases for 2-3 years of my WPF/Silverlight developing career, when I was designing panels and controls for Silverlight or WPF. By the way, it was really cool that in book author design OrbitPanel instead of WrapPanel (this is first example in each book of creating own panels, like Hello World).

Nearly the end of the book I really liked example of creating own MediaStreanSource, which generate video and audio noise instead of video and audio streams at client side with Silverlight code. Most of examples are really useful, most of them are usual problems which you need solve when you are developing own application, like when author write about printing he show the example about creating reports from list with paging support. This is ready to use code, really.

And of course the book has chapter about which every book reader write: “Structuring and testing with the MVVM/ViewModel pattern”. With chapter “WCF RIA Services”, which going after MVVM chapter – they are on 100 pages in details show how to develop Silverlight business applications, architecture specifics, etc. I think this is the best topic explanation which I saw.

I recommend this book for developers, who want to or already design business applications on Silverlight, I think this is main auditory for who Pete Brown had wrote this book.

One thought which I can’t understand, what is notice on 492 page:

If you’re really and truly bored and need a break from reading, check out http://cornify.com/ to add unicorns and rainbows to any web site or photo. Warning: 5th grade girls’ Trapper Keeper graphics overload.

Humor? :)

The art of Unit Testing with Examples in .NET

First time when I familiarized with unit testing was 5 or 6 years ago. It was start of my developing career. I remember that somebody told me about code coverage. At that time I didn’t write any Unit tests. Guy, who was my team lead, told me “Do you see operator if with three conditions? You should check all of these conditions”. So, after that I had written some code, I should go to interface and try to invoke all code which I wrote from user interface. Nice? At current time I know little more about tests and unit testing. I have not participated in projects, designed by Test Driven Development (TDD). Basics of my knowledge are a spying code of my colleagues, some articles and screencasts. I had decide that I should know much more, and became a real professional of unit testing, this is why I had start to read book The art of Unit Testing with Examples in .NET. More than, in my current job place looks like I’m just one who writing unit tests for my code. I should show good examples of my tests.

The book was written about half year ago. Most of samples was written with C#. I saw a lot of recommendation for reading this book.

Author of this book is Roy Osherove. He is famous blogger, also he is lecturing TDD master classes, sometimes he is working consultant for IT companies, if they want to implement TDD in their projects (he wrote not one time about this, bring successful and unsuccessful cases). He is working as a main architect in company Typemock. Typemock developing paid instruments for tests/unit testing and code analysis.

The book will be useful for developers of any platforms. Like I said before most of examples was written with C# (some of examples with Java). In book author use NUnit framework for unit tests, Rhino Mocks for Mock and Stub objects in Unit tests (before that I didn’t know that Stub and Mock are different, I knew only about Mocks).

So, what you will find in the book? You can download a few chapters from official book’s site, so before buy the book you can read first is it good for you or not. First chapter of book is “Hello world!”. It is about what you need to write tests, what kind of frameworks, tools, and of course first test is there. Next chapter about frameworks which author use in his book: NUnit and Rhino Mocks. He used Rhino Mocks at book as I understand because he got statistic that Rhino Mocks is frequently used framework for creating Mocks and Stubs. I think that today situation little different, I like Moq. And NUnit today is still most used unit testing framework. One time I used MbUnit, because it has more features, but NUnit today has the same features.

It the book you will find information about how to write tests, how you should design them. And also you will find antipatterns: I found out all of them, I had used them in my code. :(

Also I found answer for my old question. I wrote some article about testing applications with NHibernate, and I got comment about why you are testing ORM? I thought that this man know more than me in unit testing, so really maybe I shouldn’t test ORM Repositories. At that time I had really specific case, so I said that I need it, and said why I need these tests. I didn’t know why this guy asked me this question. Really this is my integration test. With this test I check that database schema is equal to xml-mapping, mapping is equal to classes, and if I use special queries I check them too with my tests. It is really helpful. In the book I found answer for my question – tests for ORM is really helpful, author if this book always write tests for his Data Access Layer, and he said why.

Also in the book you will find how to introduce TDD in your company, how to work with Legacy code (this is really important when you introduce TDD in exist project, not new). Also a lot of questions and answers for guy, who want to introduce TDD in his group/company, he will get a lot of questions for his colleagues (money, time, knowledge, etc).

At the end of book author made an inventory of frameworks, which you can use for testing. Of course in his list you will find paid frameworks, which was written by Typemock, where author are working.

Really I recommend this book for all companies, which use TDD in their practice and which write unit tests, so for all companies. My recommendation for team leads and managers, don’t say “You must write tests”, read book first, or ask your colleagues to read the book, make a lectures, trainings, and you will see the result.

Silverlight basics. Validation. Part 2. IDataErrorInfo & INotifyDataErrorInfo

At previous my blog post I wrote about how to implement validation with DataAnnotations. I this part of my article I will describe interfaces IDataErrorInfoand INotifyDataErrorInfo. I recommend you to read first part before read this part. Because I use example from previous part.

Few words about ValidationOnExceptions

Forgot to tell you, if you want implement validation with exceptions, you may not use DataAnnotations, you can throw your own exceptions from set methods. For example, you can implement check of password confirmation like this:

     [Display(Name = "New password confirmation")]

    public string NewPasswordConfirmation

    {

        get { return _newPasswordConfirmation; }

        set

        {

            _newPasswordConfirmation = value;

            OnPropertyChanged("NewPasswordConfirmation");

            ChangePasswordCommand.RaiseCanExecuteChanged();

            if (string.CompareOrdinal(_newPassword, value) != 0)

                throw new Exception("Password confirmation not equal to password.");

        }

    }

Looks better than CustomValidationAttribute.

IDataErrorInfo

The IDataErrorInfo interface came with Silverlight 4. If we want implement validation with this interface we should implement it in our ViewModel (one property and one method). Usually developers write own class handler, which store validation errors)

    public class ValidationHandler

    {

        private Dictionary<string, string> BrokenRules { get; set; }

        public ValidationHandler()

        {

            BrokenRules = new Dictionary<string, string>();

        }

        public string this[string property]

        {

            get { return BrokenRules[property]; }

        }

        public bool BrokenRuleExists(string property)

        {

            return BrokenRules.ContainsKey(property);

        }

        public bool ValidateRule(string property, string message, Func<bool> ruleCheck)

        {

            bool check = ruleCheck();

            if (!check)

            {

                if (BrokenRuleExists(property))

                    RemoveBrokenRule(property);

                BrokenRules.Add(property, message);

            }

            else

            {

                RemoveBrokenRule(property);

            }

            return check;

        }

        public void RemoveBrokenRule(string property)

        {

            if (BrokenRules.ContainsKey(property))

            {

                BrokenRules.Remove(property);

            }

        }

        public void Clear()

        {

            BrokenRules.Clear();

        }

    }

Now let’s rewrite our BindingModel class, we will inherit it from interface IDataErrorInfo and will implement it:

    public class BindingModel : INotifyPropertyChanged, IDataErrorInfo

    {

        private string _newPassword;

        private string _newPasswordConfirmation;

        private readonly ValidationHandler _validationHandler = new ValidationHandler();

        #region INotifyPropertyChanged

        public event PropertyChangedEventHandler PropertyChanged = delegate { };

        private void OnPropertyChanged(string propertyName)

        {

            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

        }

        #endregion

        #region IDataErrorInfo

        public string this[string columnName]

        {

            get

            {

                if (_validationHandler.BrokenRuleExists(columnName))

                {

                    return _validationHandler[columnName];

                }

                return null;

            }

        }

        public string Error

        {

            get { return throw new NotImplementedException(); }

        }

        #endregion

    }

The main properties for our BindingModel will look like this:

    [Display(Name = "New password")]

    public string NewPassword

    {

        get { return _newPassword; }

        set

        {

            _newPassword = value;

            OnPropertyChanged("NewPassword");

            if (_validationHandler.ValidateRule("NewPassword", "New password required", 

                                        () => !string.IsNullOrEmpty(value)))

            {

                _validationHandler.ValidateRule("NewPassword", "Max length of password is 80 symbols.", 

                                        () => value.Length < 80);

            }

            ChangePasswordCommand.RaiseCanExecuteChanged();

        }

    }

    [Display(Name = "New password confirmation")]

    public string NewPasswordConfirmation

    {

        get { return _newPasswordConfirmation; }

        set

        {

            _newPasswordConfirmation = value;

            OnPropertyChanged("NewPasswordConfirmation");

            _validationHandler.ValidateRule("NewPasswordConfirmation", "Password confirmation not equal to password.",

                                            () => string.CompareOrdinal(_newPassword, value) == 0);

            ChangePasswordCommand.RaiseCanExecuteChanged();

        }

    }

Each call of VaidationRule checks some condition, and if it not true, then write info about this validation error in errors collection. After binding Silverlight infrastructure will call get method of indexing property this[string columnName] and it will return error information for this property (columnName). We should set property ValidatesOnDataErrors in our binding to true if we want to use this kind of validation. Property Error throw NotImplementedException because Silverlight doesn’t use it. Quotation from MSDN: “Note that the binding engine never uses the Error property, although you can use it in custom error reporting to display object-level errors.”

In end we should implement again methods for command:

    public BindingModel()

    {

        ChangePasswordCommand = new DelegateCommand(ChangePassword, CanChangePassword);

    }

    public DelegateCommand ChangePasswordCommand { get; private set; }

    private bool CanChangePassword(object arg)

    {

        return !string.IsNullOrEmpty(_newPassword) 

            && string.CompareOrdinal(_newPassword, _newPasswordConfirmation) == 0;

    }

    private void ChangePassword(object obj)

    {

        if (ChangePasswordCommand.CanExecute(obj))

        {

            MessageBox.Show("Bingo!");

        }

    }

We again should use CanChangePassword method, because we need to set button to disabled state when object is invalid. We can’t check valid state of whole object before binding happened. Another problem with this realization: we should write validation rules twice: in property set methods and at CanChangePassword method. But this is problem of this realization; you can solve it with another realization: you can write some class ValidationHandler, which will store not only validation errors, but validation rules, so you can raise validation check in CanChangePassword method. But we still have a problem, we can’t tell to ValidationSummary or some other control at our interface that some validation errors happened or disappeared without binging.

Also you can use DataAnnotation for this approach, but you should write some helper method for that, I will tell you how in next example.

Result of IDataErrorInfo realization (Silverlight sample):

I think that behavior of this sample the same like in previous part. I want to say that this sample has bug, if user will input Password Confirmation first and then New Password, he will see validation error about password confirmation not equal, because this check happened only on NewPasswordConfirmation binding.

INotifyDataErrorInfo

The INotifyDataErrorInfointerface came with Silverlight 4 too. The main advantage of this interface you can do synchronous (like in previous samples) and asynchronous validation too. You can wait validation from server, and only after that tell to interface that all ok or some validation error occurred. I like this way of validation more than other. I will use some classes and realization from articles of Davy Brion about “MVP In Silverlight/WPF Series”.

First I got class PropertyValidation, with it we will store validation rule for properties and message which should be showed when validation error occurred.

    public class PropertyValidation<TBindingModel>

        where TBindingModel : BindingModelBase<TBindingModel>

    {

        private Func<TBindingModel, bool> _validationCriteria;

        private string _errorMessage;

        private readonly string _propertyName;

        public PropertyValidation(string propertyName)

        {

            _propertyName = propertyName;

        }

        public PropertyValidation<TBindingModel> When(Func<TBindingModel, bool> validationCriteria)

        {

            if (_validationCriteria != null)

                throw new InvalidOperationException("You can only set the validation criteria once.");

            _validationCriteria = validationCriteria;

            return this;

        }

        public PropertyValidation<TBindingModel> Show(string errorMessage)

        {

            if (_errorMessage != null)

                throw new InvalidOperationException("You can only set the message once.");

            _errorMessage = errorMessage;

            return this;

        }

        public bool IsInvalid(TBindingModel presentationModel)

        {

            if (_validationCriteria == null)

                throw new InvalidOperationException(

                    "No criteria have been provided for this validation. (Use the 'When(..)' method.)");

            return _validationCriteria(presentationModel);

        }

        public string GetErrorMessage()

        {

            if (_errorMessage == null)

                throw new InvalidOperationException(

                    "No error message has been set for this validation. (Use the 'Show(..)' method.)");

            return _errorMessage;

        }

        public string PropertyName

        {

            get { return _propertyName; }

        }

    }

You will understand how it works when we will start implement validation rules in our example. This class has generic parameter with base class BindingModelBase<T>, from which we will inherit our main BindingModel class.

Let’s implement BindingModelBase class, we will inherit it from INotifyPropertyChanged and INotifyDataErrorInfo interfaces, and will add two fields, one for store validation rules and one for store validation errors:

    public abstract class BindingModelBase<TBindingModel> : INotifyPropertyChanged, INotifyDataErrorInfo

        where TBindingModel : BindingModelBase<TBindingModel>

    {

        private readonly List<PropertyValidation<TBindingModel>> _validations = new List<PropertyValidation<TBindingModel>>();

        private Dictionary<string, List<string>> _errorMessages = new Dictionary<string, List<string>>();

        #region INotifyDataErrorInfo

        public IEnumerable GetErrors(string propertyName)

        {

            if (_errorMessages.ContainsKey(propertyName)) 

                return _errorMessages[propertyName];

            return new string[0];

        }

        public bool HasErrors

        {

            get { return _errorMessages.Count > 0; }

        }

        public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged = delegate { };

        private void OnErrorsChanged(string propertyName)

        {

            ErrorsChanged(this, new DataErrorsChangedEventArgs(propertyName));

        }

        #endregion

        #region INotifyPropertyChanged

        public event PropertyChangedEventHandler PropertyChanged = delegate { };

        protected void OnPropertyChanged(string propertyName)

        {

            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

        }

        #endregion

    }

Also I want to add one helper method additional to OnPropertyChanged, it will be method which has Expression in parameters and will let us to use it like this:

    public string NewPassword

    {

        get { return _newPassword; }

        set { _newPassword = value; OnCurrentPropertyChanged(); }

    }

This method is very useful. Implementation of this method:

    public string NewPassword

    {

        get { return _newPassword; }

        set { _newPassword = value; OnPropertyChanged(() => NewPassword); }

    }

Implementation:

    protected void OnPropertyChanged(Expression<Func<object>> expression)

    {

        OnPropertyChanged(GetPropertyName(expression));

    }

    private static string GetPropertyName(Expression<Func<object>> expression)

    {

        if (expression == null)

            throw new ArgumentNullException("expression");

        MemberExpression memberExpression;

        if (expression.Body is UnaryExpression)

            memberExpression = ((UnaryExpression)expression.Body).Operand as MemberExpression;

        else

            memberExpression = expression.Body as MemberExpression;

        if (memberExpression == null)

            throw new ArgumentException("The expression is not a member access expression", "expression");

        var property = memberExpression.Member as PropertyInfo;

        if (property == null)

            throw new ArgumentException("The member access expression does not access a property", "expression");

        var getMethod = property.GetGetMethod(true);

        if (getMethod.IsStatic)

            throw new ArgumentException("The referenced property is a static property", "expression");

        return memberExpression.Member.Name;

    }

Method get property name from expression. Next, let’s add some methods which will perform validation:

    public void ValidateProperty(Expression<Func<object>> expression)

    {

        ValidateProperty(GetPropertyName(expression));

    }

    private void ValidateProperty(string propertyName)

    {

        _errorMessages.Remove(propertyName);

        _validations.Where(v => v.PropertyName == propertyName).ToList().ForEach(PerformValidation);

        OnErrorsChanged(propertyName);

        OnPropertyChanged(() => HasErrors);

    }

    private void PerformValidation(PropertyValidation<TBindingModel> validation)

    {

        if (validation.IsInvalid((TBindingModel) this))

        {

            AddErrorMessageForProperty(validation.PropertyName, validation.GetErrorMessage());

        }

    }

    private void AddErrorMessageForProperty(string propertyName, string errorMessage)

    {

        if (_errorMessages.ContainsKey(propertyName))

        {

            _errorMessages[propertyName].Add(errorMessage);

        }

        else

        {

            _errorMessages.Add(propertyName, new List<string> {errorMessage});

        }

    }

Method ValidateProperty delete information about all validation errors which was happened with current property, then check each rule for current property, and if some rule is false it will add error to errors collection. Also we can raise validation check for each property auto with PropertyChanged event:

    protected BindingModelBase()

    {

        PropertyChanged += (s, e) => { if (e.PropertyName != "HasErrors") ValidateProperty(e.PropertyName); };

    }

For easy add validation rules to our collection we will add next method:

    protected PropertyValidation<TBindingModel> AddValidationFor(Expression<Func<object>> expression)

    {

        var validation = new PropertyValidation<TBindingModel>(GetPropertyName(expression));

        _validations.Add(validation);

        return validation;

    }

Now we can implement BindingModel class, which we will use in our last example. If we want to implement validation with INotifyDataErrorInfo interface we should set to true property ValidatesOnNotifyDataErrorsin bindings.

BindingModel implementation:

    public class BindingModel : BindingModelBase<BindingModel>

    {

        private string _newPassword;

        private string _newPasswordConfirmation;

        public DelegateCommand ChangePasswordCommand { get; private set; }

        public BindingModel()

        {

            ChangePasswordCommand = new DelegateCommand(ChangePassword);

            AddValidationFor(() => NewPassword)

                .When(x => string.IsNullOrEmpty(x._newPassword))

                .Show("New password required field.");

            AddValidationFor(() => NewPassword)

                .When(x => !string.IsNullOrEmpty(x._newPassword) && x._newPassword.Length > 80)

                .Show("New password must be a string with maximum length of 80.");

            AddValidationFor(() => NewPasswordConfirmation)

                .When(x => !string.IsNullOrEmpty(x._newPassword) && string.CompareOrdinal(x._newPassword, x._newPasswordConfirmation) != 0)

                .Show("Password confirmation not equal to password.");

        }

        [Display(Name = "New password")]

        public string NewPassword

        {

            get { return _newPassword; }

            set

            {

                _newPassword = value;

                OnPropertyChanged(() => NewPassword);

            }

        }

        [Display(Name = "New password confirmation")]

        public string NewPasswordConfirmation

        {

            get { return _newPasswordConfirmation; }

            set

            {

                _newPasswordConfirmation = value;

                OnPropertyChanged(() => NewPasswordConfirmation);

            }

        }

        private void ChangePassword(object obj)

        {

            throw new NotImplementedException();

        }

    }

In ctor we describe all three validation rules for properties. Look’s very good (Thanks Davy Brion!). I told you that I don’t like to set disabled button, so from now it will be always enabled. For realization command’s method ChangePassword I need some method which will check all validation rules of current object, it will be ValidateAll method, which I will implement in BindingModelBase class:

    public void ValidateAll()

    {

        var propertyNamesWithValidationErrors = _errorMessages.Keys;

        _errorMessages = new Dictionary<string, List<string>>();

        _validations.ForEach(PerformValidation);

        var propertyNamesThatMightHaveChangedValidation =

            _errorMessages.Keys.Union(propertyNamesWithValidationErrors).ToList();

        propertyNamesThatMightHaveChangedValidation.ForEach(OnErrorsChanged);

        OnPropertyChanged(() => HasErrors);

    }

This method deletes all validation errors in collection. Then check validation rules, write errors if rule is false, and then raise OnErrorsChanged event for each property which has changed validation state.

Implementation of method ChangePassword:

    private void ChangePassword(object obj)

    {

        ValidateAll();

        if (!HasErrors)

        {

            MessageBox.Show("Bingo!");

        }

    }

Result (Silverlight application):

I like this realization. It much more flexible and it can use all advantages of previous variants. What about DataAnnotation? If you like to describe validation rules with data annotation attributes I can give you one more help method for that. This method will get all rules from attributes and convert them to PropertyValidation:

    protected PropertyValidation<TBindingModel> AddValidationFor(Expression<Func<object>> expression)

    {

        return AddValidationFor(GetPropertyName(expression));

    }

    protected PropertyValidation<TBindingModel> AddValidationFor(string propertyName)

    {

        var validation = new PropertyValidation<TBindingModel>(propertyName);

        _validations.Add(validation);

        return validation;

    }

    protected void AddAllAttributeValidators()

    {

        PropertyInfo[] propertyInfos = GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);

        foreach (PropertyInfo propertyInfo in propertyInfos)

        {

            Attribute[] custom = Attribute.GetCustomAttributes(propertyInfo, typeof(ValidationAttribute), true);

            foreach (var attribute in custom)

            {

                var property = propertyInfo;

                var validationAttribute = attribute as ValidationAttribute;

                if (validationAttribute == null)

                    throw new NotSupportedException("validationAttribute variable should be inherited from ValidationAttribute type");

                string name = property.Name;

                var displayAttribute = Attribute.GetCustomAttributes(propertyInfo, typeof(DisplayAttribute)).FirstOrDefault() as DisplayAttribute;

                if (displayAttribute != null)

                {

                    name = displayAttribute.GetName();

                }

                var message = validationAttribute.FormatErrorMessage(name);

                AddValidationFor(propertyInfo.Name)

                    .When(x =>

                    {

                        var value = property.GetGetMethod().Invoke(this, new object[] { });

                        var result = validationAttribute.GetValidationResult(value,

                                                                new ValidationContext(this, null, null) { MemberName = property.Name });

                        return result != ValidationResult.Success;

                    })

                    .Show(message);

            }

        }

    }

And the last BindingModel variant:

    public class BindingModel : BindingModelBase<BindingModel>

    {

        private string _newPassword;

        private string _newPasswordConfirmation;

        public DelegateCommand ChangePasswordCommand { get; private set; }

        public BindingModel()

        {

            ChangePasswordCommand = new DelegateCommand(ChangePassword);

            AddAllAttributeValidators();

            AddValidationFor(() => NewPasswordConfirmation)

                .When(x => !string.IsNullOrEmpty(x._newPassword) && string.CompareOrdinal(x._newPassword, x._newPasswordConfirmation) != 0)

                .Show("Password confirmation not equal to password.");

        }

        [Display(Name = "New password")]

        [Required]

        [StringLength(80, ErrorMessage = "New password must be a string with maximum length of 80.")]

        public string NewPassword

        {

            get { return _newPassword; }

            set

            {

                _newPassword = value;

                OnPropertyChanged(() => NewPassword);

            }

        }

        [Display(Name = "New password confirmation")]

        public string NewPasswordConfirmation

        {

            get { return _newPasswordConfirmation; }

            set

            {

                _newPasswordConfirmation = value;

                OnPropertyChanged(() => NewPasswordConfirmation);

            }

        }

        private void ChangePassword(object obj)

        {

            ValidateAll();

            if (!HasErrors)

            {

                MessageBox.Show("Bingo!");

            }

        }

    }

Source code of these samples you can download from my assembla.com repository.