[If you don’t know what Ix (Interactive Extensions for .NET) is, then I recommend reading my earlier post.]

There are very good resources (like this video) on Ix operators so I am not going to spend too much time on this but I am going to talk about a few of these operators (my top three) to show how the interactive extensions can make your code easier to write and read.

I will use unit tests to express the functionality I am expecting and will then provide potential solutions without using Ix, and finally showing how Ix would simplify the implementation.

For the code snippets, assume that all methods (excluding the test methods) live in a static class named MyEnumerableScrathPad.

EnumerableEx.Return

You have an object of type T and want an enumerable sequence of T, which includes that object only.

Test

[TestMethod]

public void ReturnTest()

{

    var item = new object();

    var returnedItem = MyEnumerableScratchPad.Return(item).Single();

    Assert.AreSame(item, returnedItem);

}

Legacy implementation

public static IEnumerable<T> Return<T>(T item)

{

    return new T[] { item };

}

Using Ix

public static IEnumerable<T> Return<T>(T item)

{

    return EnumerableEx.Return(item);

}

EnumerableEx.StartWith

You have an enumerable sequence of T and you want to add an instance of type T to the beginning of that sequence.

Test

[TestMethod]

public void StartWithTest()

{

    var count = 10;

    var zero = 0;

    var originalRange = Enumerable.Range(1, count);

    var newRange =  MyEnumerableScratchPad.StartWith(originalRange, zero);

    Assert.AreEqual(zero, newRange.First());

    Assert.AreEqual(count + 1, newRange.Count());

}

Legacy implementation #1

public static IEnumerable<T> StartWith<T>(IEnumerable<T> originalSequence, 

  T first)

{

    var list = originalSequence.ToList();

    list.Insert(0, first);

    return list.AsEnumerable();

}

This will make the test pass but this implementation may force you to iterate through the items unnecessarily because of the call to ToList. We were also lucky that this implementation passed the test. If you change the value of count from 10 to int.MaxValue – 1, the test will horribly fail with an OutOfMemoryException. So the idea of converting the enumerable to a list is not a good one.

Legacy implementation #2

public static IEnumerable<T> StartWith<T>(IEnumerable<T> originalSequence, 

  T first)

{

    yield return first;

    foreach (var item in originalSequence)

        yield return item;

}

This implementation does not suffer from the problem shown above and passes the test after a fairly long delay (around 10 seconds on my laptop), which is expected as a result of the call to Count, which will iterate through the sequence and one can argue that this is not a good test but it fits the purpose here.

Using Ix

public static IEnumerable<T> StartWith<T>(IEnumerable<T> originalSequence, 

T first)

{

    return originalSequence.StartWith(first);

}

Ix also has another overload for StartWith, which takes a param array of items to be inserted at the beginning of the sequence, which can be handy.

EnumerableEx.ForEach

You have an enumerable sequence and you want to perform an action for each item of the sequence.

[TestMethod]

public void ForEachTest()

{

    var list = new List<int>();

    var range = Enumerable.Range(1, 10);

    MyEnumerableScratchPad.ForEach(range, list.Add);

    CollectionAssert.AreEqual(range.ToList(), list);

}

Legacy implementation #1

public static void ForEach<T>(IEnumerable<T> sequence, Action<T> action)

{    foreach (var item in sequence)

    {

        action(item);

    }

}

Clearly this is a valid solution but we are looking for a more compact solution.

Legacy implementation #2

public static void ForEach<T>(IEnumerable<T> sequence, Action<T> action)

{

    Array.ForEach(sequence.ToArray(), action);

}

Legacy implementation #3

public static void ForEach<T>(IEnumerable<T> sequence, Action<T> action)

{

    sequence.ToList().ForEach(action);

}

Implementations #2 and #3 are not ideal as they both force the enumeration of the sequence before the iterating through the items begins. This is not necessarily a problem but there are some cases where you want to perform the action as soon as the sequence yields a new value.

Using Ix

public static void ForEach<T>(IEnumerable<T> sequence, Action<T> action)

{

    sequence.ForEach(action);

}

Because most of the Ix operators including ForEach are ported back from the Rx world, there are some interesting additional overloads for ForEach. For example, there is one that takes action of T (the action that needs to be performed on each item) and then another action that will be performed when the iteration over the sequence is completed.

These three operators (Return, StartWith and ForEach) are among the simplest of the long list of Ix operators but nonetheless they are the ones I use most as they make code more concise and easier to read.

I have to start this post with a clarification: “Ix” is not the name of an official product. I am just calling it so to highlight the benefits of this less known part of the Reactive Extensions or “Rx” (which is a real product by the way).

Interactive Extensions used to be part of the Rx library but they can now be downloaded separately. Rx is now officially released and the stable version can be downloaded from here. Ix is now packaged separately and its experimental release can be downloaded from here. Both of these components are also available on the main Nuget feed.

Even many developers who are using Rx are unaware of this interactive part of the library and I believe it deserves more attention. But let’s start with Rx, just in case you don’t know what it is.

What is Rx?

Rx is a library developed by Microsoft, which allows you to write applications that react to events using a nice and clean implementation of the observable pattern. Rx started off as a Microsoft DevLabs incubation project but it proved to be very popular so its incubation period was ended in April 2011 and since then, it has been moved to the MSDN Data Developer Center.

What is Ix?

I refer to the interactive part of the Rx product family as “Ix”, which deals with enumerable sequences (IEnumerable<T>) whereas Rx focuses on the observable sequences (Observable<T>).

Enumerable and Observable sequences are duals

