In this article, we’ll discuss in detail the tools and methods .NET provides for developing mobile applications. Let’s take a look.

Backed by Microsoft partnership, SaM Solutions skilfully handles .NET development projects of any scale and complexity.

What Is .NET?

First let’s get a general idea of what .NET is. The traditional definition goes something like this: “.NET is an open-source and free framework by Microsoft used to develop various types of applications for various platforms and being an integral part of Windows OS.”

Diving a bit deeper, we understand that .NET is a huge ecosystem of software products (languages, developer tools, libraries, runtime environments, etc.) for cross-platform development.

The following are the key components.

• .NET Framework — the initial product released in 2002, which aimed to develop applications and services on Windows only.
• .NET Core — the platform-agnostic framework appeared in 2016 and enabled cross-platform development.
• Xamarin — the framework for developing cross-platform mobile applications. It was created by the Mono project and then purchased by Microsoft and integrated into .NET.
• MAUI (Multiplatform App UI) — the next evolutionary step of Xamarin, which will support Android, iOS, macOS and Windows.
• C#, F#, Visual Basic — most popular programming languages used in .NET.
• Visual Studio — the basic development environment for .NET projects. Options include Visual Studio Code and Visual Studio for Mac.
• Command line interface (CLI) — a toolchain for creating, running and publishing cross-platform applications.
• .NET Standard — a common set of APIs, ensuring unification within the ecosystem.  Starting with .NET 5, this approach to unification has become obsolete.
• Common Language Runtime (CLR) — the environment used to manage the execution of software components written in various languages.
• .NET 5 — a step forward to a single platform, taking the best of .NET Framework and .NET Core and enabling the development of applications for all devices from a single place. Released in 2020.
• .NET 6 — a unified development platform allowing you to create desktop, web, mobile, cloud, IoT, gaming and AI applications. Released in 2021.

Note! If there were still separate products in .NET 5 (.NET Framework, .NET Core), they have now merged under one name — .NET 6. So, you can launch this single version and create any types of solutions. All the previous products now have common libraries, APIs and infrastructure components.

As you can see, the .NET ecosystem is highly diverse, given that we’ve mentioned only some major components. The list can be complemented by numerous libraries, runtimes and other tools.

What Is the Use of the .NET Framework?

According to Statista, .NET Framework was the most used framework among developers worldwide in 2021, with .NET Core/.NET 5 in the top three as well. This fact proves that the platform has a broad scope of application, including:

• desktop applications
• web applications
• mobile applications
• enterprise systems
• IoT solutions
• games.

The following hints suggest when the various .NET products should be used.

• Use .NET Framework if you need a desktop or server-based application running on Windows OS only.
• Use .NET Core if you need a cross-platform web app (should run on Windows, Linux, macOS) — if you need a high-performance and scalable solution based on the microservices architecture and Docker containers.
• Use Xamarin if you need cross-platform, hybrid or native applications for mobile operating systems (iOS, Android).

Frontend Mobile Development in .NET

The frontend of mobile applications is the part that users see and interact with. Frontend developers and web designers work together to implement the logic and its visual representation. In .NET, there are several tools for frontend development.

Xamarin

Xamarin is the most popular open-source frontend framework in the .NET family. It enables cross-platform development — i.e., the project has several target platforms at once (Android, iOS). With Xamarin, you can create mobile applications in two different ways.

First development option — a separate UI for each platform 

Using Xamarin Native, you can develop Android and iOS apps independently. This means that you will have to write unique code for each solution with the help of native features (XML files, storyboards) provided by Xamarin.iOS and Xamarin.Android libraries. At the same time, the backend of such solutions can be shared.

As an example, I want to show you the Android layout file for one of our company’s internal applications:

And this is the resulting screen:

The main advantage of this approach is that, though coding for different platforms, you use one language, C# (instead of Swift, Java, and others). You can also incorporate third-party SDKs specific for both platforms due to bindings that Xamarin provides. This is very convenient as you get everything in one place.

Second development option — a single UI for all platforms

Using Xamarin.Forms, you can write a sharable UI code for all platforms. Of course, you will need some minor code adjustments for each target platform, but this is much quicker than having to develop separate solutions.

Take a look at this example of a UI layout based on Xamarin.Forms:

