Page 1
Page 2
It follows that the some sort of application
model or methodology is required to develop against the
.NET platform - this is called the .NET Framework
(and no the term is not borrowed from the Matrix). In the
shell of a very small nut some of the features of the .NET
framework are:
- it is object-orientated
- managed code minimizes deployment
and versioning conflicts
- there are fewer differences and increased
consistency between windows and web applications
- self describing applications (no
more DLL hell)
- much better performance
The .NET Framework includes the class
libraries and the Common Language Runtime (CLF) -
more on this later.
Understandably you could not expect
the same power and functionality from a mobile device that
you get from a desktop and this brings us to the .NET Compact
Framework - a subset of the .NET Framework tailored to the
needs of mobile devices, or as Microsoft calls them - smart
devices - Pocket PC's, smart phones and other PDA's. The
.NET Compact Framework includes much of the functionality
of the .NET Framework except for those services that are
comprised by the restrictions of mobile computing - memory,
CPU speed and interface issues.
Where it all gets exciting from a development
perspective is when we talk about managed code and to adequately
explain this we need to delve a little deeper into the overall
architecture of .NET. If you have any developer blood coursing
through your veins you will have heard the terms Common
Language Runtime (CLR) and Microsoft Intermediate
Language (MSIL) bandied about this last year. From a
coding perspective the CLR is where the rubber meets
the road. The CLR manages memory, security, versioning and
debugging. Initially only VB and C# will target the .NET
Compact Framework and be supported on the Pocket PC. The
CLR will support similar functionality across both of these
language specifications. This in itself is a boon to developers
since the same type systems are now common to all .NET languages.
For example, an integer in C# is the same as an integer
in VB. The term managed code applies since the same code
can be managed or compiled for different runtime environments.
Managed applications are target platform independent and
do not need to be recompiled in the traditional sense for
different platforms - they run on top of the specific CLR
for the targeted platform.
When you compile your code in .NET the
compiler creates processor independent Microsoft
Intermediate Language (MSIL). This code will run on
any targeted platform for which there is a Microsoft .NET
Framework - in the instance of the Pocket PC platform you
would require the .NET Compact Framework. Beginning to see
the picture?
But wait it gets better! <g>.
Before you start to think that this is all well and good
but isn't this just interpreted code? The last part of the
managed code execution process is the Just-In-Time
compilation where the IL code is compiled into native code
for the specific CPU platform you are coding! This is performed
once, on a step by step basis as each function is executed.
Once compiled the code segments are reused without any additional
compilation overhead. I have of course dramatically oversimplified
the process of the translation of MSIL into native
code, specifically leap-frogging entire subjects involving
the Native Support Library and Platform Adaption
Layer - in the sincere hope that developers will be
spared the need to understand these intricacies.
So how do you access this mobile
device development utopia? The Smart Device Extensions
(SDE) for Visual Studio .NET provide the IDE access to the
.NET Compact Framework. Currently the Smart Device Extensions
are a separate download but in the future they will be integrated
into Visual Studio .NET. The .NET Compact Framework Technology
Preview that was released at the October 2001 PDC conference
will be replaced by a Beta version some time in late April
or May. If this is still as clear as mud to you stop by
the forums
and join in the confusion with the rest of us.
Previous Page