Search icon CANCEL
Subscription
0
Cart icon
Your Cart (0 item)
Close icon
You have no products in your basket yet
Arrow left icon
Explore Products
Best Sellers
New Releases
Books
Videos
Audiobooks
Learning Hub
Free Learning
Arrow right icon
Mastering Xamarin.Forms
Mastering Xamarin.Forms

Mastering Xamarin.Forms: App architecture techniques for building multi-platform, native mobile apps with Xamarin.Forms 4 , Third Edition

Arrow left icon
Profile Icon Ed Snider
Arrow right icon
Can$12.99 Can$33.99
Full star icon Full star icon Full star icon Full star icon Half star icon 4.1 (10 Ratings)
eBook Dec 2019 200 pages 3rd Edition
eBook
Can$12.99 Can$33.99
Paperback
Can$41.99
Subscription
Free Trial
Arrow left icon
Profile Icon Ed Snider
Arrow right icon
Can$12.99 Can$33.99
Full star icon Full star icon Full star icon Full star icon Half star icon 4.1 (10 Ratings)
eBook Dec 2019 200 pages 3rd Edition
eBook
Can$12.99 Can$33.99
Paperback
Can$41.99
Subscription
Free Trial
eBook
Can$12.99 Can$33.99
Paperback
Can$41.99
Subscription
Free Trial

What do you get with eBook?

Product feature icon Instant access to your Digital eBook purchase
Product feature icon Download this book in EPUB and PDF formats
Product feature icon Access this title in our online reader with advanced features
Product feature icon DRM FREE - Read whenever, wherever and however you want
Product feature icon AI Assistant (beta) to help accelerate your learning
OR
Modal Close icon
Payment Processing...
tick Completed

Billing Address

Table of content icon View table of contents Preview book icon Preview Book

Mastering Xamarin.Forms

Getting Started

The goal of this book is to focus on how to apply best practices and patterns to mobile apps built with Xamarin.Forms, and not on the actual Xamarin.Forms toolkit and API itself. The best way to achieve this goal is to build an app end to end, applying new concepts in each chapter.

Therefore, the goal of this chapter is to simply put together the basic structure of a Xamarin.Forms mobile app code base, which will serve as a foundation that we can build from throughout the rest of this book.

In this chapter, we will do the following:

  • Introduce and define the features of the app that we will build throughout the rest of the book
  • Create a new Xamarin.Forms mobile app with an initial app structure and user interface

In the next chapter we'll introduce the Model-View-ViewModel (MVVM) pattern and add data bindings to the user interface we create in this chapter. From there we will build upon the app and its architecture, introducing best practices and patterns for things like platform-specific API dependencies, dependency injection, remote data access, authentication, and unit testing. But, just like the beginning of many new mobile projects, we will start with an idea.

Introducing the app idea

We will create a travel app named TripLog and, as the name suggests, it will be an app that will allow its users to log their travel adventures. Although the app itself will not solve any real-world problems, it will have features that will require us to solve real-world architecture and coding problems. The app will take advantage of several core concepts, such as list views, maps, location services, and live data from a RESTful API, and we will apply patterns and best practices throughout this book to implement these concepts.

Defining features

Before we get started, it is important to understand the requirements and features of the TripLog app. We will do this by quickly defining some of the high-level things this app will allow its users to do:

  • View existing log entries (online and offline)
  • Add new log entries with the following data:
    • Title
    • Location using GPS
    • Date
    • Notes
    • Rating
  • Sign into the app

The following screenshots show some of the iOS and Android screens of the app we will be creating. The first screenshot shows the initial screen running on iOS with the list of all the user's trip log entries. The middle screenshot shows the trip log detail screen using native maps. The last screenshot shows the screen that lets users add new trip log entries running on Android:

Figure 1: The TripLog app as it will appear at the end of the book

Creating the initial app

To start off the new TripLog mobile app project, we will need to create the initial solution architecture. We can also create the core shell of our app's user interface by creating the initial screens based on the basic features we have just defined.

Setting up the solution

We will start things off by creating a brand new, blank Xamarin.Forms solution within Visual Studio by performing the following steps:

  1. In Visual Studio, click on File | New Solution. This will bring up a series of dialog screens that will walk you through creating a new Xamarin.Forms solution. On the first dialog, click on App on the left-hand side, under the Multiplatform section, and then select Blank Forms App, as shown in the following screenshot:

    Figure 2: Xamarin.Forms new project setup in Visual Studio (step 1 of 3)

  2. On the next dialog screen, enter the name of the app, TripLog, and ensure that Use .NET Standard is selected for the Shared Code option, as shown in the following screenshot:

    You can use either .NET Standard or a Shared Library for the code sharing option when creating a new Xamarin.Forms project. There are benefits to both but we will use .NET Standard, as it lends itself better to the architecture patterns and testability objectives of this book.

    Figure 3: Xamarin.Forms new project setup in Visual Studio (step 2 of 3)

  3. On the final dialog screen, simply click on the Create button, as follows:

    Figure 4: Xamarin.Forms new project setup in Visual Studio (step 3 of 3)

  4. After creating the new Xamarin.Forms solution, you will have several projects created within it, as shown in the following screenshot:

Figure 5: The TripLog solution in Visual Studio

There will be a single .NET Standard project and two platform-specific projects, as follows:

  • TripLog: This is a .NET Standard project that will serve as the core layer of the solution architecture. This is the layer that will include all our business logic, data objects, Xamarin.Forms pages, and other non-platform-specific code. The code in this project is common and not specific to a platform, and can therefore be shared across the platform projects.
  • TripLog.iOS: This is the iOS platform-specific project containing all the code and assets required to build and deploy the iOS app from this solution. By default, it will have a reference to the TripLog core project.
  • TripLog.Android: This is the Android platform-specific project containing all the code and assets required to build and deploy the Android app from this solution. By default, it will have a reference to the TripLog core project.

If you are using Visual Studio for Mac, you will only get an iOS and an Android project when you create a new Xamarin.Forms solution. To include a Windows (UWP) app in your Xamarin.Forms solution, you will need to use Visual Studio for Windows. Although the screenshots and samples used throughout this book are demonstrated using Visual Studio for Mac, the code and concepts will also work in Visual Studio for Windows. Refer to the Preface of this book for further details on software and hardware requirements that need to be met to follow along with the concepts in this book.

You'll notice a file in the core library named App.xaml, which includes a code-behind class in App.xaml.cs named App that inherits from Xamarin.Forms.Application. Initially, the App constructor sets the MainPage property to a new instance of a ContentPage named MainPage that simply displays some default text.

The first thing we will do in our TripLog app is build the initial views, or screens, required for our UI, and then update that MainPage property of the App class in App.xaml.cs.

Updating the Xamarin.Forms packages

If you expand the Dependencies > NuGet folder within the main TripLog project, and the Packages folder in each of the platform projects in the solution, you will see that Xamarin.Forms is a NuGet package that is automatically included when we select the Xamarin.Forms project template. It is possible that the included NuGet packages need to be updated. Update the Xamarin.Forms NuGet packages in each of the projects within the solution to the latest version available.

New for Third Edition!

In this edition of Mastering Xamarin.Forms we will take advantage of some of the new features and capabilities of Xamarin.Forms 4. To do this, we will require a minimum stable version of 4.3 of the Xamarin.Forms NuGet package.

Creating the main page

The main page of the app will serve as the entry point into the app and will display a list of existing trip log entries. Our trip log entries will be represented by a data model named TripLogEntry. Models are a key pillar in the MVVM pattern and data binding, which we will explore more in Chapter 2, MVVM and Data Binding; however, in this chapter, we will create a simple class that will represent the TripLogEntry model.

