WinRT XAML for Serious Beginners – Where are we? Navigating Win32, MFC, GDI, GDI+, Windows Forms, WPF, Silverlight, Windows Runtime, WinRT and Windows Phone

  • Article

Wow, that’s a lot of acronyms and names! Of course, no one would expect people to know all of those. But in case you do know some of them, this post will help you make sense of how they’re related. And then we can move on to the things which are more relevant to us on our way to learning how to build modern Windows / Windows Phone apps.

The next few sections will help you get a better understanding of where these blog posts will take you.

Part 1: Windows Technologies – Yes, there’s a lot of them!

Windows_technologies

As is common with all diagrams that attempt to present a lot of information in a small amount of space, the diagram above is obviously a great simplification of reality, and is bound to be inaccurate if interpreted under the wrong light. It is not the ultimate diagram of Windows technologies. Rather, it is meant as a helpful visual aid to explain what I will be talking about in this and other posts. So don’t try to over-analyze it.

Just note that the red box contains several key technologies: WinRT XAML, the .NET Framework, the Windows Runtime and a portion of Win32. This bigger red box is usually what people are referring to when they say “Modern Windows Apps” (which includes Windows Phone apps as well, by the way). My posts in this blog will touch mostly on the smaller, shaded red box.

Part 2: XAML is used by several Microsoft technologies

xaml_platforms

XAML has been around for many years now, and it is used in many fundamental Microsoft technologies. In this blog, most of my posts will focus exclusively on XAML used with the Windows Runtime to build Windows 8.1 and Windows Phone apps.

Note, however, that if you’re searching online for help with XAML, you might find articles on Silverlight or WPF, which will usually not help you with WinRT XAML.

Part 3: Let’s make it more confusing – Windows RT!

ms_operating_systems

Once upon a time (2001) there was Windows XP. This was a version of the Windows Operating System, just like there had been Windows NT before it, and just like many years later there was Windows 8.1. Similarly, in 2012, Microsoft released Windows RT, which was a special version of Windows (based on Windows 8) that runs on ARM processors. The letters “RT” in this context don’t necessarily mean anything, and instead they simply denote this specific version of Windows.

The technologies used in building modern Windows Apps, however, are the same for all modern Microsoft Operating Systems: Windows 8.1, Windows Phone 8.1 and Windows RT all implement the Windows Runtime, which means that WinRT XAML works for all of them! .

The one thing to remember

If you take anything out of this post, let it be this: Windows Runtime is “a thing”. WinRT can be two things. Here’s what they mean

  • Windows Runtime: This is the modern façade of the Windows API’s which is used by modern apps. Whereas in the past we had Win32 API’s to call, modern apps now use mostly the Windows Runtime API surface to interact with the system. Whether those API’s still use Win32 or not under the surface is irrelevant in most cases.
  • WinRT can be either:
    • An abbreviation for “Windows Runtime”, as above; or
    • Windows RT, a version of Windows 8 optimized for ARM processors which was released in 2012. In this context, you could think that, just like there was “Windows NT” and “Windows XP”, there was “Windows RT”. The letters RT don’t necessarily mean anything in this context, but rather indicate this specific version of Windows (as “XP” and “NT” indicate other versions).

Wrapping up

The main reason to know the terms I mentioned on this topic is that they might show up in online searches as you look for answers to your app-building questions, and knowing how to tell whether the results you see are relevant to you or not is important and can save you hours of grief. As you’ll see, searching “XAML” on either Bing or Google will bring you results for WPF, Silverlight, Windows Runtime, WinRT and Windows Phone Silverlight, and not all of them will be helpful to you. Now you know!

I hope this post helps clear some of the confusion around the myriad of Microsoft technologies available for developers today. If you have any suggestions or feedback, please leave your comments below and I’ll do my best to address them in a timely manner.

In my next post I will provide some tips that have been very useful to me when searching online for answers to my app-building questions.

Going deeper – Some history for the curious among us

Once upon a time, the way to build a program that presented a graphical user interface (GUI) in Windows using Microsoft technologies would have been one of the following:

  • Write a C / C++ program with a WinMain() entry-point, where you call Win32 API’s to register your graphical Window, show it, and then start processing Windows messages that you receive (WM_PAINT, WM_MOUSEMOVE and hundreds / thousands others) and render things using GDI / GDI+.
  • Write a C / C++ program and leverage MFC to make is easier to show and manage dialogs and controls (Edit boxes, Static labels, Buttons, etc.) and also use the abstractions over GDI to render your graphics.
  • Write a .NET (VB.NET / C# / managed C++) program using Windows Forms, which offered a much easier way to have a GUI than using C / C++ and Win32 directly. The .NET framework did a great job of abstracting the complicated parts of Win32 interop for us and offered an easy-to-use layer on top of it. The resulting forms and dialogs, however, were still based on the same old Win32 controls and GDI / GDI+ rendering. If necessary, you could even go low-level and call Win32 API’s directly using P/Invoke and [DllImport] attributes.
  • Write a .NET (VB.NET / C# / managed C++) program using WPF to show visuals on the screen. This is where things first started to depart from the traditional Win32 / WinMain() / GDI paradigms. WPF programs can still use Win32 API’s if they want to, but they have their own way of rendering content to the screen and supports layering, transparency, even animations out of the box. It was a very nice improvement to the old ways, and it uses XAML (although it’s somewhat different than WinRT XAML).
  • Silverlight offered a model very similar to WPF and enabled building and publishing rich Internet applications that could run inside a browser plugin, again using XAML. It offered nice support for animations and eventually made its way to the Windows Phone platform as one of the ways to build Phone apps. This is by and large deprecated now for Phone development, although Silverlight still finds a lot of use in browsers.

And then came the next new shiny piece of technology, the “Windows Runtime”, which enabled many scenarios in new and fundamentally different ways (such as implementing an app in multiple languages (native C++, managed C# / VB.NET, JavaScript – a single app can be composed of a mix of these languages) and seamlessly call from one to the other as long as some general guidelines are followed.