So, day 1 of DevWeek. Lots and lots of Windows 8 and WinRT, as you would expect. The keynote had some actual content in it, fleshed out some of the details of how your
apps linked into the
Metro infrastructure, and confirmed that there would indeed be an enterprise version of the app store available for
Metro apps.)
However, that's, not what I want to focus this post on. What I do want to focus on is this:
Windows 8 does not make .NET developers obsolete.
Phew!
.NET in the New Ecosystem
In all the hype around Windows 8 the past few months, a lot of developers have got the impression that .NET has been sidelined in Windows 8; C++ and COM is back in vogue, and HTML5 + JavaScript is the New Way of writing applications. You know .NET? It's yesterday's tech. Enter the 21st Century and write <div>! However, after speaking to people at the conference, and after a couple of talks by Dave Wheeler on the innards of WinRT and how .NET interacts with it, my views on the coming operating system have changed somewhat.
To summarize what I've picked up, in no particular order (none of this is official, just my sense of what's been said by various people):
Metro apps do not replace desktop
apps. That is, Windows 8 fully supports .NET desktop applications written for every other previous version of Windows, and will continue to do so in the forseeable future. There are some
apps that simply do not fit into
Metro. They do not fit into the touch-based paradigm, and never will. Traditional desktop support is not going away anytime soon.
The reason Silverlight has been hidden in all the
Metro hype is that
Metro is essentially based on Silverlight design principles. Silverlight developers will have a much easier time writing
Metro apps than desktop developers, as they would already be used to all the principles of sandboxing and separation introduced with Silverlight. It's desktop developers who are going to have to adapt how they work.
.NET + XAML is equal to HTML5 + JS in importance. Although the underlying WinRT system is built on C++ & COM, most application development will be done either using .NET or HTML5. Both systems have their own wrapper around the underlying WinRT infrastructure, hiding the implementation details.
The CLR is unchanged; it's still the .NET 4 CLR, running IL in .NET assemblies. The thing that changes between desktop and
Metro is the class libraries, which have more in common with the Silverlight libraries than the desktop libraries. In
Metro, although all the types look and behave the same to callers, some of the core BCL types are now wrappers around their WinRT equivalents. These wrappers are then enhanced using standard .NET types and code to produce the
Metro .NET class libraries.
You can't simply port a desktop app into
Metro. The underlying file IO, network, timing and database access is either completely different or simply missing. Similarly, although the UI is programmed using XAML, the behaviour of the
Metro XAML is different to WPF or Silverlight XAML. Furthermore, the new design principles and touch-based interface for
Metro applications demand a completely new UI. You will be able to re-use sections of your app encapsulating pure program logic, but everything else will need to be written from scratch. Microsoft has taken the opportunity to remove a whole raft of types and methods from the
Metro framework that are obsolete (non-generic collections) or break the sandbox (synchronous APIs); if you use these, you will have to rewrite to use the alternatives, if they exist at all, to move your
apps to
Metro.
If you want to write public WinRT components in .NET, there are some quite strict rules you have to adhere to. But the compilers know about these rules; you can write them in C# or VB, and the compilers will tell you when you do something that isn't allowed and deal with the translation to WinRT metadata rather than .NET assemblies.
It is possible to write a class library that can be used in
Metro and desktop applications. However, you need to be very careful not to use types that are available in one but not the other. One can imagine developers writing their own abstraction around file IO and UIs (MVVM anyone?) that can be implemented differently in
Metro and desktop, but look the same within your shared library.
So, if you're a .NET developer, you have a lot less to worry about. .NET is a viable platform on
Metro, and traditional desktop
apps are not going away. You don't have to learn HTML5 and JavaScript if you don't want to. Hurray!
