I Got Rhythm

E4D Expert Days – I’ll be there

aelij — Sat, 04 Jun 2011 11:12:33 +0000

חברת E4D עורכת גם השנה את כנס Expert Days לטכנולוגיות מיקרוסופט, כך שאם אתם מפתחים, ראשי צוות, בודקי תוכנה או ארכיטקטים – זה המקום להיות בו.

הכנס נערך בין התאריכים 10-14.7.2011 ובמהלכו תוכלו למצוא עשרות הרצאות וסדנאות הנוגעות בכל הטכנולוגיות החמות והרלוונטיות ביותר של מיקרוסופט. כך לדוגמא נכללים בכנס סדנאות בנושא ‎.NET , Dynamic CRM, AZURE, WCF, Silverlight, Windows Phone ועוד רבות אחרות. בכל סדנא תוכלו למצוא ידע מעשי רב וכלים של ממש שישמשו אתכם באופן מיידי, כך שהשקעת הזמן שלכם בסדנאות עומדת להשתלם לכם.

בין כל המומחים המרצים בכנס, תוכלו למצוא השנה גם אותי ואשמח מאוד אם תבואו לסדנא שאני מעביר בנושא Windows Phone (אם תציינו שהגעתם דרכי – קוד מרצה 114– תקבלו 20% הנחה לרישום לסדנא שלי).

אירוע הפתיחהשל Expert Days הוא אירוע ללא תשלום, המתקיים השנה בתאריך 10.7.2011. האירוע כולל מסיבת קוקטייל, מפגש מינגלינג וסדרה של הרצאות מקצועיות שגם הן כמובן חינמיות. באירוע הפתיחה עצמו תוגרל פלטפורמת XBOX + Kinnect.

מחכה לראות אתכם שם,

אלי ארבל.

Slides from my Windows Phone + Azure lectures

aelij — Sat, 04 Jun 2011 10:30:15 +0000

Last month I gave a series of lectures in various campuses around Israel about Windows Phone and Azure.

The lecture included an introduction to Silverlight, Windows Phone, and a short overview of the Windows Azure Toolkit for Windows Phone.

During August 11-12 there will be a workshop for any student who needs assistance in submitting his app for the contest Microsoft is holding. You can find more details at the Microsoft Israel Students Facebook page.

Download slides

WCF + Tasks

aelij — Sat, 04 Jun 2011 09:04:29 +0000

In WCF we can use the APM pattern to create an asynchronous client. For example, consider the following service contract:

[ServiceContract]

public interface IHello

{

[OperationContract]

string Greet(string name);

}

An APM-enabled version of this interface would look like this:

[ServiceContract(Name = "IHello")]

public interface IHelloApm

{

[OperationContract(AsyncPattern = true)]

IAsyncResult BeginGreet(string name, AsyncCallback asyncCallback, object asyncState);

string EndGreet(IAsyncResult asyncResult);

}

WCF’s client can automatically generate a proxy that implements this interface (e.g. by inheriting from ClientBase).

However, in .NET 4.0, we now use Tasks, which provide a far more convenient API than APM. Fortunately, there’s an easy way to convert one to the other, by using the FromAsync methods in TaskFactory. This would require you to:

Create the above APM interface.
Create a client class.
Wrap each method pair (Begin & End) in a method that calls FromAsync and returns a Task.

I decided this was way too much of a hassle, and apparently the good folks at Microsoft thought along the same lines. One of the samples in the Async CTP contains an IWsdlImportExtension (called TaskWsdlImportExtension) that causes SvcUtil (the same mechanism used by “Add Service Reference” in VS) to generate methods that return Tasks. If you’re using SvcUtil to generate your proxies, you’re good to go. You can use the sample generator even without relying on the CTP itself.

But what if you write your own interfaces? Wouldn’t it be nice if you could simply create the following interface and have the runtime figure it out for you?

[ServiceContract(Name = "IHello")]

public interface IHelloAsync

{

[OperationContract]

Task<string> Greet(string name);

}

Side (but important) note: You may ponder – why not just use Task.Factory.StartNew() method and pass a delegate that calls the original (synchronous) method? Because then you’d be wasting a thread that will be kept waiting for I/O! .NET utilizes I/O Completion Ports when you use the APM methods, which provides an efficient way of waiting for I/O to complete.

Introducing TaskClient

TaskClient is very much like ClientBase (in fact, it implements the same interface, ICommunicationObject), only it uses code generation (Reflection Emit) to generate both the async interface and a class that implements the above (IHelloAsync) interface, by invoking FromAsync for each method. Sample usage:

