Alto Consulting & Training Course Details

 

Learning Objectives

After completing this course, students will be able to:

• Describe the core syntax and features of C#.
• Create and call methods, catch and handle exceptions, and describe the monitoring requirements of large-scale applications.
• Implement the basic structure and essential elements of a typical desktop application.
• Create classes, define and implement interfaces, and create and use generic collections.
• Use inheritance to create a class hierarchy, extend a .NET Framework class, and create generic classes and methods.
• Read and write data by using file input/output and streams, and serialize and deserialize data in different formats.
• Create and use an entity data model for accessing a database and use LINQ to query and update data.
• Use the types in the System.Net namespace and WCF Data Services to access and query remote data.
• Build a graphical user interface by using XAML.
• Improve the throughput and response time of applications by using tasks and asynchronous operations.
• Integrate unmanaged libraries and dynamic components into a C# application.
• Examine the metadata of types by using reflection, create and use custom attributes, generate code at runtime, and manage assembly versions.
• Encrypt and decrypt data by using symmetric and asymmetric encryption.

Audience

This course is intended for experienced developers who already have programming experience in C, C++, JavaScript, Objective-C, Microsoft Visual Basic, or Java and understand the concepts of object-oriented programming.

​This course is not designed for students who are new to programming; it is targeted at professional developers with at least one month of experience programming in an object-oriented environment.

Prerequisites

Developers attending this course should already have gained some limited experience using C# to complete basic programming tasks. More specifically, students should have hands-on experience using C# that demonstrates their understanding of the following:
 

