- Xamarin Mac And Windows App Installer
- Mac For Xamarin Development
- Xamarin Mac And Windows Applications
Sep 29, 2016 Create an Apple account and provide all the details in Apple App Store. Download XCode (4.43 GB) from there. If it asks for administrator password, enter 123 in the password textbox. After XCode is installed, go to xamarin.com, login with your credentials, and install Xamarin Studio for Mac on your macOS. Xamarin is for all mobile developers who want to reach users on major device platforms with great, native apps. Increasingly, app publishers and companies who initially built apps in Objective-C and Java are standardizing on Xamarin to share code across platforms, to go faster, and to spend more time on features and user experience, and less time maintaining disparate, duplicate code bases. Xamarin.Mac helps in the development of 100% native Mac apps in C# and.NET using macOS APIs. Mac is one of the major benefits of Xamarin that makes it a popular choice among mobile app. Step-by-step instructions for Windows. Download the sample. Follow these steps along with the video above: Choose File New Project. Or press the Create new project. Button, then select Visual C# Cross-Platform Mobile App (Xamarin.Forms). Ensure Android and iOS are selected, with.NET Standard code sharing. Wait until the NuGet packages are restored (a 'Restore completed' message.
-->App Center Distribute will let your users install a new version of the app when you distribute it via App Center. With a new version of the app available, the SDK will present an update dialog to the users to either download or postpone the new version. Once they choose to update, the SDK will start to update your application.
Warning
Google Play considers the in-app update code as malicious behavior even if it isn’t used at runtime. Use a variant of the Distribute SDK as directed in this section before submitting your app to Google Play. Failure to not remove the in-app update code can lead to noncompliance and removal of the app from Google Play.
Note
If you are running automated UI tests, enabled in-app updates will block your automated UI tests as they will try to authenticate against the App Center backend. We recommend to not enable App Center Distribute for your UI tests.
Add in-app updates to your app
Follow the Get started section if you haven't set up and started the SDK in your application, yet.
1. Add the App Center Distribute module
The App Center SDK is designed with a modular approach – a developer only needs to integrate the modules of the services that they're interested in.
Visual Studio for Mac
- Open Visual Studio for Mac.
- Click File > Open and choose your solution.
- In the solution navigator, right click the Packages section, and choose Add NuGet packages...
- Search for App Center, and install App Center Distribute.
- Click Add Packages.
Visual Studio for Windows
- Open Visual Studio for Windows.
- Click File > Open and choose your solution.
- In the solution navigator, right-click References and choose Manage NuGet Packages.
- Search for App Center, and install Microsoft.AppCenter.Distribute.
Package Manager Console
- Open the console in Visual Studio. To do this, choose Tools > NuGet Package Manager > Package Manager Console.
- If you're working in Visual Studio for Mac, make sure you have the NuGet Package Management Extensions installed. For this, choose Visual Studio > Extensions, search for NuGet and install, if necessary.
- Type the following command in the console:
Note
If you use the App Center SDK in a portable project (such as Xamarin.Forms), you must install the packages in each of the projects: the portable, Android, and iOS ones. To do that, you should open each sub-project and follow the corresponding steps described in Visual Studio for Mac or Visual Studio for Windows sections.
2. Start App Center Distribute
To use App Center, you must opt in to the module(s) that you want to use. By default no modules are started and you will have to explicitly call each of them when starting the SDK.
2.1 Add App Center Distribute imports
Add the App Center Distribute imports before you get started with using Distribute module:
- Xamarin.iOS - Open the project's
AppDelegate.cs
file and add the following lines below the existingusing
statements - Xamarin.Android - Open the project's
MainActivity.cs
file and add the following lines below the existingusing
statements - Xamarin.Forms - Open the project's
App.xaml.cs
file and add the following lines below the existingusing
statements
2.2 Add the Start()
method
Add
Distribute
to your Start()
method to start App Center Distribute service.Xamarin.iOS
Open the project's
AppDelegate.cs
file and add the Start()
call inside the FinishedLaunching()
methodXamarin.Android
Open the project's MainActivity.cs file and add the
Start()
method call inside the OnCreate()
method:To enable in-app updates for debug builds on Android, call the following method before
AppCenter.Start
:Xamarin.Forms
To create a Xamarin.Forms app targeting both Android and iOS platforms, you must create two apps in the App Center portal - one for each platform. Creating two apps will give you two App secrets - one for Android and another one for iOS. Open the project's
App.xaml.cs
(or your class that inherits from Xamarin.Forms.Application
) in the shared or portable project and add the Start()
call inside the OnStart()
override method.For your iOS application, open the
AppDelegate.cs
and add the following line before the call to LoadApplication
:This step is not necessary on Android where the debug configuration is detected automatically at runtime.
To enable in-app updates for debug builds on Android, call the following method in the project's MainActivity.cs file, in the
OnCreate
method and before LoadApplication
.Note
This method only affects debug builds, and has no impact on release builds.
2.3 [For iOS only] Modify the project's Info.plist
App Center SDK checks urls redirecting to the application to avoid sideloading, so in order for updates distributed through the portal to be handled correctly, you would need to specify
CFBundleURLSchemes
in CFBundleURLTypes
section of Info.plist
file:Note
Info.plist
, or an information property list file is a structured text file that contains essential configuration information for a bundled executable.You can find more information about it in Apple developer documentation.- Add a new key for
URL types
orCFBundleURLTypes
in your Info.plist file (in case Xcode displays your Info.plist as source code). - Change the key of the first child item to
URL Schemes
orCFBundleURLSchemes
. - Enter
appcenter-${APP_SECRET}
as the URL scheme and replace${APP_SECRET}
with the App Secret of your app.
Tip
If you want to verify that you modified the Info.plist correctly, open it as source code. It should contain the following entry with your App Secret instead of
${APP_SECRET}
:Remove in-app updates for Google Play builds
Google Play considers the in-app update code as malicious behavior even if it isn’t used at runtime. Failure to not remove the in-app update code can lead to noncompliance and removal of the app from Google Play. In order to make it easier, we provide the version of App Center Distribute SDK with stubbed APIs, so the only change for you is just a dependency swap.
- Add a new build configuration named
GooglePlay
for your Xamarin.Android project. Make sure that the project build configuration is correctly mapped to the appropriate solution configuration. See Visual Studio or Visual Studio for Mac instructions for more details. - Open Xamarin.Android project's
.csproj
in any text editor and move distribute reference into the conditional item group:NoteIf you are using old packages.config format to manage NuGet references, you can migrate to a PackageReference format, follow the migration instruction. - Save your changes and restore NuGet packages.
- You can change the configuration in the command bar at the top of the IDE.
Use private distribution group
By default, Distribute uses a public distribution group. If you want to use a private distribution group, you will need to explicitly set it via
UpdateTrack
property.Note
The default value is
UpdateTrack.Public
. This property can only be updated before the AppCenter.Start
method call. Changes to the update track are not persisted when the application process restarts, and so if the property is not always updated before the AppCenter.Start
call, it will be public, by default.After this call, a browser window will open up to authenticate the user. All the subsequent update checks will get the latest release on the private track. The update track is not persisted in the SDK across app launches.
If a user is on the private track, it means that after the successful authentication, they will get the latest release from any private distribution groups they are a member of.If a user is on the public track, it means that they will get the latest release from any public distribution group.
Disable Automatic Check for Update
By default, the SDK automatically checks for new releases:
- When the application starts.
- When the application goes into background then in foreground again.
- When enabling the Distribute module if previously disabled.
If you want to check for new releases manually, you can disable automatic check for update.To do this, call the following method before the SDK start:
Note
Sleep pillow app mac. This method must be called before the
AppCenter.Start
method call.Then you can use the
CheckForUpdate
API which is described in the following section.Manually Check for Update
Note
A manual check for update call works even when automatic updates are enabled. A manual check for update is ignored if another check is already being performed. The manual check for update will not be processed if the user has postponed updates (unless the latest version is a mandatory update).
Customize or localize the in-app update dialog
1. Customize or localize text
You can easily provide your own resource strings if you'd like to localize the text displayed in the update dialog. Look at the string files for iOS in this resource file and those for Android in this resource file. Use the same string name/key and specify the localized value to be reflected in the dialog in your own app resource files.
2. Customize the update dialog
You can customize the default update dialog's appearance by implementing the
ReleaseAvailable
callback. You need to register the callback before calling AppCenter.Start
as shown in the following example:Here is an example on Xamarin.Forms of the callback implementation that replaces the SDK dialog with a custom one:
Implementation notes for Xamarin.Android:
As shown in the example, you have to either call
Distribute.NotifyUpdateAction(UpdateAction.UPDATE);
or Distribute.NotifyUpdateAction(UpdateAction.POSTPONE);
if your callback returns true
.If you don't call
NotifyUpdateAction
, the callback will repeat on every activity change.The callback can be called again with the same release if the activity changes before the user action is notified to the SDK.
This behavior is needed to cover the following scenarios:
- Your application is sent to the background (like pressing HOME) then resumed in a different activity.
- Your activity is covered by another one without leaving the application (like clicking on some notifications).
- Other similar scenarios.
Best macos youtube app. In that case, the activity hosting the dialog might be replaced without user interaction. So the SDK calls the listener again so that you can restore the custom dialog.
Enable or disable App Center Distribute at runtime
You can enable and disable App Center Distribute at runtime. If you disable it, the SDK will not provide any in-app update functionality but you can still use Distribute service in App Center portal.
To enable App Center Distribute again, use the same API but pass
true
as a parameter.You don't need to await this call to make other API calls (such as
IsEnabledAsync
) consistent.The state is persisted in the device's storage across application launches.
Note How to install unauthorized apps on mac os.
This method must only be used after
Distribute
has been started.Check if App Center Distribute is enabled
You can also check if App Center Distribute is enabled or not:
Note
This method must only be used after
Distribute
has been started, it will always return false
before start.How do in-app updates work?
Note
For in-app updates to work, an app build should be downloaded from the link. It won't work if installed from an IDE or manually.
The in-app updates feature works as follows:
- This feature only works with RELEASE builds (by default) that are distributed using App Center Distribute service. It won't work if the iOS Guided Access feature is turned on.
- Once you integrate the SDK, build release version of your app and upload to App Center, users in that distribution group will be notified for the new release via an email.
- When each user opens the link in their email, the application will be installed on their device. It's important that they use the email link to install - we do not support side-loading. When an application is downloaded from the link, the SDK saves important information from cookies to check for updates later, otherwise the SDK doesn’t have that key information.
- If the application sets the track to private, a browser will open to authenticate the user and enable in-app updates. The browser will not open again as long as the authentication information remains valid even when switching back to the public track and back to private again later. If the browser authentication is successful, the user is redirected back to the application automatically. If the track is public (which is the default), the next step happens directly.
- On iOS 9 and 10, an instance of
SFSafariViewController
will open within the app to authenticate the user. It will close itself automatically after the authentication succeeded. - On iOS 11, the user experience is similar to iOS 10 but iOS 11 will ask the user for their permission to access login information. This is a system level dialog and it cannot be customized. If the user cancels the dialog, they can continue to use the version they are testing, but they won't get in-app-updates. They will be asked to access login information again when they launch the app the next time.
- On iOS 9 and 10, an instance of
- A new release of the app shows the in-app update dialog asking users to update your application if it has:
- iOS:
- a higher value of
CFBundleShortVersionString
or - an equal value of
CFBundleShortVersionString
but a higher value ofCFBundleVersion
. - the versions are the same but the build unique identifier is different.
- a higher value of
- Android:
- a higher value of
versionCode
or - an equal value of
versionCode
but a different value ofversionName
.
- a higher value of
Tip
If you upload the same apk/ipa a second time, the dialog will NOT appear as the binaries are identical. On iOS, if you upload a new build with the same version properties, it will show the update dialog. The reason for this is that it is a different binary. On Android, binaries are considered the same if both version properties are the same.
How do I test in-app updates?
You need to upload release builds (that use the Distribute module of the App Center SDK) to the App Center Portal to test in-app updates, increasing version numbers every time.
- Create your app in the App Center Portal if you haven't done that already.
- Create a new distribution group and name it so you can recognize that this is just meant for testing the in-app update feature.
- Add yourself (or all people who you want to include on your test of the in-app update feature). Use a new or throw-away email address for this, that was not used for that app on App Center. This ensures that you have an experience that's close to the experience of your real testers.
- Create a new build of your app that includes App Center Distribute and contains the setup logic as described below. If the group is private, don't forget to set the private in-app update track before start using the
UpdateTrack
property. - Click on the Distribute new release button in the portal and upload your build of the app.
- Once the upload has finished, click Next and select the Distribution group that you just created as the Destination of that app distribution.
- Review the Distribution and distribute the build to your in-app testing group.
- People in that group will receive an invite to be testers of the app. Once they accept the invite, they can download the app from the App Center Portal from their mobile device. Once they have in-app updates installed, you're ready to test in-app updates.
- Bump the version of your app (
CFBundleShortVersionString
orCFBundleVersion
for iOS,versionCode
for Android) - Build the release version of your app and upload a new build of your app just like you did in the previous step and distribute this to the Distribution Group you created earlier. Members of the Distribution Group will be prompted for a new version the next time the app starts.
Tip
Have a look at the information on how to utilize App Center Distribute for more detailed information about Distribution Groups etc.While it is possible to use App Center Distribute to distribute a new version of your app without adding any code, adding App Center Distribute to your app's code will result in a more seamless experience for your testers and users as they get the in-app update experience.
Disable automatic forwarding of application delegate's methods to App Center services
App Center uses swizzling to automatically forward your application delegate's methods to App Center services to improve SDK integration. There is a possibility of conflicts with other third party libraries or the application delegate itself. In this case, you might want to disable the App Center application delegate forwarding for all App Center services by following the steps below:
- Open the project's Info.plist file.
- Add
AppCenterAppDelegateForwarderEnabled
key and set the value to0
. This will disable application delegate forwarding for all App Center services. - Add
OpenUrl
callback in yourAppDelegate.cs
file.
Nearly everyone these days has a mobile phone, and most of these are smartphones. Everyone downloads apps, from social media to games to fitness.
As developers, a lot of you probably think about making an app for your phones. Whether it's just for a laugh, or to solve an actual problem, our curious minds get us thinking.
In this post you will get an introduction to how you can create mobile apps using C# and Visual Studio, taking advantage of the awesome Xamarin mobile tooling built into Visual Studio.
Xamarin Mac And Windows App Installer
Today you will cover the following set of topics:
- What is Xamarin?
- What tools will I need?
- Getting started with the Visual Studio tools for Xamarin
- Creating a simple counter app
- Learning more
If you would like to see a full integration of Twilio APIs in a .NET Core application then checkout this free 5-part video series. It's separate from this blog post tutorial but will give you a full run down of many APIs at once.
What is Xamarin?
Xamarin is a cross-platform mobile development framework that now ships with Visual Studio 2019 for Windows and Visual Studio for Mac.
It is a thin wrapper around the native APIs and tooling, so anything you can do in Java/Kotlin for Android, or Objective-C/Swift for iOS, you can do in Xamarin using the C# goodness we know and love.
In fact, it is not just C# that can be used to write Xamarin; F# can be used too! F#, as you may well know, is the functional .NET programming language. Both use the same native Android/iOS code underneath for the components, building the application, and running it. So once you deploy it there is no way to tell how the app was made—or in what language!
There is even day 1 support so, as a new OS release or feature comes out, Xamarin will have a release available to support it. That is a huge advantage over other HTML-based mobile technologies as they often require time for someone to develop the component that compiles to the native equivalent.
Xamarin Native vs Xamarin.Forms
As you will see in the image above, there are two types of Xamarin project you can create: Xamarin Native, the traditional Xamarin approach as it is sometimes called, or Xamarin.Forms.
Both share a common code base, either in C# or F#, which means business logic can be shared across platforms. So code for things like accessing databases, talking to cloud services like Azure etc, can be written once and used regardless of whether the code is being deployed to Android, iOS, UWP, or any other platform supported by Xamarin.
Where the two types of project differ is in the UI and how it is created. Either option still compiles down into the native components, but how you write it is different.
Mac For Xamarin Development
With the Xamarin Native approach, each platform’s UI is written separately. So iOS still uses Storyboards, Android uses AXML, and UWP uses XAML. The downside to this approach is that you need to be able to develop those UI’s individually; that requires not only expertise in each of those, but also time. If you are trying to prototype a cross-platform app on a low budget quickly, this can add overhead. However, because Xamarin.Native is just a thin wrapper around the native APIs, anything you can do in the native environment you can do with the Native approach. This makes it a powerful and completely viable alternative to native development, with the benefit of shared code and using the same .NET languages you love.
With Xamarin.Forms you have the option of writing your UI declaratively in code or using XAML.
The great thing with Xamarin.Forms is that you write the UI once and it is compiled to the native language for whatever platform you are deploying to, just like Xamarin.Native. As mentioned previously, it will look identical to the non-Xamarin native apps, so you will not know how it was made, and will have the time-saving benefits of a cross-platform UI.
The main difference is that Xamarin.Forms is both shared UI and shared business logic, so not everything you can do natively is possible here—or it requires more work. The individual platforms will implement some features differently, such as taking pictures and checking for cellular connectivity. This is where plugins or libraries come in. These nifty little gems (often NuGet packages) are the result of someone kind and smart deciding to take away the hard work of implementing it for each platform. So you add the library to your project and start using it to do whatever it is you are trying to achieve by calling the library code from your project code.
A few years ago the recommendation from Xamarin, at the time an independent company, was that if you wanted to do something graphics-intensive, for example, you were better off going with Xamarin.Native. However, with the evolution of products such as SkiaSharp, these limitations are shrinking every year—maybe even every month—and Xamarin.Forms becomes a viable option for more and more project ideas.
What tools will I need?
When it comes to developing Xamarin, you have 3 main IDE choices. Visual Studio 2019, Visual Studio for Mac, or Rider.
All three come with support for Xamarin out of the box. The download and installation instructions for each can be found below:
Visual Studio for both Windows and macOS supports Xamarin for free; you only require the Community edition.
Rider will require either a subscription to the whole toolbox, if you use other JetBrains products such as intelliJ, or just a subscription to the one product.
Getting started
The following steps will walk you through creating your first blank Xamarin.Forms project on both Windows and Mac and building your first Xamarin app!
These steps assume you have followed the relevant installation guide above and have all the tools required to get started.
Visual Studio 2019 for Windows
You can begin a new project by clicking Create a new project from the Welcome Window, shown below, or by selecting File > New > Project… from the menu bar.
In the Create a new project window, select Mobile from the Project Type list, Then select Mobile App (Xamarin.Forms) from the Filtering by: Mobile list and click Next.
In the Configure your new project window, enter 'Counter' in the Project name box, select a directory in which to save the project in the Location box, and accept the proposed value in the Solution box. Leave Place solution and project in the same directory unchecked. Click Create.
The New Cross Platform App window should open.
In the Select a template list, select Blank. Under Platform select Android and iOS. Click OK.
Visual Studio for Mac
You can begin a new project by clicking New on the right-hand side of the Welcome Window, shown below, or by selecting File > New Solution… from the menu bar.
On the left-hand side of the New Project window, under the Multiplatform category, click App, select Blank Forms App, ensuring that the drop-down box next to it is set to C#. Click Next.
Xamarin Mac And Windows Applications
In the App Name box, enter “Counter”. Organization Identifier is used as an identifier in your app if published to the app store, so in this case you can leave this value as the default if you wish. Click Next.
Select a Location to store the project on your hard drive. Ensure that the platforms you want to target are selected and Shared Code is set to “Use .NET Standard” then click Next.
Understanding the new solution
So the solution has loaded and your blank Xamarin.Forms project has been created, but what are all these projects you see?
Shared project
Depending on the platforms you are targeting, you will have up to 4 projects in your solution. The first is your shared project. This is where all your UI and shared code lives. You will learn more about the important files in that folder when you start writing code later in this tutorial.
Platform-specific projects
One of the projects in your solution will be called <ProjectName>.Android. As you can imagine, this is the Android project.
If you ever have written any native Android code in Kotlin or Java, this project will look very familiar. It has the Resources folder, which contains the drawable folders for images at different resolutions, layouts, and the MainActivity.cs file, in this case with a .cs extension for C#, a Properties folder containing your AppManifest file, which adds information about the application, and many other items.
Unlike in a Xamarin.Native project, the layout folder doesn’t contain your UI and all your MainActivity.cs class (configured for you) does is call into the shared code App.xaml.cs class to find what code to execute when the application loads.
If you selected iOS as a target operating system, you will also have a <ProjectName>.iOS project in your solution. It follows the same structure as a native iOS project written in Objective-C or Swift.
The AppDelegate.cs file initializes the Xamarin.Forms library and calls into the Counter shared project to find the application to run, including the UI.
There is also the Info.plist file, which acts as the application information file, and Entitlements.plist, which identifies the device features to which the application needs access, such as HealthKit, Apple Pay, Siri, and many others.
The UWP Project will also look as expected from native development, this post will only focus on Android and iOS.
Coding the Counter app
It is that time..first app time! Now you have your new project created and you understand the solution structure better, it is time to actually write some code!
This is a nice and simple app that is ideal to use to get started.
Begin with the user interface. You will want a way of displaying the current count and a button that makes the count increase.
Open the Main.XAML file in the Counter project folder. This is the default UI file the Visual Studio tooling creates from the New Project template. The file is templated with a stack layout containing a label centered vertically and horizontally saying “Welcome to Xamarin.Forms!” As you may guess from the name, a stack layout arranges UI components vertically. To learn more about different layout types in Xamarin.Forms, visit Layouts in Xamarin.Forms on docs.microsoft.com.
Delete the
StackLayout
element from the Main.XAML file and replace it with the following markup:The two main things here to take note of are the
x:Name
attribute on the Label
element and the Clicked
attribute on the Button
element. The x:Name
attribute is there so you can refer to the component in code. You do this so you can update the value as the button is clicked.As you can guess, the
Clicked
attribute on the button determines which method is called in code when the button is clicked. In this case it will be a method called IncrementCounterClicked
. The method doesn’t exist yet, so don’t worry about warnings from your IDE; you'll create the code for the method next.All Xamarin.Forms XAML files have an associated .cs partial class or “code behind” file which can be accessed by expanding the arrow next to the XAML file name in the Solution Explorer. Visual Studio and the Xamarin middleware use the file name, namespace, and class inheritance to automatically link any components referred to in the .xaml.cs code-behind file to the associated UI elements defined in the .xaml layout file for any pair of layout and code-behind files in the same namespace.
The Main.xaml.cs class is where you will code your app, including the method called from
Clicked
attribute on the Button
element in the layout.Replace the
MainPage
class in the MainPage.xaml.cs file with the following C# code:This is a very short and simple class, but it teaches you how to interact with your UI.
InitializeComponent()
is already written for you and is a Xamarin.Forms method for initializing all UI components for the associated XAML file.The
IncrementCounterClicked
method is fairly straightforward. The sender
parameter is the object that called the method, allowing it to be reused by multiple components. In this case it is only called from a Button
element so the sender will be Button
. EventArgs
allow you to pass data to the method; in this case you don’t require any, so this parameter can be ignored.As you can see, you reference your label using the
x:Name
you gave it earlier and set its text property to the string value of your current count. Boom!Customizing the appearance of your app
You will have noticed in the code you entered earlier that you make some changes to the font and color using attributes available on the components. This is the most common and “original” way of changing the appearance of your app. However, Xamarin.Forms also supports using CSS to style your app.
In this section you will learn what the same code would look like if you used CSS instead of in-line properties on the tags themselves.
This can be achieved by placing the CSS code at the top of the XAML file but this can be messy and confusing, so this it looks like the CSS is in a separate file:
Not much has changed in the above markup, but a
ContentPage.Resources
tag has been added before the StackLayout
element, which contains a Stylesheet
tag with the Source
attribute set to a styles.css file in the root of the shared project. The attributes on the components, which customize the appearance such as text color and font size, have also been removed.The CSS file itself looks like any other CSS file, but refers to the components themselves rather than id or class selectors:
It is important to note, however, that not everything that can be done regarding appearance using XAML tag properties can be done using CSS. To learn more about the different ways to use CSS and what can be customized, visit the docs.microsoft.com page on Styling Xamarin.Forms apps using CSS.
Learning more
Like many developers, now that you have experienced Xamarin you'll want to play more and do more things! You’ll probably want to run the app you just built, so look for the next post in this series: it will show you how to run your app using device emulators and actual smartphones.
Future posts in this series will cover data binding and the Model-View-ViewModel (MVVM) design pattern.
Summary
In this post, you have learned:
- What Xamarin is
- How you can use both C# and F#
- How to create your first app
- An understanding of the solution
- How to customize the appearance of a Xamarin app with CSS
Additional Resources
The code from this blog post can be found ion a companion repository on Github, with branches for the different steps. The Master branch is the most basic, then there are additional branches to allow you to see how the app architecture evolved.
No blog post is complete without useful links where you can continue learning, so below is a list of links that are very useful to new and experienced Xamarin devs alike:
Xamarin Documentation on Microsoft Docs
Xamarin.Essentials on Microsoft Docs – Essentials is an amazing library containing abstractions for common features that would be implemented differently on each platform, saving you from having to code it yourself. Examples include Accelerometer, Connectivity to a network, Geolocation and dozens more!
Cognitive Services – Cognitive Services is Microsoft’s super easy to use, super powerful AI/ML technology that allows you to bring in the magic of AI without having to train loads of models for common tasks from speech-to-text, facial recognition and language translation, to beyond.
App Center – App Center is a powerful end-to-end service intended for mobile applications. It allows you to build, test, distribute, analyse and diagnose your applications with a small amount of configuration. Perfect for anyone who likes CI/CD and/or metrics!
Xamarin.Forms Solutions – A fantastic book giving you great samples for solving common tasks in Xamarin.Forms.
Xamarin in Action – This book is about native development in Xamarin rather than Xamarin.Forms, but for those who want to write apps using the native approach instead this is a must-have book to get you started creating your first app.
Luce Carter is a Software Developer at dunnhumby by day, Microsoft MVP and Twilio Champion by night. She is also the face behind the scenes, editing content for @JamesMontemagno, ensuring editorial quality in his blogs and episode descriptions on his podcast network, @soundbitefm. She can be found at @LuceCarter1 on Twitter, LuceCarter on Github and blogs on her own website. She writes C# in her dayjob, working mainly on an ASP.Net backend but Xamarin is her passion. When not writing apps for fun she can be found speaking around the UK or Europe on her two favourite Microsoft technologies, Xamarin and Cognitive Services.