programming in c#store.globalknowledge.net/course-overviews/ie/m20483_c_.pdf · programming in c#...

M20483 C www.globalknowledge.com/en-ie/ [email protected] 353-1-814 8200

Programming in C#

Duration: 5 Days Course Code: M20483 Version: C

Overview:

This training course teaches developers the programming skills that are required for developers to create Windows applications using the C#language. During their five days in the classroom students review the basics of C# program structure, language syntax, and implementationdetails, and then consolidate their knowledge throughout the week as they build an application that incorporates several features of the .NETFramework 4.5.The course introduces many of the techniques and technologies employed by modern desktop and enterprise applications, including:Buildingnew data types,Handling events,Programming the user interface,Accessing a database,Using remote data,Performing operationsasynchronously,Integrating with unmanaged code,Creating custom attributes andEncrypting and decrypting data.At the end of the course, students should leave the class with a solid knowledge of C# and how to use it to develop .NET Framework 4.5applications. This course uses Visual Studio 2012, running on Windows 8.

Target Audience:

This course is intended for experienced developers who already have programming experience in C, C++, JavaScript, Objective-C, MicrosoftVisual 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 ofexperience programming in an object-oriented environment.

Objectives:

Describe the core syntax and features of C#.

Use the types in the System.Net namespace and WCF DataServices to access and query remote data.

Create and call methods, catch and handle exceptions, anddescribe the monitoring requirements of large-scale applications.

Build a graphical user interface by using XAML.

Implement the basic structure and essential elements of a typicaldesktop application.

Improve the throughput and response time of applications by usingtasks and asynchronous operations.

Create classes, define and implement interfaces, and create anduse generic collections.

Integrate unmanaged libraries and dynamic components into a C#application.

Use inheritance to create a class hierarchy, extend a .NETFramework class, and create generic classes and methods.

Examine the metadata of types by using reflection, create and usecustom attributes, generate code at runtime, and manage assemblyversions.

Read and write data by using file input/output and streams, andserialize and deserialize data in different formats.

Encrypt and decrypt data by using symmetric and asymmetricencryption.

Create and use an entity data model for accessing a databaseand use LINQ to query and update data.


Prerequisites: Testing and Certification

Developers attending this course should already have gained This course helps prepare candidates for exam 70-483.some limited experience using C# to complete basic programming When you pass Exam 70-483: Programming in C#, you completetasks. More specifically, students should have hands-on the requirements for the following certification(s):experience using C# that demonstrates their understanding of the Programming in C# Specialistfollowing: Exam 70-483: Programming in C#: counts as credit toward theHow to name, declare, initialize and assign values to variables following certification(s):within an application. MCSD: Windows Store Apps using C#How to use:arithmetic operators to perform arithmetic calculations involvingone or more variables;relational operators to test the relationship between two variablesor expressions;logical operators to combine expressions that contain relationaloperators.How to create the code syntax for simple programmingstatements using C# language keywords and recognize syntaxerrors 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 toiterate through a data array.How to use the Visual Studio IDE to locate simple logic errors.How to create a Function that accepts arguments (parametersand returns a value of a specified type.How to design and build a simple user interface using standardcontrols from the Visual Studio toolbox.How to connect to a SQL Server database and the basics of howto retrieve and store data.How to sort data in a loop.How to recognize the classes and methods used in a program.


Content:

Module 1: Review of C# Syntax Module 9: Designing the User Interface for aline line Graphical Application

Overview of Writing Applications using C# Datatypes, Operators, and Expressions lineC# Programming Language Constructs Using XAML to Design a User InterfaceImplementing Edit Functionality for the

line Students ListDatatypes, Operators, and Expressions Implementing Insert Functionality for the lineC# Programming Language Constructs Students List Datatypes, Operators, and ExpressionsImplementing Edit Functionality for the Implementing Delete Functionality for the C# Programming Language ConstructsStudents List Students List Implementing Edit Functionality for theImplementing Insert Functionality for the Displaying the Student Age Students ListStudents List Creating Overloaded Methods and Using Implementing Insert Functionality for theImplementing Delete Functionality for the Optional and Output Parameters Students ListStudents List Handling Exceptions Implementing Delete Functionality for theDisplaying the Student Age Monitoring Applications Students ListCreating Overloaded Methods and Using Refactoring the Enrolment Code Displaying the Student AgeOptional and Output Parameters Validating Student Information Creating Overloaded Methods and UsingHandling Exceptions Saving Changes to the Class List Optional and Output ParametersMonitoring Applications Organizing Data into Collections Handling ExceptionsRefactoring the Enrolment Code Handling Events Monitoring ApplicationsValidating Student Information Adding Navigation Logic to the Refactoring the Enrolment CodeSaving Changes to the Class List Application Validating Student InformationOrganizing Data into Collections Creating Data Types to Store User and Saving Changes to the Class ListHandling Events Grade Information Organizing Data into CollectionsAdding Navigation Logic to the Application Displaying User and Grade Information Handling EventsCreating Data Types to Store User and Defining and Implementing Interfaces Adding Navigation Logic to the ApplicationGrade Information Implementing Type-safe Collections Creating Data Types to Store User andDisplaying User and Grade Information Implementing the Teacher, Student, and Grade InformationDefining and Implementing Interfaces Grade Types as Classes Displaying User and Grade InformationImplementing Type-safe Collections Adding Data Validation to the Grade Defining and Implementing InterfacesImplementing the Teacher, Student, and Class Implementing Type-safe CollectionsGrade Types as Classes Displaying Students in Name Order Implementing the Teacher, Student, andAdding Data Validation to the Grade Class Enabling Teachers to Modify Class and Grade Types as ClassesDisplaying Students in Name Order Grade Data Adding Data Validation to the Grade ClassEnabling Teachers to Modify Class and Extending .NET Framework Classes Displaying Students in Name OrderGrade Data Creating Generic Types Enabling Teachers to Modify Class andExtending .NET Framework Classes Creating and Inheriting from the User Grade DataCreating Generic Types Base Class Extending .NET Framework ClassesCreating and Inheriting from the User Base Implementing Password Complexity by Creating Generic TypesClass Using an Abstract Method Creating and Inheriting from the User BaseImplementing Password Complexity by Creating the ClassFullException Class ClassUsing an Abstract Method Serializing and Deserializing Data Implementing Password Complexity byCreating the ClassFullException Class Performing I/O Using Streams Using an Abstract MethodSerializing and Deserializing Data Serializing the Data for the Grades Creating the ClassFullException ClassPerforming I/O Using Streams Report as XML Serializing and Deserializing DataSerializing the Data for the Grades Report Previewing the Grades Report Performing I/O Using Streamsas XML Persisting the Serialized Grades Data to Serializing the Data for the Grades ReportPreviewing the Grades Report a File as XMLPersisting the Serialized Grades Data to a Querying Data by Using LINQ Previewing the Grades ReportFile Updating Data by Using LINQ Persisting the Serialized Grades Data to aQuerying Data by Using LINQ Creating an Entity Model from the The FileUpdating Data by Using LINQ School of Fine Arts Database Querying Data by Using LINQCreating an Entity Model from the The Updating Student and Grade Data Using Updating Data by Using LINQSchool of Fine Arts Database the Entity Framework Creating an Entity Model from the TheUpdating Student and Grade Data Using the Extending the Entity Model to Validate School of Fine Arts DatabaseEntity Framework Data Updating Student and Grade Data UsingExtending the Entity Model to Validate Data Accessing Data in the Cloud the Entity FrameworkAccessing Data in the Cloud Creating a WCF Data Service for the Extending the Entity Model to ValidateCreating a WCF Data Service for the SchoolGrades Database DataSchoolGrades Database Integrating the WCF Data Service into Accessing Data in the CloudIntegrating the WCF Data Service into the the Application Creating a WCF Data Service for theApplication Retrieving Student Photographs Over the SchoolGrades DatabaseRetrieving Student Photographs Over the Web (if time permits) Integrating the WCF Data Service into theWeb (if time permits) Binding Controls to Data Application


Binding Controls to Data Styling a User Interface Retrieving Student Photographs Over theStyling a User Interface Customizing the Appearance of Student Web (if time permits)Customizing the Appearance of Student Photographs Binding Controls to DataPhotographs Styling the Logon View Styling a User InterfaceStyling the Logon View Animating the StudentPhoto Control (If Customizing the Appearance of StudentAnimating the StudentPhoto Control (If Time Time Permits) PhotographsPermits) Performing Operations Asynchronously Styling the Logon ViewPerforming Operations Asynchronously Synchronizing Concurrent Access to Animating the StudentPhoto Control (IfSynchronizing Concurrent Access to Data Data Time Permits)Managing the Lifetime of Objects and Managing the Lifetime of Objects and Performing Operations AsynchronouslyControlling Unmanaged Resources Controlling Unmanaged Resources Synchronizing Concurrent Access to DataGenerating the Grades Report by Using Generating the Grades Report by Using Managing the Lifetime of Objects andMicrosoft Office Word Microsoft Office Word Controlling Unmanaged ResourcesControlling the Lifetime of Word Objects by Controlling the Lifetime of Word Objects Generating the Grades Report by UsingImplementing the Dispose Pattern by Implementing the Dispose Pattern Microsoft Office WordCreating and Using Custom Attributes Creating and Using Custom Attributes Controlling the Lifetime of Word Objects byGenerating Managed Code Generating Managed Code Implementing the Dispose PatternVersioning, Signing and Deploying Versioning, Signing and Deploying Creating and Using Custom AttributesAssemblies Assemblies Generating Managed CodeCreating the IncludeInReport Attribute Creating the IncludeInReport Attribute Versioning, Signing and DeployingGenerating the Report Generating the Report AssembliesStoring the Grades.Utilities Assembly Storing the Grades.Utilities Assembly Creating the IncludeInReport AttributeCentrally Centrally Generating the ReportImplementing Asymmetric Encryption Implementing Asymmetric Encryption Storing the Grades.Utilities AssemblyEncrypting the Grades Report Encrypting the Grades Report CentrallyDecrypting the Grades Report Decrypting the Grades Report Implementing Asymmetric Encryption

Encrypting the Grades ReportDecrypting the Grades Report

line lineDatatypes, Operators, and Expressions Datatypes, Operators, and ExpressionsC# Programming Language Constructs C# Programming Language Constructs lineImplementing Edit Functionality for the Implementing Edit Functionality for the Datatypes, Operators, and ExpressionsStudents List Students List C# Programming Language ConstructsImplementing Insert Functionality for the Implementing Insert Functionality for the Implementing Edit Functionality for theStudents List Students List Students ListImplementing Delete Functionality for the Implementing Delete Functionality for the Implementing Insert Functionality for theStudents List Students List Students ListDisplaying the Student Age Displaying the Student Age Implementing Delete Functionality for theCreating Overloaded Methods and Using Creating Overloaded Methods and Using Students ListOptional and Output Parameters Optional and Output Parameters Displaying the Student AgeHandling Exceptions Handling Exceptions Creating Overloaded Methods and UsingMonitoring Applications Monitoring Applications Optional and Output ParametersRefactoring the Enrolment Code Refactoring the Enrolment Code Handling ExceptionsValidating Student Information Validating Student Information Monitoring ApplicationsSaving Changes to the Class List Saving Changes to the Class List Refactoring the Enrolment CodeOrganizing Data into Collections Organizing Data into Collections Validating Student InformationHandling Events Handling Events Saving Changes to the Class ListAdding Navigation Logic to the Application Adding Navigation Logic to the Organizing Data into CollectionsCreating Data Types to Store User and Application Handling EventsGrade Information Creating Data Types to Store User and Adding Navigation Logic to the ApplicationDisplaying User and Grade Information Grade Information Creating Data Types to Store User andDefining and Implementing Interfaces Displaying User and Grade Information Grade InformationImplementing Type-safe Collections Defining and Implementing Interfaces Displaying User and Grade InformationImplementing the Teacher, Student, and Implementing Type-safe Collections Defining and Implementing InterfacesGrade Types as Classes Implementing the Teacher, Student, and Implementing Type-safe CollectionsAdding Data Validation to the Grade Class Grade Types as Classes Implementing the Teacher, Student, andDisplaying Students in Name Order Adding Data Validation to the Grade Grade Types as ClassesEnabling Teachers to Modify Class and Class Adding Data Validation to the Grade ClassGrade Data Displaying Students in Name Order Displaying Students in Name OrderExtending .NET Framework Classes Enabling Teachers to Modify Class and Enabling Teachers to Modify Class andCreating Generic Types Grade Data Grade DataCreating and Inheriting from the User Base Extending .NET Framework Classes Extending .NET Framework ClassesClass Creating Generic Types Creating Generic TypesImplementing Password Complexity by Creating and Inheriting from the User Creating and Inheriting from the User BaseUsing an Abstract Method Base Class ClassCreating the ClassFullException Class Implementing Password Complexity by Implementing Password Complexity by


Serializing and Deserializing Data Using an Abstract Method Using an Abstract MethodPerforming I/O Using Streams Creating the ClassFullException Class Creating the ClassFullException ClassSerializing the Data for the Grades Report Serializing and Deserializing Data Serializing and Deserializing Dataas XML Performing I/O Using Streams Performing I/O Using StreamsPreviewing the Grades Report Serializing the Data for the Grades Serializing the Data for the Grades ReportPersisting the Serialized Grades Data to a Report as XML as XMLFile Previewing the Grades Report Previewing the Grades ReportQuerying Data by Using LINQ Persisting the Serialized Grades Data to Persisting the Serialized Grades Data to aUpdating Data by Using LINQ a File FileCreating an Entity Model from the The Querying Data by Using LINQ Querying Data by Using LINQSchool of Fine Arts Database Updating Data by Using LINQ Updating Data by Using LINQUpdating Student and Grade Data Using the Creating an Entity Model from the The Creating an Entity Model from the TheEntity Framework School of Fine Arts Database School of Fine Arts DatabaseExtending the Entity Model to Validate Data Updating Student and Grade Data Using Updating Student and Grade Data UsingAccessing Data in the Cloud the Entity Framework the Entity FrameworkCreating a WCF Data Service for the Extending the Entity Model to Validate Extending the Entity Model to ValidateSchoolGrades Database Data DataIntegrating the WCF Data Service into the Accessing Data in the Cloud Accessing Data in the CloudApplication Creating a WCF Data Service for the Creating a WCF Data Service for theRetrieving Student Photographs Over the SchoolGrades Database SchoolGrades DatabaseWeb (if time permits) Integrating the WCF Data Service into Integrating the WCF Data Service into theBinding Controls to Data the Application ApplicationStyling a User Interface Retrieving Student Photographs Over the Retrieving Student Photographs Over theCustomizing the Appearance of Student Web (if time permits) Web (if time permits)Photographs Binding Controls to Data Binding Controls to DataStyling the Logon View Styling a User Interface Styling a User InterfaceAnimating the StudentPhoto Control (If Time Customizing the Appearance of Student Customizing the Appearance of StudentPermits) Photographs PhotographsPerforming Operations Asynchronously Styling the Logon View Styling the Logon ViewSynchronizing Concurrent Access to Data Animating the StudentPhoto Control (If Animating the StudentPhoto Control (IfManaging the Lifetime of Objects and Time Permits) Time Permits)Controlling Unmanaged Resources Performing Operations Asynchronously Performing Operations AsynchronouslyGenerating the Grades Report by Using Synchronizing Concurrent Access to Synchronizing Concurrent Access to DataMicrosoft Office Word Data Managing the Lifetime of Objects andControlling the Lifetime of Word Objects by Managing the Lifetime of Objects and Controlling Unmanaged ResourcesImplementing the Dispose Pattern Controlling Unmanaged Resources Generating the Grades Report by UsingCreating and Using Custom Attributes Generating the Grades Report by Using Microsoft Office WordGenerating Managed Code Microsoft Office Word Controlling the Lifetime of Word Objects byVersioning, Signing and Deploying Controlling the Lifetime of Word Objects Implementing the Dispose PatternAssemblies by Implementing the Dispose Pattern Creating and Using Custom AttributesCreating the IncludeInReport Attribute Creating and Using Custom Attributes Generating Managed CodeGenerating the Report Generating Managed Code Versioning, Signing and DeployingStoring the Grades.Utilities Assembly Versioning, Signing and Deploying AssembliesCentrally Assemblies Creating the IncludeInReport AttributeImplementing Asymmetric Encryption Creating the IncludeInReport Attribute Generating the ReportEncrypting the Grades Report Generating the Report Storing the Grades.Utilities AssemblyDecrypting the Grades Report Storing the Grades.Utilities Assembly Centrally

Centrally Implementing Asymmetric EncryptionImplementing Asymmetric Encryption Encrypting the Grades Report

line Encrypting the Grades Report Decrypting the Grades ReportDatatypes, Operators, and Expressions Decrypting the Grades ReportC# Programming Language ConstructsImplementing Edit Functionality for the Module 5: Creating a Class Hierarchy by lineStudents List Using Inheritance Datatypes, Operators, and ExpressionsImplementing Insert Functionality for the line C# Programming Language ConstructsStudents List Creating Class Hierarchies Implementing Edit Functionality for theImplementing Delete Functionality for the Students ListStudents List Implementing Insert Functionality for theDisplaying the Student Age line Students ListCreating Overloaded Methods and Using Datatypes, Operators, and Expressions Implementing Delete Functionality for theOptional and Output Parameters C# Programming Language Constructs Students ListHandling Exceptions Implementing Edit Functionality for the Displaying the Student AgeMonitoring Applications Students List Creating Overloaded Methods and UsingRefactoring the Enrolment Code Implementing Insert Functionality for the Optional and Output ParametersValidating Student Information Students List Handling ExceptionsSaving Changes to the Class List Implementing Delete Functionality for the Monitoring Applications