• How to name, declare, initialize and assign values to variables within an application.
• How to use:
• arithmetic operators to perform arithmetic calculations involving one or more variables;
• relational operators to test the relationship between two variables or expressions;
• logical operators to combine expressions that contain relational operators.
• How to create the code syntax for simple programming statements using C# language keywords and recognize syntax errors using the Visual Studio IDE.
• How to create a simple branching structure using an IF statement.
• How to create a simple looping structure using a For statement to iterate through a data array.
• How to use the Visual Studio IDE to locate simple logic errors.
• How to create a Function that accepts arguments (parameters and returns a value of a specified type.
• How to design and build a simple user interface using standard controls from the Visual Studio toolbox.
• How to connect to a SQL Server database and the basics of how to retrieve and store data.
• How to sort data in a loop.
• How to recognize the classes and methods used in a program.

Course Outline

Module 1: Review of C# Syntax

• Overview of Writing Applications using C#
• Datatypes, Operators, and Expressions
• C# Programming Language Constructs

Lab : Developing the Class Enrolment Application

• Implementing Edit Functionality for the Students List
• Implementing Insert Functionality for the Students List
• Implementing Delete Functionality for the Students List
• Displaying the Student Age

After completing this module, students will be able to:

• Describe the architecture of .NET Framework applications and use the features that Visual Studio 2012 and C# provide to support .NET Framework development.
• Use the basic data types, operators, and expressions provided by C#.
• Use standard C# programming constructs.

Module 2: Creating Methods, Handling Exceptions, and Monitoring Applications

• Creating and Invoking Methods
• Creating Overloaded Methods and Using Optional and Output Parameters
• Handling Exceptions
• Monitoring Applications

Lab : Extending the Class Enrolment Application Functionality

• Refactoring the Enrolment Code
• Validating Student Information
• Saving Changes to the Class List

After completing this module, students will be able to:

• Create and invoke methods, pass parameters to methods, and return values from methods.
• Create overloaded methods, and use optional parameters and output parameters.
• Catch and handle exceptions and write information to the event log.
• Explain the requirement for implementing logging, tracing, and profiling when building large-scale applications.

Module 3: Developing the Code for a Graphical Application

• Implementing Structs and Enums
• Organizing Data into Collections
• Handling Events

Lab : Writing the Code for the Grades Prototype Application

• Adding Navigation Logic to the Application
• Creating Data Types to Store User and Grade Information
• Displaying User and Grade Information

After completing this module, students will be able to:

• Define and use structures and enumerations.
• Create and use simple collections for storing data in-memory.
• Create, subscribe to, and raise events.

Module 4: Creating Classes and Implementing Type-safe Collections

• Creating Classes
• Defining and Implementing Interfaces
• Implementing Type-safe Collections

Lab : Adding Data Validation and Type-safety to the Grades Application

• Implementing the Teacher, Student, and Grade Types as Classes
• Adding Data Validation to the Grade Class
• Displaying Students in Name Order
• Enabling Teachers to Modify Class and Grade Data

After completing this module, students will be able to:

• Create and use custom classes.
• Define and implement custom interfaces.
• Use generics to implement type-safe collections.

Module 5: Creating a Class Hierarchy by Using Inheritance

• Creating Class Hierarchies
• Extending .NET Framework Classes
• Creating Generic Types

Lab : Refactoring Common Functionality into the User Class

• Creating and Inheriting from the User Base Class
• Implementing Password Complexity by Using an Abstract Method
• Creating the ClassFullException Class

After completing this module, students will be able to:

• Define abstract classes and inherit from base classes to create a class hierarchy.
• Inherit from .NET Framework classes and use extension methods to add custom functionality to the inherited class.
• Create generic classes and methods.

Module 6: Reading and Writing Local Data

• Reading and Writing Files
• Serializing and Deserializing Data
• Performing I/O Using Streams

Lab : Generating the Grades Report

• Serializing the Data for the Grades Report as XML
• Previewing the Grades Report
• Persisting the Serialized Grades Data to a File

After completing this module, students will be able to:

• Read and write data to and from the file system by using file I/O.
• Convert data into a format that can be written to or read from a file or other data source.
• Use streams to send and receive data to or from a file or other data source.

Module 7: Accessing a Database

• Creating and Using Entity Data Models
• Querying Data by Using LINQ
• Updating Data by Using LINQ

Lab : Retrieving and Modifying Grade Data

• Creating an Entity Model from the The School of Fine Arts Database
• Updating Student and Grade Data Using the Entity Framework
• Extending the Entity Model to Validate Data

After completing this module, students will be able to:

• Create an entity data model, describe the key classes contained in the model, and customize the generated code.
• Use LINQ to query and work with data.
• Use LINQ to insert, update, and delete data.

Module 8: Accessing Remote Data

• Accessing Data Across the Web
• Accessing Data in the Cloud

Lab : Retrieving and Modifying Grade Data in the Cloud

• Creating a WCF Data Service for the SchoolGrades Database
• Integrating the WCF Data Service into the Application
• Retrieving Student Photographs Over the Web

After completing this module, students will be able to:

• Use the classes in the System.Net namespace to send and receive data across the Web.
• Create and use a WCF Data Service to access data in the cloud.

Module 9: Designing the User Interface for a Graphical Application

• Using XAML to Design a User Interface
• Binding Controls to Data
• Styling a User Interface

Lab : Customizing Student Photographs and Styling the Application

• Customizing the Appearance of Student Photographs
• Styling the Logon View and the StudentPhoto Control

After completing this module, students will be able to:

• Define XAML views and controls to design a simple graphical user interface.
• Use XAML data binding techniques to bind XAML elements to a data source and display data.
• Add styling and dynamic transformations to a XAML user interface.

Module 10: Improving Application Performance and Responsiveness

• Implementing Multitasking by using Tasks and Lambda Expressions
• Performing Operations Asynchronously
• Synchronizing Concurrent Access to Data

Lab : Improving the Responsiveness and Performance of the Application

• Ensuring that the User Interface Remains Responsive When Retrieving Data for Teachers
• Providing Visual Feedback During Long-Running Operations

After completing this module, students will be able to:

• Create tasks and lambda expressions to implement multitasking.
• Define and use asynchronous methods to improve application responsiveness.
• Coordinate concurrent access to data shared across multiple tasks by using synchronous primitives and concurrent collections.

Module 11: Integrating with Unmanaged Code

• Creating and Using Dynamic Objects
• Managing the Lifetime of Objects and Controlling Unmanaged Resources

Lab : Upgrading the Grades Report

• Generating the Grades Report by Using Microsoft Office Word
• Controlling the Lifetime of Word Objects by Implementing the Dispose Pattern

After completing this module, students will be able to:

• Integrate unmanaged code into a C# application by using the Dynamic Language Runtime.
• Control the lifetime of unmanaged resources and ensure that they are disposed properly.

Module 12: Creating Reusable Types and Assemblies

• Examining Object Metadata
• Creating and Using Custom Attributes
• Generating Managed Code
• Versioning, Signing and Deploying Assemblies

Lab : Specifying the Data to Include in the Grades Report

• Creating the IncludeInReport Attribute
• Generating the Report
• Storing the Grades.Utilities Assembly Centrally

After completing this module, students will be able to:

• Examine the metadata of objects at runtime by using reflection.
• Create and use custom attribute class.
• Generate managed code at runtime by using CodeDOM.
• Manage different versions of an assembly and deploy an assembly to the Global Assembly Cache.

Module 13: Encrypting and Decrypting Data

• Implementing Symmetric Encryption
• Implementing Asymmetric Encryption

Lab : Encrypting and Decrypting Grades Reports

• Encrypting the Grades Report
• Decrypting the Grades Report

After completing this module, students will be able to:

• Perform symmetric encryption by using the classes in the System.Security namespace.
• Perform asymmetric encryption by using the classes in the System.Security namespace.​