The output of this code is exactly the same screen as in the screenshot above.

Moreover, Xamarin supports other platforms such as Windows, Mac, Linux (GTK) and Tizen, so you can develop an application that will run on a wider range of mobile devices. Thus, Xamarin is rightly considered to be a comprehensive mobile app platform that frontend developers can leverage for cross-platform projects.

MonoGame and Unity

The two other options for mobile frontend development in .NET are Unity and MonoGame. While Xamarin is used for general-purpose mobile solutions, these frameworks focus on the development of mobile gaming applications for iOS and Android (but they also support other platforms).

MonoGame is a free framework used to create games for mobile devices, consoles and desktop computers. This is the successor to the Microsoft XNA framework that was used to develop games for Windows a decade ago. The code in MonoGame is written in C# and targets the iOS and Android mobile platforms, as well as other platforms that run games, including Windows, macOS, Linux, PS4, PS Vita, Xbox One and Nintendo Switch.

MonoGame is a less powerful tool than Unity. However, it provides a range of features that enable 2D and 3D rendering, the management of sounds, and images and states in the game.

Unity is a fully featured platform offering real-time 3D experiences not only for game development but also for creating films, automotive solutions, architectural projects and more. With built-in VR/AR capabilities, Unity can be a great tool for any application that requires realistic visualization.

Unity provides a simple-to-use editor where you create objects and then implement their logic with the help of .NET technologies.

Here’s an example of the Unity script:

Platforms supported by Unity include:

• mobile — iOS, Android, tvOS
• desktop — Windows (UWP), Mac, Linux
• web — WebGL
• console — PlayStation, Xbox, Nintendo Switch, Stadia.

As you can see, gaming engines like Unity provide advanced capabilities for mobile development, which is highly valued by modern users. However, when considering the tool for frontend mobile development, keep in mind all the technical requirements. Frameworks like Unity with VR/AR/3D capabilities can cause certain difficulties to mobile solutions because mobile devices have limited resources (battery life, processing power, etc.) and  might not be able to perform tasks as quickly as required. At the same time, script writing based on Xamarin is lightweight.

How to Build and Run Mobile Applications?

The process of building and running mobile apps differs from that for desktop or web apps, because with mobile, you focus on a wide range of devices instead of a general-purpose PC. Hence, you can’t use a “traditional” computer; you need either a physical mobile device or an emulator that imitates the performance of such devices.

With applications for Android, it’s simple: you can work on a computer with any operating system, use Visual Studio to select either a virtual device (emulator) or a connected physical device, and run your application.

With iOS solutions, you can work only on a computer running macOS. The good news is that Xamarin provides the Remoted iOS Simulator for Windows, so you can test your iOS apps in their target simulator and display it on your Windows machine.

Backend Mobile Development in .NET

The backend part of a mobile solution “lives” at the server side and out of the user’s sight. Of course, there are simple mobile applications such as a calculator or voice recorder that don’t need a backend, since they don’t have to store and process data. But to create large solutions with complicated business logic, the backend development team has to work hard in order to make the magic happen under the hood.

ASP.NET Core and ASP.NET Web API

It should be noted that backend development for mobile applications is the same as for web apps. Thus, if you need to develop several mobile and web solutions with the same functionality, you can share the backend service, which is super convenient and time- and cost-efficient.

To develop the web service infrastructure for your mobile application, you need to create a REST API serving as a mediator between the mobile frontend and backend. For this purpose, you can use ASP.NET Core, selecting a web API project template in the .NET Core infrastructure. Then, you’ll need to add a database context, apply CRUD methods, configure URL paths, routing, return values, etc.

Visual Studio App Center

In case you need to go beyond the backend development process and integrate it with the system administration, virtualization, security management, continuous integration/continuous deployment (CI/CD) and other practices, you should focus on the DevOps tools.

Visual Studio App Center is a web portal designed to enable DevOps practices in mobile app development. It provides integrated development services for automating the life cycle of applications for iOS, Android, Windows and macOS. Using Visual Studio App Center, you can:

• connect a repository
• build a project in the cloud
• test your application on thousands of devices at once
• distribute apps to beta testers and app stores
• monitor performance in real time
• track crash reports and analytics.