Organizing Data into Collections Students List Refactoring the Enrolment CodeHandling Events Displaying the Student Age Validating Student InformationAdding Navigation Logic to the Application Creating Overloaded Methods and Using Saving Changes to the Class ListCreating Data Types to Store User and Optional and Output Parameters Organizing Data into CollectionsGrade Information Handling Exceptions Handling EventsDisplaying User and Grade Information Monitoring Applications Adding Navigation Logic to the ApplicationDefining and Implementing Interfaces Refactoring the Enrolment Code Creating Data Types to Store User andImplementing Type-safe Collections Validating Student Information Grade InformationImplementing the Teacher, Student, and Saving Changes to the Class List Displaying User and Grade InformationGrade Types as Classes Organizing Data into Collections Defining and Implementing InterfacesAdding Data Validation to the Grade Class Handling Events Implementing Type-safe CollectionsDisplaying Students in Name Order Adding Navigation Logic to the Implementing the Teacher, Student, andEnabling Teachers to Modify Class and Application Grade Types as ClassesGrade Data Creating Data Types to Store User and Adding Data Validation to the Grade ClassExtending .NET Framework Classes Grade Information Displaying Students in Name OrderCreating Generic Types Displaying User and Grade Information Enabling Teachers to Modify Class andCreating and Inheriting from the User Base Defining and Implementing Interfaces Grade DataClass Implementing Type-safe Collections Extending .NET Framework ClassesImplementing Password Complexity by Implementing the Teacher, Student, and Creating Generic TypesUsing an Abstract Method Grade Types as Classes Creating and Inheriting from the User BaseCreating the ClassFullException Class Adding Data Validation to the Grade ClassSerializing and Deserializing Data Class Implementing Password Complexity byPerforming I/O Using Streams Displaying Students in Name Order Using an Abstract MethodSerializing the Data for the Grades Report Enabling Teachers to Modify Class and Creating the ClassFullException Classas XML Grade Data Serializing and Deserializing DataPreviewing the Grades Report Extending .NET Framework Classes Performing I/O Using StreamsPersisting the Serialized Grades Data to a Creating Generic Types Serializing the Data for the Grades ReportFile Creating and Inheriting from the User as XMLQuerying Data by Using LINQ Base Class Previewing the Grades ReportUpdating Data by Using LINQ Implementing Password Complexity by Persisting the Serialized Grades Data to aCreating an Entity Model from the The Using an Abstract Method FileSchool of Fine Arts Database Creating the ClassFullException Class Querying Data by Using LINQUpdating Student and Grade Data Using the Serializing and Deserializing Data Updating Data by Using LINQEntity Framework Performing I/O Using Streams Creating an Entity Model from the TheExtending the Entity Model to Validate Data Serializing the Data for the Grades School of Fine Arts DatabaseAccessing Data in the Cloud Report as XML Updating Student and Grade Data UsingCreating a WCF Data Service for the Previewing the Grades Report the Entity FrameworkSchoolGrades Database Persisting the Serialized Grades Data to Extending the Entity Model to ValidateIntegrating the WCF Data Service into the a File DataApplication Querying Data by Using LINQ Accessing Data in the CloudRetrieving Student Photographs Over the Updating Data by Using LINQ Creating a WCF Data Service for theWeb (if time permits) Creating an Entity Model from the The SchoolGrades DatabaseBinding Controls to Data School of Fine Arts Database Integrating the WCF Data Service into theStyling a User Interface Updating Student and Grade Data Using ApplicationCustomizing the Appearance of Student the Entity Framework Retrieving Student Photographs Over thePhotographs Extending the Entity Model to Validate Web (if time permits)Styling the Logon View Data Binding Controls to DataAnimating the StudentPhoto Control (If Time Accessing Data in the Cloud Styling a User InterfacePermits) Creating a WCF Data Service for the Customizing the Appearance of StudentPerforming Operations Asynchronously SchoolGrades Database PhotographsSynchronizing Concurrent Access to Data Integrating the WCF Data Service into Styling the Logon ViewManaging the Lifetime of Objects and the Application Animating the StudentPhoto Control (IfControlling Unmanaged Resources Retrieving Student Photographs Over the Time Permits)Generating the Grades Report by Using Web (if time permits) Performing Operations AsynchronouslyMicrosoft Office Word Binding Controls to Data Synchronizing Concurrent Access to DataControlling the Lifetime of Word Objects by Styling a User Interface Managing the Lifetime of Objects andImplementing the Dispose Pattern Customizing the Appearance of Student Controlling Unmanaged ResourcesCreating and Using Custom Attributes Photographs Generating the Grades Report by UsingGenerating Managed Code Styling the Logon View Microsoft Office WordVersioning, Signing and Deploying Animating the StudentPhoto Control (If Controlling the Lifetime of Word Objects byAssemblies Time Permits) Implementing the Dispose PatternCreating the IncludeInReport Attribute Performing Operations Asynchronously Creating and Using Custom AttributesGenerating the Report Synchronizing Concurrent Access to Generating Managed CodeStoring the Grades.Utilities Assembly Data Versioning, Signing and DeployingCentrally Managing the Lifetime of Objects and AssembliesImplementing Asymmetric Encryption Controlling Unmanaged Resources Creating the IncludeInReport Attribute


Encrypting the Grades Report Generating the Grades Report by Using Generating the ReportDecrypting the Grades Report Microsoft Office Word Storing the Grades.Utilities Assembly

Controlling the Lifetime of Word Objects Centrallyby Implementing the Dispose Pattern Implementing Asymmetric Encryption

line Creating and Using Custom Attributes Encrypting the Grades ReportDatatypes, Operators, and Expressions Generating Managed Code Decrypting the Grades ReportC# Programming Language Constructs Versioning, Signing and DeployingImplementing Edit Functionality for the AssembliesStudents List Creating the IncludeInReport Attribute lineImplementing Insert Functionality for the Generating the Report Datatypes, Operators, and ExpressionsStudents List Storing the Grades.Utilities Assembly C# Programming Language ConstructsImplementing Delete Functionality for the Centrally Implementing Edit Functionality for theStudents List Implementing Asymmetric Encryption Students ListDisplaying the Student Age Encrypting the Grades Report Implementing Insert Functionality for theCreating Overloaded Methods and Using Decrypting the Grades Report Students ListOptional and Output Parameters Implementing Delete Functionality for theHandling Exceptions Students ListMonitoring Applications line Displaying the Student AgeRefactoring the Enrolment Code Datatypes, Operators, and Expressions Creating Overloaded Methods and UsingValidating Student Information C# Programming Language Constructs Optional and Output ParametersSaving Changes to the Class List Implementing Edit Functionality for the Handling ExceptionsOrganizing Data into Collections Students List Monitoring ApplicationsHandling Events Implementing Insert Functionality for the Refactoring the Enrolment CodeAdding Navigation Logic to the Application Students List Validating Student InformationCreating Data Types to Store User and Implementing Delete Functionality for the Saving Changes to the Class ListGrade Information Students List Organizing Data into CollectionsDisplaying User and Grade Information Displaying the Student Age Handling EventsDefining and Implementing Interfaces Creating Overloaded Methods and Using Adding Navigation Logic to the ApplicationImplementing Type-safe Collections Optional and Output Parameters Creating Data Types to Store User andImplementing the Teacher, Student, and Handling Exceptions Grade InformationGrade Types as Classes Monitoring Applications Displaying User and Grade InformationAdding Data Validation to the Grade Class Refactoring the Enrolment Code Defining and Implementing InterfacesDisplaying Students in Name Order Validating Student Information Implementing Type-safe CollectionsEnabling Teachers to Modify Class and Saving Changes to the Class List Implementing the Teacher, Student, andGrade Data Organizing Data into Collections Grade Types as ClassesExtending .NET Framework Classes Handling Events Adding Data Validation to the Grade ClassCreating Generic Types Adding Navigation Logic to the Displaying Students in Name OrderCreating and Inheriting from the User Base Application Enabling Teachers to Modify Class andClass Creating Data Types to Store User and Grade DataImplementing Password Complexity by Grade Information Extending .NET Framework ClassesUsing an Abstract Method Displaying User and Grade Information Creating Generic TypesCreating the ClassFullException Class Defining and Implementing Interfaces Creating and Inheriting from the User BaseSerializing and Deserializing Data Implementing Type-safe Collections ClassPerforming I/O Using Streams Implementing the Teacher, Student, and Implementing Password Complexity bySerializing the Data for the Grades Report Grade Types as Classes Using an Abstract Methodas XML Adding Data Validation to the Grade Creating the ClassFullException ClassPreviewing the Grades Report Class Serializing and Deserializing DataPersisting the Serialized Grades Data to a Displaying Students in Name Order Performing I/O Using StreamsFile Enabling Teachers to Modify Class and Serializing the Data for the Grades ReportQuerying Data by Using LINQ Grade Data as XMLUpdating Data by Using LINQ Extending .NET Framework Classes Previewing the Grades ReportCreating an Entity Model from the The Creating Generic Types Persisting the Serialized Grades Data to aSchool of Fine Arts Database Creating and Inheriting from the User FileUpdating Student and Grade Data Using the Base Class Querying Data by Using LINQEntity Framework Implementing Password Complexity by Updating Data by Using LINQExtending the Entity Model to Validate Data Using an Abstract Method Creating an Entity Model from the TheAccessing Data in the Cloud Creating the ClassFullException Class School of Fine Arts DatabaseCreating a WCF Data Service for the Serializing and Deserializing Data Updating Student and Grade Data UsingSchoolGrades Database Performing I/O Using Streams the Entity FrameworkIntegrating the WCF Data Service into the Serializing the Data for the Grades Extending the Entity Model to ValidateApplication Report as XML DataRetrieving Student Photographs Over the Previewing the Grades Report Accessing Data in the CloudWeb (if time permits) Persisting the Serialized Grades Data to Creating a WCF Data Service for theBinding Controls to Data a File SchoolGrades DatabaseStyling a User Interface Querying Data by Using LINQ Integrating the WCF Data Service into theCustomizing the Appearance of Student Updating Data by Using LINQ Application


Photographs Creating an Entity Model from the The Retrieving Student Photographs Over theStyling the Logon View School of Fine Arts Database Web (if time permits)Animating the StudentPhoto Control (If Time Updating Student and Grade Data Using Binding Controls to DataPermits) the Entity Framework Styling a User InterfacePerforming Operations Asynchronously Extending the Entity Model to Validate Customizing the Appearance of StudentSynchronizing Concurrent Access to Data Data PhotographsManaging the Lifetime of Objects and Accessing Data in the Cloud Styling the Logon ViewControlling Unmanaged Resources Creating a WCF Data Service for the Animating the StudentPhoto Control (IfGenerating the Grades Report by Using SchoolGrades Database Time Permits)Microsoft Office Word Integrating the WCF Data Service into Performing Operations AsynchronouslyControlling the Lifetime of Word Objects by the Application Synchronizing Concurrent Access to DataImplementing the Dispose Pattern Retrieving Student Photographs Over the Managing the Lifetime of Objects andCreating and Using Custom Attributes Web (if time permits) Controlling Unmanaged ResourcesGenerating Managed Code Binding Controls to Data Generating the Grades Report by UsingVersioning, Signing and Deploying Styling a User Interface Microsoft Office WordAssemblies Customizing the Appearance of Student Controlling the Lifetime of Word Objects byCreating the IncludeInReport Attribute Photographs Implementing the Dispose PatternGenerating the Report Styling the Logon View Creating and Using Custom AttributesStoring the Grades.Utilities Assembly Animating the StudentPhoto Control (If Generating Managed CodeCentrally Time Permits) Versioning, Signing and DeployingImplementing Asymmetric Encryption Performing Operations Asynchronously AssembliesEncrypting the Grades Report Synchronizing Concurrent Access to Creating the IncludeInReport AttributeDecrypting the Grades Report Data Generating the Report

Managing the Lifetime of Objects and Storing the Grades.Utilities AssemblyControlling Unmanaged Resources Centrally

line Generating the Grades Report by Using Implementing Asymmetric EncryptionDatatypes, Operators, and Expressions Microsoft Office Word Encrypting the Grades ReportC# Programming Language Constructs Controlling the Lifetime of Word Objects Decrypting the Grades ReportImplementing Edit Functionality for the by Implementing the Dispose PatternStudents List Creating and Using Custom AttributesImplementing Insert Functionality for the Generating Managed Code lineStudents List Versioning, Signing and Deploying Datatypes, Operators, and ExpressionsImplementing Delete Functionality for the Assemblies C# Programming Language ConstructsStudents List Creating the IncludeInReport Attribute Implementing Edit Functionality for theDisplaying the Student Age Generating the Report Students ListCreating Overloaded Methods and Using Storing the Grades.Utilities Assembly Implementing Insert Functionality for theOptional and Output Parameters Centrally Students ListHandling Exceptions Implementing Asymmetric Encryption Implementing Delete Functionality for theMonitoring Applications Encrypting the Grades Report Students ListRefactoring the Enrolment Code Decrypting the Grades Report Displaying the Student AgeValidating Student Information Creating Overloaded Methods and UsingSaving Changes to the Class List Optional and Output ParametersOrganizing Data into Collections line Handling ExceptionsHandling Events Datatypes, Operators, and Expressions Monitoring ApplicationsAdding Navigation Logic to the Application C# Programming Language Constructs Refactoring the Enrolment CodeCreating Data Types to Store User and Implementing Edit Functionality for the Validating Student InformationGrade Information Students List Saving Changes to the Class ListDisplaying User and Grade Information Implementing Insert Functionality for the Organizing Data into CollectionsDefining and Implementing Interfaces Students List Handling EventsImplementing Type-safe Collections Implementing Delete Functionality for the Adding Navigation Logic to the ApplicationImplementing the Teacher, Student, and Students List Creating Data Types to Store User andGrade Types as Classes Displaying the Student Age Grade InformationAdding Data Validation to the Grade Class Creating Overloaded Methods and Using Displaying User and Grade InformationDisplaying Students in Name Order Optional and Output Parameters Defining and Implementing InterfacesEnabling Teachers to Modify Class and Handling Exceptions Implementing Type-safe CollectionsGrade Data Monitoring Applications Implementing the Teacher, Student, andExtending .NET Framework Classes Refactoring the Enrolment Code Grade Types as ClassesCreating Generic Types Validating Student Information Adding Data Validation to the Grade ClassCreating and Inheriting from the User Base Saving Changes to the Class List Displaying Students in Name OrderClass Organizing Data into Collections Enabling Teachers to Modify Class andImplementing Password Complexity by Handling Events Grade DataUsing an Abstract Method Adding Navigation Logic to the Extending .NET Framework ClassesCreating the ClassFullException Class Application Creating Generic TypesSerializing and Deserializing Data Creating Data Types to Store User and Creating and Inheriting from the User BasePerforming I/O Using Streams Grade Information ClassSerializing the Data for the Grades Report Displaying User and Grade Information Implementing Password Complexity by


as XML Defining and Implementing Interfaces Using an Abstract MethodPreviewing the Grades Report Implementing Type-safe Collections Creating the ClassFullException ClassPersisting the Serialized Grades Data to a Implementing the Teacher, Student, and Serializing and Deserializing DataFile Grade Types as Classes Performing I/O Using StreamsQuerying Data by Using LINQ Adding Data Validation to the Grade Serializing the Data for the Grades ReportUpdating Data by Using LINQ Class as XMLCreating an Entity Model from the The Displaying Students in Name Order Previewing the Grades ReportSchool of Fine Arts Database Enabling Teachers to Modify Class and Persisting the Serialized Grades Data to aUpdating Student and Grade Data Using the Grade Data FileEntity Framework Extending .NET Framework Classes Querying Data by Using LINQExtending the Entity Model to Validate Data Creating Generic Types Updating Data by Using LINQAccessing Data in the Cloud Creating and Inheriting from the User Creating an Entity Model from the TheCreating a WCF Data Service for the Base Class School of Fine Arts DatabaseSchoolGrades Database Implementing Password Complexity by Updating Student and Grade Data UsingIntegrating the WCF Data Service into the Using an Abstract Method the Entity FrameworkApplication Creating the ClassFullException Class Extending the Entity Model to ValidateRetrieving Student Photographs Over the Serializing and Deserializing Data DataWeb (if time permits) Performing I/O Using Streams Accessing Data in the CloudBinding Controls to Data Serializing the Data for the Grades Creating a WCF Data Service for theStyling a User Interface Report as XML SchoolGrades DatabaseCustomizing the Appearance of Student Previewing the Grades Report Integrating the WCF Data Service into thePhotographs Persisting the Serialized Grades Data to ApplicationStyling the Logon View a File Retrieving Student Photographs Over theAnimating the StudentPhoto Control (If Time Querying Data by Using LINQ Web (if time permits)Permits) Updating Data by Using LINQ Binding Controls to DataPerforming Operations Asynchronously Creating an Entity Model from the The Styling a User InterfaceSynchronizing Concurrent Access to Data School of Fine Arts Database Customizing the Appearance of StudentManaging the Lifetime of Objects and Updating Student and Grade Data Using PhotographsControlling Unmanaged Resources the Entity Framework Styling the Logon ViewGenerating the Grades Report by Using Extending the Entity Model to Validate Animating the StudentPhoto Control (IfMicrosoft Office Word Data Time Permits)Controlling the Lifetime of Word Objects by Accessing Data in the Cloud Performing Operations AsynchronouslyImplementing the Dispose Pattern Creating a WCF Data Service for the Synchronizing Concurrent Access to DataCreating and Using Custom Attributes SchoolGrades Database Managing the Lifetime of Objects andGenerating Managed Code Integrating the WCF Data Service into Controlling Unmanaged ResourcesVersioning, Signing and Deploying the Application Generating the Grades Report by UsingAssemblies Retrieving Student Photographs Over the Microsoft Office WordCreating the IncludeInReport Attribute Web (if time permits) Controlling the Lifetime of Word Objects byGenerating the Report Binding Controls to Data Implementing the Dispose PatternStoring the Grades.Utilities Assembly Styling a User Interface Creating and Using Custom AttributesCentrally Customizing the Appearance of Student Generating Managed CodeImplementing Asymmetric Encryption Photographs Versioning, Signing and DeployingEncrypting the Grades Report Styling the Logon View AssembliesDecrypting the Grades Report Animating the StudentPhoto Control (If Creating the IncludeInReport Attribute

Time Permits) Generating the ReportPerforming Operations Asynchronously Storing the Grades.Utilities Assembly