Let's now start creating the main page by performing the following steps:

  1. First, delete the default MainPage.xaml and its code-behind file, MainPage.xaml.cs, from the TripLog project. We will create our own MainPage.
  2. Next, add a new folder named Views to the root of the TripLog project. This folder will be where app pages in the application live.
  3. Next, add a new Xamarin.Forms XAML ContentPage to the Views folder in the TripLog project and name it MainPage.
  4. Next, update the MainPage property of the App class in App.xaml.cs to a new instance of Xamarin.Forms.NavigationPage whose root is a new instance of TripLog.MainPage that we just created:
    using Xamarin.Forms;
    using TripLog.Views;
    namespace TripLog
    {
        public partial class App : Application
        {
            public App()
            {
                InitializeComponent();
                MainPage = new NavigationPage(new MainPage());
            }
            // ...
        }
    }
    

    Notice how we are wrapping our MainPage with a NavigationPage. By doing this, we automatically get native components for navigating between pages.

  5. Create a new folder in the TripLog project named Models.
  6. Create a new empty class file in the Models folder named TripLogEntry.
  7. Update the TripLogEntry class with auto-implemented properties representing the attributes of an entry:
    public class TripLogEntry
    {
        public string Title { get; set; } 
        public double Latitude { get; set; } 
        public double Longitude { get; set; } 
        public DateTime Date { get; set; } 
        public int Rating { get; set; } 
        public string Notes { get; set; }
    }
    
  8. Now that we have a model to represent our trip log entries, we can use it to display some trips on the main page using a CollectionView control. We will use a DataTemplate to describe how the model data should be displayed in each of the rows in the CollectionView using the following XAML in the ContentPage.Content tag in MainPage.xaml:
    <ContentPage 
        xmlns="http://xamarin.com/schemas/2014/forms"
        xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
        x:Class="TripLog.Views.MainPage"
        Title="TripLog">
        <ContentPage.Content>
            <CollectionView x:Name="trips"
                SelectionMode="Single">
                <CollectionView.ItemTemplate>
                    <DataTemplate>
                        <Grid Padding="10">
                            <Grid.ColumnDefinitions>
                                <ColumnDefinition Width="1*" />
                                <ColumnDefinition Width="3*" />
                            </Grid.ColumnDefinitions>
                            <Grid.RowDefinitions>
                                <RowDefinition Height="Auto" />
                                <RowDefinition Height="Auto" />
                            </Grid.RowDefinitions>
                            <Label Grid.RowSpan="2"
                                   Text="{Binding Date, StringFormat='{0:MMM d}'}" />
                            <Label Grid.Column="1"
                                   Text="{Binding Title}"
                                   FontAttributes="Bold" />
                            <Label Grid.Column="1"
                                   Grid.Row="1"
                                   Text="{Binding Notes}" />
                        </Grid>
                    </DataTemplate>
                </CollectionView.ItemTemplate>
            </CollectionView>
        </ContentPage.Content>
    </ContentPage>
    
  9. In the main page's code-behind, MainPage.xaml.cs, we will populate the CollectionView ItemsSource with a hardcoded collection of TripLogEntry objects. In the next chapter, we will move this collection to the page's data context (that is, its ViewModel), and in Chapter 6, API Data Access, we will replace this hardcoded data with data from a live Azure backend:
    public partial class MainPage : ContentPage
    {
        public MainPage()
        {
            InitializeComponent();
            var items = new List<TripLogEntry>
            {
                new TripLogEntry
                {
                    Title = "Washington Monument", 
                    Notes = "Amazing!",
                    Rating = 3,
                    Date = new DateTime(2019, 2, 5),
                    Latitude = 38.8895,
                    Longitude = -77.0352
                },
                new TripLogEntry
                {
                    Title = "Statue of Liberty", 
                    Notes = "Inspiring!",
                    Rating = 4,
                    Date = new DateTime(2019, 4, 13),
                    Latitude = 40.6892,
                    Longitude = -74.0444
                },
                new TripLogEntry
                {
                    Title = "Golden Gate Bridge", 
                    Notes = "Foggy, but beautiful.", 
                    Rating = 5,
                    Date = new DateTime(2019, 4, 26),
                    Latitude = 37.8268,
                    Longitude = -122.4798
                }
            };
            trips.ItemsSource = items;
        }
    }
    

At this point, we have a single page that is displayed as the app's main page. If we debug the app and run it in a simulator, emulator, or on a physical device, we should see the main page showing the list of log entries we hardcoded into the view, as shown in the following screenshot:

Figure 6: The TripLog main page

In Chapter 2, MVVM and Data Binding, we will refactor this quite a bit as we implement MVVM and leverage the benefits of data binding.

Creating the new entry page

The new entry page of the app will give the user a way to add a new log entry by presenting a series of fields to collect the log entry details. There are several ways to build a form to collect data in Xamarin.Forms. You can simply use a StackLayout and present a stack of Label and Entry controls on the screen, or you can also use a TableView with various types of ViewCell elements. In most cases, a TableView will give you a very nice default, platform-specific look and feel. However, if your design calls for a more customized aesthetic, you might be better off leveraging the other layout options available in Xamarin.Forms. For the purpose of this app, we will use a TableView.

There are some key data points we need to collect when our users log new entries with the app, such as title, location, date, rating, and notes. For now, we will use a regular EntryCell element for each of these fields. We will update, customize, and add things to these fields later in this book. For example, we will wire the location fields to a geolocation service that will automatically determine the location. We will also update the date field to use an actual platform-specific date picker control. For now, we will just focus on building the basic app shell.

In order to create the new entry page that contains a TableView, perform the following steps:

  1. First, add a new Xamarin.Forms XAML ContentPage to the Views folder in the TripLog project and name it NewEntryPage.
  2. Update the new entry page using the following XAML to build the TableView that will represent the data entry form on the page:
    <ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
        xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
        x:Class="TripLog.Views.NewEntryPage"
        Title="New Entry">
        <ContentPage.Content>
            <TableView Intent="Form">
                <TableView.Root>
                    <TableSection>
                        <EntryCell Label="Title" />
                        <EntryCell Label="Latitude"
                            Keyboard="Numeric" />
                        <EntryCell Label="Longitude"
                            Keyboard="Numeric" />
                        <EntryCell Label="Date" />
                        <EntryCell Label="Rating"
                            Keyboard="Numeric" />
                        <EntryCell Label="Notes" />
                    </TableSection>
                </TableView.Root>
            </TableView>
        </ContentPage.Content>
    </ContentPage>
    

