The past few days I've posted
MonoDroid and
MonoTouch apps for
Monospace - and while they aren't perfect examples of the sort of code-sharing and efficiency that's possible with Mono I thought it would be interesting to compare them as the functionality they offer is very similar.
First, these are the high-level code metrics (as calculated by Visual Studio):
Unfortunately I didn't align the namespaces very well. Here's the explanation:
Total lines of code (TLOC)
Mono-for-Android:
802 lines
MonoTouch:
1,420 lines (2,033 - 613 in SQLite)
At first glance, the MonoDroid app 'wins' with just half the code of the MonoTouch version. I've ignored the SQLite library and the MonoTouch.Dialog framework as they aren't "user code", and any non-.cs files (eg XML markup).
Common code
Although difficult to 'see' because I've rushed these codebases into the public domain, there is a bit of 'code re-use' in these apps (ie. it was only written once, and the c# shared across both platforms using the power of Mono :)
ConfXml ==
MIX10Xml == approx 200 lines of business objects (DTOs mainly) that match the serialized
conf.xml
format that is the shared data structure for both platforms.
The
ConceptDevelopment.Kelvin
code is also shared (different sizes in each aren't relevant for now).
Removing the common code from the comparison results in these totals:
Mono-for-Android:
575 lines (802-199-28)
MonoTouch:
1,145 lines (1,420-178-97)
"Re-used" code
Mono-for-Android's
Main.cs::DeserializeConferenceFile, LoadWhatsOn
and MonoTouch's
AppDelegate.cs::FinishedLaunching
both contain "very similar" code in the form of the
conf.xml
deserializer and parser. In MonoTouch it's 70 lines and in MonoDroid it's 307 lines. The MonoTouch version is heavily assisted by the Linq/MonoTouch.Dialog code in
HomeController
(another 150 lines or so) which explains part of the difference... but what is
shared is the deserialization logic and a number of Linq statements that help parse it for display. These would be harded to shift into a common library due to the dependency on MonoTouch.Dialog - but there was definitely an efficiency gain by having the code already written and tested on one platform before porting to the other. I'll adjust both by the same 'average' LOC count to try and reflect the 'copy/paste but modify' efficiency gain.
Mono-for-Android:
375 lines (575-200)
MonoTouch:
945 lines (1,145-200)
Feature parity
Adjust the MonoTouch solution to allow for the fact that it implements the Map feature that is not available on MonoDroid - 118 lines of code across a few classes.
MonoTouch:
827 lines (945-118)
What's left?
Once we've removed the libraries, the shared data structure, common code and allowed for some "copy/paste re-use", what's left to differentiate the two codebases? Basically just the UI and the code that binds our DTOs to it.
| Mono-for-Android | MonoTouch (iOS) |
Code | 375 lines | 827 lines |
'markup' | 14 AXML | 1 XIB |
Views | 7 Activities | 9 ViewControllers |
DataSources | 6 Adapters | 5 TableViewSource |
Some notes on the difference:
- There are 350 lines of AXML to define the layouts used in MonoDroid - the equivalent task in MonoTouch is done mostly in C#, significantly contributing to the LOC difference. I could have implemented a lot of that MonoTouch layout in XIBs using InterfaceBuilder - I just don't like doing it that way.
- The
UITabBarController
takes more code to setup than
OnCreateOptionsMenu
.
- The iOS
SQLite
implementation of saving Favorites is more verbose than the XML-serialized-file solution used on Android.
- The MonoTouch source is almost 2 years old, and in some places isn't as succinct as it could be.
Conclusion
So is MonoTouch instrinsically more verbose than MonoDroid? I don't think so - it depends greatly on your preference for constructing your Views (XIBs or in-code). The more important question: does building with Mono* make it easier to port your app to other mobile platforms... and the answer is
YES! In future
this code might get tidied up into a
good example of a cross-platform app... in that case I'll re-examine the stats to make an even better case.
Look at it this way: the iOS app took 1,400 lines of code (it was written first). For an additional 375 LOC (plus some layout XML) we got an Android port - almost for free!
Thankfully it sounds like
Xamarin Studio is coming along nicely.