line Synchronizing Concurrent Access to CentrallyDatatypes, Operators, and Expressions Data Implementing Asymmetric EncryptionC# Programming Language Constructs Managing the Lifetime of Objects and Encrypting the Grades ReportImplementing Edit Functionality for the Controlling Unmanaged Resources Decrypting the Grades ReportStudents List Generating the Grades Report by UsingImplementing Insert Functionality for the Microsoft Office Word Module 10: Improving ApplicationStudents List Controlling the Lifetime of Word Objects Performance and Responsiveness Implementing Delete Functionality for the by Implementing the Dispose Pattern lineStudents List Creating and Using Custom Attributes Implementing Multitasking by using TasksDisplaying the Student Age Generating Managed Code and Lambda ExpressionsCreating Overloaded Methods and Using Versioning, Signing and DeployingOptional and Output Parameters AssembliesHandling Exceptions Creating the IncludeInReport Attribute lineMonitoring Applications Generating the Report Datatypes, Operators, and ExpressionsRefactoring the Enrolment Code Storing the Grades.Utilities Assembly C# Programming Language ConstructsValidating Student Information Centrally Implementing Edit Functionality for theSaving Changes to the Class List Implementing Asymmetric Encryption Students ListOrganizing Data into Collections Encrypting the Grades Report Implementing Insert Functionality for theHandling Events Decrypting the Grades Report Students ListAdding Navigation Logic to the Application Implementing Delete Functionality for the


Creating Data Types to Store User and Students ListGrade Information line Displaying the Student AgeDisplaying User and Grade Information Datatypes, Operators, and Expressions Creating Overloaded Methods and UsingDefining and Implementing Interfaces C# Programming Language Constructs Optional and Output ParametersImplementing Type-safe Collections Implementing Edit Functionality for the Handling ExceptionsImplementing the Teacher, Student, and Students List Monitoring ApplicationsGrade Types as Classes Implementing Insert Functionality for the Refactoring the Enrolment CodeAdding Data Validation to the Grade Class Students List Validating Student InformationDisplaying Students in Name Order Implementing Delete Functionality for the Saving Changes to the Class ListEnabling Teachers to Modify Class and Students List Organizing Data into CollectionsGrade Data Displaying the Student Age Handling EventsExtending .NET Framework Classes Creating Overloaded Methods and Using Adding Navigation Logic to the ApplicationCreating Generic Types Optional and Output Parameters Creating Data Types to Store User andCreating and Inheriting from the User Base Handling Exceptions Grade InformationClass Monitoring Applications Displaying User and Grade InformationImplementing Password Complexity by Refactoring the Enrolment Code Defining and Implementing InterfacesUsing an Abstract Method Validating Student Information Implementing Type-safe CollectionsCreating the ClassFullException Class Saving Changes to the Class List Implementing the Teacher, Student, andSerializing and Deserializing Data Organizing Data into Collections Grade Types as ClassesPerforming I/O Using Streams Handling Events Adding Data Validation to the Grade ClassSerializing the Data for the Grades Report Adding Navigation Logic to the Displaying Students in Name Orderas XML Application Enabling Teachers to Modify Class andPreviewing the Grades Report Creating Data Types to Store User and Grade DataPersisting the Serialized Grades Data to a Grade Information Extending .NET Framework ClassesFile Displaying User and Grade Information Creating Generic TypesQuerying Data by Using LINQ Defining and Implementing Interfaces Creating and Inheriting from the User BaseUpdating Data by Using LINQ Implementing Type-safe Collections ClassCreating an Entity Model from the The Implementing the Teacher, Student, and Implementing Password Complexity bySchool of Fine Arts Database Grade Types as Classes Using an Abstract MethodUpdating Student and Grade Data Using the Adding Data Validation to the Grade Creating the ClassFullException ClassEntity Framework Class Serializing and Deserializing DataExtending the Entity Model to Validate Data Displaying Students in Name Order Performing I/O Using StreamsAccessing Data in the Cloud Enabling Teachers to Modify Class and Serializing the Data for the Grades ReportCreating a WCF Data Service for the Grade Data as XMLSchoolGrades Database Extending .NET Framework Classes Previewing the Grades ReportIntegrating the WCF Data Service into the Creating Generic Types Persisting the Serialized Grades Data to aApplication Creating and Inheriting from the User FileRetrieving Student Photographs Over the Base Class Querying Data by Using LINQWeb (if time permits) Implementing Password Complexity by Updating Data by Using LINQBinding Controls to Data Using an Abstract Method Creating an Entity Model from the TheStyling a User Interface Creating the ClassFullException Class School of Fine Arts DatabaseCustomizing the Appearance of Student Serializing and Deserializing Data Updating Student and Grade Data UsingPhotographs Performing I/O Using Streams the Entity FrameworkStyling the Logon View Serializing the Data for the Grades Extending the Entity Model to ValidateAnimating the StudentPhoto Control (If Time Report as XML DataPermits) Previewing the Grades Report Accessing Data in the CloudPerforming Operations Asynchronously Persisting the Serialized Grades Data to Creating a WCF Data Service for theSynchronizing Concurrent Access to Data a File SchoolGrades DatabaseManaging the Lifetime of Objects and Querying Data by Using LINQ Integrating the WCF Data Service into theControlling Unmanaged Resources Updating Data by Using LINQ ApplicationGenerating the Grades Report by Using Creating an Entity Model from the The Retrieving Student Photographs Over theMicrosoft Office Word School of Fine Arts Database Web (if time permits)Controlling the Lifetime of Word Objects by Updating Student and Grade Data Using Binding Controls to DataImplementing the Dispose Pattern the Entity Framework Styling a User InterfaceCreating and Using Custom Attributes Extending the Entity Model to Validate Customizing the Appearance of StudentGenerating Managed Code Data PhotographsVersioning, Signing and Deploying Accessing Data in the Cloud Styling the Logon ViewAssemblies Creating a WCF Data Service for the Animating the StudentPhoto Control (IfCreating the IncludeInReport Attribute SchoolGrades Database Time Permits)Generating the Report Integrating the WCF Data Service into Performing Operations AsynchronouslyStoring the Grades.Utilities Assembly the Application Synchronizing Concurrent Access to DataCentrally Retrieving Student Photographs Over the Managing the Lifetime of Objects andImplementing Asymmetric Encryption Web (if time permits) Controlling Unmanaged ResourcesEncrypting the Grades Report Binding Controls to Data Generating the Grades Report by UsingDecrypting the Grades Report Styling a User Interface Microsoft Office Word

Customizing the Appearance of Student Controlling the Lifetime of Word Objects by


Module 2: Creating Methods, Handling Photographs Implementing the Dispose PatternExceptions, and Monitoring Applications Styling the Logon View Creating and Using Custom Attributesline Animating the StudentPhoto Control (If Generating Managed Code

Creating and Invoking Methods Time Permits) Versioning, Signing and DeployingPerforming Operations Asynchronously AssembliesSynchronizing Concurrent Access to Creating the IncludeInReport Attribute

line Data Generating the ReportDatatypes, Operators, and Expressions Managing the Lifetime of Objects and Storing the Grades.Utilities AssemblyC# Programming Language Constructs Controlling Unmanaged Resources CentrallyImplementing Edit Functionality for the Generating the Grades Report by Using Implementing Asymmetric EncryptionStudents List Microsoft Office Word Encrypting the Grades ReportImplementing Insert Functionality for the Controlling the Lifetime of Word Objects Decrypting the Grades ReportStudents List by Implementing the Dispose PatternImplementing Delete Functionality for the Creating and Using Custom AttributesStudents List Generating Managed Code lineDisplaying the Student Age Versioning, Signing and Deploying Datatypes, Operators, and ExpressionsCreating Overloaded Methods and Using Assemblies C# Programming Language ConstructsOptional and Output Parameters Creating the IncludeInReport Attribute Implementing Edit Functionality for theHandling Exceptions Generating the Report Students ListMonitoring Applications Storing the Grades.Utilities Assembly Implementing Insert Functionality for theRefactoring the Enrolment Code Centrally Students ListValidating Student Information Implementing Asymmetric Encryption Implementing Delete Functionality for theSaving Changes to the Class List Encrypting the Grades Report Students ListOrganizing Data into Collections Decrypting the Grades Report Displaying the Student AgeHandling Events Creating Overloaded Methods and UsingAdding Navigation Logic to the Application Optional and Output ParametersCreating Data Types to Store User and line Handling ExceptionsGrade Information Datatypes, Operators, and Expressions Monitoring ApplicationsDisplaying User and Grade Information C# Programming Language Constructs Refactoring the Enrolment CodeDefining and Implementing Interfaces Implementing Edit Functionality for the Validating Student InformationImplementing Type-safe Collections Students List Saving Changes to the Class ListImplementing the Teacher, Student, and Implementing Insert Functionality for the Organizing Data into CollectionsGrade Types as Classes Students List Handling EventsAdding Data Validation to the Grade Class Implementing Delete Functionality for the Adding Navigation Logic to the ApplicationDisplaying Students in Name Order Students List Creating Data Types to Store User andEnabling Teachers to Modify Class and Displaying the Student Age Grade InformationGrade Data Creating Overloaded Methods and Using Displaying User and Grade InformationExtending .NET Framework Classes Optional and Output Parameters Defining and Implementing InterfacesCreating Generic Types Handling Exceptions Implementing Type-safe CollectionsCreating and Inheriting from the User Base Monitoring Applications Implementing the Teacher, Student, andClass Refactoring the Enrolment Code Grade Types as ClassesImplementing Password Complexity by Validating Student Information Adding Data Validation to the Grade ClassUsing an Abstract Method Saving Changes to the Class List Displaying Students in Name OrderCreating the ClassFullException Class Organizing Data into Collections Enabling Teachers to Modify Class andSerializing and Deserializing Data Handling Events Grade DataPerforming I/O Using Streams Adding Navigation Logic to the Extending .NET Framework ClassesSerializing the Data for the Grades Report Application Creating Generic Typesas XML Creating Data Types to Store User and Creating and Inheriting from the User BasePreviewing the Grades Report Grade Information ClassPersisting the Serialized Grades Data to a Displaying User and Grade Information Implementing Password Complexity byFile Defining and Implementing Interfaces Using an Abstract MethodQuerying Data by Using LINQ Implementing Type-safe Collections Creating the ClassFullException ClassUpdating Data by Using LINQ Implementing the Teacher, Student, and Serializing and Deserializing DataCreating an Entity Model from the The Grade Types as Classes Performing I/O Using StreamsSchool of Fine Arts Database Adding Data Validation to the Grade Serializing the Data for the Grades ReportUpdating Student and Grade Data Using the Class as XMLEntity Framework Displaying Students in Name Order Previewing the Grades ReportExtending the Entity Model to Validate Data Enabling Teachers to Modify Class and Persisting the Serialized Grades Data to aAccessing Data in the Cloud Grade Data FileCreating a WCF Data Service for the Extending .NET Framework Classes Querying Data by Using LINQSchoolGrades Database Creating Generic Types Updating Data by Using LINQIntegrating the WCF Data Service into the Creating and Inheriting from the User Creating an Entity Model from the TheApplication Base Class School of Fine Arts DatabaseRetrieving Student Photographs Over the Implementing Password Complexity by Updating Student and Grade Data UsingWeb (if time permits) Using an Abstract Method the Entity FrameworkBinding Controls to Data Creating the ClassFullException Class Extending the Entity Model to Validate


Styling a User Interface Serializing and Deserializing Data DataCustomizing the Appearance of Student Performing I/O Using Streams Accessing Data in the CloudPhotographs Serializing the Data for the Grades Creating a WCF Data Service for theStyling the Logon View Report as XML SchoolGrades DatabaseAnimating the StudentPhoto Control (If Time Previewing the Grades Report Integrating the WCF Data Service into thePermits) Persisting the Serialized Grades Data to ApplicationPerforming Operations Asynchronously a File Retrieving Student Photographs Over theSynchronizing Concurrent Access to Data Querying Data by Using LINQ Web (if time permits)Managing the Lifetime of Objects and Updating Data by Using LINQ Binding Controls to DataControlling Unmanaged Resources Creating an Entity Model from the The Styling a User InterfaceGenerating the Grades Report by Using School of Fine Arts Database Customizing the Appearance of StudentMicrosoft Office Word Updating Student and Grade Data Using PhotographsControlling the Lifetime of Word Objects by the Entity Framework Styling the Logon ViewImplementing the Dispose Pattern Extending the Entity Model to Validate Animating the StudentPhoto Control (IfCreating and Using Custom Attributes Data Time Permits)Generating Managed Code Accessing Data in the Cloud Performing Operations AsynchronouslyVersioning, Signing and Deploying Creating a WCF Data Service for the Synchronizing Concurrent Access to DataAssemblies SchoolGrades Database Managing the Lifetime of Objects andCreating the IncludeInReport Attribute Integrating the WCF Data Service into Controlling Unmanaged ResourcesGenerating the Report the Application Generating the Grades Report by UsingStoring the Grades.Utilities Assembly Retrieving Student Photographs Over the Microsoft Office WordCentrally Web (if time permits) Controlling the Lifetime of Word Objects byImplementing Asymmetric Encryption Binding Controls to Data Implementing the Dispose PatternEncrypting the Grades Report Styling a User Interface Creating and Using Custom AttributesDecrypting the Grades Report Customizing the Appearance of Student Generating Managed Code

Photographs Versioning, Signing and DeployingStyling the Logon View Assemblies

line Animating the StudentPhoto Control (If Creating the IncludeInReport AttributeDatatypes, Operators, and Expressions Time Permits) Generating the ReportC# Programming Language Constructs Performing Operations Asynchronously Storing the Grades.Utilities AssemblyImplementing Edit Functionality for the Synchronizing Concurrent Access to CentrallyStudents List Data Implementing Asymmetric EncryptionImplementing Insert Functionality for the Managing the Lifetime of Objects and Encrypting the Grades ReportStudents List Controlling Unmanaged Resources Decrypting the Grades ReportImplementing Delete Functionality for the Generating the Grades Report by UsingStudents List Microsoft Office Word Module 11: Integrating with Unmanaged CodeDisplaying the Student Age Controlling the Lifetime of Word Objects lineCreating Overloaded Methods and Using by Implementing the Dispose Pattern Creating and Using Dynamic ObjectsOptional and Output Parameters Creating and Using Custom AttributesHandling Exceptions Generating Managed CodeMonitoring Applications Versioning, Signing and Deploying lineRefactoring the Enrolment Code Assemblies Datatypes, Operators, and ExpressionsValidating Student Information Creating the IncludeInReport Attribute C# Programming Language ConstructsSaving Changes to the Class List Generating the Report Implementing Edit Functionality for theOrganizing Data into Collections Storing the Grades.Utilities Assembly Students ListHandling Events Centrally Implementing Insert Functionality for theAdding Navigation Logic to the Application Implementing Asymmetric Encryption Students ListCreating Data Types to Store User and Encrypting the Grades Report Implementing Delete Functionality for theGrade Information Decrypting the Grades Report Students ListDisplaying User and Grade Information Displaying the Student AgeDefining and Implementing Interfaces Module 6: Reading and Writing Local Data Creating Overloaded Methods and UsingImplementing Type-safe Collections line Optional and Output ParametersImplementing the Teacher, Student, and Reading and Writing Files Handling ExceptionsGrade Types as Classes Monitoring ApplicationsAdding Data Validation to the Grade Class Refactoring the Enrolment CodeDisplaying Students in Name Order line Validating Student InformationEnabling Teachers to Modify Class and Datatypes, Operators, and Expressions Saving Changes to the Class ListGrade Data C# Programming Language Constructs Organizing Data into CollectionsExtending .NET Framework Classes Implementing Edit Functionality for the Handling EventsCreating Generic Types Students List Adding Navigation Logic to the ApplicationCreating and Inheriting from the User Base Implementing Insert Functionality for the Creating Data Types to Store User andClass Students List Grade InformationImplementing Password Complexity by Implementing Delete Functionality for the Displaying User and Grade InformationUsing an Abstract Method Students List Defining and Implementing InterfacesCreating the ClassFullException Class Displaying the Student Age Implementing Type-safe CollectionsSerializing and Deserializing Data Creating Overloaded Methods and Using Implementing the Teacher, Student, and