Now that we have created the new entry page, we need to add a way for users to get to this new screen from the main page. We will do this by adding a New button to the main page's toolbar. In Xamarin.Forms, this is accomplished by adding a ToolbarItem to the ContentPage.ToolbarItems collection and wiring up the ToolbarItem.Clicked event to navigate to the new entry page, as shown in the following XAML:

<!-- MainPage.xaml -->
<ContentPage
    xmlns="http://xamarin.com/schemas/2014/forms"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
    x:Class="TripLog.Views.MainPage"
    Title="TripLog">
    <ContentPage.ToolbarItems>
        <ToolbarItem Text="New" Clicked="New_Clicked" />
    </ContentPage.ToolbarItems>
    <ContentPage.Content>
        <!-- ... -->
    </ContentPage.Content>
</ContentPage>
// MainPage.xaml.cs
public partial class MainPage : ContentPage
{
    // ...
    void New_Clicked(object sender, EventArgs e)
    {
        Navigation.PushAsync(new NewEntryPage());
    }
}

In Chapter 3, Navigation, we will build a custom service to handle navigation between pages and will replace the Clicked event with a data-bound ICommand ViewModel property, but for now, we will use the default Xamarin.Forms navigation mechanism.

When we run the app, we will see a New button on the toolbar of the main page. Clicking on the New button should bring us to the new entry page, as shown in the following screenshot:

Figure 7: The TripLog new entry page

We will need to add a save button to the new entry page toolbar so that we can save new items. For now, this button will just be a placeholder in the UI that we will bind an ICommand to in Chapter 2, MVVM and Data Binding. The save button will be added to the new entry page toolbar in the same way the New button was added to the main page toolbar. Update the XAML in NewEntryPage.xaml to include a new ToolbarItem, as shown in the following code:

<ContentPage>
    <ContentPage.ToolbarItems>
        <ToolbarItem Text="Save" />
    </ContentPage.ToolbarItems>
    
    <!-- ... -->
</ContentPage>

When we run the app again and navigate to the new entry page, we should now see the Save button on the toolbar, as shown in the following screenshot:

Figure 8: The TripLog new entry page with Save button

Creating the entry detail page

When a user clicks on one of the log entry items on the main page, we want to take them to a page that displays more details about that particular item, including a map that plots the item's location. Along with additional details and a more in-depth view of the item, a detail page is also a common area where actions on that item might take place, such as editing the item or sharing the item on social media. The detail page will take an instance of a TripLogEntry model as a constructor parameter, which we will use in the rest of the page to display the entry details to the user.