var taskClient = new TaskClient<IHelloAsync>();

taskClient.Channel.Greet(“Seattle”).ContinueWith(t => Console.WriteLine(t.Result));

Channel is IHelloAsync, and Greet returns a Task. We use a continuation to write the result to the console. When combined with Async CTP’s await keyword, this makes calling services that much easier.

The generated class looks something like this:

publicclassHelloAsyncClient : IHelloAsync

{
privatereadonlyFunc<IHelloApm> _channel; 
public HelloAsyncClient(Func<IHelloApm> channel)

{

_channel = channel;

}
public Task<string> Greet(string name)

{

IHelloApm channel = _channel();

return

Task.Factory.FromAsync(

new Func<string, AsyncCallback, object, IAsyncResult>(channel.BeginGreet),

new Func<IAsyncResult, string>(channel.EndGreet), name, null, TaskCreationOptions);

}
public TaskCreationOptions TaskCreationOptions { get; set; }

}

Note that the channel is lazily evaluated on each call. This allows for more sophisticated channel management options.

Known limitations:

TaskClient currently won’t handle overloaded methods in the interface.
Ref/Out parameters are not supported (nor will they be; they do not make sense in async interfaces).
The interface must be public.

A word of caution: While the code attached to this post works, it wasn’t thoroughly tested. So, if you would like to use this in a production environment, we are planning on making it available in a future release WCF Contrib. This is a well established library of WCF extensions. I suggest checking it out, and waiting for more news.

Attachment: ServiceModelTasks.zip

*N Async, Part 1

aelij — Fri, 12 Nov 2010 17:49:07 +0000

You’ve all read about the asynchrony promise of C# 5 (if you haven’t, I highly recommend reading Eric Lippert’s series about the subject or this post won’t make much sense). I think it’s a great step forward, and it would make asynchronous programming all a lot easier.

We already know how to think in Tasks instead of threads, .NET 4.0 taught us that.

We already know how to use continuations (or at least some weak form of it), C# 2.0 iterators taught us that.

So, as an experiment*, I went ahead and implemented a weak form of the await/async magic** using “the materials in the room”, i.e. tasks and iterators – minus the syntactic sugar, of course. Let’s have a look.

First, A Sample

In C# 5 we would have (taken from Anders’ Netflix sample):

async void LoadMoviesAsync(int year)
{
    while (true)
    {
        var movies = await QueryMoviesAsync(year, imageCount, pageSize, cts.Token);
        if (movies.Length == 0) break;
        DisplayMovies(movies);
    }
}

While in my implementation it would look like this:

IEnumerable<Task> LoadMovies(int year)
{
    while (true)
    {
        var moviesTask = Async.Await<Movie[]>(result =>
            QueryMovies(result, year, imageCount, pageSize, cts.Token));
        yield return moviesTask;
        var movies = moviesTask.Result;
        if (movies.Length == 0) break;
        DisplayMovies(movies);
    }
}

What’s going on here?

First of all, as you can see, the methods look very similar. We have created an iterator that allows us to start running the method and break after every yield. The implementation of Async.Await() method is surprisingly simple:

The Await() method simply creates an enumerator, which starts up the state machine.
It calls MoveNext(), which executes the method up to the next yield.
We get a Task from the yield, and attach a continuation to it, which calls MoveNext() again, and so on.

public static Task Await(Func<TaskCompletionSource, IEnumerable<Task>> func)
{
    var completionSource = new TaskCompletionSource();
    Await(func(completionSource));
    return completionSource.Task;
}
 
public static void Await(IEnumerable<Task> iterator)
{
    IEnumerator<Task> enumerator = iterator.GetEnumerator();
    Run(enumerator);
}
 
private static void Run(IEnumerator<Task> enumerator)
{
    if (enumerator.MoveNext())
    {
        enumerator.Current.ContinueWith(t => Run(enumerator));
    }
}

Why do we need TaskCompletionSource?

The return value of the iterator method must always be IEnumerable. But what if we want to return a value from a method? Remember, it doesn’t execute synchronously anymore! That is why methods that (originally) do not return void, have the option of adding an argument of TaskCompletionSource. In the method, we can call TaskCompletionSource.SetResult() to set the result. We also return the Task the TCS creates, so the caller could access the result. The overload of Await() that we use in this case simply wraps around this functionality, and enables a more concise syntax.

When an asynchronous method has no return value, TaskCompletionSource is not needed.

