Xamarin

Xamarin allows two different ways of creating applications, based on the amount of code reusability and customization.

The first approach is the Traditional Native Approach wherein platform-specific apps using Xamarin.iOSiOS and Xamarin.Android can be made. This way of creating apps is generally used when there is a lot of customization specific to the platform is required as it allows direct access to platform-specific APIs. Xamarin.iOS is used for iOS applications and Xamarin.Android is used to create Android applications.

The second approach is creating apps through Xamarin.Forms approach. Xamarin.Forms are used when there is a possibility of reuse of a lot of platform-independent code and the focus is less on custom UI. The platform-independent code is separated and kept in Shared Project or PCL or .NET Standard Library and Platform Specific projects consume this common code by including it.

Pages are Xamarin Forms generic representation of Cross Mobil Application Screens. A Page occupies most or all of a screen and contains a single child.

On IOS, the Page is mapped to ViewController, on Android, it is mapped to somewhat like Activity and on Universal Windows Platform, it is mapped to  Page. Pages can be of several types, viz. Master /Detail Page, navigational Page, Carousel Page, Tabbed Page, Template Page, etc.

• Content Page

A Content Page is the most basic type of page which contains the content in a  Stak Layout Grid Layout or Scroll View. The content is usually text or images

• Master-Detail Page

The Master-Detail Page is divided into two sections: Master and Detail. Master usually contains a list of items or Menu. Clicking on the item would show details about the item on the Detail Page

• Navigation Page

Navigation Page allows navigating from one page to the next by keeping a stack of all the pages. As the user goes deeper inside the app the pages get stacked one on top of the other and when the user tries to come back to the entry page thee pages are popped out in the reverse order of stacking

• Tabbed Page

Tabbed Image allows viewing multiple child pages across the same page wherein each Tab represents a child page. One child page is active at a time and it is easier to navigate to the other Tab child page by clicking on the Tab

• Carousal Page

Just like Tabbed page, Carousel Page is also Multipage. It is similar to the gallery. Only the difference is Instead of clicking on the tab, the Carousal allows swiping gestures on the pages to navigate between the multiple child pages

• Templated Page

When a user wants to show full mobile screen say for a Game or for showing splash Screen, Template Pages are used. They cover the entire screen area.

FreshMvvm is a super light Mvvm Framework designed specifically for Xamarin.Forms only. It's designed to be Easy, Simple and Flexible. It is easy to learn and uses convention over configuration.

Fresh MVVM deviates a little from MVVM as it uses the concept of Page and PageModel instead of View and ViewModel.

The various features of Fresh MVVM are:

• Every Page must be associated with a Page Model
• The PageModel can have an Init method to initialize Model variables and a ReversInit() method (a destructor) that is called when a model is popped with object
• Page Model allows dependencies to be automatically injected into the Constructor
• A Page must have a corresponding PageModel, with naming important so an ImagePageModel must have an ImagePage
• PageModel can have dependencies automatically injected into the Constructor
• The navigation in Fresh MVVM takes place between Page Models.
• Supports automatic wiring of BindingContext
• Supports automatic wiring of Page events (eg. appearing)
• FreshMvvm comes with a built-in Inversion of Control Container
• Page Model Important Methods:
  • Init(): The Init() method is called when the page is about to be loaded. User can pass an "object" to this method to allow setting up the Page with external data before it is being loaded
  • ReversInit(): The ReverseInit()  method is called when the page I about to be popped from the stack. It allows returning an "object" which can contain the data returned by the Page
  • ViewIsDisappearing(): ViewisDisappearing() is called when the view is about to disappear from the screen
  • ViewIsAppearing(): ViewisIsAppearing() is called when the view is about to appear on the screen.

MVVMCross

MVVMCross is a .NET cross-platform MVVM framework. It allows making cross-platform solutions, for platforms such as Xamarin.Forms, Xamarin.Android, Xamarin.iOS, Xamarin.Mac, Xamarin.tvOS, UWP, and WPF. It is currently inactive state of development.