In order to create the entry detail page, perform the following steps:

  1. First, add a new Xamarin.Forms XAML ContentPage to the Views folder in the TripLog project and name it DetailPage.
  2. Update the constructor of the DetailPage class in DetailPage.xaml.cs to take a TripLogEntry parameter named entry, as shown in the following code:
    using Xamarin.Forms;
    using TripLog.Models;
    // ...
    public partial class DetailPage : ContentPage
    {
        public DetailPage(TripLogEntry entry)
        {
            // ...
        }
    }
    
  3. Add the Xamarin.Forms.Maps NuGet package to the core TripLog project and to each of the platform-specific projects. This separate NuGet package is required in order to use the Xamarin.Forms Map control in the next step.
  4. Update the XAML in DetailPage.xaml to include a Grid layout to display a Map control and some Label controls to display the trip's details, as shown in the following code:
    <ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
        xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
        xmlns:maps="clr-namespace:Xamarin.Forms.Maps;assembly=Xamarin.Forms.Maps"
        x:Class="TripLog.Views.DetailPage">
        <ContentPage.Content>
            <Grid>
                <Grid.RowDefinitions>
                    <RowDefinition Height="4*" />
                    <RowDefinition Height="Auto" />
                    <RowDefinition Height="1*" />
                </Grid.RowDefinitions>
                <maps:Map x:Name="map" Grid.RowSpan="3" />
                <BoxView Grid.Row="1" BackgroundColor="White"
                    Opacity=".8" />
                <StackLayout Padding="10" Grid.Row="1">
                    <Label x:Name="title"
                        HorizontalOptions="Center" />
                    <Label x:Name="date"
                        HorizontalOptions="Center" />
                    <Label x:Name="rating"
                        HorizontalOptions="Center" />
                    <Label x:Name="notes"
                        HorizontalOptions="Center" />
                </StackLayout>
            </Grid>
        </ContentPage.Content>
    </ContentPage>
    
  5. Update the detail page's code-behind, DetailPage.xaml.cs, to center the map and plot the trip's location. We also need to update the Label controls on the detail page with the properties of the entry constructor parameter:
    using Xamarin.Forms;
    using Xamarin.Forms.Maps;
    using TripLog.Models;
    
    // ...
    public DetailPage(TripLogEntry entry)
    {
        InitializeComponent();
        map.MoveToRegion(MapSpan.FromCenterAndRadius(
            new Position(entry.Latitude, 
                entry.Longitude),
                Distance.FromMiles(.5)));
        map.Pins.Add(new Pin
        {
            Type = PinType.Place, 
            Label = entry.Title,
            Position = new Position(entry.Latitude, entry.Longitude)
        });
        title.Text = entry.Title;
        date.Text = entry.Date.ToString("M");
        rating.Text = $"{entry.Rating} star rating";
        notes.Text = entry.Notes;
    }
    
  6. Next, we need to wire up the ItemTapped event of the CollectionView on the main page to pass the tapped item over to the entry detail page that we have just created, as shown in the following code:
    <!-- MainPage.xaml -->
    <CollectionView x:Name="trips"
        SelectionMode="Single"
        SelectionChanged="Trips_SelectionChanged">
        <!-- ... -->
    </CollectionView>
    // MainPage.xaml.cs 
    public partial class MainPage : ContentPage
    {
        // ...
        async void Trips_SelectionChanged(object s, SelectionChangedEventArgs e)
        {
            var trip = (TripLogEntry)e.CurrentSelection.FirstOrDefault();
            if (trip != null)
            {
                await Navigation.PushAsync(new DetailPage(trip));
            }
            // Clear selection 
            trips.SelectedItem = null;
        }
    }
    
  7. Next, add your Google Maps API Key to the AndroidManifest.xml file in the Android project:
    <application android:label="TripLog.Android">
        <meta-data 
            android:name="com.google.android.maps.v2.API_KEY"
            android:value="YOUR-MAPS-API-KEY-HERE" />
    </application>
    

    There are some additional steps required for Google Maps to work in the Android app. You can read more about how to properly set everything up in the Xamarin.Forms Map documentation at https://docs.microsoft.com/en-us/xamarin/xamarin-forms/user-interface/map.

  8. Finally, we will need to initialize the Xamarin.Forms.Maps library in each platform-specific startup class (AppDelegate for iOS and MainActivity for Android) using the following code:
    // in iOS AppDelegate 
    global::Xamarin.Forms.Forms.Init(); 
    Xamarin.FormsMaps.Init(); 
    LoadApplication(new App());
    // in Android MainActivity 
    global::Xamarin.Forms.Forms.Init(this, savedInstanceState); 
    Xamarin.FormsMaps.Init(this, savedInstanceState); 
    LoadApplication(new App());
    

Now, when we run the app and tap on one of the log entries on the main page, it will navigate us to the details page to see more detail about that particular log entry, as shown in the following screenshot:

Figure 9: The TripLog entry detail page

Summary

In this chapter, we built a simple three-page app with static data, leveraging the most basic concepts of the Xamarin.Forms toolkit. We used the default Xamarin.Forms navigation APIs to move between the three pages, which we will refactor in Chapter 3, Navigation, to use a more flexible, custom navigation approach.

Now that we have built the foundation of the app, including the basic UI for each page within the app, we'll begin enhancing the app with better architecture design patterns, live data with offline syncing, nicer looking UI elements, and tests. In the next chapter, we will introduce the MVVM pattern and data binding to the app to enforce a separation between the user interface layer and the business and data access logic.

Left arrow icon Right arrow icon

Key benefits

  • Updated for Xamarin.Forms 4
  • Packed with real-world scenarios and solutions to help you build professional grade mobile apps with Xamarin.Forms
  • Includes design patterns and best practice techniques that every mobile developer should know

Description

Discover how to extend and build upon the components of the most recent version of Xamarin.Forms to develop an effective, robust mobile app architecture. This new edition features Xamarin.Forms 4 updates, including CollectionView and RefreshView, new coverage of client-side validation, and updates on how to implement user authentication. Mastering Xamarin.Forms, Third Edition is one of the few Xamarin books structured around the development of a simple app from start to finish, beginning with a basic Xamarin.Forms app and going step by step through several advanced topics to create a solution architecture rich with the benefits of good design patterns and best practices. This book introduces a core separation between the app's user interface and the app's business logic by applying the MVVM pattern and data binding, and then focuses on building a layer of plugin-like services that handle platform-specific utilities such as navigation and geo-location, as well as how to loosely use these services in the app with inversion of control and dependency injection. You’ll connect the app to a live web-based API and set up offline synchronization before testing the app logic through unit testing. Finally, you will learn how to add monitoring to your Xamarin.Forms projects to track crashes and analytics and gain a proactive edge on quality.

