Xamarin with Visual Studio. Launch your mobile development career by creating Android and iOS applications using .NET and C#

Cover Page
Title Page
Copyright Page
Dedication Page
About the Author
About the Reviewer
Acknowledgement
Preface
Errata
Table of Contents
1. The Importance of Mobile App Development
	Introduction
	Structure
	Objectives
	The importance of mobile app development
		Mobile devices and applications
			A brief history of modern mobile devices
			Mobile devices for everyone
			Mobile devices everywhere
		The importance of mobile apps for companies
		Career opportunities with mobile app development
			Making money with mobile app development
		Summarizing how a mobile system works
	The importance of a cross-platform approach
		Limitations of cross-platform code
		Application size and performance
			Understanding native applications
			Demystifying application performance issues
	Staying up to date with new devices and platforms
		Getting updates from Apple
		Getting updates from Google
		Getting news from Microsoft
	Conclusion
	Points to remember
2. Xamarin and Microsoft in the Mobile App Market
	Introduction
	Structure
	Objectives
	Xamarin as the app development framework
		Mobile App Development with Microsoft Skills
		Xamarin as a company
			Introducing the mono project
			The transition to Xamarin
		Microsoft in the mobile app ecosystem
			The importance of Microsoft investments on Xamarin
			Improved productivity with Microsoft tools and services
	Understanding Xamarin and Xamarin.Forms
		Advantages of Xamarin.Forms
		Hints about .NET MAUI
	Installing and configuring the development tools
		System requirements for Xamarin
			System requirements on Windows
			System requirements on macOS
			Android and iOS Devices
		Installing and configuring Microsoft Visual Studio
			Selecting workloads
			Checking for individual components
		Configuring Android devices for developer mode
		Minimum macOS configuration
	Conclusion
	Questions
	Points to remember
3. Introducing .NET and Visual Studio
	Introduction
	Structure
	Objectives
	Introducing .NET
		Introducing the .NET framework for Windows
			Locating the .NET framework on disk
			The .NET framework architecture
			The Common Language Runtime (CLR)
			Compilers and the concept of Assembly
			Assemblies in .NET
			The Base Class Library
		From .NET Framework to .NET Core
			Advantages of .NET Core
	.NET 6: One .NET
	Building applications with Visual Studio
		Signing in with a Microsoft account
			Synchronized settings
		Introducing the Start window
		Understanding projects and solutions
			Creating projects with C#
			Creating your first C# project
	Working with the Visual Studio IDE
		Working with tool windows
			Solution Explorer
			The Error List
			The Properties window
			The Output window
		Editing project properties
			Editing application settings
		Basic code editing features
			Syntax colorization
			Zooming the code editor
			Introducing IntelliSense
			Changing the Code Editor options
	Compiling, running, and debugging code
		Understanding configurations
		Running and Debugging Code
		Debugging your code
			Preparing the sample project for debugging
			Breakpoints and data tips
			Detecting and fixing runtime errors
	Conclusion
	Points to remember
	Key terms
4. The C# Programming Language
	Introduction
	Structure
	Objectives
	Understanding data types
		Meet the Common Type System
		Clarifying value types and reference types
		.NET primitive types
			Declaring and consuming variables
			Clarifying the difference between value and reference types
	Common data operators
		Equals and Not Equals Operators
		Arithmetic operators
		Conversion operators
			Direct type conversion
			Converting types with the Convert class
			String conversion
		Logical operators
		Working with strings
			Checking for Null or Empty strings
			Concatenating strings
			Formatting strings
	Iterating objects
	Understanding loops
		Introducing the do loop
		Introducing the while loop
	Conditional code blocks
		The if conditional code block
		The switch conditional code block
	Introducing arrays
		Single-dimensional arrays
		Multi-dimensional arrays
		Jagged arrays
	Object-oriented programming (OOP)
		Understanding access modifiers
		Defining reference types with classes
			Storing information with fields and properties
			Running actions with methods
			Introducing constructors and static classes
			Defining derived types with inheritance
		Understanding interfaces and abstract classes
			Defining interfaces
			Implementing interfaces
			Introducing abstract classes
		Organizing types within namespaces
			Accessing types within namespaces with using directives
		Defining value types with structures
			Assigning structures to variables
			Visibility of structures and their members
		Defining enumerations
			Using enumerations
		Implementing error handling
		Implementing events
	Advanced C# programming
		Generics and Nullable Types
			Working with Nullable types
		Language INtegrated Query (LINQ)
		Asynchronous programming
	Conclusion
	Suggested readings