If you have watched Inside the Rx video on Channel9 or read Bart De Smet’s blog post on this topic, you already know that enumerable sequences are the duals of the observable sequences. When the Rx team created the operators for the observable sequences, they also back ported some of those operators to the enumerable world and that is how Ix was born.

Rx and Ix

The following diagram shows the dependencies between major Rx and Ix components. Note that the reactive extensions come with a few more assemblies (related to async support, client profile and more) which are not displayed here.

So like Rx, Ix takes a dependency on:

- CoreEx: Providing the core functionality such as a selection of helpers for disposable objects, schedulers and concurrent data structures.

- System.Observable: Containing IObservable<T> and IObserver<T> interfaces. [Not applicable to .NET 4.0 as it is included in mscorlib 4.0]

The pre-release versions of the Rx product family consisted of various components such as System.Reactive, System.Interactive, CoreEx and System.Observable (for all runtimes except .NET 4.0). In the official release, the component structure is simplified and there are only two assemblies involved: System.Reactive and System.Interactive. All of the types required by those assemblies are now embedded in so for example, the IObservable and IObserver interfaces for runtimes other than .NET 4 now live inside System.Reactive. Same applies to the disposable and scheduler types.

If you are not using Rx family for whatever reason, it is now a good time to do so. I will go as far as saying:

If you are a .NET developer, then you should be using Rx and/or Ix in your projects or you are doing something wrong!

You might say I am taking it too far but I insist! If you are using Rx already, then you know what I am talking about. If you aren’t, you will know it when you start using it. Rx targets various platforms and frameworks including .NET (3.5, 4.0 for both client and full profiles), Silverlight (3, 4, 5), Windows Phone, Xbox and Javascript so you can use it in any .NET project.

How to Get Rx and Ix?

These extensions can be downloaded by following the links on the product landing page on MSDN. You can also find a variety of Rx and Ix components on the official Nuget feed.

What is in System.Interactive?

The primary type in Ix is the EnumerableEx type, which adds a long list of operators (in the form of extension methods) to IEnumerable<T>, plus a few operators for enumerable sequence of numbers (to support average, min, max, etc).When developers look at the list of operators provided by these extensions, most people ask “Why aren’t these included in .NET Framework anyway?”. I think (and hope) that this is just a matter of time before they make their way into the framework. Once you start using these extensions, you will soon find out that you cannot live without them, especially if you use LINQ frequently.

In the next post, I will briefly go through some of the Ix operators to show how it can help you in writing code that is easier to write and read.

Then I came across XMind, which is an open source mind mapping and brainstroming tool. I have been using it for a couple of weeks now and I am very impressed with this product. I am not a mind mapping professional and I am sure more advanced users will find limitations but it does the job for me and many others. You can also upgrade to XMind Pro, which has an annual subscription model and provides some additional features like brainstorming support and export to PDF/Word/PowerPoint.

If you are looking for an affordable (or even a free!) mind mapping tool, make sure you give it a try.

Like many UI elements, some of the properties of the Application object can be accessed from the main UI thread only. For example if you try to access the MainWindow or ShutdownMode properties from any UI thread other than the main one, an InvalidOperationException is raised saying you can only access it from the thread that created it.

The Application object also has a property called Windows, which is an enumerated list of windows created in the application. As you can expect, if you try to access this property from another thread, you will receive an error. Now what happens if you marshal the call back into the main UI thread by calling Dispatcher.Invoke (or BeginInvoke) or access the property from the main UI thread? It will only include the windows that were created on the main UI thread and it won’t enumerate the windows created on the other threads. If you need a list of all windows in the application, you need to manage this yourself. If your application creates windows on multiple threads, I don’t think creating a plain list of all windows created in the application would be a good idea anyway as you may need to handle interactions with those windows differently.

Visual Studio 2010 and .NET Framework 4 Training Kit (June 2010)

Covers:

• C# 4
• Visual Basic 10
• F#
• Parallel Extensions
• Windows Communication Foundation
• Windows Workflow
• Windows Presentation Foundation
• ASP.NET 4
• Windows 7
• Entity Framework
• ADO.NET Data Services
• Managed Extensibility Framework
• Visual Studio Team System

Download Page

Identity Developer Training Kit (June 2010)

Covers:

• Windows Identity Foundation

Download Page

Windows Azure Training Kit (June 2010)

Covers:

• Windows Azure
• SQL Azure
• Windows Azure AppFabric Service Bus
• Windows Azure AppFabric Access Control Service
• Dallas
• Access and Identity in the Cloud
• Windows Azure Storage
• Windows Azure Deployment

Download Page

Windows Server AppFabric Samples (June 2010)

Covers:

• Windows Server AppFabric Cache
• Windows Server AppFabric Hosting

Download Page

Silverlight 4 Training (April 2010)

Covers:

• Silverlight 4
• WCF RIA Services

Download Page

The virtual machine image comes in multiple flavours to support these virtualization technologies: Hyper-V, Windows Virtual PC (for Windows 7) and Virtual PC 2007 SP1. All of these images will expire on 15 Dec 2010.

Refer to Brian Keller’s post for additional details.

According to the Born to Learn blog post and the exam prep guide, the following four major areas are measured in this exam:

This text will be displayed to the users when they try to use an artifact in any of the projects in that project collection:

Note that this only affects those artifacts that are managed by TFS (work items, builds and source control items). Users can continue accessing the reports (handled by SSRS and SSAS) and documents (handled by SharePoint).

This is a minor feature but can be very useful when you need to service the project collection. It is still a good idea to make the users aware of the servicing plans in advance though!