Who is this book for?

This book is intended for .NET developers who are familiar with Xamarin mobile application development and the open source Xamarin.Forms toolkit. If you have already started working with Xamarin.Forms and want to take your app to the next level, making it more maintainable, testable and flexible, then this book is for you.

What you will learn

  • Find out how, when, and why to use architecture patterns and best practices with Xamarin.Forms
  • Implement the Model-View-ViewModel (MVVM) pattern and data binding in Xamarin.Forms mobile apps
  • Incorporate client-side validation in Xamarin.Forms mobile apps
  • Extend the Xamarin.Forms navigation API with a custom ViewModel-centric navigation service
  • Leverage the inversion of control and dependency injection patterns in Xamarin.Forms mobile apps
  • Work with online and offline data in Xamarin.Forms mobile apps
  • Use platform-specific APIs to build rich custom user interfaces in Xamarin.Forms mobile apps
  • Explore how to monitor mobile app quality using Visual Studio App Center

Product Details

Country selected
Publication date, Length, Edition, Language, ISBN-13
Publication date : Dec 30, 2019
Length: 200 pages
Edition : 3rd
Language : English
ISBN-13 : 9781839216817
Category :

What do you get with eBook?

Product feature icon Instant access to your Digital eBook purchase
Product feature icon Download this book in EPUB and PDF formats
Product feature icon Access this title in our online reader with advanced features
Product feature icon DRM FREE - Read whenever, wherever and however you want
Product feature icon AI Assistant (beta) to help accelerate your learning
OR
Modal Close icon
Payment Processing...
tick Completed

Billing Address

Product Details

Publication date : Dec 30, 2019
Length: 200 pages
Edition : 3rd
Language : English
ISBN-13 : 9781839216817
Category :

Packt Subscriptions

See our plans and pricing
Modal Close icon
$19.99 billed monthly
Feature tick icon Unlimited access to Packt's library of 7,000+ practical books and videos
Feature tick icon Constantly refreshed with 50+ new titles a month
Feature tick icon Exclusive Early access to books as they're written
Feature tick icon Solve problems while you work with advanced search and reference features
Feature tick icon Offline reading on the mobile app
Feature tick icon Simple pricing, no contract
$199.99 billed annually
Feature tick icon Unlimited access to Packt's library of 7,000+ practical books and videos
Feature tick icon Constantly refreshed with 50+ new titles a month
Feature tick icon Exclusive Early access to books as they're written
Feature tick icon Solve problems while you work with advanced search and reference features
Feature tick icon Offline reading on the mobile app
Feature tick icon Choose a DRM-free eBook or Video every month to keep
Feature tick icon PLUS own as many other DRM-free eBooks or Videos as you like for just Can$6 each
Feature tick icon Exclusive print discounts
$279.99 billed in 18 months
Feature tick icon Unlimited access to Packt's library of 7,000+ practical books and videos
Feature tick icon Constantly refreshed with 50+ new titles a month
Feature tick icon Exclusive Early access to books as they're written
Feature tick icon Solve problems while you work with advanced search and reference features
Feature tick icon Offline reading on the mobile app
Feature tick icon Choose a DRM-free eBook or Video every month to keep
Feature tick icon PLUS own as many other DRM-free eBooks or Videos as you like for just Can$6 each
Feature tick icon Exclusive print discounts

Frequently bought together


Stars icon
Total Can$ 209.97
C# 8.0 and .NET Core 3.0 – Modern Cross-Platform Development
Can$111.99
Mastering Xamarin.Forms
Can$41.99
Hands-On RESTful Web Services with ASP.NET Core 3
Can$55.99
Total Can$ 209.97 Stars icon
Banner background image

Table of Contents

11 Chapters
Getting Started Chevron down icon Chevron up icon
MVVM and Data Binding Chevron down icon Chevron up icon
Navigation Chevron down icon Chevron up icon
Platform-Specific Services and Dependency Injection Chevron down icon Chevron up icon
User Interface Chevron down icon Chevron up icon
API Data Access Chevron down icon Chevron up icon
Authentication Chevron down icon Chevron up icon
Testing Chevron down icon Chevron up icon
App Monitoring Chevron down icon Chevron up icon
Other Books You May Enjoy Chevron down icon Chevron up icon
Index Chevron down icon Chevron up icon

Customer reviews

Top Reviews
Rating distribution
Full star icon Full star icon Full star icon Full star icon Half star icon 4.1
(10 Ratings)
5 star 70%
4 star 10%
3 star 0%
2 star 0%
1 star 20%
Filter icon Filter
Top Reviews

Filter reviews by