Performing I/O Using Streams Optional and Output Parameters Grade Types as ClassesSerializing the Data for the Grades Report Handling Exceptions Adding Data Validation to the Grade Classas XML Monitoring Applications Displaying Students in Name OrderPreviewing the Grades Report Refactoring the Enrolment Code Enabling Teachers to Modify Class andPersisting the Serialized Grades Data to a Validating Student Information Grade DataFile Saving Changes to the Class List Extending .NET Framework ClassesQuerying Data by Using LINQ Organizing Data into Collections Creating Generic TypesUpdating Data by Using LINQ Handling Events Creating and Inheriting from the User BaseCreating an Entity Model from the The Adding Navigation Logic to the ClassSchool of Fine Arts Database Application Implementing Password Complexity byUpdating Student and Grade Data Using the Creating Data Types to Store User and Using an Abstract MethodEntity Framework Grade Information Creating the ClassFullException ClassExtending the Entity Model to Validate Data Displaying User and Grade Information Serializing and Deserializing DataAccessing Data in the Cloud Defining and Implementing Interfaces Performing I/O Using StreamsCreating a WCF Data Service for the Implementing Type-safe Collections Serializing the Data for the Grades ReportSchoolGrades Database Implementing the Teacher, Student, and as XMLIntegrating the WCF Data Service into the Grade Types as Classes Previewing the Grades ReportApplication Adding Data Validation to the Grade Persisting the Serialized Grades Data to aRetrieving Student Photographs Over the Class FileWeb (if time permits) Displaying Students in Name Order Querying Data by Using LINQBinding Controls to Data Enabling Teachers to Modify Class and Updating Data by Using LINQStyling a User Interface Grade Data Creating an Entity Model from the TheCustomizing the Appearance of Student Extending .NET Framework Classes School of Fine Arts DatabasePhotographs Creating Generic Types Updating Student and Grade Data UsingStyling the Logon View Creating and Inheriting from the User the Entity FrameworkAnimating the StudentPhoto Control (If Time Base Class Extending the Entity Model to ValidatePermits) Implementing Password Complexity by DataPerforming Operations Asynchronously Using an Abstract Method Accessing Data in the CloudSynchronizing Concurrent Access to Data Creating the ClassFullException Class Creating a WCF Data Service for theManaging the Lifetime of Objects and Serializing and Deserializing Data SchoolGrades DatabaseControlling Unmanaged Resources Performing I/O Using Streams Integrating the WCF Data Service into theGenerating the Grades Report by Using Serializing the Data for the Grades ApplicationMicrosoft Office Word Report as XML Retrieving Student Photographs Over theControlling the Lifetime of Word Objects by Previewing the Grades Report Web (if time permits)Implementing the Dispose Pattern Persisting the Serialized Grades Data to Binding Controls to DataCreating and Using Custom Attributes a File Styling a User InterfaceGenerating Managed Code Querying Data by Using LINQ Customizing the Appearance of StudentVersioning, Signing and Deploying Updating Data by Using LINQ PhotographsAssemblies Creating an Entity Model from the The Styling the Logon ViewCreating the IncludeInReport Attribute School of Fine Arts Database Animating the StudentPhoto Control (IfGenerating the Report Updating Student and Grade Data Using Time Permits)Storing the Grades.Utilities Assembly the Entity Framework Performing Operations AsynchronouslyCentrally Extending the Entity Model to Validate Synchronizing Concurrent Access to DataImplementing Asymmetric Encryption Data Managing the Lifetime of Objects andEncrypting the Grades Report Accessing Data in the Cloud Controlling Unmanaged ResourcesDecrypting the Grades Report Creating a WCF Data Service for the Generating the Grades Report by Using

SchoolGrades Database Microsoft Office WordIntegrating the WCF Data Service into Controlling the Lifetime of Word Objects by

line the Application Implementing the Dispose PatternDatatypes, Operators, and Expressions Retrieving Student Photographs Over the Creating and Using Custom AttributesC# Programming Language Constructs Web (if time permits) Generating Managed CodeImplementing Edit Functionality for the Binding Controls to Data Versioning, Signing and DeployingStudents List Styling a User Interface AssembliesImplementing Insert Functionality for the Customizing the Appearance of Student Creating the IncludeInReport AttributeStudents List Photographs Generating the ReportImplementing Delete Functionality for the Styling the Logon View Storing the Grades.Utilities AssemblyStudents List Animating the StudentPhoto Control (If CentrallyDisplaying the Student Age Time Permits) Implementing Asymmetric EncryptionCreating Overloaded Methods and Using Performing Operations Asynchronously Encrypting the Grades ReportOptional and Output Parameters Synchronizing Concurrent Access to Decrypting the Grades ReportHandling Exceptions DataMonitoring Applications Managing the Lifetime of Objects andRefactoring the Enrolment Code Controlling Unmanaged Resources lineValidating Student Information Generating the Grades Report by Using Datatypes, Operators, and ExpressionsSaving Changes to the Class List Microsoft Office Word C# Programming Language ConstructsOrganizing Data into Collections Controlling the Lifetime of Word Objects Implementing Edit Functionality for the


Handling Events by Implementing the Dispose Pattern Students ListAdding Navigation Logic to the Application Creating and Using Custom Attributes Implementing Insert Functionality for theCreating Data Types to Store User and Generating Managed Code Students ListGrade Information Versioning, Signing and Deploying Implementing Delete Functionality for theDisplaying User and Grade Information Assemblies Students ListDefining and Implementing Interfaces Creating the IncludeInReport Attribute Displaying the Student AgeImplementing Type-safe Collections Generating the Report Creating Overloaded Methods and UsingImplementing the Teacher, Student, and Storing the Grades.Utilities Assembly Optional and Output ParametersGrade Types as Classes Centrally Handling ExceptionsAdding Data Validation to the Grade Class Implementing Asymmetric Encryption Monitoring ApplicationsDisplaying Students in Name Order Encrypting the Grades Report Refactoring the Enrolment CodeEnabling Teachers to Modify Class and Decrypting the Grades Report Validating Student InformationGrade Data Saving Changes to the Class ListExtending .NET Framework Classes Organizing Data into CollectionsCreating Generic Types line Handling EventsCreating and Inheriting from the User Base Datatypes, Operators, and Expressions Adding Navigation Logic to the ApplicationClass C# Programming Language Constructs Creating Data Types to Store User andImplementing Password Complexity by Implementing Edit Functionality for the Grade InformationUsing an Abstract Method Students List Displaying User and Grade InformationCreating the ClassFullException Class Implementing Insert Functionality for the Defining and Implementing InterfacesSerializing and Deserializing Data Students List Implementing Type-safe CollectionsPerforming I/O Using Streams Implementing Delete Functionality for the Implementing the Teacher, Student, andSerializing the Data for the Grades Report Students List Grade Types as Classesas XML Displaying the Student Age Adding Data Validation to the Grade ClassPreviewing the Grades Report Creating Overloaded Methods and Using Displaying Students in Name OrderPersisting the Serialized Grades Data to a Optional and Output Parameters Enabling Teachers to Modify Class andFile Handling Exceptions Grade DataQuerying Data by Using LINQ Monitoring Applications Extending .NET Framework ClassesUpdating Data by Using LINQ Refactoring the Enrolment Code Creating Generic TypesCreating an Entity Model from the The Validating Student Information Creating and Inheriting from the User BaseSchool of Fine Arts Database Saving Changes to the Class List ClassUpdating Student and Grade Data Using the Organizing Data into Collections Implementing Password Complexity byEntity Framework Handling Events Using an Abstract MethodExtending the Entity Model to Validate Data Adding Navigation Logic to the Creating the ClassFullException ClassAccessing Data in the Cloud Application Serializing and Deserializing DataCreating a WCF Data Service for the Creating Data Types to Store User and Performing I/O Using StreamsSchoolGrades Database Grade Information Serializing the Data for the Grades ReportIntegrating the WCF Data Service into the Displaying User and Grade Information as XMLApplication Defining and Implementing Interfaces Previewing the Grades ReportRetrieving Student Photographs Over the Implementing Type-safe Collections Persisting the Serialized Grades Data to aWeb (if time permits) Implementing the Teacher, Student, and FileBinding Controls to Data Grade Types as Classes Querying Data by Using LINQStyling a User Interface Adding Data Validation to the Grade Updating Data by Using LINQCustomizing the Appearance of Student Class Creating an Entity Model from the ThePhotographs Displaying Students in Name Order School of Fine Arts DatabaseStyling the Logon View Enabling Teachers to Modify Class and Updating Student and Grade Data UsingAnimating the StudentPhoto Control (If Time Grade Data the Entity FrameworkPermits) Extending .NET Framework Classes Extending the Entity Model to ValidatePerforming Operations Asynchronously Creating Generic Types DataSynchronizing Concurrent Access to Data Creating and Inheriting from the User Accessing Data in the CloudManaging the Lifetime of Objects and Base Class Creating a WCF Data Service for theControlling Unmanaged Resources Implementing Password Complexity by SchoolGrades DatabaseGenerating the Grades Report by Using Using an Abstract Method Integrating the WCF Data Service into theMicrosoft Office Word Creating the ClassFullException Class ApplicationControlling the Lifetime of Word Objects by Serializing and Deserializing Data Retrieving Student Photographs Over theImplementing the Dispose Pattern Performing I/O Using Streams Web (if time permits)Creating and Using Custom Attributes Serializing the Data for the Grades Binding Controls to DataGenerating Managed Code Report as XML Styling a User InterfaceVersioning, Signing and Deploying Previewing the Grades Report Customizing the Appearance of StudentAssemblies Persisting the Serialized Grades Data to PhotographsCreating the IncludeInReport Attribute a File Styling the Logon ViewGenerating the Report Querying Data by Using LINQ Animating the StudentPhoto Control (IfStoring the Grades.Utilities Assembly Updating Data by Using LINQ Time Permits)Centrally Creating an Entity Model from the The Performing Operations AsynchronouslyImplementing Asymmetric Encryption School of Fine Arts Database Synchronizing Concurrent Access to DataEncrypting the Grades Report Updating Student and Grade Data Using Managing the Lifetime of Objects and


Decrypting the Grades Report the Entity Framework Controlling Unmanaged ResourcesExtending the Entity Model to Validate Generating the Grades Report by UsingData Microsoft Office Word

line Accessing Data in the Cloud Controlling the Lifetime of Word Objects byDatatypes, Operators, and Expressions Creating a WCF Data Service for the Implementing the Dispose PatternC# Programming Language Constructs SchoolGrades Database Creating and Using Custom AttributesImplementing Edit Functionality for the Integrating the WCF Data Service into Generating Managed CodeStudents List the Application Versioning, Signing and DeployingImplementing Insert Functionality for the Retrieving Student Photographs Over the AssembliesStudents List Web (if time permits) Creating the IncludeInReport AttributeImplementing Delete Functionality for the Binding Controls to Data Generating the ReportStudents List Styling a User Interface Storing the Grades.Utilities AssemblyDisplaying the Student Age Customizing the Appearance of Student CentrallyCreating Overloaded Methods and Using Photographs Implementing Asymmetric EncryptionOptional and Output Parameters Styling the Logon View Encrypting the Grades ReportHandling Exceptions Animating the StudentPhoto Control (If Decrypting the Grades ReportMonitoring Applications Time Permits)Refactoring the Enrolment Code Performing Operations AsynchronouslyValidating Student Information Synchronizing Concurrent Access to lineSaving Changes to the Class List Data Datatypes, Operators, and ExpressionsOrganizing Data into Collections Managing the Lifetime of Objects and C# Programming Language ConstructsHandling Events Controlling Unmanaged Resources Implementing Edit Functionality for theAdding Navigation Logic to the Application Generating the Grades Report by Using Students ListCreating Data Types to Store User and Microsoft Office Word Implementing Insert Functionality for theGrade Information Controlling the Lifetime of Word Objects Students ListDisplaying User and Grade Information by Implementing the Dispose Pattern Implementing Delete Functionality for theDefining and Implementing Interfaces Creating and Using Custom Attributes Students ListImplementing Type-safe Collections Generating Managed Code Displaying the Student AgeImplementing the Teacher, Student, and Versioning, Signing and Deploying Creating Overloaded Methods and UsingGrade Types as Classes Assemblies Optional and Output ParametersAdding Data Validation to the Grade Class Creating the IncludeInReport Attribute Handling ExceptionsDisplaying Students in Name Order Generating the Report Monitoring ApplicationsEnabling Teachers to Modify Class and Storing the Grades.Utilities Assembly Refactoring the Enrolment CodeGrade Data Centrally Validating Student InformationExtending .NET Framework Classes Implementing Asymmetric Encryption Saving Changes to the Class ListCreating Generic Types Encrypting the Grades Report Organizing Data into CollectionsCreating and Inheriting from the User Base Decrypting the Grades Report Handling EventsClass Adding Navigation Logic to the ApplicationImplementing Password Complexity by Creating Data Types to Store User andUsing an Abstract Method line Grade InformationCreating the ClassFullException Class Datatypes, Operators, and Expressions Displaying User and Grade InformationSerializing and Deserializing Data C# Programming Language Constructs Defining and Implementing InterfacesPerforming I/O Using Streams Implementing Edit Functionality for the Implementing Type-safe CollectionsSerializing the Data for the Grades Report Students List Implementing the Teacher, Student, andas XML Implementing Insert Functionality for the Grade Types as ClassesPreviewing the Grades Report Students List Adding Data Validation to the Grade ClassPersisting the Serialized Grades Data to a Implementing Delete Functionality for the Displaying Students in Name OrderFile Students List Enabling Teachers to Modify Class andQuerying Data by Using LINQ Displaying the Student Age Grade DataUpdating Data by Using LINQ Creating Overloaded Methods and Using Extending .NET Framework ClassesCreating an Entity Model from the The Optional and Output Parameters Creating Generic TypesSchool of Fine Arts Database Handling Exceptions Creating and Inheriting from the User BaseUpdating Student and Grade Data Using the Monitoring Applications ClassEntity Framework Refactoring the Enrolment Code Implementing Password Complexity byExtending the Entity Model to Validate Data Validating Student Information Using an Abstract MethodAccessing Data in the Cloud Saving Changes to the Class List Creating the ClassFullException ClassCreating a WCF Data Service for the Organizing Data into Collections Serializing and Deserializing DataSchoolGrades Database Handling Events Performing I/O Using StreamsIntegrating the WCF Data Service into the Adding Navigation Logic to the Serializing the Data for the Grades ReportApplication Application as XMLRetrieving Student Photographs Over the Creating Data Types to Store User and Previewing the Grades ReportWeb (if time permits) Grade Information Persisting the Serialized Grades Data to aBinding Controls to Data Displaying User and Grade Information FileStyling a User Interface Defining and Implementing Interfaces Querying Data by Using LINQCustomizing the Appearance of Student Implementing Type-safe Collections Updating Data by Using LINQPhotographs Implementing the Teacher, Student, and Creating an Entity Model from the The


Styling the Logon View Grade Types as Classes School of Fine Arts DatabaseAnimating the StudentPhoto Control (If Time Adding Data Validation to the Grade Updating Student and Grade Data UsingPermits) Class the Entity FrameworkPerforming Operations Asynchronously Displaying Students in Name Order Extending the Entity Model to ValidateSynchronizing Concurrent Access to Data Enabling Teachers to Modify Class and DataManaging the Lifetime of Objects and Grade Data Accessing Data in the CloudControlling Unmanaged Resources Extending .NET Framework Classes Creating a WCF Data Service for theGenerating the Grades Report by Using Creating Generic Types SchoolGrades DatabaseMicrosoft Office Word Creating and Inheriting from the User Integrating the WCF Data Service into theControlling the Lifetime of Word Objects by Base Class ApplicationImplementing the Dispose Pattern Implementing Password Complexity by Retrieving Student Photographs Over theCreating and Using Custom Attributes Using an Abstract Method Web (if time permits)Generating Managed Code Creating the ClassFullException Class Binding Controls to DataVersioning, Signing and Deploying Serializing and Deserializing Data Styling a User InterfaceAssemblies Performing I/O Using Streams Customizing the Appearance of StudentCreating the IncludeInReport Attribute Serializing the Data for the Grades PhotographsGenerating the Report Report as XML Styling the Logon ViewStoring the Grades.Utilities Assembly Previewing the Grades Report Animating the StudentPhoto Control (IfCentrally Persisting the Serialized Grades Data to Time Permits)Implementing Asymmetric Encryption a File Performing Operations AsynchronouslyEncrypting the Grades Report Querying Data by Using LINQ Synchronizing Concurrent Access to DataDecrypting the Grades Report Updating Data by Using LINQ Managing the Lifetime of Objects and

Creating an Entity Model from the The Controlling Unmanaged ResourcesSchool of Fine Arts Database Generating the Grades Report by Using