As a result, you can build your application, monitor its performance and stability, and address reported errors from a single cloud-based platform.

Azure Mobile Apps

One more option for building and hosting the backend for .NET-based mobile solutions is Azure Mobile Apps. The technology offers a range of capabilities for cross-platform and native applications:

• On-premises or cloud data storage
• Customer authentication
• Offline data synchronization
• Personalized push notifications
• Built-in autoscale

If you compare Visual Studio App Center and Azure Mobile Apps, both tools are popular among .NET developers. However, the former has a wider range of DevOps services and is more actively developed at the moment. Hence, the choice of the most appropriate tool should be based on the project goals, tech needs and financial capabilities.

Why Consider .NET as an Excellent Option?

.NET has been on the market for so long that it has become a recognized brand. Today, there is an extended ecosystem of software products, libraries and tools that are written specifically for the .NET Framework. This provides incredible flexibility in terms of solutions you can develop with .NET.

We’ve compiled a list of the best reasons why you should consider .NET for mobile development.

• Sharable code — you can create a single codebase for several platforms, which reduces development time and expenses.
• Single technological stack — all the tools you need for mobile app development, including IDE, SDK, testing and analytical tools, are available in one place.
• Security and reliability — Microsoft contributes to the reliable operation of its servers and continuously improves the security features of its products. You can therefore be sure that you’ll produce secure and reliable solutions if you develop them with .NET.
• Support — .NET is an open-source technology with strong corporate support by Microsoft. Its global community brings together millions of developers who contribute to the platform’s further development and who would be glad to help you address any issues that may arise with your project.

As you can see, over the years of its existence, .NET has become the most profitable development environment for a wide range of platforms, including Android, Linux, macOS and iOS.

SaM Solutions is a certified Microsoft partner with the following competencies:

• Gold Application Development
• Gold Collaboration and Content
• Silver DevOps
• Silver Cloud Platform

Our team of experienced and motivated .NET developers have successfully implemented numerous projects and earned the praise of many satisfied customers over the years. We will gladly transform your ideas into efficient mobile (or other) solutions, so don’t hesitate to contact us.

This article provides a detailed overview of a popular cross-platform development tool — Xamarin.

Mobile Market Penetration in Figures

The statistics are a core indicator in evaluating the significance of mobile devices in today’s life. Let’s take a look at the market as of 2022:

• According to Statista, the number of smartphone users today surpasses 6.5 billion people, which is over 83% of the world’s population.
• There are 4.32 billion unique mobile internet users in 2021.
• Mobile internet traffic accounts for 56.89% of the global web traffic.
• The market share of different mobile operating systems is estimated as follows: Android — 71.6%, iOS — 27.68%, with other players such as Samsung, KaiOS, Windows Phone, etc. taking less than 1% each.
• The survey by JetBrains revealed that 53% of developers use cross-platform technologies and frameworks for creating mobile apps.

This data proves that mobile solutions have become an integral part of our life and will significantly impact all spheres in the years to come. Therefore, mobile app development services will be in high demand.

What’s more, mobile frameworks for cross-platform coding are growing in popularity because applications compatible with several platforms offer a more flexible and complete customer experience.

Let’s move on to give you a comprehensive overview of Xamarin, a popular tool for cross-platform development.

What Is Xamarin?

Microsoft acquired Xamarin, which had been initially based on the Mono project, in 2016 and integrated it into the .NET platform.

Today, this is a popular open-source framework for developing cross-platform mobile applications. A single technology stack of Xamarin, C# and .NET, together with the reuse of up to 95 percent of the code, enables the quick and easy creation of mobile apps for Android, iOS and Windows operating systems.

Xamarin is a software company that created the Common Language Infrastructure (CLI) implementations and was purchased by Microsoft in 2016.

Xamarin is a development platform that aims to create mobile applications for iOS, Android and Windows.

How good is Xamarin? Judging by the statistics, Xamarin’s products are quite popular around the world. According to the company’s reports, more than 15,000 organizations and about 1.4 million developers are using them in 120 countries. Among the most renowned customers are Bosch, Siemens, Slack, Pinterest, and others. The fact that several industry leaders have based their solutions on this platform proves its reliability and efficiency.