Nadine MeiĂźner Apr 19, 2021
Full star icon Full star icon Full star icon Full star icon Full star icon 5
Wurde verschenkt. Dem beschenkten gefiel es Sehr.
Amazon Verified review Amazon
Skye Mar 06, 2020
Full star icon Full star icon Full star icon Full star icon Full star icon 5
If you have never tried Xamarin.Forms it can be very intimidating to jump in as a good Xamarin.Forms developer needs to understand iOS, Android and the Xamarin.Forms APIs. This book touches on every aspect of mobile app development from writing XAML, custom native renderers and app monitoring/analytics. I now recommend this book to Xamarin Developers and team members.Mastering Xamarin.Forms walks you through building a travel logging app from start to finish. This method of writing allows the app that is being written in each chapter to build on itself. There are detailed code samples for the reader to follow along using Visual Studio on windows or mac. I recommend to read the book chapter-to-chapter, but afterwards it is a great reference.I really enjoyed seeing the detailed code samples and explanations for all the popular topics. The author goes into detail about different open source projects in the Xamarin Ecosystem and shows the value of leveraging these libraries. Offline Data is a common troublesome topic in any mobile app, the chapter dedicated to offline data provides excellent advice for getting started in offline data.
Amazon Verified review Amazon
Jsh Apr 20, 2020
Full star icon Full star icon Full star icon Full star icon Full star icon 5
The blurb on the back cover says “Master Xamarin.Forms, Third Edition is one of the few Xamarin books structured around the development of a simple app from start to finish, beginning with a basic Xamarin.Forms app and going step by step through several advanced topics to create a solution architecture rich with the benefits of good design patterns and best practices”. That’s a fair description. I’ve read a lot of Xamarin.Forms books (probably the majority of Xamarin.Forms books), having been working with Xamarin.Forms solidly for 5+ years, and this is the best example I have seen of building up an app from scratch using good design patterns and practices.Whilst there are parts of the book where I would have liked it to go a bit further, there are bits where I would have liked an explanation of the pros and cons of possible alternatives rather than immediately pursuing one choice, and there are bits that I would do differently in complex apps, for the most part I find myself very satisfied with this book. It’s good to see the way that experienced developers do things. I already make use of some of Ed Snider’s work, using a NuGet that he worked on in my current app, as well as having used some of his code as a starting point that I have then adapted. As a result, I knew that Ed knows his stuff, and this book confirms that.One thing that I am also appreciative of, is that this book is well written and proofread. Whilst I haven’t typed all of the code in to check it, what I haven’t done is highlight error after error in the text, which is what I find myself doing in many of the Xamarin.Forms books that I have read. This one has been written well, so I haven’t been distracted from the technical content by errors in use of language.Recommended for intermediate and advanced developers.
Amazon Verified review Amazon
Alexandre Malavasi Jan 10, 2020
Full star icon Full star icon Full star icon Full star icon Full star icon 5
I just read a review copy of the this book written by Microsoft MVP Ed Snider and found it really easy to understand, even if the reader is not a Xamarin Developer, but is just familiar with .NET/C# platform.The book is absolutely worthwhile read for anyone who already knows and works with Xamarin, because it’s not only all of Xamarin.Forms 4' many features, it also takes you to the next level by showing you how to build high quality and standard enterprise mobile applications.I like the way the author explores the recommended approach for good and scalable architecture and the detailed explanation of the View-ViewModel (MVVM) framework. If you have never worked with this pattern, which is mandatory for a standard Xamarin app, the book is full of detailed examples that explain these patterns and show you how to put them to practical use.The book also contains a complete content reference to handling data between the App and external API’s Rest, covering local cache data, integrating with Azure Functions, HTTP requests and more.Given the breadth of its coverage from implementation from scratch with Authentication, to architecture design, API data service, unit tests, and dependency injection examples, I highly recommend this book for any mobile developers who want to learn Xamarin or go into it deeply. It is very well-written and offers lots of useful insights. Of all the books out there on Xamarin.Forms, this is the best one.
Amazon Verified review Amazon
Alvin Ashcraft Jan 19, 2020
Full star icon Full star icon Full star icon Full star icon Full star icon 5
There aren’t a lot of great Xamarin books available, but you can add this one to the shortlist. Mastering Xamarin.Forms by Ed Snider is a fantastic reference for mobile developers. If you’re a .NET developer with at least some exposure to Xamarin development, this book will give you the knowledge you need to build great mobile apps with Xamarin.Forms with Visual Studio on your Mac or Windows environment.Snider takes my favorite approach when writing the book. He builds an end-to-end sample app throughout the book, building onto it with the patterns and practices learned in each chapter. For me, getting hands-on and building a real-world app while reading a book or watching a video training course reinforces the lessons. The app in this book is a TripLog, which can be used as a travel log or diary.After creating the project and a couple of initial screens, Snider dives right into some patterns for mobile app development, starting with the MVVM (model-view-view model) pattern. With each pattern or practice, he explains the concept, how to implement it in Xamarin.Forms and .NET, and then explains how our apps benefit from the implementation. For MVVM, he goes into data binding and validation, which become trivial with the pattern.The next several chapters detail best practices for navigation, leveraging dependency injection to create platform-specific implementations across iOS, Android or UWP on Windows, and some UI tips for handling platform differences through custom renderers. Snider pulls some Azure concepts into the book with Azure Functions. Learn to make API calls from an app service into Azure Functions and then add authentication to Azure Functions and a login screen to the app. I’ve never used any data caching frameworks in my mobile apps, so the section on Akavache for caching was really helpful. It was pretty trivial to add some offline caching to the Xamarin app.The unit testing section is really thorough. I have seen many .NET books that just glance over the topic of unit testing and best practices for testing, but Snider really gives a solid base for readers here. Finally, in the final chapter, monitoring is covered. He mainly explains how to set up Visual Studio App Center to track some usage and the health of the app while it’s running out in the world. When optimally configured, this data can give the information developers need to keep their user base happy and engaged. Kudos to Ed Snider for a really well-written book for Xamarin.Forms developers. I strongly encourage you to check it out if you’re getting serious about building mobile apps.
Amazon Verified review Amazon
Get free access to Packt library with over 7500+ books and video courses for 7 days!
Start Free Trial