5. Building Apps with Xamarin and Xamarin.Forms
	Introduction
	Structure
	Objective
	Understanding Xamarin.Android Projects
		Understanding the project structure
		Drawing and handling the user interface
		Configuring the App Manifest
		Debugging an Android app
			Configuring debugging and Build options
	Understanding Xamarin.iOS projects
		Understanding the project structure
		Handling the user interface
		Debugging an iOS app
			Understanding provisioning profiles and developer accounts
			Configuring App Package options
	Cross-platform projects with Xamarin.Forms
		Understanding the project structure
			Introducing XAML, App.xaml, and MainPage.xaml
		Running and debugging apps
	Preparing apps for publication
		Preparing Android packages
		Preparing iOS packages
	Conclusion
	Points to remember
	Key terms
6. Organizing the User Interface with Layouts
	Introduction
	Structure
	Objectives
	Understanding the concept of layout
		Alignment and spacing options
		Understanding the visual tree
			.NET objects hierarchy
	Organizing the user interface
		Creating a Sample Project
		The StackLayout
		The FlexLayout
		The Grid
			Spacing, proportions and spans for rows and columns
		The AbsoluteLayout
		The RelativeLayout
		The ScrollView
		Controlling the ScrollView programmatically
		The Frame
		The ContentView
			Using a ContentView
	Styling the user interface with cascading style sheets
		Defining CSS styles as a XAML resource
		Consuming CSS files in XAML
		Creating and implementing CSS styles in C#
	Conclusion
	Points to remember
	Key terms
7. Understanding Common Views
	Introduction
	Structure
	Objectives
	Creating a sample project
		Common properties
	Working with text
		Displaying text with the label
		Accepting user input with entry and editor
			Entering passwords
		Applying and managing fonts
			Implementing custom fonts
			Complex text formatting with FormattedString
	User interaction with buttons
	Selecting dates and time
		Selecting dates with the DatePicker
		Selecting a time with the TimePicker
	Displaying HTML content
	Selecting Boolean and numerical values
		Turning options on and off with the switch
		User choices with the CheckBox
		Multiple choices with RadioButton
			Implementing multiple groups
		Value selection with the Slider
		Incremental value selection with the Stepper
	Implementing search functionalities
	Handling long-running tasks
	Displaying images
		Handling the aspect
		Managing image files
	Adding interactivity to Views
		Implementing GestureRecognizers
		Displaying and handling alerts
	Understanding visual states
	Conclusion
	Key terms
	Suggested readings
8. Pages and Navigation
	Introduction
	Structure
	Objectives
	Introducing available pages
		Individual pages: The ContentPage
		Master-details views: The FlyoutPage
		Organizing contents within tabs: The TabbedPage
		Scrolling pages: The CarouselPage
	Navigating between pages
		Sharing data between pages
		Implementing custom titles
		Understanding pages lifecycle
		Intercepting the physical back button
	Common app features: The Shell
		Understanding the structure of the Shell
		Adding a Flyout menu
		Leveraging built-in navigation: The Tab bar
		Implementing both the Flyout and Tab bar
		Implementing the Search bar
		Programmatically interacting with the Shell
		Changing the Shell styles
	Conclusions
	Key terms
	Suggested readings