Statista also proves the popularity of Xamarin by including it in the list of the most used frameworks among software engineers, preceded by Flutter, React Native, Cordova and Ionic.

Cross-platform mobile frameworks used by software developers worldwide from 2019 to 2021

Platforms Supported by Xamarin

Currently, Xamarin supports the creation of reusable code for the following platforms:

• Android (including the Android Wear version for developing software for wearable devices)
• iOS (including watchOS for Apple Watch and tvOS for Apple TV)
• Windows (UWP and WPF)

Note! Windows Phone is not supported as of Xamarin 3.x

• Linux (GTK)
• Mac
• Tizen

How Xamarin Works

The basic principle of Xamarin work is code sharing. In simple words, software developers write the code once and then apply it to various platforms with slight modifications, instead of writing the platform-specific code for an Android project and an iOS project from scratch.

.NET, as the foundation of Xamarin, performs memory allocation, the automatic garbage collection, and other tasks.

Xamarin Development Approaches

There are two ways of developing cross-platform applications using Xamarin.

1. Xamarin.Forms technology allows you to design a visual user interface once, attach some C# logic to it and share this codebase across Android, iOS and Windows platforms with some minor code changes. In this case, the UI code and the backend are pulled together for all solutions. This approach ensures a faster development time, and it’s cheaper. However, the application performance is not ideal.
2. Xamarin Native includes Xamarin.iOS, Xamarin.Android and Xamarin.Mac libraries that allow you to design separate UI applications for each platform. In this case, the UI code is unique for each solution, but the backend is shared, just as with Xamarin.Forms. With this approach, the development process is slower and more expensive, but it ensures perfect native behavior by apps.

Xamarin Cross-Platform Development Features

• Base Class Library (BCL) — a standard .NET library of classes with powerful features that Xamarin can access and make use of, such as serialization, XML, networking, etc.
• Visual Studio — an integrated development environment (IDE) that Xamarin uses to build apps. It provides essential features such as code autocomplete, integrated source control, and more.
• Interoperation with programming languages — Xamarin can invoke libraries written in C, C++, Java and Objective-C, which significantly expands code-writing opportunities.
• Xamarin Component Store — a built-in collection of free and paid third-party components (services, libraries, UI controls).
• Backend integrations — you can integrate your Xamarin-based applications with powerful backend platforms, including SAP, Azure, and Parse.

Building Cross-Platform Apps with Xamarin: Advantages

Cross-platform mobile development is becoming widespread as it has certain advantages over native development. Why use Xamarin for creating cross-platform solutions? In short, because this is a developer’s dream tool — they can create code once and use it across various platforms, without impairing the app’s performance, maintainability, or user experience.

Xamarin is a universal tool that allows you to create a single application logic using C# and .NET for three mobile platforms at once.

Let’s discuss in more detail the reasons to use Xamarin for cross-platform mobile development.

1. Single Technological Stack

One of the main pros of Xamarin is that a single language, C#, creates all kinds of solutions. Moreover, there’s no need to switch between environments — you can do everything in Visual Studio. This is convenient and time-effective because developers perform the same process using one language instead of two different languages. Hence, Xamarin is easy to learn.

2. Native User Experience

Xamarin has full access to native APIs and toolkits used on Android, iOS and Windows platforms. Consequently, it can provide native (or near-native) design and performance for every application.

The nativeness is possible due to the usage of platform-specific elements and technologies available in C# and Visual Studio:

• Xamarin.Android and Xamarin.iOS give .NET developers access to complete Android and iOS SDKs.
• Xamarin.Essentials library provides access to core overlapping native APIs.
• Xamarin.Forms exposes a user interface (UI) toolkit for all mobile platforms.

Thus, you can take advantage of all the unique elements in one place and create a single solution with platform-specific interfaces.

3. Shareable Code

Xamarin is often referred to as a “write once, use everywhere” development platform because it creates code that’s 60–95% reusable. A single codebase can run on various platforms, providing native performance, and may require slight changes only.

4. Time and Costs Saving

A shareable codebase and a single technological stack save time spent on the development cycle. You code once and can then reuse most of this code for other solutions, making only slight adjustments and not spending time on the same procedure. This means you can release your product faster.