line Updating Student and Grade Data Using Microsoft Office WordDatatypes, Operators, and Expressions the Entity Framework Controlling the Lifetime of Word Objects byC# Programming Language Constructs Extending the Entity Model to Validate Implementing the Dispose PatternImplementing Edit Functionality for the Data Creating and Using Custom AttributesStudents List Accessing Data in the Cloud Generating Managed CodeImplementing Insert Functionality for the Creating a WCF Data Service for the Versioning, Signing and DeployingStudents List SchoolGrades Database AssembliesImplementing Delete Functionality for the Integrating the WCF Data Service into Creating the IncludeInReport AttributeStudents List the Application Generating the ReportDisplaying the Student Age Retrieving Student Photographs Over the Storing the Grades.Utilities AssemblyCreating Overloaded Methods and Using Web (if time permits) CentrallyOptional and Output Parameters Binding Controls to Data Implementing Asymmetric EncryptionHandling Exceptions Styling a User Interface Encrypting the Grades ReportMonitoring Applications Customizing the Appearance of Student Decrypting the Grades ReportRefactoring the Enrolment Code PhotographsValidating Student Information Styling the Logon View Module 12: Creating Reusable Types andSaving Changes to the Class List Animating the StudentPhoto Control (If AssembliesOrganizing Data into Collections Time Permits) lineHandling Events Performing Operations Asynchronously Examining Object MetadataAdding Navigation Logic to the Application Synchronizing Concurrent Access toCreating Data Types to Store User and DataGrade Information Managing the Lifetime of Objects and lineDisplaying User and Grade Information Controlling Unmanaged Resources Datatypes, Operators, and ExpressionsDefining and Implementing Interfaces Generating the Grades Report by Using C# Programming Language ConstructsImplementing Type-safe Collections Microsoft Office Word Implementing Edit Functionality for theImplementing the Teacher, Student, and Controlling the Lifetime of Word Objects Students ListGrade Types as Classes by Implementing the Dispose Pattern Implementing Insert Functionality for theAdding Data Validation to the Grade Class Creating and Using Custom Attributes Students ListDisplaying Students in Name Order Generating Managed Code Implementing Delete Functionality for theEnabling Teachers to Modify Class and Versioning, Signing and Deploying Students ListGrade Data Assemblies Displaying the Student AgeExtending .NET Framework Classes Creating the IncludeInReport Attribute Creating Overloaded Methods and UsingCreating Generic Types Generating the Report Optional and Output ParametersCreating and Inheriting from the User Base Storing the Grades.Utilities Assembly Handling ExceptionsClass Centrally Monitoring ApplicationsImplementing Password Complexity by Implementing Asymmetric Encryption Refactoring the Enrolment CodeUsing an Abstract Method Encrypting the Grades Report Validating Student InformationCreating the ClassFullException Class Decrypting the Grades Report Saving Changes to the Class ListSerializing and Deserializing Data Organizing Data into CollectionsPerforming I/O Using Streams Handling EventsSerializing the Data for the Grades Report line Adding Navigation Logic to the Applicationas XML Datatypes, Operators, and Expressions Creating Data Types to Store User and


Previewing the Grades Report C# Programming Language Constructs Grade InformationPersisting the Serialized Grades Data to a Implementing Edit Functionality for the Displaying User and Grade InformationFile Students List Defining and Implementing InterfacesQuerying Data by Using LINQ Implementing Insert Functionality for the Implementing Type-safe CollectionsUpdating Data by Using LINQ Students List Implementing the Teacher, Student, andCreating an Entity Model from the The Implementing Delete Functionality for the Grade Types as ClassesSchool of Fine Arts Database Students List Adding Data Validation to the Grade ClassUpdating Student and Grade Data Using the Displaying the Student Age Displaying Students in Name OrderEntity Framework Creating Overloaded Methods and Using Enabling Teachers to Modify Class andExtending the Entity Model to Validate Data Optional and Output Parameters Grade DataAccessing Data in the Cloud Handling Exceptions Extending .NET Framework ClassesCreating a WCF Data Service for the Monitoring Applications Creating Generic TypesSchoolGrades Database Refactoring the Enrolment Code Creating and Inheriting from the User BaseIntegrating the WCF Data Service into the Validating Student Information ClassApplication Saving Changes to the Class List Implementing Password Complexity byRetrieving Student Photographs Over the Organizing Data into Collections Using an Abstract MethodWeb (if time permits) Handling Events Creating the ClassFullException ClassBinding Controls to Data Adding Navigation Logic to the Serializing and Deserializing DataStyling a User Interface Application Performing I/O Using StreamsCustomizing the Appearance of Student Creating Data Types to Store User and Serializing the Data for the Grades ReportPhotographs Grade Information as XMLStyling the Logon View Displaying User and Grade Information Previewing the Grades ReportAnimating the StudentPhoto Control (If Time Defining and Implementing Interfaces Persisting the Serialized Grades Data to aPermits) Implementing Type-safe Collections FilePerforming Operations Asynchronously Implementing the Teacher, Student, and Querying Data by Using LINQSynchronizing Concurrent Access to Data Grade Types as Classes Updating Data by Using LINQManaging the Lifetime of Objects and Adding Data Validation to the Grade Creating an Entity Model from the TheControlling Unmanaged Resources Class School of Fine Arts DatabaseGenerating the Grades Report by Using Displaying Students in Name Order Updating Student and Grade Data UsingMicrosoft Office Word Enabling Teachers to Modify Class and the Entity FrameworkControlling the Lifetime of Word Objects by Grade Data Extending the Entity Model to ValidateImplementing the Dispose Pattern Extending .NET Framework Classes DataCreating and Using Custom Attributes Creating Generic Types Accessing Data in the CloudGenerating Managed Code Creating and Inheriting from the User Creating a WCF Data Service for theVersioning, Signing and Deploying Base Class SchoolGrades DatabaseAssemblies Implementing Password Complexity by Integrating the WCF Data Service into theCreating the IncludeInReport Attribute Using an Abstract Method ApplicationGenerating the Report Creating the ClassFullException Class Retrieving Student Photographs Over theStoring the Grades.Utilities Assembly Serializing and Deserializing Data Web (if time permits)Centrally Performing I/O Using Streams Binding Controls to DataImplementing Asymmetric Encryption Serializing the Data for the Grades Styling a User InterfaceEncrypting the Grades Report Report as XML Customizing the Appearance of StudentDecrypting the Grades Report Previewing the Grades Report Photographs

Persisting the Serialized Grades Data to Styling the Logon Viewa File Animating the StudentPhoto Control (If

line Querying Data by Using LINQ Time Permits)Datatypes, Operators, and Expressions Updating Data by Using LINQ Performing Operations AsynchronouslyC# Programming Language Constructs Creating an Entity Model from the The Synchronizing Concurrent Access to DataImplementing Edit Functionality for the School of Fine Arts Database Managing the Lifetime of Objects andStudents List Updating Student and Grade Data Using Controlling Unmanaged ResourcesImplementing Insert Functionality for the the Entity Framework Generating the Grades Report by UsingStudents List Extending the Entity Model to Validate Microsoft Office WordImplementing Delete Functionality for the Data Controlling the Lifetime of Word Objects byStudents List Accessing Data in the Cloud Implementing the Dispose PatternDisplaying the Student Age Creating a WCF Data Service for the Creating and Using Custom AttributesCreating Overloaded Methods and Using SchoolGrades Database Generating Managed CodeOptional and Output Parameters Integrating the WCF Data Service into Versioning, Signing and DeployingHandling Exceptions the Application AssembliesMonitoring Applications Retrieving Student Photographs Over the Creating the IncludeInReport AttributeRefactoring the Enrolment Code Web (if time permits) Generating the ReportValidating Student Information Binding Controls to Data Storing the Grades.Utilities AssemblySaving Changes to the Class List Styling a User Interface CentrallyOrganizing Data into Collections Customizing the Appearance of Student Implementing Asymmetric EncryptionHandling Events Photographs Encrypting the Grades ReportAdding Navigation Logic to the Application Styling the Logon View Decrypting the Grades ReportCreating Data Types to Store User and Animating the StudentPhoto Control (If


Grade Information Time Permits)Displaying User and Grade Information Performing Operations Asynchronously lineDefining and Implementing Interfaces Synchronizing Concurrent Access to Datatypes, Operators, and ExpressionsImplementing Type-safe Collections Data C# Programming Language ConstructsImplementing the Teacher, Student, and Managing the Lifetime of Objects and Implementing Edit Functionality for theGrade Types as Classes Controlling Unmanaged Resources Students ListAdding Data Validation to the Grade Class Generating the Grades Report by Using Implementing Insert Functionality for theDisplaying Students in Name Order Microsoft Office Word Students ListEnabling Teachers to Modify Class and Controlling the Lifetime of Word Objects Implementing Delete Functionality for theGrade Data by Implementing the Dispose Pattern Students ListExtending .NET Framework Classes Creating and Using Custom Attributes Displaying the Student AgeCreating Generic Types Generating Managed Code Creating Overloaded Methods and UsingCreating and Inheriting from the User Base Versioning, Signing and Deploying Optional and Output ParametersClass Assemblies Handling ExceptionsImplementing Password Complexity by Creating the IncludeInReport Attribute Monitoring ApplicationsUsing an Abstract Method Generating the Report Refactoring the Enrolment CodeCreating the ClassFullException Class Storing the Grades.Utilities Assembly Validating Student InformationSerializing and Deserializing Data Centrally Saving Changes to the Class ListPerforming I/O Using Streams Implementing Asymmetric Encryption Organizing Data into CollectionsSerializing the Data for the Grades Report Encrypting the Grades Report Handling Eventsas XML Decrypting the Grades Report Adding Navigation Logic to the ApplicationPreviewing the Grades Report Creating Data Types to Store User andPersisting the Serialized Grades Data to a Grade InformationFile line Displaying User and Grade InformationQuerying Data by Using LINQ Datatypes, Operators, and Expressions Defining and Implementing InterfacesUpdating Data by Using LINQ C# Programming Language Constructs Implementing Type-safe CollectionsCreating an Entity Model from the The Implementing Edit Functionality for the Implementing the Teacher, Student, andSchool of Fine Arts Database Students List Grade Types as ClassesUpdating Student and Grade Data Using the Implementing Insert Functionality for the Adding Data Validation to the Grade ClassEntity Framework Students List Displaying Students in Name OrderExtending the Entity Model to Validate Data Implementing Delete Functionality for the Enabling Teachers to Modify Class andAccessing Data in the Cloud Students List Grade DataCreating a WCF Data Service for the Displaying the Student Age Extending .NET Framework ClassesSchoolGrades Database Creating Overloaded Methods and Using Creating Generic TypesIntegrating the WCF Data Service into the Optional and Output Parameters Creating and Inheriting from the User BaseApplication Handling Exceptions ClassRetrieving Student Photographs Over the Monitoring Applications Implementing Password Complexity byWeb (if time permits) Refactoring the Enrolment Code Using an Abstract MethodBinding Controls to Data Validating Student Information Creating the ClassFullException ClassStyling a User Interface Saving Changes to the Class List Serializing and Deserializing DataCustomizing the Appearance of Student Organizing Data into Collections Performing I/O Using StreamsPhotographs Handling Events Serializing the Data for the Grades ReportStyling the Logon View Adding Navigation Logic to the as XMLAnimating the StudentPhoto Control (If Time Application Previewing the Grades ReportPermits) Creating Data Types to Store User and Persisting the Serialized Grades Data to aPerforming Operations Asynchronously Grade Information FileSynchronizing Concurrent Access to Data Displaying User and Grade Information Querying Data by Using LINQManaging the Lifetime of Objects and Defining and Implementing Interfaces Updating Data by Using LINQControlling Unmanaged Resources Implementing Type-safe Collections Creating an Entity Model from the TheGenerating the Grades Report by Using Implementing the Teacher, Student, and School of Fine Arts DatabaseMicrosoft Office Word Grade Types as Classes Updating Student and Grade Data UsingControlling the Lifetime of Word Objects by Adding Data Validation to the Grade the Entity FrameworkImplementing the Dispose Pattern Class Extending the Entity Model to ValidateCreating and Using Custom Attributes Displaying Students in Name Order DataGenerating Managed Code Enabling Teachers to Modify Class and Accessing Data in the CloudVersioning, Signing and Deploying Grade Data Creating a WCF Data Service for theAssemblies Extending .NET Framework Classes SchoolGrades DatabaseCreating the IncludeInReport Attribute Creating Generic Types Integrating the WCF Data Service into theGenerating the Report Creating and Inheriting from the User ApplicationStoring the Grades.Utilities Assembly Base Class Retrieving Student Photographs Over theCentrally Implementing Password Complexity by Web (if time permits)Implementing Asymmetric Encryption Using an Abstract Method Binding Controls to DataEncrypting the Grades Report Creating the ClassFullException Class Styling a User InterfaceDecrypting the Grades Report Serializing and Deserializing Data Customizing the Appearance of Student

Performing I/O Using Streams PhotographsModule 3: Developing the Code for a Graphical Serializing the Data for the Grades Styling the Logon View


Application Report as XML Animating the StudentPhoto Control (Ifline Previewing the Grades Report Time Permits)

Implementing Structs and Enums Persisting the Serialized Grades Data to Performing Operations Asynchronouslya File Synchronizing Concurrent Access to DataQuerying Data by Using LINQ Managing the Lifetime of Objects and

line Updating Data by Using LINQ Controlling Unmanaged ResourcesDatatypes, Operators, and Expressions Creating an Entity Model from the The Generating the Grades Report by UsingC# Programming Language Constructs School of Fine Arts Database Microsoft Office WordImplementing Edit Functionality for the Updating Student and Grade Data Using Controlling the Lifetime of Word Objects byStudents List the Entity Framework Implementing the Dispose PatternImplementing Insert Functionality for the Extending the Entity Model to Validate Creating and Using Custom AttributesStudents List Data Generating Managed CodeImplementing Delete Functionality for the Accessing Data in the Cloud Versioning, Signing and DeployingStudents List Creating a WCF Data Service for the AssembliesDisplaying the Student Age SchoolGrades Database Creating the IncludeInReport AttributeCreating Overloaded Methods and Using Integrating the WCF Data Service into Generating the ReportOptional and Output Parameters the Application Storing the Grades.Utilities AssemblyHandling Exceptions Retrieving Student Photographs Over the CentrallyMonitoring Applications Web (if time permits) Implementing Asymmetric EncryptionRefactoring the Enrolment Code Binding Controls to Data Encrypting the Grades ReportValidating Student Information Styling a User Interface Decrypting the Grades ReportSaving Changes to the Class List Customizing the Appearance of StudentOrganizing Data into Collections PhotographsHandling Events Styling the Logon View lineAdding Navigation Logic to the Application Animating the StudentPhoto Control (If Datatypes, Operators, and ExpressionsCreating Data Types to Store User and Time Permits) C# Programming Language ConstructsGrade Information Performing Operations Asynchronously Implementing Edit Functionality for theDisplaying User and Grade Information Synchronizing Concurrent Access to Students ListDefining and Implementing Interfaces Data Implementing Insert Functionality for theImplementing Type-safe Collections Managing the Lifetime of Objects and Students ListImplementing the Teacher, Student, and Controlling Unmanaged Resources Implementing Delete Functionality for theGrade Types as Classes Generating the Grades Report by Using Students ListAdding Data Validation to the Grade Class Microsoft Office Word Displaying the Student AgeDisplaying Students in Name Order Controlling the Lifetime of Word Objects Creating Overloaded Methods and UsingEnabling Teachers to Modify Class and by Implementing the Dispose Pattern Optional and Output ParametersGrade Data Creating and Using Custom Attributes Handling ExceptionsExtending .NET Framework Classes Generating Managed Code Monitoring ApplicationsCreating Generic Types Versioning, Signing and Deploying Refactoring the Enrolment CodeCreating and Inheriting from the User Base Assemblies Validating Student InformationClass Creating the IncludeInReport Attribute Saving Changes to the Class ListImplementing Password Complexity by Generating the Report Organizing Data into CollectionsUsing an Abstract Method Storing the Grades.Utilities Assembly Handling EventsCreating the ClassFullException Class Centrally Adding Navigation Logic to the ApplicationSerializing and Deserializing Data Implementing Asymmetric Encryption Creating Data Types to Store User andPerforming I/O Using Streams Encrypting the Grades Report Grade InformationSerializing the Data for the Grades Report Decrypting the Grades Report Displaying User and Grade Informationas XML Defining and Implementing InterfacesPreviewing the Grades Report Module 7: Accessing a Database Implementing Type-safe CollectionsPersisting the Serialized Grades Data to a line Implementing the Teacher, Student, andFile Creating and Using Entity Data Models Grade Types as ClassesQuerying Data by Using LINQ Adding Data Validation to the Grade ClassUpdating Data by Using LINQ Displaying Students in Name OrderCreating an Entity Model from the The line Enabling Teachers to Modify Class andSchool of Fine Arts Database Datatypes, Operators, and Expressions Grade DataUpdating Student and Grade Data Using the C# Programming Language Constructs Extending .NET Framework ClassesEntity Framework Implementing Edit Functionality for the Creating Generic TypesExtending the Entity Model to Validate Data Students List Creating and Inheriting from the User BaseAccessing Data in the Cloud Implementing Insert Functionality for the ClassCreating a WCF Data Service for the Students List Implementing Password Complexity bySchoolGrades Database Implementing Delete Functionality for the Using an Abstract MethodIntegrating the WCF Data Service into the Students List Creating the ClassFullException ClassApplication Displaying the Student Age Serializing and Deserializing DataRetrieving Student Photographs Over the Creating Overloaded Methods and Using Performing I/O Using StreamsWeb (if time permits) Optional and Output Parameters Serializing the Data for the Grades ReportBinding Controls to Data Handling Exceptions as XMLStyling a User Interface Monitoring Applications Previewing the Grades Report


