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!