Since everything is written in C# and within the .NET framework, there is no need for separate teams to work on the app. The development, testing and deployment are significantly streamlined when performed by a single team. This eliminates additional expenses and ensures quick time to market.

It is especially beneficial for companies with limited human and hardware resources.

4. Testing

The platform offers comprehensive solutions to test and monitor application user interface and performance — Xamarin Test Cloud and Xamarin Test Recorder. These tools allow you to run automated tests on multiple real devices in the cloud and find performance issues before the release.

5. Simplified Maintenance

It is remarkably easy to maintain apps developed with Xamarin.Forms as they share code. If you need to update applications and address some issues, just do it in the source code, and all changes will be automatically applied to other solutions. Again, it saves time, developer involvement and finances.

What’s more, the Xamarin community deserves respect for providing comprehensive customer support backed with well-organized documentation and training opportunities.

6. Technical Support by Microsoft

The framework guarantees stability, continuous technical backing and fast issue resolution because it’s supported by Microsoft — one of the world’s leading tech software companies.

Moreover, Microsoft provides access to robust educational opportunities, including Xamarin courses, which can be self-paced, and comprehensive tech documents on the official Microsoft Learn platform. This means that developers are not working in a vacuum and can receive support while improving their expertise.

Building Cross-Platform Apps with Xamarin: Challenges

Like any other software product, Xamarin is not a perfect fit for all projects. Here are some challenges that may prevent you from using this cross-platform development tool.

1. Heavy Applications

Xamarin-based solutions can be twice as big as native files and require extra adjustments because they use numerous core libraries and functionality. A couple of additional megabytes may be critical for some projects.

2. No Complicated Graphics

It’s tough to build appealing Xamarin solutions loaded with complex graphic elements or animation. Hence, this platform is not the best choice for creating apps with advanced visualization or gaming apps.

However, nothing is impossible: the open-source platform allows developers to create new APIs and plugins to expand the capacity and add new possibilities.

3. Updating Lag

When updates for Android, iOS and Windows are released, Xamarin developers can’t use them immediately. They need some time to properly integrate new features into the ecosystem, which causes an updating delay (of one or two days) and may affect the company’s reputation.

4. Performance

Though Xamarin-based applications provide near-native performance, they are still slower than native solutions. If performance is critical for a client company, Xamarin may not be the best fit.

Xamarin Integrated Development Environment (IDE)

You can use several IDEs for developing Xamarin-based applications.

Initially, there was Xamarin Studio, a proprietary environment for Mac and Windows app development (later only for Mac apps). This tool is now obsolete and has been replaced by Visual Studio for Mac.

Currently, Visual Studio is the basic environment for working with Xamarin. It has four versions:

• Visual Studio Community — an option for small teams, students and open-source projects.
• Visual Studio Professional — a set of powerful tools for code-writing for small teams of professional developers.
• Visual Studio Enterprise — an environment for large, complex projects.
• Visual Studio Code (VS Code) — not a full-featured IDE, but a lightweight code editor providing basic tools for creating simple applications.

Latest News: .NET MAUI

Xamarin is not standing still. The next milestone in platform development is the release of .NET MAUI, scheduled for Q2 2022. MAUI stands for Multiplatform App UI, and will be a merger of .NET and Xamarin.Forms.

The new product will feature the improved Xamarin.Forms architecture and low-code elements, and will provide access to all native APIs. Xamarin.Native will become part of the .NET 6 platform.

Microsoft will still support Xamarin for some time, but they won’t release new versions.

Developers are looking forward to getting acquainted with MAUI and leveraging its capabilities for new projects. We at SaM Solutions stay tuned for updates and will guarantee the smooth migration of our existing Xamarin-based apps to the new platform.

Our Experience with Xamarin

Xamarin experts at SaM Solutions have been providing services for more than eight years and have successfully completed more than ten projects.

Our Xamarin competencies include:

• Business needs and requirements analysis
• App development
• Support and maintenance
• UI/UX design
• Legacy native mobile app improvement and performance optimization
• Mobile testing services

One of our clients needed a solution with two separate mobile apps for two specific user groups to collaborate. Developing different apps for iOS and Android would have been time-consuming and would have resulted in high expenses along the way. That’s why the client opted for Xamarin cross-platform development.