What’s missing?

In the next installment(s) we will discuss:

Task Schedulers (how to make sure we’re in the right context for UI operations)
Limited exception handling

* Yes, it means I wouldn’t recommend using this in “real” code – just wait for C# 5. This is just for fun.

** And I use the term very figuratively.

Creating the CodeValue Blogs Pivot

aelij — Fri, 12 Nov 2010 12:23:00 +0000

Pivot is a Microsoft Silverlight control which can visualize collections of data, filter and sort them in a very appealing manner. To see what I mean, check out the CodeValue Blogs Pivot:

http://codevalue.net/blogspivot/

This allows you to browse through our blogs, and to filter them by tags, dates and authors.

Pivot uses a proprietary XML format, called CXML. An item in the collection is comprised of an image, a URI and any other metadata you choose to add. I’ve created a small utility which takes an RSS feed, transforms it into CXML, creates snapshots of all site images and adds metadata (author, date and tags).

In addition, because Pivot presents many large images, you can optionally (highly recommended!) configure the collection to use Deep Zoom (which breaks down your images to pyramids, much like how Google Maps works). To do that, you can use Pauthor, a free utility that can be found on CodePlex. The attached code contains a batch file with a sample that shows how to use it.

Lastly, since Deep Zoom uses many files (for example, 140 Pivot items might generate ~7500 Deep Zoom files – depending on image sizes), uploading them individually can be a real pain. Fortunately, many website hosts support uploading archives (such as ZIP files) and unarchiving them on the server.

Some interesting facts about the code:

I used Parallel.ForEach() to parallelize the creation of items. Note that I’m assuming LINQ to XML is okay for cross-threaded reading (which is not documented, and I wouldn’t use in production code), but for writing (a single point in the end) I added a lock.
The UriImageCreator class relies on the Windows Forms WebBrowser control, but uses WPF’s Dispatcher to handle the message loop. This is because Dispatcher makes it easier to marshal calls into the message loop. I’ve borrowed some of this code from Pauthor (which uses it for its HTML template feature), and made it thread-safe. Note it is using a single thread to load the WebBrowser controls (so we only have one message loop), but websites will be loaded asynchronously because of how the WebBrowser control works.
I used NDesk.Options to parse command-line arguments. It provides a very neat interface with object initializers and lambda expressions.

Attachment: Rss2Cxml.zip

Goodbye and hello, as always

aelij — Sun, 22 Aug 2010 13:53:11 +0000

Today I’m saying goodbye to Sela. I’ve been a senior consultant at Sela for the past 9 months, and it has been a good experience for me; I’m much more experienced with giving lectures and teaching classes. I’ve also had a chance to meet and work with some of the leading experts in their fields.

But today is a new day. I’m off to a completely new adventure for me – starting a new company, called CodeValue. Along with a group of very talented people, we intend to form a company that would build extremely essential developer tools, and also provide consulting services of the highest quality.

Go on, browse to our new website and check out the team. You’ll want to book us for your next project.

Reflectoron: Transform and Roll Out!

aelij — Thu, 15 Jul 2010 07:35:00 +0000

A few months ago I’ve decided to write a Prism tutorial by building a WPF UI for the .NET Reflector.

Red Gate, the owner of Reflector, liked the idea so they asked me to write it for their magazine, Simple Talk.

Today the article was published, and you may read it on the Simple Talk website. I hope you enjoy it.

http://www.simple-talk.com/dotnet/.net-framework/reflectoron-in-prism-a-wpf-mvvm-tutorial/

* My whimsical choice of titles continues; I’ve decided to name the thing “Reflectoron” because it’s Reflector + Avalon. It also reminded me of the Transformers, hence the blog post title.

WPF Controls Class Diagram

aelij — Fri, 25 Jun 2010 18:36:00 +0000

I’ve prepared a class diagram for my students of main WPF controls, divided into Decorators, Panels, Content Controls and Items Controls. The diagram was generated using the new Visual Studio 2010 Visualization and Modeling Tools (with a bit of manual cleanup).

I’ve also attached an XPS version and the DGML source.

Attachment: WPF Controls Class Diagram.zip

Peaceful Coexistence

aelij — Fri, 25 Jun 2010 18:21:00 +0000

One of the new features in .NET 4.0 is Side-By-Side In-Process (SxS InProc) execution of older CLRs (e.g. .NET 2.0). Previously, SxS was supported only in different processes. If you look it up, you’ll find these two (yet to be updated) blog posts by the CLR team, an MSDN Magazine article as well as one in the MSDN Library. You can get a good review of supported scenarios and some code, but what they all sorely lack is a working sample. (Update: There’s a new detailed article from the CLR team.)

