MS_40541 Build Native Cross-Platform Mobile Apps with a Shared C# Business Logic for ios, Android, and UWP in C#.NET with Xamarin and Visual Studio

Transcription

1 Build Native Cross-Platform Mobile Apps with a Shared C# Business Logic for ios, Android, and UWP in C#.NET with Xamarin and Visual Studio Av. Revolución No. 374 Col. San Pedro de los Pinos, C.P , México, CDMX. Tel/Fax: Por favor no imprimas este documento si no es necesario.

2 About this course. During this course, students will learn to create cross-platform applications that share business logic while leveraging platform-specific UI and navigation features of each platform. Length. 5 Days. Audience profile. This course is intended for developers with at least basic C# knowledge with 6-12 months of.net experience. Students should own and/or have used both an ios and Android devices and be familiar with the paradigms on each platform. Some courses delivered in this agenda can count towards the Xamarin certification progress. Hardware/Software: IOS development requires a Mac running the latest OS, with XCode and Visual Studio installed. Android development can be performed on either macos or Windows. For Windows development, we recommend a Windows 10 PC with Visual Studio 2017 and the Mobile development with.net workload installed. An ios and an Android device is highly recommended. Prerequisites. Before attending this course, students must have the following technical knowledge: Basic knowledge of C# and six months of experience developing using.net. At course completion. After completing this course, students will be able to: Build cross-platform mobile applications with C# using the Xamarin tools for Visual Studio. Build native UI for Android and ios applications. Access REST services, store data locally using SQLite, customize data presentations and choose appropriate UI and design strategies that are best suited for a particular application. Exam. None. Course outline. Module 1: Getting Started with Xamarin (XAM101). By the end of this module, you will be able to choose the Xamarin approach that is right for you. You will also set up your development machine and run an app on Windows, the ios simulator, and an Android emulator. Define the state of mobile technology today. Discuss mobile app trends. Identify approaches to development. Discover the Xamarin Approach. Setup your development environment. Pag. 2

3 Labs: Cross-Platform Applications with Xamarin. Demonstration - Cross Platform Applications with Xamarin. Demonstration View a Xamarin.Forms Project. Setup Validation Validate your development environment ready. Be able to identify mobile development trends. Identify the different approaches to mobile development. Describe the Xamarin approach to development. Set up and validate their development environment. Module 2: Introduction to Xamarin.iOS (IOS101). This module takes you through the entire development process. You will create a new project in Visual Studio, code the user interface and behavior, build the project, and test it on an iphone simulator. As you build your app, you will learn several ios design patterns such as Model-View-Controller, protocols, and delegates. Introduce the development tools. (De)constructing the application. Add views and behavior. Labs: Create a Tip Calculator for ios in Xamarin. Group Exercise: Create and run your first ios application. Add a root view controller to the Tip Calculator. Create the UI for the Tip Calculator. Add logic to your Tip Calculator. Explore the IDE choices for ios development. Create an app using the project templates. Introductoin the development tools. (De)constructing the application. Add views and behavior. Explore a new project. Explore ios terminology. Create screens. Manage parent-child relationships. Position views. Add behavior. Module 3: Using the Xamarin.iOS Designer (IOS102). Use the Xamarin.iOS Storyboard Designer to design a responsive, multi-screen application. Create a single screen application. Describe and use Auto Layout. Interact with designer-defined views programmatically. Navigate between view controllers. KeD es una marca registrada ante el Instituto Mexicano de la Propiedad Intelectual Pag. 3

4 Labs: Use the ios Designer to create a multi-screen application. Create the UI for a single view application. Add constraints to the fireworks app. Add a second screen to your app and code a button to navigate to it. Add segues to define the navigation. Describe the uses of the ios Designer. Identify controls and properties. Demonstrate the designer workflow. Lay out subviews on a ViewController. Describe the Auto Layout system. Identify and add constraints using the Designer. Associate a class for the UIViewController. Identify partial methods. Name views. Inspect outlets and actions. Present a view controller. Dismiss a view controller programmatically. Use segues to perform navigation. Module 4: TableViews in ios (IOS110). During this module you will learn to use the UITableView to display a collection in your Xamarin.iOS app. You will use the built-in styles to visualize your data, learn to handle item-selection events and navigate the app to a new page. Finally, you will see how to configure cell reuse to reduce memory usage and boost performance. Explore Table Views. Utilize built-in cell styles. Add selection behavior. Implement cell reuse. Labs: Use a Table View, populate it with data and perform basic customizations. Add a Table View to an application. Populate a Table View. Use built-in cell styles. Use the accessory styles and row selection. Implement cell reuse. Add a Table View to your UI. Fill the Table View with data. Use the built-in cell styles. Change the cell style. Add an accessory view. Respond to the accessory tap. Enable cell reuse in the designer. Enable cell reuse programmatically. Pag. 4