As a result, the cross-platform solution was developed and successfully launched on iOS and Android. Our team was involved in the following stages of product creation:

• Requirement definition
• Application development
• Testing
• Design
• Execution
• Support and maintenance

In another project, the challenge was to develop a mobile application for both iOS and Android platforms that would control electronic locks in smart home systems.

Our Xamarin team was responsible for the system architecture design, development, quality assurance and automated testing. They successfully created and launched the IoT mobile application.

Making a Mobile Choice

Developing mobile applications with Xamarin makes programming more efficient and cost-effective while maintaining all native apps’ features. But this is not a “one size fits all” solution.

In many cases, we have found Xamarin to be a successful tool that dramatically cuts both creation- and maintenance-related costs due to a sharable codebase without compromising quality. So, we see it as a potential game-changer for many.

Still, Android and iOS continue to rule the mobile industry, and you have to weigh the pros and cons of native vs. cross-platform development when choosing the fastest, cheapest and most efficient way to build your solution.

Specialists at SaM Solutions have in-depth experience in creating both native and cross-platform mobile apps. We are a reliable partner, so don’t hesitate to contact us for a detailed discussion of your future project.

In this article, I will tell you how you can easily configure a part of continuous integration and continuous delivery (CI/CD) while engaged in cross-platform development with the help of Azure Pipelines. You will also learn how to build projects on your local machines instead of Microsoft-hosted agents.

Why Build a Xamarin App with Azure Pipelines?

Xamarin is a framework for cross-platform mobile app development that targets Android, iOS and Windows using C#, .NET and Visual Studio. Xamarin allows a large portion of code to be shared between platforms, with only a small percentage that needs to be platform-specific.

Imagine this situation: you’ve implemented some changes for the iOS part, but they have disrupted something in the Android part, and you can’t even launch it. Of course, separate compilation and testing of several solutions are possible, but it would be time-consuming.

So, the best way out is to use Azure Pipelines — a cloud service that allows you to automatically build and test several jobs in parallel and make them available to other users. This option is quick, easy and safe.

In simple words, I push changes to the branch and then observe in Azure how the builds are compiling. If I see that the build for iOS is done, and the build for Android failed (a red icon), I understand that there is an issue and can immediately fix it.

Instruction for Azure Pipelines Configuration

To use Azure Pipelines, you need to have:

• A Microsoft account
• An organization in Azure DevOps
• Your source code stored in a version control system

For the first step, sign in to your Azure DevOps organization and navigate to your project. From the left menu select Pipelines, then click New button and select New build pipeline.

Select the Version control system and the necessary repository.

On the Configure step, you can select Starter pipeline (to start with a minimal pipeline) or Xamarin.Android\Xamarin.iOS (to start with minimal logic of building a Xamarin Android\iOS project). Let’s choose Xamarin.Android. It generates the following YAML file:

#Xamarin.Android
#Build a Xamarin.Android project.
#Add steps that test, sign, and distribute an app, save build artifacts, and more:
#https://docs.microsoft.com/azure/devops/pipelines/languages/xamarin

trigger:
master

pool:
vmImage: 'macos-latest'

variables:
buildConfiguration: 'Release'
outputDirectory: '$(build.binariesDirectory)/$(buildConfiguration)'

steps:
- task: NuGetToolInstaller@0

- task: NuGetCommand@2
inputs:
restoreSolution: '**/*.sln'

- task: XamarinAndroid@1
inputs:
projectFile: '**/*droid*.csproj'
outputDirectory: '$(outputDirectory)'
configuration: '$(buildConfiguration)'

Let’s briefly take a look at it and fix some lines:

• Trigger (as the name suggests) works on a push to specific branches. In the code above, the build will start only when we push something to the master branch.
• Pool is an agent pool on which build will run; by default, it uses Azure Agents Pool. (Later in the article I will describe how to configure your own pool on your local machine).
• Next, we can pass some variables. For example, build configuration and output directory.
• In the section steps, we start working with our project. We install NuGet (NuGetToolInstaller@0), install and update packages (NuGetCommand@2) and Build Xamarin Android project (XamarinAndroid@1).

After some changes the file looks like this:

#https://docs.microsoft.com/azure/devops/pipelines/languages/xamarin