Customizing the Appearance of Student Refactoring the Enrolment Code Persisting the Serialized Grades Data to aPhotographs Validating Student Information FileStyling the Logon View Saving Changes to the Class List Querying Data by Using LINQAnimating the StudentPhoto Control (If Time Organizing Data into Collections Updating Data by Using LINQPermits) Handling Events Creating an Entity Model from the ThePerforming Operations Asynchronously Adding Navigation Logic to the School of Fine Arts DatabaseSynchronizing Concurrent Access to Data Application Updating Student and Grade Data UsingManaging the Lifetime of Objects and Creating Data Types to Store User and the Entity FrameworkControlling Unmanaged Resources Grade Information Extending the Entity Model to ValidateGenerating the Grades Report by Using Displaying User and Grade Information DataMicrosoft Office Word Defining and Implementing Interfaces Accessing Data in the CloudControlling the Lifetime of Word Objects by Implementing Type-safe Collections Creating a WCF Data Service for theImplementing the Dispose Pattern Implementing the Teacher, Student, and SchoolGrades DatabaseCreating and Using Custom Attributes Grade Types as Classes Integrating the WCF Data Service into theGenerating Managed Code Adding Data Validation to the Grade ApplicationVersioning, Signing and Deploying Class Retrieving Student Photographs Over theAssemblies Displaying Students in Name Order Web (if time permits)Creating the IncludeInReport Attribute Enabling Teachers to Modify Class and Binding Controls to DataGenerating the Report Grade Data Styling a User InterfaceStoring the Grades.Utilities Assembly Extending .NET Framework Classes Customizing the Appearance of StudentCentrally Creating Generic Types PhotographsImplementing Asymmetric Encryption Creating and Inheriting from the User Styling the Logon ViewEncrypting the Grades Report Base Class Animating the StudentPhoto Control (IfDecrypting the Grades Report Implementing Password Complexity by Time Permits)

Using an Abstract Method Performing Operations AsynchronouslyCreating the ClassFullException Class Synchronizing Concurrent Access to Data

line Serializing and Deserializing Data Managing the Lifetime of Objects andDatatypes, Operators, and Expressions Performing I/O Using Streams Controlling Unmanaged ResourcesC# Programming Language Constructs Serializing the Data for the Grades Generating the Grades Report by UsingImplementing Edit Functionality for the Report as XML Microsoft Office WordStudents List Previewing the Grades Report Controlling the Lifetime of Word Objects byImplementing Insert Functionality for the Persisting the Serialized Grades Data to Implementing the Dispose PatternStudents List a File Creating and Using Custom AttributesImplementing Delete Functionality for the Querying Data by Using LINQ Generating Managed CodeStudents List Updating Data by Using LINQ Versioning, Signing and DeployingDisplaying the Student Age Creating an Entity Model from the The AssembliesCreating Overloaded Methods and Using School of Fine Arts Database Creating the IncludeInReport AttributeOptional and Output Parameters Updating Student and Grade Data Using Generating the ReportHandling Exceptions the Entity Framework Storing the Grades.Utilities AssemblyMonitoring Applications Extending the Entity Model to Validate CentrallyRefactoring the Enrolment Code Data Implementing Asymmetric EncryptionValidating Student Information Accessing Data in the Cloud Encrypting the Grades ReportSaving Changes to the Class List Creating a WCF Data Service for the Decrypting the Grades ReportOrganizing Data into Collections SchoolGrades DatabaseHandling Events Integrating the WCF Data Service intoAdding Navigation Logic to the Application the Application lineCreating Data Types to Store User and Retrieving Student Photographs Over the Datatypes, Operators, and ExpressionsGrade Information Web (if time permits) C# Programming Language ConstructsDisplaying User and Grade Information Binding Controls to Data Implementing Edit Functionality for theDefining and Implementing Interfaces Styling a User Interface Students ListImplementing Type-safe Collections Customizing the Appearance of Student Implementing Insert Functionality for theImplementing the Teacher, Student, and Photographs Students ListGrade Types as Classes Styling the Logon View Implementing Delete Functionality for theAdding Data Validation to the Grade Class Animating the StudentPhoto Control (If Students ListDisplaying Students in Name Order Time Permits) Displaying the Student AgeEnabling Teachers to Modify Class and Performing Operations Asynchronously Creating Overloaded Methods and UsingGrade Data Synchronizing Concurrent Access to Optional and Output ParametersExtending .NET Framework Classes Data Handling ExceptionsCreating Generic Types Managing the Lifetime of Objects and Monitoring ApplicationsCreating and Inheriting from the User Base Controlling Unmanaged Resources Refactoring the Enrolment CodeClass Generating the Grades Report by Using Validating Student InformationImplementing Password Complexity by Microsoft Office Word Saving Changes to the Class ListUsing an Abstract Method Controlling the Lifetime of Word Objects Organizing Data into CollectionsCreating the ClassFullException Class by Implementing the Dispose Pattern Handling EventsSerializing and Deserializing Data Creating and Using Custom Attributes Adding Navigation Logic to the ApplicationPerforming I/O Using Streams Generating Managed Code Creating Data Types to Store User and


Serializing the Data for the Grades Report Versioning, Signing and Deploying Grade Informationas XML Assemblies Displaying User and Grade InformationPreviewing the Grades Report Creating the IncludeInReport Attribute Defining and Implementing InterfacesPersisting the Serialized Grades Data to a Generating the Report Implementing Type-safe CollectionsFile Storing the Grades.Utilities Assembly Implementing the Teacher, Student, andQuerying Data by Using LINQ Centrally Grade Types as ClassesUpdating Data by Using LINQ Implementing Asymmetric Encryption Adding Data Validation to the Grade ClassCreating an Entity Model from the The Encrypting the Grades Report Displaying Students in Name OrderSchool of Fine Arts Database Decrypting the Grades Report Enabling Teachers to Modify Class andUpdating Student and Grade Data Using the Grade DataEntity Framework Extending .NET Framework ClassesExtending the Entity Model to Validate Data line Creating Generic TypesAccessing Data in the Cloud Datatypes, Operators, and Expressions Creating and Inheriting from the User BaseCreating a WCF Data Service for the C# Programming Language Constructs ClassSchoolGrades Database Implementing Edit Functionality for the Implementing Password Complexity byIntegrating the WCF Data Service into the Students List Using an Abstract MethodApplication Implementing Insert Functionality for the Creating the ClassFullException ClassRetrieving Student Photographs Over the Students List Serializing and Deserializing DataWeb (if time permits) Implementing Delete Functionality for the Performing I/O Using StreamsBinding Controls to Data Students List Serializing the Data for the Grades ReportStyling a User Interface Displaying the Student Age as XMLCustomizing the Appearance of Student Creating Overloaded Methods and Using Previewing the Grades ReportPhotographs Optional and Output Parameters Persisting the Serialized Grades Data to aStyling the Logon View Handling Exceptions FileAnimating the StudentPhoto Control (If Time Monitoring Applications Querying Data by Using LINQPermits) Refactoring the Enrolment Code Updating Data by Using LINQPerforming Operations Asynchronously Validating Student Information Creating an Entity Model from the TheSynchronizing Concurrent Access to Data Saving Changes to the Class List School of Fine Arts DatabaseManaging the Lifetime of Objects and Organizing Data into Collections Updating Student and Grade Data UsingControlling Unmanaged Resources Handling Events the Entity FrameworkGenerating the Grades Report by Using Adding Navigation Logic to the Extending the Entity Model to ValidateMicrosoft Office Word Application DataControlling the Lifetime of Word Objects by Creating Data Types to Store User and Accessing Data in the CloudImplementing the Dispose Pattern Grade Information Creating a WCF Data Service for theCreating and Using Custom Attributes Displaying User and Grade Information SchoolGrades DatabaseGenerating Managed Code Defining and Implementing Interfaces Integrating the WCF Data Service into theVersioning, Signing and Deploying Implementing Type-safe Collections ApplicationAssemblies Implementing the Teacher, Student, and Retrieving Student Photographs Over theCreating the IncludeInReport Attribute Grade Types as Classes Web (if time permits)Generating the Report Adding Data Validation to the Grade Binding Controls to DataStoring the Grades.Utilities Assembly Class Styling a User InterfaceCentrally Displaying Students in Name Order Customizing the Appearance of StudentImplementing Asymmetric Encryption Enabling Teachers to Modify Class and PhotographsEncrypting the Grades Report Grade Data Styling the Logon ViewDecrypting the Grades Report Extending .NET Framework Classes Animating the StudentPhoto Control (If

Creating Generic Types Time Permits)Creating and Inheriting from the User Performing Operations Asynchronously

line Base Class Synchronizing Concurrent Access to DataDatatypes, Operators, and Expressions Implementing Password Complexity by Managing the Lifetime of Objects andC# Programming Language Constructs Using an Abstract Method Controlling Unmanaged ResourcesImplementing Edit Functionality for the Creating the ClassFullException Class Generating the Grades Report by UsingStudents List Serializing and Deserializing Data Microsoft Office WordImplementing Insert Functionality for the Performing I/O Using Streams Controlling the Lifetime of Word Objects byStudents List Serializing the Data for the Grades Implementing the Dispose PatternImplementing Delete Functionality for the Report as XML Creating and Using Custom AttributesStudents List Previewing the Grades Report Generating Managed CodeDisplaying the Student Age Persisting the Serialized Grades Data to Versioning, Signing and DeployingCreating Overloaded Methods and Using a File AssembliesOptional and Output Parameters Querying Data by Using LINQ Creating the IncludeInReport AttributeHandling Exceptions Updating Data by Using LINQ Generating the ReportMonitoring Applications Creating an Entity Model from the The Storing the Grades.Utilities AssemblyRefactoring the Enrolment Code School of Fine Arts Database CentrallyValidating Student Information Updating Student and Grade Data Using Implementing Asymmetric EncryptionSaving Changes to the Class List the Entity Framework Encrypting the Grades ReportOrganizing Data into Collections Extending the Entity Model to Validate Decrypting the Grades ReportHandling Events Data


Adding Navigation Logic to the Application Accessing Data in the CloudCreating Data Types to Store User and Creating a WCF Data Service for the lineGrade Information SchoolGrades Database Datatypes, Operators, and ExpressionsDisplaying User and Grade Information Integrating the WCF Data Service into C# Programming Language ConstructsDefining and Implementing Interfaces the Application Implementing Edit Functionality for theImplementing Type-safe Collections Retrieving Student Photographs Over the Students ListImplementing the Teacher, Student, and Web (if time permits) Implementing Insert Functionality for theGrade Types as Classes Binding Controls to Data Students ListAdding Data Validation to the Grade Class Styling a User Interface Implementing Delete Functionality for theDisplaying Students in Name Order Customizing the Appearance of Student Students ListEnabling Teachers to Modify Class and Photographs Displaying the Student AgeGrade Data Styling the Logon View Creating Overloaded Methods and UsingExtending .NET Framework Classes Animating the StudentPhoto Control (If Optional and Output ParametersCreating Generic Types Time Permits) Handling ExceptionsCreating and Inheriting from the User Base Performing Operations Asynchronously Monitoring ApplicationsClass Synchronizing Concurrent Access to Refactoring the Enrolment CodeImplementing Password Complexity by Data Validating Student InformationUsing an Abstract Method Managing the Lifetime of Objects and Saving Changes to the Class ListCreating the ClassFullException Class Controlling Unmanaged Resources Organizing Data into CollectionsSerializing and Deserializing Data Generating the Grades Report by Using Handling EventsPerforming I/O Using Streams Microsoft Office Word Adding Navigation Logic to the ApplicationSerializing the Data for the Grades Report Controlling the Lifetime of Word Objects Creating Data Types to Store User andas XML by Implementing the Dispose Pattern Grade InformationPreviewing the Grades Report Creating and Using Custom Attributes Displaying User and Grade InformationPersisting the Serialized Grades Data to a Generating Managed Code Defining and Implementing InterfacesFile Versioning, Signing and Deploying Implementing Type-safe CollectionsQuerying Data by Using LINQ Assemblies Implementing the Teacher, Student, andUpdating Data by Using LINQ Creating the IncludeInReport Attribute Grade Types as ClassesCreating an Entity Model from the The Generating the Report Adding Data Validation to the Grade ClassSchool of Fine Arts Database Storing the Grades.Utilities Assembly Displaying Students in Name OrderUpdating Student and Grade Data Using the Centrally Enabling Teachers to Modify Class andEntity Framework Implementing Asymmetric Encryption Grade DataExtending the Entity Model to Validate Data Encrypting the Grades Report Extending .NET Framework ClassesAccessing Data in the Cloud Decrypting the Grades Report Creating Generic TypesCreating a WCF Data Service for the Creating and Inheriting from the User BaseSchoolGrades Database ClassIntegrating the WCF Data Service into the line Implementing Password Complexity byApplication Datatypes, Operators, and Expressions Using an Abstract MethodRetrieving Student Photographs Over the C# Programming Language Constructs Creating the ClassFullException ClassWeb (if time permits) Implementing Edit Functionality for the Serializing and Deserializing DataBinding Controls to Data Students List Performing I/O Using StreamsStyling a User Interface Implementing Insert Functionality for the Serializing the Data for the Grades ReportCustomizing the Appearance of Student Students List as XMLPhotographs Implementing Delete Functionality for the Previewing the Grades ReportStyling the Logon View Students List Persisting the Serialized Grades Data to aAnimating the StudentPhoto Control (If Time Displaying the Student Age FilePermits) Creating Overloaded Methods and Using Querying Data by Using LINQPerforming Operations Asynchronously Optional and Output Parameters Updating Data by Using LINQSynchronizing Concurrent Access to Data Handling Exceptions Creating an Entity Model from the TheManaging the Lifetime of Objects and Monitoring Applications School of Fine Arts DatabaseControlling Unmanaged Resources Refactoring the Enrolment Code Updating Student and Grade Data UsingGenerating the Grades Report by Using Validating Student Information the Entity FrameworkMicrosoft Office Word Saving Changes to the Class List Extending the Entity Model to ValidateControlling the Lifetime of Word Objects by Organizing Data into Collections DataImplementing the Dispose Pattern Handling Events Accessing Data in the CloudCreating and Using Custom Attributes Adding Navigation Logic to the Creating a WCF Data Service for theGenerating Managed Code Application SchoolGrades DatabaseVersioning, Signing and Deploying Creating Data Types to Store User and Integrating the WCF Data Service into theAssemblies Grade Information ApplicationCreating the IncludeInReport Attribute Displaying User and Grade Information Retrieving Student Photographs Over theGenerating the Report Defining and Implementing Interfaces Web (if time permits)Storing the Grades.Utilities Assembly Implementing Type-safe Collections Binding Controls to DataCentrally Implementing the Teacher, Student, and Styling a User InterfaceImplementing Asymmetric Encryption Grade Types as Classes Customizing the Appearance of StudentEncrypting the Grades Report Adding Data Validation to the Grade PhotographsDecrypting the Grades Report Class Styling the Logon View


Displaying Students in Name Order Animating the StudentPhoto Control (IfEnabling Teachers to Modify Class and Time Permits)

line Grade Data Performing Operations AsynchronouslyDatatypes, Operators, and Expressions Extending .NET Framework Classes Synchronizing Concurrent Access to DataC# Programming Language Constructs Creating Generic Types Managing the Lifetime of Objects andImplementing Edit Functionality for the Creating and Inheriting from the User Controlling Unmanaged ResourcesStudents List Base Class Generating the Grades Report by UsingImplementing Insert Functionality for the Implementing Password Complexity by Microsoft Office WordStudents List Using an Abstract Method Controlling the Lifetime of Word Objects byImplementing Delete Functionality for the Creating the ClassFullException Class Implementing the Dispose PatternStudents List Serializing and Deserializing Data Creating and Using Custom AttributesDisplaying the Student Age Performing I/O Using Streams Generating Managed CodeCreating Overloaded Methods and Using Serializing the Data for the Grades Versioning, Signing and DeployingOptional and Output Parameters Report as XML AssembliesHandling Exceptions Previewing the Grades Report Creating the IncludeInReport AttributeMonitoring Applications Persisting the Serialized Grades Data to Generating the ReportRefactoring the Enrolment Code a File Storing the Grades.Utilities AssemblyValidating Student Information Querying Data by Using LINQ CentrallySaving Changes to the Class List Updating Data by Using LINQ Implementing Asymmetric EncryptionOrganizing Data into Collections Creating an Entity Model from the The Encrypting the Grades ReportHandling Events School of Fine Arts Database Decrypting the Grades ReportAdding Navigation Logic to the Application Updating Student and Grade Data UsingCreating Data Types to Store User and the Entity FrameworkGrade Information Extending the Entity Model to Validate lineDisplaying User and Grade Information Data Datatypes, Operators, and ExpressionsDefining and Implementing Interfaces Accessing Data in the Cloud C# Programming Language ConstructsImplementing Type-safe Collections Creating a WCF Data Service for the Implementing Edit Functionality for theImplementing the Teacher, Student, and SchoolGrades Database Students ListGrade Types as Classes Integrating the WCF Data Service into Implementing Insert Functionality for theAdding Data Validation to the Grade Class the Application Students ListDisplaying Students in Name Order Retrieving Student Photographs Over the Implementing Delete Functionality for theEnabling Teachers to Modify Class and Web (if time permits) Students ListGrade Data Binding Controls to Data Displaying the Student AgeExtending .NET Framework Classes Styling a User Interface Creating Overloaded Methods and UsingCreating Generic Types Customizing the Appearance of Student Optional and Output ParametersCreating and Inheriting from the User Base Photographs Handling ExceptionsClass Styling the Logon View Monitoring ApplicationsImplementing Password Complexity by Animating the StudentPhoto Control (If Refactoring the Enrolment CodeUsing an Abstract Method Time Permits) Validating Student InformationCreating the ClassFullException Class Performing Operations Asynchronously Saving Changes to the Class ListSerializing and Deserializing Data Synchronizing Concurrent Access to Organizing Data into CollectionsPerforming I/O Using Streams Data Handling EventsSerializing the Data for the Grades Report Managing the Lifetime of Objects and Adding Navigation Logic to the Applicationas XML Controlling Unmanaged Resources Creating Data Types to Store User andPreviewing the Grades Report Generating the Grades Report by Using Grade InformationPersisting the Serialized Grades Data to a Microsoft Office Word Displaying User and Grade InformationFile Controlling the Lifetime of Word Objects Defining and Implementing InterfacesQuerying Data by Using LINQ by Implementing the Dispose Pattern Implementing Type-safe CollectionsUpdating Data by Using LINQ Creating and Using Custom Attributes Implementing the Teacher, Student, andCreating an Entity Model from the The Generating Managed Code Grade Types as ClassesSchool of Fine Arts Database Versioning, Signing and Deploying Adding Data Validation to the Grade ClassUpdating Student and Grade Data Using the Assemblies Displaying Students in Name OrderEntity Framework Creating the IncludeInReport Attribute Enabling Teachers to Modify Class andExtending the Entity Model to Validate Data Generating the Report Grade DataAccessing Data in the Cloud Storing the Grades.Utilities Assembly Extending .NET Framework ClassesCreating a WCF Data Service for the Centrally Creating Generic TypesSchoolGrades Database Implementing Asymmetric Encryption Creating and Inheriting from the User BaseIntegrating the WCF Data Service into the Encrypting the Grades Report ClassApplication Decrypting the Grades Report Implementing Password Complexity byRetrieving Student Photographs Over the Using an Abstract MethodWeb (if time permits) Creating the ClassFullException ClassBinding Controls to Data line Serializing and Deserializing DataStyling a User Interface Datatypes, Operators, and Expressions Performing I/O Using StreamsCustomizing the Appearance of Student C# Programming Language Constructs Serializing the Data for the Grades ReportPhotographs Implementing Edit Functionality for the as XMLStyling the Logon View Students List Previewing the Grades Report