5 Module 5: Introduction to Xamarin.Android (AND101). During this module you will create a new project in Visual Studio, code the user interface and behavior for an Activity, build the project, and test it on an Android emulator. You ll also see how to keep your development environment up-todate as new Android versions are released. Create a Xamarin.Android project. Decompose an app into Activities. Build an Activity s UI. Write an Activity s behavior. Update your Android SDK. Labs: Create a Xamarin.Android application with Views, layouts and behavior. Create a Xamarin.Android Project. Add views to a layout file manually and with the Designer. Implement an Activity s behavior and run your app in an emulator. Update the Tools and SDK Platform. Create a new Xamarin.Android project. Define the concept of an Activity. Decompose an app into Activities. Add Views to a Layout in XML. Use the Designer tool. Designate a Main Activity. See how the Main Activity is listed in the app Manifest. Load an Activity s UI. Access Views from code. Review native Android development. Understand the Xamarin.Android development process. Update your Android Tools. Update your Android Platform SDK. Module 6: Activities and Intents (AND102). In this module you will code the core patterns that make Activities work together. You will see how to start Activities, pass arguments, and retrieve results. You will also see how to launch standard Android Activities such as the camera or the web browser. Start an Activity in your.apk. Finish an Activity. Pass arguments to an Activity. Get Activity results. Start a system Activity. Labs: Create an app with collaborating Activities. Explore the completed lab exercise. Start an Activity in your.spk. Programmatically end an Activity. KeD es una marca registrada ante el Instituto Mexicano de la Propiedad Intelectual Pag. 5

6 Pass arguments to an Activity. Get Activity Results. Launch a system Activity. Create an explicit Intent. Start an Activity. Implement Stack Navigation. Programmatically finish an Activity. Load a Bundle of arguments into an Intent. Retrieve the arguments in the target Activity. Pass and return a request code and Bundle. Retrieve results. Create an implicit Intent. Load Intent Action, Data, and Extras. Verify that Android found an Activity that matches your implicit Intent. Module 7: ListViews and Adapters in Android (AND110). In this module you will code an Adapter to populate the ListView and handle item-selection events to implement a simple master-detail pattern. You will also see two advanced tasks: layout recycling with view holders to boost performance and fast scrolling with section indexers to help the user navigate large data sets. Handle list-item click events. Implement a custom adapter. Use layout recycling and the view-holder pattern. Labs: Use an Adapter to populate a ListView and then customize it to boost efficiency. Populate a ListView using an ArrayAdapter. Handle list-item click events. Implement a custom adapter. Use layout recycling and the view-holder pattern. Enable fast scrolling and a code a section indexer. Add a ListView to a UI. Use ArrayAdapter to populate a ListView. Identify the limitations of ArrayAdapter. Subscribe to the ListView.ItemClick event. Determine which list items was clicked. Reuse inflated layouts to reduce memory usage. Cache view references to increase performance. Enable ListView fast scrolling. Implement ISectionIndexer on a custom Adapter. Module 8: Introduction to Cross-Platform Development (XAM110). In this module, we will explore ways to structure your shared code using Portable Class Libraries,.NET Standard libraries, Pag. 6

7 and Shared Asset Projects. We will look at the pros and cons of each approach and see how to access platform-specific features in each model. Add shared components to your application. Share code using Shared Projects. Share code using Portable Class Libraries. Share code using.net Standard Libraries. Labs: Share code across Windows, Android and ios. Share code across Windows, Android and ios. Display content from a shared JSON file onto Windows, Android and ios. Use a portable library to display content on Windows, Android and ios. Demonstration: Create a.net Standard library and use.net Standard APIs. Share code across Windows, Android and ios using a Shared Project. Share code across Windows, Android and ios using Portable Class Libraries. Share code using.net Standard Libraries. Module 9: Consuming REST-based Web Services (XAM150). In this module, you will learn to consume REST-based web services with HttpClient using both the managed networking stack and the platform-specific handlers that boost performance. You will also learn some common strategies for dealing with the unique challenges that mobile devices face when communicating over the network. Obtain the device s network capabilities. Introduce REST. Consume REST services with Xamarin. Labs: Use, consume and communicate with REST services. Determine the network connectivity. Communicate with a Book Service. Demonstration: Leverage the native platform network stack. Determine if the device has a connection. Obtain the device s connection type. Determine when network availability changes. Identify REST services. Utilize URLs in REST. Describe guidelines for using REST. Identify REST services. Utilize URLs in REST. Describe guidelines for using REST. Customize the HttpClient handler. Leverage platform network stacks. Use App Transport Security on ios. KeD es una marca registrada ante el Instituto Mexicano de la Propiedad Intelectual Pag. 7