pool:
vmImage: 'macos-latest'
variables:
 buildConfiguration: 'Release'
outputDirectory: '$(build.binariesDirectory)/$(buildConfiguration)'
steps:
- task: NuGetToolInstaller@0
- task: NuGetCommand@2
 inputs:
restoreSolution: '**/HelloWorld.Droid.sln'
- task: XamarinAndroid@1
 inputs:
projectFile: '**/HelloWorld.Droid.csproj'
outputDirectory: '$(outputDirectory)'
configuration: '$(buildConfiguration)'

Click Save and Run. The build pipeline is created and automatically starts building.

You can find more information about the Android part here.

Now we need to create an iOS build. There are two possible approaches:

• Create a separate build pipeline
• Add another job inside the current pipeline

The difference is that if we have two separate builds, we can run them in parallel. But for the first variant, we need another agent. Just repeat steps described above, but choose Xamarin.iOS on the Configure step.

For the second variant (another job in one pipeline file), edit our Azure Pipeline file according to the screenshot below:

jobs:
- job: Android
 pool:
vmImage: 'vs2017-win2016'
 variables:
buildConfiguration: 'Release'
outputDirectory: '$(build.binariesDirectory)/$(buildConfiguration)'
steps:
- task: NuGetToolInstaller@0
- task: NuGetCommand@2
inputs:
restoreSolution: '**/HelloWorld.Droid.sln'
- task: XamarinAndroid@1
inputs:
projectFile: '**/HelloWorld.Droid.csproj'
outputDirectory: '$(outputDirectory)'
configuration: '$(buildConfiguration)'

- job: iOS
 pool:
 vmImage: 'macos-latest'
 variables:
 buildConfiguration: 'Release'
steps:
- task: NuGetToolInstaller@0
inputs:
versionSpec: '4.3.0'
- task: NuGetCommand@2
inputs:
restoreSolution: '**/HelloWorld.iOS.sln'
- task: XamariniOS@2
inputs:
solutionFile: '**/HelloWorld.iOS.csproj'
configuration: '$(buildConfiguration)'
buildForSimulator: true
packageApp: false

You can find more information about the iOS part here.

Click Save and go to Pipelines – Builds. It’s automatically started. Now we can see the building process of our solution. It’s separate for two jobs (Android and iOS). If the job has a red status, it means that something has gone wrong. You can click on the failed job and expand the failed step to see full information about it. In my example, everything goes well and I can see the Succeed status.

Steps to Configure the Local Agent on a Mac

If you want to run builds on your local machine or run two builds in parallel or save the results of your program (.ipa and .apk files for example), the best solution for you is to create your own self-hosted agent. Below, I described steps you should take to configure it yourself on your local machine.

STEP 1

First of all, you need to generate a PAT (Personal Access Token). For this, go to Azure DevOps and click on your profile (in the upper right corner of the screen), then click on Security:

Create a personal access token by clicking the New Token button. Enter the name, select expiration, for the scope select Agent Pools (read, manage) and make sure all the other boxes are cleared. Click Create and copy the token. You’ll use this token when you configure the agent.

STEP 2

Now we should create the Agent Pool. For this, click project settings (in the lower left corner of the screen), select Agent pools and click the Add pool button.

In the window that appears, enter a name and click Create. The Agent Pool is created. Now we should download and configure the agent on the machine.

STEP 3

To download the agent, select the pool you’ve just created from the list, then click New Agent. In the modal window select your OS (on which the agent will be located) and click Download the agent. It starts downloading.

Unpack the agent into the directory of your choice. Then run config.cmd.

• When setup asks for your server URL, for Azure DevOps Services, answer https://dev.azure.com/{your-organization}.
• When setup asks for your authentication type, click Enter (it will choose PAT). Then paste the PAT token you created into the command prompt window.
• And finally, choose run the agent as a service.

After you finish configuring the agent, the console is closed automatically. To run the agent, open run.cmd. 

To check your agent status, do the following:

• Go to your Azure DevOps portal
• Then go to project settings
• Select agent pools list
• Select your pool
• Finally, go to Agents tab

Our agent should be shown there and the status should be online.

Build should run automatically on your local machine when you push something to your repository.

That’s all. Hope, this information is useful for your work.