The common scenario for SxS would be a host (such as Outlook) that loads .NET add-ins which are configured to run in different versions of the CLR. In this case, it is sufficient to provide an app.config that would tell the host which .NET version you need. The default COM activation behavior in .NET 4 is to use the CLR version the component was compiled with.

The scenario I’ve been trying to solve isn’t mentioned in any of these articles; I would like to host a WPF 3.5 control in a WPF 4 application. Why? Because I’m using a crucial 3rd party control that unfortunately doesn’t work with .NET 4.

I remembered that there was already a way to host WPF controls from different AppDomains, by using the .NET Add-In framework (System.AddIn). This article from the CLR Add-In team blog has a nice sample that shows how it’s done.

So, we will utilize the FrameworkElementAdapters class to help us convert a FrameworkElement to a Win32 handle, pass it from the CLR v2 component via COM and then convert it back to a FrameworkElement in CLR v4. Sounds complicated? Maybe. But it will take only a handful of code lines to accomplish.

Creating the Control

First, we create a WPF user control. Then, we create a COM interface that contains the handle and any other properties we may want to use on “the other side”.

[Guid("45421E7C-EA8E-4987-A669-5334795D1627")]
public interface IMyControl
{
    IntPtr Handle { get; }
}

Now, we implement the interface using the FrameworkElementAdapters class:

[Guid("4F03582A-8ECA-4A27-9E4E-00AB54078592")]
    public class MyControl : IMyControl
    {
        private UserControl1 _instance;
        private INativeHandleContract _contract;
 
        public MyControl()
        {
            _instance = new UserControl1();
            _contract = FrameworkElementAdapters.ViewToContractAdapter(_instance);
            Handle = _contract.GetHandle();
        }
 
        public IntPtr Handle { get; private set; }
    }

We must also tag the assembly (or the required types) with the [ComVisible(true)] attribute.

Now, for the host, we simply reference the assembly containing the user control and instantiate the COM object. We also need to provide a simple implementation of INativeHandleContract (see the sample code).

_control = (WpfSxsControls.IMyControl)Activator.CreateInstance(
    Type.GetTypeFromCLSID(new Guid(“{4F03582A-8ECA-4A27-9E4E-00AB54078592}”)));
Content = FrameworkElementAdapters.ContractToViewAdapter(
    new NativeHandleContract(_control.Handle));

Lastly, there’s the issue of COM registration. You can either register the COM object in the registry, which can cause deployment problems (mainly during uninstall). To do it quickly from VS, simply check the following box in the Build tab of the control assembly’s project properties:

Or you can use Registration-Free COM. The provided sample code uses the latter method.

Caveats

You’re using COM, which means everything you’re exposing from your control needs to be COM-patible.
You’re using COM, which means passing delegates (and that includes registering to .NET events) becomes a lot less trivial.
Debugging can be a serious issue; it seems VS is not capable of attaching to the other (older) CLR.
Some work needs to be done to handle focus changes.

You can ameliorate some of these issues by using COM only to activate the older CLR and then use some IPC technology (e.g. WCF, Remoting) to communicate with your control. I strongly recommend this approach if you have a complex object model.

Running the Sample

Just compile and run. The C++ project in the solution is used only to generate a Win32 Resource file which embeds the manifest that is required for reg-free COM. You can see that it is working if the title of the windows shows CLR v4 and above the first text box there’s a text indicating it’s coming from CLR v2.

Attachment: WpfSxs.zip

MIX10

aelij — Sun, 21 Mar 2010 20:59:54 +0000

I recently attended the Microsoft MIX10 conference in Las Vegas. I had a nice time, but mostly because of the location; Las Vegas is an interesting place. The conference itself was mainly a PR for the new Windows Phone, but there were a couple of very interesting lectures I would like to share:

The Art, Technology and Science of Reading
by Kevin Larson (blog)
http://live.visitmix.com/MIX10/Sessions/DS07
This is a fascinating lecture about how we (humans) process words visually. Kevin discusses several studies his group conducted on the subject, with some surprising results.

The Elephant in the Room
by Nishant Kothary (blog)
http://live.visitmix.com/MIX10/Sessions/DS13
Nishant effectively demonstrates how we tend to form ill-advised bias towards our peers, and how it applies to the process of software design.