Animating the StudentPhoto Control (If Time Implementing Insert Functionality for the Persisting the Serialized Grades Data to aPermits) Students List FilePerforming Operations Asynchronously Implementing Delete Functionality for the Querying Data by Using LINQSynchronizing Concurrent Access to Data Students List Updating Data by Using LINQManaging the Lifetime of Objects and Displaying the Student Age Creating an Entity Model from the TheControlling Unmanaged Resources Creating Overloaded Methods and Using School of Fine Arts DatabaseGenerating the Grades Report by Using Optional and Output Parameters Updating Student and Grade Data UsingMicrosoft Office Word Handling Exceptions the Entity FrameworkControlling the Lifetime of Word Objects by Monitoring Applications Extending the Entity Model to ValidateImplementing the Dispose Pattern Refactoring the Enrolment Code DataCreating and Using Custom Attributes Validating Student Information Accessing Data in the CloudGenerating Managed Code Saving Changes to the Class List Creating a WCF Data Service for theVersioning, Signing and Deploying Organizing Data into Collections SchoolGrades DatabaseAssemblies Handling Events Integrating the WCF Data Service into theCreating the IncludeInReport Attribute Adding Navigation Logic to the ApplicationGenerating the Report Application Retrieving Student Photographs Over theStoring the Grades.Utilities Assembly Creating Data Types to Store User and Web (if time permits)Centrally Grade Information Binding Controls to DataImplementing Asymmetric Encryption Displaying User and Grade Information Styling a User InterfaceEncrypting the Grades Report Defining and Implementing Interfaces Customizing the Appearance of StudentDecrypting the Grades Report Implementing Type-safe Collections Photographs

Implementing the Teacher, Student, and Styling the Logon ViewGrade Types as Classes Animating the StudentPhoto Control (If

line Adding Data Validation to the Grade Time Permits)Datatypes, Operators, and Expressions Class Performing Operations AsynchronouslyC# Programming Language Constructs Displaying Students in Name Order Synchronizing Concurrent Access to DataImplementing Edit Functionality for the Enabling Teachers to Modify Class and Managing the Lifetime of Objects andStudents List Grade Data Controlling Unmanaged ResourcesImplementing Insert Functionality for the Extending .NET Framework Classes Generating the Grades Report by UsingStudents List Creating Generic Types Microsoft Office WordImplementing Delete Functionality for the Creating and Inheriting from the User Controlling the Lifetime of Word Objects byStudents List Base Class Implementing the Dispose PatternDisplaying the Student Age Implementing Password Complexity by Creating and Using Custom AttributesCreating Overloaded Methods and Using Using an Abstract Method Generating Managed CodeOptional and Output Parameters Creating the ClassFullException Class Versioning, Signing and DeployingHandling Exceptions Serializing and Deserializing Data AssembliesMonitoring Applications Performing I/O Using Streams Creating the IncludeInReport AttributeRefactoring the Enrolment Code Serializing the Data for the Grades Generating the ReportValidating Student Information Report as XML Storing the Grades.Utilities AssemblySaving Changes to the Class List Previewing the Grades Report CentrallyOrganizing Data into Collections Persisting the Serialized Grades Data to Implementing Asymmetric EncryptionHandling Events a File Encrypting the Grades ReportAdding Navigation Logic to the Application Querying Data by Using LINQ Decrypting the Grades ReportCreating Data Types to Store User and Updating Data by Using LINQGrade Information Creating an Entity Model from the The Module 13: Encrypting and Decrypting DataDisplaying User and Grade Information School of Fine Arts Database lineDefining and Implementing Interfaces Updating Student and Grade Data Using Implementing Symmetric EncryptionImplementing Type-safe Collections the Entity FrameworkImplementing the Teacher, Student, and Extending the Entity Model to ValidateGrade Types as Classes Data lineAdding Data Validation to the Grade Class Accessing Data in the Cloud Datatypes, Operators, and ExpressionsDisplaying Students in Name Order Creating a WCF Data Service for the C# Programming Language ConstructsEnabling Teachers to Modify Class and SchoolGrades Database Implementing Edit Functionality for theGrade Data Integrating the WCF Data Service into Students ListExtending .NET Framework Classes the Application Implementing Insert Functionality for theCreating Generic Types Retrieving Student Photographs Over the Students ListCreating and Inheriting from the User Base Web (if time permits) Implementing Delete Functionality for theClass Binding Controls to Data Students ListImplementing Password Complexity by Styling a User Interface Displaying the Student AgeUsing an Abstract Method Customizing the Appearance of Student Creating Overloaded Methods and UsingCreating the ClassFullException Class Photographs Optional and Output ParametersSerializing and Deserializing Data Styling the Logon View Handling ExceptionsPerforming I/O Using Streams Animating the StudentPhoto Control (If Monitoring ApplicationsSerializing the Data for the Grades Report Time Permits) Refactoring the Enrolment Codeas XML Performing Operations Asynchronously Validating Student InformationPreviewing the Grades Report Synchronizing Concurrent Access to Saving Changes to the Class List


Persisting the Serialized Grades Data to a Data Organizing Data into CollectionsFile Managing the Lifetime of Objects and Handling EventsQuerying Data by Using LINQ Controlling Unmanaged Resources Adding Navigation Logic to the ApplicationUpdating Data by Using LINQ Generating the Grades Report by Using Creating Data Types to Store User andCreating an Entity Model from the The Microsoft Office Word Grade InformationSchool of Fine Arts Database Controlling the Lifetime of Word Objects Displaying User and Grade InformationUpdating Student and Grade Data Using the by Implementing the Dispose Pattern Defining and Implementing InterfacesEntity Framework Creating and Using Custom Attributes Implementing Type-safe CollectionsExtending the Entity Model to Validate Data Generating Managed Code Implementing the Teacher, Student, andAccessing Data in the Cloud Versioning, Signing and Deploying Grade Types as ClassesCreating a WCF Data Service for the Assemblies Adding Data Validation to the Grade ClassSchoolGrades Database Creating the IncludeInReport Attribute Displaying Students in Name OrderIntegrating the WCF Data Service into the Generating the Report Enabling Teachers to Modify Class andApplication Storing the Grades.Utilities Assembly Grade DataRetrieving Student Photographs Over the Centrally Extending .NET Framework ClassesWeb (if time permits) Implementing Asymmetric Encryption Creating Generic TypesBinding Controls to Data Encrypting the Grades Report Creating and Inheriting from the User BaseStyling a User Interface Decrypting the Grades Report ClassCustomizing the Appearance of Student Implementing Password Complexity byPhotographs Using an Abstract MethodStyling the Logon View line Creating the ClassFullException ClassAnimating the StudentPhoto Control (If Time Datatypes, Operators, and Expressions Serializing and Deserializing DataPermits) C# Programming Language Constructs Performing I/O Using StreamsPerforming Operations Asynchronously Implementing Edit Functionality for the Serializing the Data for the Grades ReportSynchronizing Concurrent Access to Data Students List as XMLManaging the Lifetime of Objects and Implementing Insert Functionality for the Previewing the Grades ReportControlling Unmanaged Resources Students List Persisting the Serialized Grades Data to aGenerating the Grades Report by Using Implementing Delete Functionality for the FileMicrosoft Office Word Students List Querying Data by Using LINQControlling the Lifetime of Word Objects by Displaying the Student Age Updating Data by Using LINQImplementing the Dispose Pattern Creating Overloaded Methods and Using Creating an Entity Model from the TheCreating and Using Custom Attributes Optional and Output Parameters School of Fine Arts DatabaseGenerating Managed Code Handling Exceptions Updating Student and Grade Data UsingVersioning, Signing and Deploying Monitoring Applications the Entity FrameworkAssemblies Refactoring the Enrolment Code Extending the Entity Model to ValidateCreating the IncludeInReport Attribute Validating Student Information DataGenerating the Report Saving Changes to the Class List Accessing Data in the CloudStoring the Grades.Utilities Assembly Organizing Data into Collections Creating a WCF Data Service for theCentrally Handling Events SchoolGrades DatabaseImplementing Asymmetric Encryption Adding Navigation Logic to the Integrating the WCF Data Service into theEncrypting the Grades Report Application ApplicationDecrypting the Grades Report Creating Data Types to Store User and Retrieving Student Photographs Over the

Grade Information Web (if time permits)Module 4: Creating Classes and Implementing Displaying User and Grade Information Binding Controls to DataType-safe Collections Defining and Implementing Interfaces Styling a User Interfaceline Implementing Type-safe Collections Customizing the Appearance of Student

Creating Classes Implementing the Teacher, Student, and PhotographsGrade Types as Classes Styling the Logon ViewAdding Data Validation to the Grade Animating the StudentPhoto Control (If

line Class Time Permits)Datatypes, Operators, and Expressions Displaying Students in Name Order Performing Operations AsynchronouslyC# Programming Language Constructs Enabling Teachers to Modify Class and Synchronizing Concurrent Access to DataImplementing Edit Functionality for the Grade Data Managing the Lifetime of Objects andStudents List Extending .NET Framework Classes Controlling Unmanaged ResourcesImplementing Insert Functionality for the Creating Generic Types Generating the Grades Report by UsingStudents List Creating and Inheriting from the User Microsoft Office WordImplementing Delete Functionality for the Base Class Controlling the Lifetime of Word Objects byStudents List Implementing Password Complexity by Implementing the Dispose PatternDisplaying the Student Age Using an Abstract Method Creating and Using Custom AttributesCreating Overloaded Methods and Using Creating the ClassFullException Class Generating Managed CodeOptional and Output Parameters Serializing and Deserializing Data Versioning, Signing and DeployingHandling Exceptions Performing I/O Using Streams AssembliesMonitoring Applications Serializing the Data for the Grades Creating the IncludeInReport AttributeRefactoring the Enrolment Code Report as XML Generating the ReportValidating Student Information Previewing the Grades Report Storing the Grades.Utilities AssemblySaving Changes to the Class List Persisting the Serialized Grades Data to Centrally


Organizing Data into Collections a File Implementing Asymmetric EncryptionHandling Events Querying Data by Using LINQ Encrypting the Grades ReportAdding Navigation Logic to the Application Updating Data by Using LINQ Decrypting the Grades ReportCreating Data Types to Store User and Creating an Entity Model from the TheGrade Information School of Fine Arts DatabaseDisplaying User and Grade Information Updating Student and Grade Data Using lineDefining and Implementing Interfaces the Entity Framework Datatypes, Operators, and ExpressionsImplementing Type-safe Collections Extending the Entity Model to Validate C# Programming Language ConstructsImplementing the Teacher, Student, and Data Implementing Edit Functionality for theGrade Types as Classes Accessing Data in the Cloud Students ListAdding Data Validation to the Grade Class Creating a WCF Data Service for the Implementing Insert Functionality for theDisplaying Students in Name Order SchoolGrades Database Students ListEnabling Teachers to Modify Class and Integrating the WCF Data Service into Implementing Delete Functionality for theGrade Data the Application Students ListExtending .NET Framework Classes Retrieving Student Photographs Over the Displaying the Student AgeCreating Generic Types Web (if time permits) Creating Overloaded Methods and UsingCreating and Inheriting from the User Base Binding Controls to Data Optional and Output ParametersClass Styling a User Interface Handling ExceptionsImplementing Password Complexity by Customizing the Appearance of Student Monitoring ApplicationsUsing an Abstract Method Photographs Refactoring the Enrolment CodeCreating the ClassFullException Class Styling the Logon View Validating Student InformationSerializing and Deserializing Data Animating the StudentPhoto Control (If Saving Changes to the Class ListPerforming I/O Using Streams Time Permits) Organizing Data into CollectionsSerializing the Data for the Grades Report Performing Operations Asynchronously Handling Eventsas XML Synchronizing Concurrent Access to Adding Navigation Logic to the ApplicationPreviewing the Grades Report Data Creating Data Types to Store User andPersisting the Serialized Grades Data to a Managing the Lifetime of Objects and Grade InformationFile Controlling Unmanaged Resources Displaying User and Grade InformationQuerying Data by Using LINQ Generating the Grades Report by Using Defining and Implementing InterfacesUpdating Data by Using LINQ Microsoft Office Word Implementing Type-safe CollectionsCreating an Entity Model from the The Controlling the Lifetime of Word Objects Implementing the Teacher, Student, andSchool of Fine Arts Database by Implementing the Dispose Pattern Grade Types as ClassesUpdating Student and Grade Data Using the Creating and Using Custom Attributes Adding Data Validation to the Grade ClassEntity Framework Generating Managed Code Displaying Students in Name OrderExtending the Entity Model to Validate Data Versioning, Signing and Deploying Enabling Teachers to Modify Class andAccessing Data in the Cloud Assemblies Grade DataCreating a WCF Data Service for the Creating the IncludeInReport Attribute Extending .NET Framework ClassesSchoolGrades Database Generating the Report Creating Generic TypesIntegrating the WCF Data Service into the Storing the Grades.Utilities Assembly Creating and Inheriting from the User BaseApplication Centrally ClassRetrieving Student Photographs Over the Implementing Asymmetric Encryption Implementing Password Complexity byWeb (if time permits) Encrypting the Grades Report Using an Abstract MethodBinding Controls to Data Decrypting the Grades Report Creating the ClassFullException ClassStyling a User Interface Serializing and Deserializing DataCustomizing the Appearance of Student Module 8: Accessing Remote Data Performing I/O Using StreamsPhotographs line Serializing the Data for the Grades ReportStyling the Logon View Accessing Data Across the Web as XMLAnimating the StudentPhoto Control (If Time Previewing the Grades ReportPermits) Persisting the Serialized Grades Data to aPerforming Operations Asynchronously line FileSynchronizing Concurrent Access to Data Datatypes, Operators, and Expressions Querying Data by Using LINQManaging the Lifetime of Objects and C# Programming Language Constructs Updating Data by Using LINQControlling Unmanaged Resources Implementing Edit Functionality for the Creating an Entity Model from the TheGenerating the Grades Report by Using Students List School of Fine Arts DatabaseMicrosoft Office Word Implementing Insert Functionality for the Updating Student and Grade Data UsingControlling the Lifetime of Word Objects by Students List the Entity FrameworkImplementing the Dispose Pattern Implementing Delete Functionality for the Extending the Entity Model to ValidateCreating and Using Custom Attributes Students List DataGenerating Managed Code Displaying the Student Age Accessing Data in the CloudVersioning, Signing and Deploying Creating Overloaded Methods and Using Creating a WCF Data Service for theAssemblies Optional and Output Parameters SchoolGrades DatabaseCreating the IncludeInReport Attribute Handling Exceptions Integrating the WCF Data Service into theGenerating the Report Monitoring Applications ApplicationStoring the Grades.Utilities Assembly Refactoring the Enrolment Code Retrieving Student Photographs Over theCentrally Validating Student Information Web (if time permits)Implementing Asymmetric Encryption Saving Changes to the Class List Binding Controls to Data


Encrypting the Grades Report Organizing Data into Collections Styling a User InterfaceDecrypting the Grades Report Handling Events Customizing the Appearance of Student

Adding Navigation Logic to the PhotographsApplication Styling the Logon View

