C# everywhereBuilding cross-platform apps with Xamarin

Gill Cleeren@gillcleeren

Hi, I’m Gill!Gill CleerenMVP and Regional Director.NET Architect @ OrdinaTrainer & speaker

@gillcleeren

gill@snowball.be

Agenda

• What is Xamarin then? Can I eat it?• Code re-use: myth or reality?• Shared projects: because sharing is caring, right?• PCL where L stands for Love?

• And what about Xamarin.Forms?

What is Xamarin then? Can I eat it?

What is Xamarin?

• Xamarin enables developers to reach all major mobile platforms!• Native User Interface• Native Performance• Shared Code Across Platforms• C# & .NET Framework

What is Xamarin?

• Toolset on top of Visual Studio• Output and build to Android, iOS and Windows• Native apps

• Commercial product• $2000/year for business subscriptions

• The “No-Compromise” approach

Advantages of using Xamarin

• Full control• Familiar development environment• Native controls • Native performance• Code reuse• Active component store

Disadvantages of Xamarin

• You need a license• It’s not a shared UI Platform• You need to understand each platforms UI controls and UX paradigms• You need a Mac for iOS dev

The promise: C#. Everywhere.

Silo’d Approach

Build Apps Multiple Times• Multiple Teams• Multiple Code Bases• Different toolsets

Write Once, Run Anywhere Approach

• Lowest common denominator• Browser fragmentation•Developing & designing for 1 platform, happen to get other platforms

Black Box

Xamarin’s Unique Approach

•Native User Interface•Native Performance• Shared code across platforms• C# & .NET Framework• Full API Coverage

And where is C# coming into play then?

C# Is AwesomeWe (l) C#. This is why.

• LINQ Support

• Work With XML Easily XDocument

• Event Handling & Delegates

C# Is Awesome – JSON Made EasyWe (l) C#. This is why.

See the Difference – Attributed Strings C# with XamarinObjective-C

C# is a bit easier than Objective-C. A tiny bit.

C# with XamarinObjective-C

C# is a bit easier than Objective-C. A tiny bit.

C# with XamarinJava

C# & Async with Xamarin

And compared to Java…

Write Beautiful & Maintainable Code

We’ll wait here then.

Write Everything in C#

iOS, Android, Windows, Windows Phone, Mac

2.5+ Billion Devices!

Anything you can do in Objective-C or Java can be done in C# and Visual Studio with

Xamarin!

100% API Coverage

Android runtime model

• Mono VM + Java VM execute side-by-side (supports both Dalvik and ART)• Mono VM JITs IL into native code and executes most of your code• Can utilize native libraries directly as well as .NET BCL

iOS Runtime model

• Native ARMx code – no JIT is being used here• Mono runtime provides system services such as Garbage Collection• Full access to iOS frameworks such as MapKit as well as .NET BCL

DEMOLooking at a complete Xamarin application

Code re-use: myth or reality?

Code sharing in general

• Large chunks of the code we write are shareable between platforms• Data access• Service access• Services• “ViewModels”

• What isn’t shareable by default• View/UI code

• Different situation with Xamarin.Forms…• Event handlers• Services bound the platform

Statistics from Xamarin for some “basic” apps

Components22%

Services18%

Shared24%

Windows Phone10%

iOS14%

Android12

12%

Code

ComponentsServicesSharedWindows PhoneiOSAndroid

Code sharing options

• The ultimate goal is reaching an architecture as shown below• A layered architecture will help us here!

Code sharing options

• Shared projects: • allows organizing the shared code• #if directives for platform specific code

• PCL• “include” the platforms we want to support• Abstract to interfaces where platforms have specific implementations

Creating a Xamarin cross-platform solution• We start from an *.sln file (solution file)• Make your choice: shared project or PCL• Shared project: simply plugs in the code into each platform, use #if to control

code execution• PCL: Portable Class Library (PCL) is a special type of project that can be used

across disparate CLI platforms such as Xamarin.iOS and Xamarin.Android, as well as Silverlight, WPF, Windows Phone and Xbox

Creating a Xamarin cross-platform solution

Platform divergence:Dealing with multiple platforms• Some concepts are the same on all platforms• Feature selection via tabs or menus• Lists of data and scrolling• Single views of data• Editing single views of data• Navigating back

Platform divergence:Dealing with multiple platforms• On the other hand, some are platform-specific• Screen sizes• Navigation metaphors• Keyboard• Touch• Gestures• Push notifications

Platform divergence:Dealing with multiple platforms• And then, some are device-specific• We’ll need to write code to check if a feature is present or offer an alternative

(map for location selection instead of GPS)

• Typical cases:• Camera• Geo-location• Accelerometer, gyroscope and compass • Twitter and Facebook• Near Field Communications (NFC)

Dealing with divergence:Abstracting platforms• Inheritance/base classes can be created in the shared projects

• Base functionality already created (cross-platform!)• Limited somewhat since C# only allows base single inheritance

• Xamarin.Forms • Uses a common, abstracted base for the UI creation

• Xamarin Mobile augments the .NET Base Class Libraries with a set of APIs that can be used to access device-specific features in a cross-platform way• Media Picker: taking photos or selecting a media item• Geolocation• Address book access• Code can be written in shared code since it’s ignorant (for us) to the used platform