8 Pag. 8 Module 10: Working with SQLite and Mobile Data (XAM160). During this module you will learn to identify the proper location for your database file and how to insert, update, retrieve, and delete data efficiently using asynchronous I/O calls. Choose a data storage strategy. Store data locally with SQLite. Use SQLite asynchronously. Labs: Utilize SQLite to store and access data. Determine your database file path. Add SQLite.Net to your projects. Access a SQLite database with SQLite.Net. Access a SQLite database using asynchronous methods. Identify data storage options. Select a storage location. Get the storage path for each platform. Add a SQLite Portable Class Library to the project. Define SQLite table schema using attributes. Create and connect to a SQLite database. Perform basic CRUD operations. Refactor database connection to use SQLiteAsyncConnection. Refactor table creation to use Async counterpart. Refactor CRUD operations to use Async counterparts. Module 11: Toolbar and App Bar (AND180). In this module you will learn to create a Toolbar, populate it from an XML menu file, and respond to item-click events. You will also learn how to integrate a Toolbar into your Activity by setting it as the Activity s app bar. Add a Toolbar to an Activity. Populate Toolbar Actions from an XML menu file. Use a Toolbar as an Activity s app bar. Set a navigation icon on an app bar. Labs: Create and populate a Toolbar and set it as the Activity s AppBar. Add a Toolbar to an Activity. Populate Toolbar Actions from an XML menu file. Add a checkable submenu. Use a Toolbar as an Activity s app bar. Set a navigation icon on an app bar. Add a ListView to a UI. Use ArrayAdapter to populate a ListView. Identify the limitations of ArrayAdapter. Subscribe to the ListView.ItemClick event.

9 Determine which list items was clicked. Inflate a layout file with LayoutInflater. Code a custom Adapter. Reuse inflated layouts to reduce memory usage. Cache view references to increase performance. Enable ListView fast scrolling. Implement ISectionIndexer on a custom Adapter. Module 12: Android Navigation Patterns (AND205). This module teaches you how to code three common navigation patterns: tab, gestural, and drawer. It also includes guidelines to help you decide which pattern is appropriate for your app as well as teaches you to use fragments and FrameLayout. Use Fragment and FrameLayout to swap views. Implement tab navigation with TabLayout. Implement gestural navigation with ViewPager. Combine gestural and tab navigation. Implement drawer navigation with DrawerLayout. Labs: Build three common navigation patterns in Xamarin.Android. Use Fragment and FrameLayout to swap views. Implement tab navigation with TabLayout. Implement gestural navigation with ViewPager. Combine gestural and tab navigation. Implement drawer navigation with DrawerLayout. Add a Fragment to a FrameLayout dynamically. Include a TabLayout in your UI. Add tabs using code-behind. Add tabs using XML. Respond when a tab is tapped. Add a ViewPager to your UI. Code an adapter to supply the ViewPager with Fragments. Use a ViewPager to populate a TabLayout with tabs. Use DrawerLayout to display a drawer menu. Use an app bar navigation button to open the drawer. Code an XML file for your menu. Swap content when your menu is clicked. Module 13: ios Navigation (IOS205). During this module you will implement three ios navigation patterns: stack, tab, and master-detail. You will also learn how to identify which pattern is most appropriate for your app. Progress through pages of data with stack-based navigation. Show different views of related data with tab navigation. Display hierarchical relationships with master/detail navigation. KeD es una marca registrada ante el Instituto Mexicano de la Propiedad Intelectual Pag. 9

10 Labs: Implement Stack, Tab and Master/Detail navigation. Implement Stack Navigation. Implement Tab Navigation. Implement Master/Detail. Create a Navigation Controller programmatically. Utilize the designer to create a Navigation Controller. Customize the Navigation Controller. Create a Tab Bar Controller. Populate a Tab Bar Controller. Customize the Tab Bar Controller. Create a Split View Controller. Use a Split View Controller programmatically. Use the ios Designer to define a Split View Controller. Module 14: Advanced Cross-Platform Development (XAM300). Use the Factory pattern, the Service Locator pattern, and Dependency Injection to access platform-specific APIs from shared code in a loosely-coupled manner. Locate dependencies using the Factory Pattern. Use a Service Locator to register and retrieve dependencies. Use an IoC container to automatically inject dependencies. Labs: Define, locate and use dependencies. Use the Factory Pattern to access a dependency from shared code. Group Exercise: Build a Service Locator. Use Dependency Injection. Define a Factory. Assign a dependency to a Factory. Access the Factory from shared code. Define a Service Locator. Register dependencies with a Service Locator. Resolve dependencies from a Service Locator. Register dependencies with an IoC container. Inject dependencies. and Automate dependence injection. Module 15: Diagnosing Memory Issues (XAM370). This module begins by showing you how memory leaks happen in managed memory even with a sophisticated garbage collector and how to discover and fix them. It then shows you several memory issues that are specific to Xamarin.iOS and Xamarin.Android. Identify and fix memory leaks in your code. Recognize and fix Xamarin.iOS specific memory problems. Recognize and fix Xamarin.Android specific memory problems. Pag. 10

11 Labs: Find and correct memory leaks in your Xamarin applications. Using the Xamarin Profiler to monitor allocations. Finding and fixing delegate reference leaks. Identifying and breaking strong reference cycles. Watch out for peer promotions. Show ListView memory and performance with a custom adapter. Find memory leaks in your code. Fix common leaks in managed code. Module 16: Preparing for Publishing (XAM220). Prepare your app for release through the App Store, Google Play, and Windows Marketplace. Getting ready to publish your app. Understanding publishing styles. Publishing to a store. Update your app for publishing. Choose a distribution strategy. Publish to a store. clientes@ked.com.mx Av. Revolución No. 374 Col. San Pedro de los Pinos, C.P , México, CDMX. Tel/Fax: Por favor no imprimas este documento si no es necesario.