line Creating Data Types to Store User and Animating the StudentPhoto Control (IfDatatypes, Operators, and Expressions Grade Information Time Permits)C# Programming Language Constructs Displaying User and Grade Information Performing Operations AsynchronouslyImplementing Edit Functionality for the Defining and Implementing Interfaces Synchronizing Concurrent Access to DataStudents List Implementing Type-safe Collections Managing the Lifetime of Objects andImplementing Insert Functionality for the Implementing the Teacher, Student, and Controlling Unmanaged ResourcesStudents List Grade Types as Classes Generating the Grades Report by UsingImplementing Delete Functionality for the Adding Data Validation to the Grade Microsoft Office WordStudents List Class Controlling the Lifetime of Word Objects byDisplaying the Student Age Displaying Students in Name Order Implementing the Dispose PatternCreating Overloaded Methods and Using Enabling Teachers to Modify Class and Creating and Using Custom AttributesOptional and Output Parameters Grade Data Generating Managed CodeHandling Exceptions Extending .NET Framework Classes Versioning, Signing and DeployingMonitoring Applications Creating Generic Types AssembliesRefactoring the Enrolment Code Creating and Inheriting from the User Creating the IncludeInReport AttributeValidating Student Information Base Class Generating the ReportSaving Changes to the Class List Implementing Password Complexity by Storing the Grades.Utilities AssemblyOrganizing Data into Collections Using an Abstract Method CentrallyHandling Events Creating the ClassFullException Class Implementing Asymmetric EncryptionAdding Navigation Logic to the Application Serializing and Deserializing Data Encrypting the Grades ReportCreating Data Types to Store User and Performing I/O Using Streams Decrypting the Grades ReportGrade Information Serializing the Data for the GradesDisplaying User and Grade Information Report as XMLDefining and Implementing Interfaces Previewing the Grades Report lineImplementing Type-safe Collections Persisting the Serialized Grades Data to Datatypes, Operators, and ExpressionsImplementing the Teacher, Student, and a File C# Programming Language ConstructsGrade Types as Classes Querying Data by Using LINQ Implementing Edit Functionality for theAdding Data Validation to the Grade Class Updating Data by Using LINQ Students ListDisplaying Students in Name Order Creating an Entity Model from the The Implementing Insert Functionality for theEnabling Teachers to Modify Class and School of Fine Arts Database Students ListGrade Data Updating Student and Grade Data Using Implementing Delete Functionality for theExtending .NET Framework Classes the Entity Framework Students ListCreating Generic Types Extending the Entity Model to Validate Displaying the Student AgeCreating and Inheriting from the User Base Data Creating Overloaded Methods and UsingClass Accessing Data in the Cloud Optional and Output ParametersImplementing Password Complexity by Creating a WCF Data Service for the Handling ExceptionsUsing an Abstract Method SchoolGrades Database Monitoring ApplicationsCreating the ClassFullException Class Integrating the WCF Data Service into Refactoring the Enrolment CodeSerializing and Deserializing Data the Application Validating Student InformationPerforming I/O Using Streams Retrieving Student Photographs Over the Saving Changes to the Class ListSerializing the Data for the Grades Report Web (if time permits) Organizing Data into Collectionsas XML Binding Controls to Data Handling EventsPreviewing the Grades Report Styling a User Interface Adding Navigation Logic to the ApplicationPersisting the Serialized Grades Data to a Customizing the Appearance of Student Creating Data Types to Store User andFile Photographs Grade InformationQuerying Data by Using LINQ Styling the Logon View Displaying User and Grade InformationUpdating Data by Using LINQ Animating the StudentPhoto Control (If Defining and Implementing InterfacesCreating an Entity Model from the The Time Permits) Implementing Type-safe CollectionsSchool of Fine Arts Database Performing Operations Asynchronously Implementing the Teacher, Student, andUpdating Student and Grade Data Using the Synchronizing Concurrent Access to Grade Types as ClassesEntity Framework Data Adding Data Validation to the Grade ClassExtending the Entity Model to Validate Data Managing the Lifetime of Objects and Displaying Students in Name OrderAccessing Data in the Cloud Controlling Unmanaged Resources Enabling Teachers to Modify Class andCreating a WCF Data Service for the Generating the Grades Report by Using Grade DataSchoolGrades Database Microsoft Office Word Extending .NET Framework ClassesIntegrating the WCF Data Service into the Controlling the Lifetime of Word Objects Creating Generic TypesApplication by Implementing the Dispose Pattern Creating and Inheriting from the User BaseRetrieving Student Photographs Over the Creating and Using Custom Attributes ClassWeb (if time permits) Generating Managed Code Implementing Password Complexity byBinding Controls to Data Versioning, Signing and Deploying Using an Abstract MethodStyling a User Interface Assemblies Creating the ClassFullException ClassCustomizing the Appearance of Student Creating the IncludeInReport Attribute Serializing and Deserializing Data


Photographs Generating the Report Performing I/O Using StreamsStyling the Logon View Storing the Grades.Utilities Assembly Serializing the Data for the Grades ReportAnimating the StudentPhoto Control (If Time Centrally as XMLPermits) Implementing Asymmetric Encryption Previewing the Grades ReportPerforming Operations Asynchronously Encrypting the Grades Report Persisting the Serialized Grades Data to aSynchronizing Concurrent Access to Data Decrypting the Grades Report FileManaging the Lifetime of Objects and Querying Data by Using LINQControlling Unmanaged Resources Updating Data by Using LINQGenerating the Grades Report by Using line Creating an Entity Model from the TheMicrosoft Office Word Datatypes, Operators, and Expressions School of Fine Arts DatabaseControlling the Lifetime of Word Objects by C# Programming Language Constructs Updating Student and Grade Data UsingImplementing the Dispose Pattern Implementing Edit Functionality for the the Entity FrameworkCreating and Using Custom Attributes Students List Extending the Entity Model to ValidateGenerating Managed Code Implementing Insert Functionality for the DataVersioning, Signing and Deploying Students List Accessing Data in the CloudAssemblies Implementing Delete Functionality for the Creating a WCF Data Service for theCreating the IncludeInReport Attribute Students List SchoolGrades DatabaseGenerating the Report Displaying the Student Age Integrating the WCF Data Service into theStoring the Grades.Utilities Assembly Creating Overloaded Methods and Using ApplicationCentrally Optional and Output Parameters Retrieving Student Photographs Over theImplementing Asymmetric Encryption Handling Exceptions Web (if time permits)Encrypting the Grades Report Monitoring Applications Binding Controls to DataDecrypting the Grades Report Refactoring the Enrolment Code Styling a User Interface

Validating Student Information Customizing the Appearance of StudentSaving Changes to the Class List Photographs

line Organizing Data into Collections Styling the Logon ViewDatatypes, Operators, and Expressions Handling Events Animating the StudentPhoto Control (IfC# Programming Language Constructs Adding Navigation Logic to the Time Permits)Implementing Edit Functionality for the Application Performing Operations AsynchronouslyStudents List Creating Data Types to Store User and Synchronizing Concurrent Access to DataImplementing Insert Functionality for the Grade Information Managing the Lifetime of Objects andStudents List Displaying User and Grade Information Controlling Unmanaged ResourcesImplementing Delete Functionality for the Defining and Implementing Interfaces Generating the Grades Report by UsingStudents List Implementing Type-safe Collections Microsoft Office WordDisplaying the Student Age Implementing the Teacher, Student, and Controlling the Lifetime of Word Objects byCreating Overloaded Methods and Using Grade Types as Classes Implementing the Dispose PatternOptional and Output Parameters Adding Data Validation to the Grade Creating and Using Custom AttributesHandling Exceptions Class Generating Managed CodeMonitoring Applications Displaying Students in Name Order Versioning, Signing and DeployingRefactoring the Enrolment Code Enabling Teachers to Modify Class and AssembliesValidating Student Information Grade Data Creating the IncludeInReport AttributeSaving Changes to the Class List Extending .NET Framework Classes Generating the ReportOrganizing Data into Collections Creating Generic Types Storing the Grades.Utilities AssemblyHandling Events Creating and Inheriting from the User CentrallyAdding Navigation Logic to the Application Base Class Implementing Asymmetric EncryptionCreating Data Types to Store User and Implementing Password Complexity by Encrypting the Grades ReportGrade Information Using an Abstract Method Decrypting the Grades ReportDisplaying User and Grade Information Creating the ClassFullException ClassDefining and Implementing Interfaces Serializing and Deserializing DataImplementing Type-safe Collections Performing I/O Using StreamsImplementing the Teacher, Student, and Serializing the Data for the GradesGrade Types as Classes Report as XMLAdding Data Validation to the Grade Class Previewing the Grades ReportDisplaying Students in Name Order Persisting the Serialized Grades Data toEnabling Teachers to Modify Class and a FileGrade Data Querying Data by Using LINQExtending .NET Framework Classes Updating Data by Using LINQCreating Generic Types Creating an Entity Model from the TheCreating and Inheriting from the User Base School of Fine Arts DatabaseClass Updating Student and Grade Data UsingImplementing Password Complexity by the Entity FrameworkUsing an Abstract Method Extending the Entity Model to ValidateCreating the ClassFullException Class DataSerializing and Deserializing Data Accessing Data in the CloudPerforming I/O Using Streams Creating a WCF Data Service for theSerializing the Data for the Grades Report SchoolGrades Database


as XML Integrating the WCF Data Service intoPreviewing the Grades Report the ApplicationPersisting the Serialized Grades Data to a Retrieving Student Photographs Over theFile Web (if time permits)Querying Data by Using LINQ Binding Controls to DataUpdating Data by Using LINQ Styling a User InterfaceCreating an Entity Model from the The Customizing the Appearance of StudentSchool of Fine Arts Database PhotographsUpdating Student and Grade Data Using the Styling the Logon ViewEntity Framework Animating the StudentPhoto Control (IfExtending the Entity Model to Validate Data Time Permits)Accessing Data in the Cloud Performing Operations AsynchronouslyCreating a WCF Data Service for the Synchronizing Concurrent Access toSchoolGrades Database DataIntegrating the WCF Data Service into the Managing the Lifetime of Objects andApplication Controlling Unmanaged ResourcesRetrieving Student Photographs Over the Generating the Grades Report by UsingWeb (if time permits) Microsoft Office WordBinding Controls to Data Controlling the Lifetime of Word ObjectsStyling a User Interface by Implementing the Dispose PatternCustomizing the Appearance of Student Creating and Using Custom AttributesPhotographs Generating Managed CodeStyling the Logon View Versioning, Signing and DeployingAnimating the StudentPhoto Control (If Time AssembliesPermits) Creating the IncludeInReport AttributePerforming Operations Asynchronously Generating the ReportSynchronizing Concurrent Access to Data Storing the Grades.Utilities AssemblyManaging the Lifetime of Objects and CentrallyControlling Unmanaged Resources Implementing Asymmetric EncryptionGenerating the Grades Report by Using Encrypting the Grades ReportMicrosoft Office Word Decrypting the Grades ReportControlling the Lifetime of Word Objects byImplementing the Dispose PatternCreating and Using Custom Attributes lineGenerating Managed Code Datatypes, Operators, and ExpressionsVersioning, Signing and Deploying C# Programming Language ConstructsAssemblies Implementing Edit Functionality for theCreating the IncludeInReport Attribute Students ListGenerating the Report Implementing Insert Functionality for theStoring the Grades.Utilities Assembly Students ListCentrally Implementing Delete Functionality for theImplementing Asymmetric Encryption Students ListEncrypting the Grades Report Displaying the Student AgeDecrypting the Grades Report Creating Overloaded Methods and Using

Optional and Output ParametersHandling Exceptions

line Monitoring ApplicationsDatatypes, Operators, and Expressions Refactoring the Enrolment CodeC# Programming Language Constructs Validating Student InformationImplementing Edit Functionality for the Saving Changes to the Class ListStudents List Organizing Data into CollectionsImplementing Insert Functionality for the Handling EventsStudents List Adding Navigation Logic to theImplementing Delete Functionality for the ApplicationStudents List Creating Data Types to Store User andDisplaying the Student Age Grade InformationCreating Overloaded Methods and Using Displaying User and Grade InformationOptional and Output Parameters Defining and Implementing InterfacesHandling Exceptions Implementing Type-safe CollectionsMonitoring Applications Implementing the Teacher, Student, andRefactoring the Enrolment Code Grade Types as ClassesValidating Student Information Adding Data Validation to the GradeSaving Changes to the Class List ClassOrganizing Data into Collections Displaying Students in Name OrderHandling Events Enabling Teachers to Modify Class andAdding Navigation Logic to the Application Grade Data


Creating Data Types to Store User and Extending .NET Framework ClassesGrade Information Creating Generic TypesDisplaying User and Grade Information Creating and Inheriting from the UserDefining and Implementing Interfaces Base ClassImplementing Type-safe Collections Implementing Password Complexity byImplementing the Teacher, Student, and Using an Abstract MethodGrade Types as Classes Creating the ClassFullException ClassAdding Data Validation to the Grade Class Serializing and Deserializing DataDisplaying Students in Name Order Performing I/O Using StreamsEnabling Teachers to Modify Class and Serializing the Data for the GradesGrade Data Report as XMLExtending .NET Framework Classes Previewing the Grades ReportCreating Generic Types Persisting the Serialized Grades Data toCreating and Inheriting from the User Base a FileClass Querying Data by Using LINQImplementing Password Complexity by Updating Data by Using LINQUsing an Abstract Method Creating an Entity Model from the TheCreating the ClassFullException Class School of Fine Arts DatabaseSerializing and Deserializing Data Updating Student and Grade Data UsingPerforming I/O Using Streams the Entity FrameworkSerializing the Data for the Grades Report Extending the Entity Model to Validateas XML DataPreviewing the Grades Report Accessing Data in the CloudPersisting the Serialized Grades Data to a Creating a WCF Data Service for theFile SchoolGrades DatabaseQuerying Data by Using LINQ Integrating the WCF Data Service intoUpdating Data by Using LINQ the ApplicationCreating an Entity Model from the The Retrieving Student Photographs Over theSchool of Fine Arts Database Web (if time permits)Updating Student and Grade Data Using the Binding Controls to DataEntity Framework Styling a User InterfaceExtending the Entity Model to Validate Data Customizing the Appearance of StudentAccessing Data in the Cloud PhotographsCreating a WCF Data Service for the Styling the Logon ViewSchoolGrades Database Animating the StudentPhoto Control (IfIntegrating the WCF Data Service into the Time Permits)Application Performing Operations AsynchronouslyRetrieving Student Photographs Over the Synchronizing Concurrent Access toWeb (if time permits) DataBinding Controls to Data Managing the Lifetime of Objects andStyling a User Interface Controlling Unmanaged ResourcesCustomizing the Appearance of Student Generating the Grades Report by UsingPhotographs Microsoft Office WordStyling the Logon View Controlling the Lifetime of Word ObjectsAnimating the StudentPhoto Control (If Time by Implementing the Dispose PatternPermits) Creating and Using Custom AttributesPerforming Operations Asynchronously Generating Managed CodeSynchronizing Concurrent Access to Data Versioning, Signing and DeployingManaging the Lifetime of Objects and AssembliesControlling Unmanaged Resources Creating the IncludeInReport AttributeGenerating the Grades Report by Using Generating the ReportMicrosoft Office Word Storing the Grades.Utilities AssemblyControlling the Lifetime of Word Objects by CentrallyImplementing the Dispose Pattern Implementing Asymmetric EncryptionCreating and Using Custom Attributes Encrypting the Grades ReportGenerating Managed Code Decrypting the Grades ReportVersioning, Signing and DeployingAssembliesCreating the IncludeInReport Attribute lineGenerating the Report Datatypes, Operators, and ExpressionsStoring the Grades.Utilities Assembly C# Programming Language ConstructsCentrally Implementing Edit Functionality for theImplementing Asymmetric Encryption Students ListEncrypting the Grades Report Implementing Insert Functionality for theDecrypting the Grades Report Students List

Implementing Delete Functionality for the


Students ListDisplaying the Student AgeCreating Overloaded Methods and UsingOptional and Output ParametersHandling ExceptionsMonitoring ApplicationsRefactoring the Enrolment CodeValidating Student InformationSaving Changes to the Class ListOrganizing Data into CollectionsHandling EventsAdding Navigation Logic to theApplicationCreating Data Types to Store User andGrade InformationDisplaying User and Grade InformationDefining and Implementing InterfacesImplementing Type-safe CollectionsImplementing the Teacher, Student, andGrade Types as ClassesAdding Data Validation to the GradeClassDisplaying Students in Name OrderEnabling Teachers to Modify Class andGrade DataExtending .NET Framework ClassesCreating Generic TypesCreating and Inheriting from the UserBase ClassImplementing Password Complexity byUsing an Abstract MethodCreating the ClassFullException ClassSerializing and Deserializing DataPerforming I/O Using StreamsSerializing the Data for the GradesReport as XMLPreviewing the Grades ReportPersisting the Serialized Grades Data toa FileQuerying Data by Using LINQUpdating Data by Using LINQCreating an Entity Model from the TheSchool of Fine Arts DatabaseUpdating Student and Grade Data Usingthe Entity FrameworkExtending the Entity Model to ValidateDataAccessing Data in the CloudCreating a WCF Data Service for theSchoolGrades DatabaseIntegrating the WCF Data Service intothe ApplicationRetrieving Student Photographs Over theWeb (if time permits)Binding Controls to DataStyling a User InterfaceCustomizing the Appearance of StudentPhotographsStyling the Logon ViewAnimating the StudentPhoto Control (IfTime Permits)Performing Operations AsynchronouslySynchronizing Concurrent Access toDataManaging the Lifetime of Objects andControlling Unmanaged Resources


Generating the Grades Report by UsingMicrosoft Office WordControlling the Lifetime of Word Objectsby Implementing the Dispose PatternCreating and Using Custom AttributesGenerating Managed CodeVersioning, Signing and DeployingAssembliesCreating the IncludeInReport AttributeGenerating the ReportStoring the Grades.Utilities AssemblyCentrallyImplementing Asymmetric EncryptionEncrypting the Grades ReportDecrypting the Grades Report

Further Information:

For More information, or to book your course, please call us on 353-1-814 8200

[email protected]

www.globalknowledge.com/en-ie/

Global Knowledge, 3rd Floor Jervis House, Millennium Walkway, Dublin 1

http://www.globalknowledge.com/en-ie/

programming in c#store.globalknowledge.net/course-overviews/ie/m20483_c_.pdf · programming in c#...

Documents