Dealing with divergence: divergent platform code• Some cases won’t work with just abstraction• Conditional compile can help out

• __MOBILE__ is true for iOS and Android projects• __IOS__ can be used to detect iOS devices• __ANDROID__ can be used to detect Android devices• __ANDROID_XX__ can be used to detect specific Android API version

• __ANDROID_11__• __WINDOWS_PHONE__ and __SILVERLIGHT__ can be used to detect Windows Phone

devices

Using precompiler statementspublic static string DatabaseFilePath { get { var filename = "MwcDB.db3";#if SILVERLIGHT var path = filename;#else

#if __ANDROID__ string libraryPath = Environment.GetFolderPath(Environment.SpecialFolder.Personal); ;#else // we need to put in /Library/ on iOS5.1 to meet Apple's iCloud terms // (they don't want non-user-generated data in Documents) string documentsPath = Environment.GetFolderPath (Environment.SpecialFolder.Personal); // Documents folder string libraryPath = Path.Combine (documentsPath, "..", "Library");#endif var path = Path.Combine (libraryPath, filename); #endif return path;}

DEMOXamarin.Mobile

Shared projects

Before Shared Projects…

• We could use file linking• Add existing item >> Add as Link• File isn’t duplicated, instead, it lives in the original location only

• When compiling, it is part of the compiled output• Can include precompiler statements to have different behaviour on different

OS’s• Disadvantage: refactoring not ideal + testing not great

Today: Shared Projects

• AKA Shared Resource Projects• Allow writing code which is shared between multiple target projects incl Xamarin• New project type makes it possible to share on project-level

• IDE knows this, supports this

• Also supports precompiler statements• Different coloring based on the application

• Only 1 copy of the file exists• Supports testing and refactoring • Supported since XS 5 and VS 2013 Update 2• Also works with Windows Phone 8 and Windows 8.1

Shared Projects internals

• Shared project has no DLL output• Code gets compiled in each project which references it• Project gets copied into each referencing project

DEMOShared projects

PCLs

What’s a PCL then?

• When creating a regular project, the DLL is restricted to that platform only• By default, a WP8 Class Library won’t work from Xamarin

• A PCL overcomes this: we can choose the platforms we want our code to run on• Choices are the Profile identifier: describes which platforms are supported• Based on selection, features may/may not be available

Selecting the right targets

Only select the targets you need in your application. This will give you a broader API! This selects the profile!

Missing profiles

• Not all combinations are allowed, simply because they aren’t defined by Microsoft• IDE will try to select the closest match (or an error if you have done

something you shouldn’t )

Advantages of PCLs

• Centralized code sharing – write and test code in a single project that can be consumed by other libraries or applications• Refactoring operations will affect all code loaded in the solution (the

Portable Class Library and the platform-specific projects)• The PCL project can be easily referenced by other projects in a

solution, or the output assembly can be shared for others to reference in their solutions

Disadvantages of PCLs

• Because the same Portable Class Library is shared between multiple applications, platform-specific libraries cannot be referenced (eg. Community.CsharpSqlite.WP7)• The Portable Class Library subset may not include classes that would

otherwise be available in both MonoTouch and Mono for Android (such as DllImport or System.IO.File)

• Using abstractions (DI or Provider pattern) can help circumventing some of these restrictions!

Going around PCL limitations

• PCLs uses the smallest common denominator• All features in the PCL (and the profile) must be available on all targets

• By default, no support for File, SteamReader…

• Solutions: • Rely on what’s there (often lower-level abstractions)• Build your PCL with abstractions (interface, events…) and implement the

abstraction in your platform specific code• Events• Concrete implementations of interfaces• IOC

DEMOPCLs

And what with Xamarin.Forms?

So what is Xamarin.Forms really?

• Xamarin.Forms is a cross-platform natively backed UI toolkit abstraction that allows developers to easily create user interfaces that can be shared across Android, iOS, and Windows Phone• Allows rapid development of cross-platform UIs• Abstraction on top of UI elements• More code sharing than ever before• Still native apps• Still native performance and look and feel

With Xamarin.Forms

With Xamarin.Forms:

more code-sharing, native controls

Shared UI Code

Main features

• RAD, forms-based app creation• 40+ Pages, Layouts, and Controls

• Build from code behind or XAML

• Two-way Data Binding• Navigation• Animation API• Dependency Service• Messaging Center• Support for

• Android 4.0+• iOS 6.1+• Windows Phone 8.0+ (Silverlight only)

Shared UI Code

Getting started

• Resulting solution:

• Note that XS doesn’t support the WP8 currently• Will open but not load/compile

• Shared Project or PCL holds shared code, used by all other projects• iOS, Android and WP8 projects contain platform-specific UI code

DEMOCode sharing with Xamarin.Forms

Creating a XAML-based application

• Add a XAML file (ContentPage)• Also creates the code-behind

DEMOXAML-based Xamarin.Forms

Summary

• Xamarin == native cross platform• Strong backing of shared projects and PCLs help code re-use• Xamarin.Forms goes the extra mile• Still somewhat limited though