Top 50 Xamarin Cross Platform Development Interview questions (C# - Xaml)

Introduction:
It is time to learn xamarin cross platform development and people are already started in so many organizations, because of we can deliver native iOS, Android, and Windows apps using existing skills, teams, and code(C#, xaml ) with free of cost. Many company's are started hiring the Xamarin developers, and if you are good at xamarin, they are ready to give bigger packages for you as much as possible. If you are looking for Xamarin developer position in new company and you may need to face interview questions on Xamarin Technology. Here I am going to explain you most common interview questions with answers and also please correct me if any wrong content found in this article. Also pleases note that for accuracy purpose I visited Xamarin official website and googling as well to adapted some content.

1. What is the difference between Native App and Cross Platform APP?

• Native App: If we want to develop native apps, we need to choose the specific native language (C#, Objective-C, Swift, and Java) for developing specific native app for Windows, Android, iOS.
• Cross Platform App: This is the way to develop all three mobile apps using single code base wrapped in a native application layer, but it always requires customization of interfaces to native languages.

2. What is Xamarin?
It is cross platform development technology, where we can build native user interfaces for iOS, Android and Windows Phone using single codebase with C#.

3. Xamarin history?

• Xamarin is a Microsoft-owned San Francisco, California based software company founded in May 2011 by the engineers that created Mono, Mono for Android and MonoTouch .
• Novell had granted a perpetual license for Mono on july 2011 for MONO 
• On May 16, 2011: Miguel de Icaza announced on his blog that Mono would be developed and supported by Xamarin,
• December 2012, Xamarin released Xamarin.Mac which allows developers to build C#-based applications for the Apple OS X operating system and package them for publishing via the Apple App Store.
• Xamarin 2.0 was released in February 2013 Xamarin.Android and Xamarin.iOS that make it possible to do native Android, iOS and Windows development in C#, with either Visual Studio or Xamarin Studio.
• Xamarin.forms: Introduced in Xamarin 3 on May 28, 2014 and allows one to use portable controls subsets that are mapped to native controls of Android, iOS and Windows Phone.
• On February 24, 2016: Microsoft announced it signed a definitive agreement to acquire Xamarin
• On March 30, 2016: Microsoft acquired the xamarin. And made it for all with free of cost.

4. Mono vs. Monodevelop vs Xamarin

Mono: It is a framework and an open source implementation of Microsoft’s .NET Framework based on the open standards of European Computer Manufacturer's Association (ECMA) for the C# language and the Common Language Runtime. And Mono allows C# developers to write cross platform code targeting Windows, Mac OS X, Linux, Android, and iOS. 

MonoDevelop: It is an open source integrated development environment (IDE) for Linux, OS X, and Windows. Its primary focus is development of projects that use Mono and .NET frameworks.

Xamarin: a subsidiary of Microsoft - is a company founded by the engineers who created Mono. Xamarin is the primary maintainer and commercial sponsor of Mono. It provides professional developer tools that make cross platform code easier to author, test, and maintain.

5. What are the programming languages that support Xamarin Development?

• Xamarin is unique in this space by offering a single language – C#, class library, and runtime that works across all three mobile platforms of iOS, Android, and Windows Phone (Windows Phone’s native language is already C#)
• Also offers xaml support for creating user interface.

6. Why Xaml in Xamarin.Forms?

• XAML(Extensible Application Markup Language) allows developers to define user interfaces in Xamarin.Forms applications using markup rather than code.
• XAML defines the visual appearance of a UI, and an associated code-behind file defines the logic. The UI design can be adjusted without necessarily making changes to the logic in code-behind. XAML in this role simplifies the workflow between individuals who might have a primary visual design responsibility and individuals who are responsible for app logic and information design.

7. What are disadvantage of Xaml in Xamarin.Forms?

• XAML cannot contain code. All event handlers must be defined in a code file.
• XAML cannot contain loops for repetitive processing. (However,ListView —can generate multiple children based on the objects in its ItemsSource collection.)
• XAML cannot contain conditional processing (However, a data-binding can reference a code-based binding converter that effectively allows some conditional processing.)
• XAML generally cannot instantiate classes that do not define a parameterless constructor. (However there is sometimes a way around this restriction.)
• XAML generally cannot call methods. (Again, this restriction can sometimes be overcome.)

8. What are the IDE's we can use for Xamarin App Development?

Xamarin Studio: This is Xamarin’s C# developer environment that runs on both Windows and Mac. Xamarin Studio has many of the features of Microsoft’s Visual Studio and uses exactly the same formats as Visual Studio: solutions (.sln) and C# projects (.csproj).

Visual Studio: Xamarin offers a Visual Studio extension/plugin for visual studio 2012, visual studio 2013 update 1. And now Xamarin development is directly available from Visual studio 2015.

9. What was the major advantage of Xamarin Development?

• We can deliver native iOS, Android, and Windows apps using existing skills, teams, and code(C#, xaml )
• We can take full advantage of Native API’s with Xamarin Technology . And Xamarin.Forms elements map to native controls and behaviors
• Xamarin Component Store allows adding high-quality components to your app directly from your IDE, including controls, web service APIs and more.
• PCL/ Shared projects makes very easy for developers to share the same code base across different projects.

10. What are difference between Xamarin Studio and Visual Studio?

Notes:

• We can't create Windows Phone, Windows & UWP from Xamarin Studio.
• Xamarin Studio in Mac can allows you to develop iOS & Android apps.
• Xmarin Studio in Windows can allows you to develop Android apps only. And it encourage Windows users to move to Visual Studio.
• Xamarin for Visual Studio supports any VS 2015, VS 2013 Update 2 and Visual Studio 2012 with non-Express editions. And visual studio can't install on Mac machine.
• To test iOS app on Windows OS with VS, must be a Mac computer accessible on same network.
• To develop Xamarin.Forms apps for the Universal Windows Platform (UWP) requires Windows 10 with Visual Studio 2015

11. What are the life cycle's of Xamarin.forms app development?
Life-Cycle means a specific sequence of the application from start to finish of the application. So there are three important states in the life cycle of a Xamarin app development.
OnStart: Called when the application starts.
OnSleep: Called each time the application goes to the background.
OnResume: Called when the application is resumed, after being sent to the background.
Note:
There is no method for application termination. Under normal circumstances (ie. not a crash) application termination will happen fom the OnSleep state, without any additional notifications to your code.

12.How many ways we can create Xamarin applications?
There are two ways to deliver native iOS, Android, and Windows apps using Xamarin Technology
Traditional Xamarin approach: This approach can provide direct access to platform-specific API’s. And we can create platform specific apps such as using Xamarin.iOS for iOS applications, using Xamarin.Android we can create Android applications.

Xamarin.forms: This architecture is the same as that of traditional cross-platform apps. The most used method is to implement Portable Libraries or Shared Projects to save the shared code, and then create specific applications for each platform that will consume this shared code. 

13. When to use Xamarin.Forms vs Xamarin Native?
Xamarin.Forms:

• Apps that require little platform-specific functionality.
• Apps where code sharing is more important than custom UI.

Xamarin.IOS,Xamarin.Android:

• Apps that require specialized interactions.
• Apps with highly polished design.
• Apps that use many platform-specific APIs.
• Apps where custom UI is more important than code sharing.

14. What are different extension output files generated from xamarin.forms?
If we run the Xamarin app, it can generate following application packages for different platforms
.xap/.Appx for windows phone 8, Windows, UWP
.ipa file for IOS
.apk file for Android

15. What are the different application package running modes in Xamarin?
When you compile an application, you usually choose between below two modes:
Debug: Debug mode pads the executable file with extra information used for debugging purpose. After your application is bug-free and feature-complete, there's no longer any need to keep the debug information.
Release: Compiling in Release mode gives you a more compact (and even slightly faster) executable that doesn't include unnecessary internal debugging symbols
Note: Packages should be in release mode, which would be provided to an App store.

16. How does Xamarin.Android(Mono for Android) work?
On Android, Xamarin ships a fully functional implementation of the .NET runtime, called Mono, bundled with your app so that your code executes with all of the power of C# and .NET, including JIT-compilation, memory management, reflection, and the .NET base class libraries. Developers can use any native features by interacting with .NET class libraries that provide one-to-one mappings to all of the native APIs on Android.

17. What is the difference between Xaml & axml in Xamarin Technology?

• AXML and XAML are two different XML specifications.
• AXML is just supported/available for Xamarin.Android.
• XAML is the way Xamarin Forms could standardize Cross Platform UI based on XML specification.
• XAML is the way Xamarin Forms could standardize Cross Platform UI based on XML specification.
• If you are using native Xamarin Android you will do UI using axml, if using Forms then using XAML.

18. How does Xamarin.IOS work?
On iOS, Xamarin uses Mono, a fully functional implementation of the .NET runtime, to fully compile your app into a native ARM executable ahead of time (AOT) so that your code executes with all of the power of C# and .NET, including memory management, reflection, and the .NET base class libraries. Developers can use any native features by interacting with .NET class libraries that provide one-to-one mappings to all of the native APIs on iOS, while complying with Apple's security restrictions which prevent execution of dynamically generated code on device.

19. What is the project structure of Xamarin.Forms?
If we create App with xamarin.forms project using xamarin studio or visual studio. Then created project will have bellow structure:

• Shared: Shared Project containing the code common to all projects and it will be either PCL or Shared Project.
• AppAndroid: Xamarin.Android application project.
• AppiOS: Xamarin.iOS application project.
• AppWinPhone: Windows Phone application project.
• AppWindows: Windows application project.
• AppUWP: Universal Windows Platform application project.

20. What are the different code sharing techniques in xamarin.forms?
There are two alternative methods for sharing code between cross-platform applications:

• Portable Libraries(PCL)
• Shared Projects

The goal of a code-sharing strategy is to support the architecture, where a single codebase can be utilized by multiple platforms.

21. Difference between Portable Class Library (PCL) & Shared Projects?
Portable Class Library (PCL):

- Produce libraries that can be shared across multiple platform.

- Targeting specific platform includes interfaces

- Refactoring operations always update.

 Shared Projects:

- Shared code can be branched based on the platform using compiler directives( eg. using #if __ANDROID__, #if __IOS__, #if WINDOWS_PHONE_APP, #if WINDOWS_APP..etc)

- No output assembly.

- Refactoring operations ,not update automatically.

22. What does Pages in Xamarin.Forms?

The Page class is a visual element that occupies most or all of the screen and contains a single child. And pages in xamarin.forms are directly mapped to like below:

• In iOS  it is a View Controller
• In Windows Phone it is a Page.
• In Android it is a Activity.

23. What are the different kinds of Pages in Xamarin.Forms?

Fortunately Xamarin.Forms support multiple page representations, And every representation is having its own purpose like below:

• ContentPage: A Page that displays a single View, often a container such as a StackLayout or a ScrollView.
• MasterDetailPage: A Page that manages two panes of information.
• NavigationPage: A Page that manages the navigation and user-experience of a stack of other pages.
• TabbedPage: A Page that allows navigation between children pages, using tabs.
• TemplatedPage: A Page that displays full-screen content with a control template, and the base class for ContentPage.
• CarouselPage: A Page allowing swipe gestures between subpages, like a gallery.

24. What are the layout controls available in Xamarin.Forms?

Layout is the process of sizing and positioning child elements in UI.

• ContentPresenter: A layout manager for templated views. Used within a ControlTemplate to mark where the content to be presented appears.
• ContentView: An element with a single content. ContentView has very little use of its own. Its purpose is to serve as a base class for user-defined compound views.
• Frame: An element containing a single child, with some framing options. Frame have a default Xamarin.Forms.Layout.Padding of 20.
• ScrollView: An element capable of scrolling if it's Content requires.
• TemplatedView: An element that displays content with a control template, and the base class for ContentView.
• AbsoluteLayout: Positions child elements at absolute requested positions. User assigned anchors and bounds defines the position and size of the control.
• Grid: A layout containing views arranged in rows and columns.
• RelativeLayout: A Layout that uses Constraints to layout its children.
• StackLayout: A Layout that positions child elements in a single line which can be oriented vertically or horizontally. This layout will set the child bounds automatically during a layout cycle. User assigned bounds will be overwritten and thus should not be set on a child element by the user.

25. What is Views?
Views are commonly known as controls of widgets. And they can refer to visual objects such as Label, Button, Entry, Image, BoxView, ListView, TableView..etc. All UI elements are typically are sub-classes of View.

26. What is is the difference between ListView & TableView?

• The ListView and TableView controls are so similar, you can think of them as a single control. The major difference between the two is the manner in which they lay out their items, and it’s easy to change the layout so each control emulates the other.
• The ListView control displays its data stacked vertically, much like a standard listbox. Use this control to display an ordered list of data, especially long lists that require scrolling like a list of email messages, a list of contacts, or search results.
• The TableView control displays its data stacked horizontally in rows (although you can alter this behavior and have it displayed in columns first, as well). You use this control when you need more space for rich visualization of each item to be displayed.
• One of the big differences is ListView provides you a ItemsSource and a Itemtemplate and TableView does not. So items must be added as children manually.

27. How to draw rectangle in Xamarin.Forms?
BoxView is used to draw a solid colored rectangle. So below source code can create Accent colored rectanlge with width ->200 & Height->100

1. <BoxView Color="Accent"  WidthRequest ="200"  HeightRequest = "100"/>  

28. What is the difference between Editor & Entry?
Both views are helpful for user to enter text, but there is a small difference is Entry only has one line, whereas a Editor usually has multiple lines that allows user to press ENTER.

29. What is Cell in Xamarin.Forms?
Simple it is not a visual element, but it just describes a template for creating a visual element. And one important note is that Cells are elements designed to be added to ListView or TableView controls.

30. What is difference between Entry and EntryCell in Xamarin.Forms?

• Entry is a visual element, where user can enter single line text. 
• EntryCell is not visual element, it is subtype of Cell and it describes a template for label and a single line text entry field. It is normally for use in a ListView or TableView.

31. What is difference between Margin & Padding property?

• Margin is applied to the outside of you element hence effecting how far your element is away from other elements.
• Padding is applied to the inside of your element hence effecting how far your element's content is away from the border.

32. How to display alert in Xamarin.Forms?
It is very common UI task is displaying an alert or asking a user to make a choice. So to display alert in Xamarin.Forms, we can use the DisplayAlert method on any Page like below:

1. DisplayAlert ("Alert", "You have been alerted", "OK");  

33. What is difference between DisplayAlert and DisplayActionSheet?

• Xamarin.Forms has two methods on the Page class for interacting with the user via a pop-up: DisplayAlert and DisplayActionSheet. They are rendered with appropriate native controls on each platform.
• DisplayAlert presents an alert dialog to the application user with a single cancel, and it does not having importance to collect information from the user.      public Task DisplayAlert (String title, String message, String cancel) 
• DisplayActionSheet displays a native platform action sheet, allowing the application user to choose from several buttons. Example: await DisplayActionSheet ("ActionSheet: SavePhoto?", "Cancel", "Delete", "Photo Roll", "Email");  
  

34. Why we need write platform specific code in Xamarin Forms?
Xamarin Forms can almost provides 90-95% of share code for all three mobile platform projects (Windows, Android, iOS). However, there are going to be cases where you need to get at something that really isn’t generic, something that’s done a little differently on each platform. That could be something relatively significant (like a custom “renderer”) or something as simple knowing the platform-specific path for local storage, geolocation,text-to-speech..etc.

35. How to write platform specific code in PCL project of Xamarin.Forms?
We already know compiler directives concept (#ifdef option) is not available in PCL . But in alternative we have majorly there are three ways to create platform specific code in PCL project.

• DependencyService: It can allows apps to call into platform-specific functionality from shared code. This functionality enables Xamarin.Forms apps to do anything that a native app can do.
• Device: It is a class contains a number of properties and methods to help developers customize layout and functionality on a per-platform basis. (Ex:Device.OnPlatform, Device.OS, Device.Idiom..etc)
• Custom Renderers: By default each page, layout, and control in xamarin.forms are rendered differently on each platform, using a Renderer class that in turn creates a native control, arranges it on the screen, and adds the behavior specified in the shared code. But using Custom renderers, developers can be used for small styling changes or sophisticated platform-specific layout and behavior customization.

36. How does DependencyService work in Xamarin.Forms?
DependencyService can useful for accessing native mobile features (local storage, geolocation,text-to-speech..etc). But we need to follow below four steps to use DependencyService:

• Interface: The required functionality is defined by an interface in shared code.
• Implementation Per Platform: Classes that implement the interface must be added to each platform project.
• Registration: Each implementing class must be registered with DependencyService via a metadata attribute. Registration enables DependencyService to find the implementing class and supply it in place of the interface at run time.
• Call to DependencyService: Shared code needs to explicitly call DependencyService to ask for implementations of the interface.

37. How does Custom Renderers work in Xamarin.Forms?
Custom Renderers can be used for small styling changes or sophisticated platform-specific layout and behavior customization. But we need to follow below three steps:

• Create a subclass of the renderer class that renders the native control.
• Override the method that renders the native control and write logic to customize the control. Often, the OnElementChanged method is used to render the native control, which is called when the corresponding Xamarin.Forms control is created.
• Add an ExportRenderer attribute to the custom renderer class to specify that it will be used to render the Xamarin.Forms control. This attribute is used to register the custom renderer with Xamarin.Forms.

Below image represents steps for Customizing an Entry with Custom Renderer

38. How to use Device.OnPlatform in xaml and C#?
Device.OnPlatform is a generic method that has three optional parameters: iOS, Android, and WinPhone. It can be used to provide platform-specific values. For example if we want to set different padding values for different platform we can use like below:
In Xaml:

1. <ContentPage.Padding> 
2. <OnPlatform x:TypeArguments="Thickness" iOS="0, 20, 0, 0" Android="0" WinPhone="0"/> //left and right padding: 0; top padding: 20 (only on iOS)  
3. </ContentPage.Padding>  

In C#:
On page constructor

1. Padding = new Thickness (0, Device.OnPlatform(20,0,0), 0, 0);  //left and right padding: 0; top padding: 20 (only on iOS)  

39. What are list of compiler directives available in Shared Asset Project(SAP) ?
Compiler directives are only available in Shared projects and not in PCL. And these are useful to write platform specific code using C# preprocessor directives #if, #elif, #else, and #endif with conditional-compilation symbols defined for the three platforms, as list of compiler directives shown below:

• __IOS__ for iOS
• __ANDROID__ for Android
• WINDOWS_UWP for the Universal Windows Platform
• WINDOWS_APP for Windows 8.1
• WINDOWS_PHONE_APP for Windows Phone 8.1

For example, to get operating system in windows phone 

1. #if  WINDOWS_PHONE_APP  
2.   
3. EasClientDeviceInformation devInfo = new EasClientDeviceInformation(); 
4. versionLabel.Text = devInfo.OperatingSystem; //To get device operating system.
5.  
6. #endif

40. What is Data Binding in Xamarin?

• Data binding is a technique to automatically synchronize a user interface with its data source. When a binding is established and the data or your business model changes, then it reflects the updates automatically to the UI elements and vice versa. 
• Data binding connects two objects, called the source and the target. The source object provides the data. The target object, which must be a bindable property, will consume (and often display) data from the source object. It is also possible to bind, not to a standard data source, but to another element on the page.

41. What are different type of Data Binding modes in Xamarin?
Data binding connects two objects, called the source and the target. So the relationship between target and source is defined by members of the BindingMode enumeration and there is four kinds of binding modes are available in Xamarin.Forms.

• Default (Optional & not considered)
• OneWay — changes in the source affect the target (normal).
• OneWayToSource — changes in the target affect the source.
• TwoWay — changes in the source and target affect each other.

Note: If you don’t specify anything, the default binding mode is OneWay

42. What are the different scenarios to use Data Binding in Xamarin.Forms?
Not only with data source, we can also use Data Binding concept in various scenarios like below:
*View-to-View Bindings: This is the scenario, when we want to link properties of two views on the same page. In this case, you need to set the BindingContext of the target object using the x:Reference markup extension. 
*Backwards Bindings: A single view can have data bindings on several of its properties.
*Binding with Model: Here the scenario is like, a view property is binding with specific class object.
*Binding with Collections: It is scenario, where we want to bind list of objects to view. For example ListView defines an ItemsSource property of type IEnumerable, and it displays the items in that collection.

43. How to make View-to-View Data Binding in Xamarin.Forms with Xaml?
Sometimes we may need to link one property of view with another property of view. For example below Xaml program can describes the scenario is like when we want to control Opacity value of Lable with Silder control Value. 

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <ContentPage xmlns="http://xamarin.com/schemas/2014/forms" xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml" x:Class="CustomEntry.ViewtoViewBinding">  
3.     <StackLayout VerticalOptions="Start" Padding="20,70,20,0" >   
4.         <Label Text="Lable Opacity Demo" FontSize="Large" VerticalOptions="CenterAndExpand" HorizontalOptions="Center"  Opacity="{Binding Source {x:Reference Name=slider}, Path=Value}" />  
5.         <Slider x:Name="slider" VerticalOptions="CenterAndExpand" />   
6.     </StackLayout>  
7. </ContentPage> 

44. Why we need to use Model-View-ViewModel(MVVM) pattern in Xamarin?
The Model-View-ViewModel pattern can be used on all XAML platforms. Its intent is to provide a clean separation of concerns between the user interface controls and their logic.

Benefits:

• During the development process, developers and designers can work more independently and concurrently on their components. The designers can concentrate on the view, and if they are using Expression Blend, they can easily generate sample data to work with, while the developers can work on the view model and model components.
• The developers can create unit tests for the view model and the model without using the view. The unit tests for the view model can exercise exactly the same functionality as used by the view.
• It is easy to redesign the UI of the application without touching the code because the view is implemented entirely in XAML. A new version of the view should work with the existing view model.
• If there is an existing implementation of the model that encapsulates existing business logic, it may be difficult or risky to change. In this scenario, the view model acts as an adapter for the model classes and enables you to avoid making any major changes to the model code.

45. What is use of ICommand in Xamarin.Forms?
Typically, when you write an application without using the MVVM pattern, to manage the user’s interaction with the user interface (for example, he clicks on a button) you subscribe to a event handler: this way, a new method will be generated in code (C#) behind, which will contain the code that will be execute when the event is raised.

This approach is that it creates a strong connection between the View and the code: event handlers can be managed only in code behind, but you can’t simply move it to a ViewModel. The solution is to use commands, which are special objects (that implement the ICommand interface) that define the operation to perform when the command is executed.

46.What is NuGet and how it can help in Xamarin App Development?
NuGet is the most popular package manager for .NET development. It is built in to Xamarin Studio 5 and Visual Studio. You can easily search for and add packages/third party libraries to your Xamarin.Forms using either IDE.

47. What does behaviors in Xamarin.Forms?
Behaviors are very important and useful to add functionality to user interface controls without having to subclass them. Instead, the functionality is implemented in a behavior class and attached to the control as if it was part of the control itself. For example adding an email validator to an Entry, controlling an animation, adding an effect to a control.
Xamarin.Forms supports two different styles of behaviors:

• Xamarin.Forms behaviors: classes that derive from the Behavior or Behavior<T> class, where T is the type of the control to which the behavior should apply.
• Attached behaviors: static classes with one or more attached properties

48. What are uses of DataPages in Xamarin.Forms?

Data pages allow developers to quickly and easily consume a supported data source and render it using built-in UI scaffolding that can be customized with themes.
Note: Xamarin.Forms DataPages were announced at Evolve 2016

49.How to increase rows & columns space of Grid in Xamarin.Forms?
Yes, we can set space between rows in the Grid using RowSpacing. And also we can sets the distance between columns in the Grid using ColumnSpacing .

1. <Grid Name="GridSpaceDemo" RowSpacing="3" ColumnSpacing="2"  >  
2.           <Grid.RowDefinitions>  
3.             <RowDefinition Height="Auto"/>  
4.             <RowDefinition Height="Auto"/>  
5.           <RowDefinition Height="Auto"/>  
6.           </Grid.RowDefinitions>  
7.       <Grid.ColumnDefinitions>  
8.         <ColumnDefinition Width="Auto"/>  
9.         <ColumnDefinition Width="Auto"/>  
10.         <ColumnDefinition Width="Auto"/>  
11.       </Grid.ColumnDefinitions>  
12.           <!--Grid child items-->  
13.     
14.   </Grid>  

50.What is the difference between Modal pages and Modeless pages?
Modal Page: We’ll use modal pages when your application needs some information from the user and you don’t want the user to return to the previous page until that information is provided. Below C# code is used to navigate to specific page name is DetailPage. 

1. async void ModelPageNavigation ()  
2. {  
3.    
4.     await Navigation.PushModalAsync (new DetailPage ()); //Navigate to Details Page  
5. }  

Modeless Page: The difference between modal and modeless pages mostly involves the user interface that the operating system provides Back button on the page to return back to the previous page.

async void ModelessPageNavigation ()  

{  

   

    await Navigation.PushAsync (new DetailPage ()); //Navigate to Details Page, will create Back button navigation page  

}  

In next article, I will explain more Xamarin advanced interview questions. And also suggested to read all previous UWP, Windows Phone (Both silverlight and WinRT) interview questions from below links

1. Top Windows 10 UWP App Development Interview questions (C#-Xaml) – Part1
2. Top Windows Phone interview questions c# - Part1
3. Top Windows Phone interview questions c# - Part2 
4. Windows App Development Tips:Top Basics for Beginners(C#-XAML)

All the very best for your interview :)

FeedBack Note:

Please share your thoughts,what you think about this post,Is this post really helpful for you?I always welcome if you drop comments on this post and it would be impressive.

Follow me always at @Subramanyam_B

Have a nice day by Subramanyam Raju :)