9. Resources and Data Binding
	Introduction
	Structure
	Objectives
	Creating a sample project
	Understanding and Defining Resources
		Defining resources
		Defining and assigning styles
			Implementing style inheritance
			Implementing implicit styling
	Binding data to the user interface
		Getting started with data binding
			Property change notifications: INotifyPropertyChanged
			Assigning the binding context
		Working with data collections
			Displaying data: The ListView
			The DataTemplate as a resource
		Binding different types: Value converters
		Displaying Collections efficiently
			Displaying lists with the CollectionView
			Scrolling lists with the CarouselView
			Displaying item indicators with the IndicatorView
			Selecting items with the Picker
		Introducing bindable layouts
	Advanced data binding: The Model-View-ViewModel pattern
		Defining the data model
		Implementing the business logic: Commands and ViewModels
			Exposing data
			Defining actions with Commands
		Designing the user interface
			MVVM frameworks
		Pull-to-Refresh gesture: The RefreshView
	Local data access with SQLite databases
		Installing the SQLite NuGet package
		Getting the database path
		Implementing a data model
		Implementing a data access layer
		Invoking the data access layer
		Extending the user interface
	Conclusion
	Key terms
10. Brushes, Shapes, and Media
	Introduction
	Structure
	Objectives
	Creating a sample project
	Coloring objects with brushes
		Defining linear gradients
		Defining circular gradients
	Drawing shapes
		Drawing circles and ellipses
		Drawing rectangles
		Drawing lines
		Drawing polygons
		Drawing custom shapes
			Further studies: Path and geometries
	Working with multimedia
		Installing the Xamarin Community Toolkit
			Implementing the MediaElement
			Controlling the media file
			Playing local files
	Conclusion
	Key terms
	Suggested readings
11. Managing the Application Lifecycle
	Introduction
	Structure
	Objectives
	Creating a sample project
	The Application class
		Working with themes
		Defining global variables
	Events of the Application lifecycle
		Understanding and using Application events
			A real-world example: Storing and retrieving data
			A real-world scenario: Restoring data forms
		Responding to page events
	Sending messages through the app
		Broadcast messages with MVVM
			MessagingCenter tips and tricks
	Conclusion
	Key terms
	Suggested readings
12. Working with Web API
	Introduction
	Structure
	Objectives
	Chapter prerequisites
		Getting a Free Azure subscription
		Downloading Postman
	Understanding web services and Web API
	JSON: A standard data exchange format
	Creating Web API in Visual Studio
		Understanding the project structure
		Creating a data model
		Implementing controllers
		Retrieving data
		Creating and updating data objects
		Deleting data objects
		Testing Web API services
			Making API calls with Postman
	Publishing Web API services
	Consuming Web API with Xamarin.Forms
		Creating a data model
		Creating the ViewModel
			Calling Web API services from C#
		Designing the user interface
		Testing the application
	Conclusion
	Key terms
	Suggested readings
13. Working with Native API
	Introduction
	Structure
	Objectives
	Preparing a sample project
	Working with the device class
		Working with Timers
		Running thread-safe code
		Device-based content orientation
		Conditional XAML: OnPlatform and OnIdiom
	Advanced view customization: Custom renderers
		Defining a custom view
		Defining the Android renderer
		Defining the iOS renderer
	Applying custom renderers to views
		More information on custom renderers
	Managing native properties with effects
		Declaring effects
		Implementing platform-specific effects
		Testing the code
	Displaying native views
	Customizing views with platform-specifics
	Accessing device features: The DependencyService class
	Cross-platform access to native API: Xamarin.Essentials
		Checking the network connection
		Checking the battery status
		Sending emails and SMS messages
			Sending emails
			Sending SMS messages
		Opening contents
		Opening the web browser
		Opening default apps
		Storing user preferences
		Storing secure settings
			Secure settings with app version tracking
		More essentials API
		Hints about plugins
	Conclusion
	Key terms
	Suggested readings
14. Finding a Job
	Introduction
	Structure
	Objectives
	Preparing your resume
	Finding jobs, the modern way: Using LinkedIn
		Searching for a job
	A step forward: Attracting jobs
		Connecting with the right contacts
		Sharing contents from others
		Sharing your knowledge
			Writing articles and other content
			Joining online communities
			Sharing your code
			Final considerations about LinkedIn
	Preparing for job interviews
		Technical interviews
		Personal interviews
	Conclusion
	Points to remember
15. Succeeding as a Mobile App Developer
	Introduction
	Structure
	Objectives
	Developing your passion and curiosity
		Experiment on custom projects
		Experimenting with third-party components
	Learning to be a team player
	Staying up-to-date with development technologies
		Attending conferences and meetups
	Conclusion
	Points to remember
	Suggested readings
Index