MVVM Cross requires the application to be divided into two parts: the Core and the UI. The Core part contains the View Models, Service, Models, and the Business logic whereas the UI parts consist of the different Views and platform-specific code that interacts with the Core. The views are View Screens that contain the graphical content. In addition to Core and UI, the application may contain additional libraries for various functionalities.

The various high-level features that MvvmCross provides are:

• An MVVM architecture pattern
• A flexible Navigation system
• Data Binding to allow source-target automatic binding
• Platform specifics support
• Inversion of Control container
• Dependency Injection engine
• Plugins for common functionalities. A lot of customizable plugins are available for common tasks.

The cons of using MVVM Cross are:

• It has a steep learning curve and lacks a Wiki for how to get started developing apps.

MVVM Light

MVVM Light is another Framework that allows the creation of Enterprise-Grade apps using the MVVM Architectural pattern on Xamarin. MVVM Light enables developers to create and develop  MVVM applications on a variety of platforms like Xamarin.Forms, Xamarin.Android, Xamarin.iOS, UWP, and WPF. It allows you to separate the View from Model and hence right more testable and extensible applications.  It is not in active development now. It does not support async commands.

A typical MVVM Light application is divided into the following parts:

• View: It is a platform-specific user interface that is associated with the screen
• View Model: IT exposes the data and the properties related to data
• ViewModel Locator: It registers custom ViewModels.

MVVM Light advocates the use of a Messenger for loosely-coupled communication everywhere in the app, including data binding, dialogs, and navigation:

• Supports two-way data binding
• Supplies a DelegateCommand class for wiring up ViewModel commands. 

This is one of the most frequently asked Xamarin interview questions for experienced in recent times.

XAML(Extensible Application Markup Language) allows developers to define the UI in Xamarin.Forms application using markup instead of code. The Designer allows previewing this UI thereby simplifying the design process.

The Xamarin.Forms pages have markup which has the responsibility of visual design for the UI and associated code to specify some action or logic based on interaction with the UI.

Xamarin.Android additionally supports AXML which is also a markup language specifically made for Xamarin.Android.

The main advantage of using XAML is it provides a clean separation of markup and code, so while the developer can concentrate on the behavior of the application (i.e. the code), the graphic designers can focus on the look and feel of the application. XAML can be compiled, and it takes full advantage of the Longhorn graphics subsystem, helping developers to produce great visual effects. In a XAML file, there is a clear hierarchy of graphical elements and it is easy to understand the GUI design of the app i.e. which element encloses which other elements. The separation of concerns ensures that any changes to the visual aspects of the application may not affect the business logic.

The drawbacks of using XAML are, XAML cannot contain any logic, all the logic has to go into separate code files. It does not directly support conditional processing or loops for repetitive processing of tasks

The lifecycle of an app contains the sequence of methods that are called since the time the app is launched until the time it is in the memory. The Lifecycle methods allow developers to write code for initialization or logic or transition so that the app components are initialized or show a specific behavior as and when they transit from one state to another. The developer may want to save state, initialize graphical components with data or reset apps state or free memory during these App methods.

The various life cycle methods of XamarinForms Apps are:

• OnStart: when the application initializes onStart is called. It is the best place to initialize objects
• OnSleep: Once the application goes to the background, the state is called ‘resume’. The app does not die here rather is kept in memory but with reduced priority. OnSleep() is similar to OnPause() in Android
• OnResume: OnResume is called when the application is resumed, i.e after being sent to the background. Similar to OnResume on Android.

While writing an application with MVVM, developers specify data bindings in the View Model to bind the UI and the underlying code. Sometimes it may be required that instead of simple properties, the app may have to react to commands initiated by a user that affect something in the View Model. Such commands are generally associated with button clicks of a button or Tap event of a gesture and are handled by the appropriate background handler. These Commands, that implement the ICommand interface, define the operation to be performed when the appropriate Click or Tap is performed. To use the command interface, one has to define a data binding that targets the Command Property of the Button whereas the source is a property in the ViewModel of type ICommand.