FAQs

How do I buy and download an eBook? Chevron down icon Chevron up icon

Where there is an eBook version of a title available, you can buy it from the book details for that title. Add either the standalone eBook or the eBook and print book bundle to your shopping cart. Your eBook will show in your cart as a product on its own. After completing checkout and payment in the normal way, you will receive your receipt on the screen containing a link to a personalised PDF download file. This link will remain active for 30 days. You can download backup copies of the file by logging in to your account at any time.

If you already have Adobe reader installed, then clicking on the link will download and open the PDF file directly. If you don't, then save the PDF file on your machine and download the Reader to view it.

Please Note: Packt eBooks are non-returnable and non-refundable.

Packt eBook and Licensing When you buy an eBook from Packt Publishing, completing your purchase means you accept the terms of our licence agreement. Please read the full text of the agreement. In it we have tried to balance the need for the ebook to be usable for you the reader with our needs to protect the rights of us as Publishers and of our authors. In summary, the agreement says:

  • You may make copies of your eBook for your own use onto any machine
  • You may not pass copies of the eBook on to anyone else
How can I make a purchase on your website? Chevron down icon Chevron up icon

If you want to purchase a video course, eBook or Bundle (Print+eBook) please follow below steps:

  1. Register on our website using your email address and the password.
  2. Search for the title by name or ISBN using the search option.
  3. Select the title you want to purchase.
  4. Choose the format you wish to purchase the title in; if you order the Print Book, you get a free eBook copy of the same title. 
  5. Proceed with the checkout process (payment to be made using Credit Card, Debit Cart, or PayPal)
Where can I access support around an eBook? Chevron down icon Chevron up icon
  • If you experience a problem with using or installing Adobe Reader, the contact Adobe directly.
  • To view the errata for the book, see www.packtpub.com/support and view the pages for the title you have.
  • To view your account details or to download a new copy of the book go to www.packtpub.com/account
  • To contact us directly if a problem is not resolved, use www.packtpub.com/contact-us
What eBook formats do Packt support? Chevron down icon Chevron up icon

Our eBooks are currently available in a variety of formats such as PDF and ePubs. In the future, this may well change with trends and development in technology, but please note that our PDFs are not Adobe eBook Reader format, which has greater restrictions on security.

You will need to use Adobe Reader v9 or later in order to read Packt's PDF eBooks.

What are the benefits of eBooks? Chevron down icon Chevron up icon
  • You can get the information you need immediately
  • You can easily take them with you on a laptop
  • You can download them an unlimited number of times
  • You can print them out
  • They are copy-paste enabled
  • They are searchable
  • There is no password protection
  • They are lower price than print
  • They save resources and space
What is an eBook? Chevron down icon Chevron up icon

Packt eBooks are a complete electronic version of the print edition, available in PDF and ePub formats. Every piece of content down to the page numbering is the same. Because we save the costs of printing and shipping the book to you, we are able to offer eBooks at a lower cost than print editions.

When you have purchased an eBook, simply login to your account and click on the link in Your Download Area. We recommend you saving the file to your hard drive before opening it.

For optimal viewing of our eBooks, we recommend you download and install the free Adobe Reader version 9.