C# everywhere Building cross-platform apps with Xamarin Gill Cleeren @gillcleeren.
Transcript of C# everywhere Building cross-platform apps with Xamarin Gill Cleeren @gillcleeren.
Hi, I’m Gill!Gill CleerenMVP and Regional Director.NET Architect @ OrdinaTrainer & speaker
@gillcleeren
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?
• 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
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
C# Is AwesomeWe (l) C#. This is why.
• LINQ Support
• Work With XML Easily XDocument
• Event Handling & Delegates
See the Difference – Attributed Strings C# with XamarinObjective-C
C# is a bit easier than Objective-C. A tiny bit.
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
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;}
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
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
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
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