Vous êtes sur la page 1sur 26

Programming with C# 4.

Day 1
Overview of the Microsoft .NET Platform (Using Framework 4.0) Common Language Runtime (CLR) The Assembly Security and Scope Metadata Assembly types: Private, Shared and Native The Global Assembly Cache (GAC) Signing .NET Assemblies Creating Strong-Named Assemblies Managing .NET Assemblies Deploying Assemblies to the Global Assembly Cache Configuring Assemblies for Side-by-Side Deployment Microsoft Intermediate Language (MSIL) Just in time compilation (JIT) The command line utilities vs Visual Studio Understanding the Framework Understanding the Common Type System (CTS) Understanding Namespaces Understanding how to use the standard .NET Libraries Useful .NET utilities that ship with Visual Studio Creating and deploying Windows and ASP.NET applications Useful .NET utilities that ship with Visual Studio Overview of C# Structure of a C# Program Introduction to Operators Basic Input / Output Operations Recommended Practices Compiling, Running, and Debugging

Day 2
Using Value-Type Variables Common Type System Naming Variables Using Built-In Data Types Creating User-Defined Data Types Enums Structures Converting Data Types Using Reference-Type Variables Using Reference-Type Variables Using Common Reference Types Immutable Strings and use of StringBuilder

The Object Hierarchy Namespaces in the .NET Framework Data Conversions Statements and Exceptions Introduction to Statements Using Selection Statements Using Iteration Statements Using Jump Statements Handling Basic Exceptions Raising Exceptions

Day 3
Methods and Parameters Using Methods Using Parameters Using Overloaded Methods Specifying Optional Parameters and Output Parameters Partial Methods Arrays & Collection Overview of Arrays Creating Arrays Using Arrays Understanding .NET collections Ordered vs. Unordered Collections Collection classes CollectionBase, ArrayList, HashTable, Dictionary, Queue, Stack, LinkedList, SortedList, Generic Collection Collection Interfaces: IList, IEnumerable, IEnumerator, IDictionary Specialized Collections like CollectionsUtil, NameValueCollection

Day 4
Essentials of Object-Oriented Programming Classes and Objects Using Encapsulation C# and Object Orientation Defining Object-Oriented Systems Static Classes Partial Classes Properties and Indexers Using Properties Using Indexers Aggregation, Namespaces, and Advanced Scope Using Internal Classes, Methods, and Data Using Aggregation

Using Namespaces Using Modules and Assemblies

Day 5
Creating and Destroying Objects Using Constructors Initializing Data Objects and Memory Resource Managements Introduction to Generics Introduction to Generics Benefits of Generics Creating Generic Types Constraints on Type Parameters Generic Classes Generic Methods Inbuilt Generic Collections The default Keywords Inheritance in C# Deriving Classes Implementing Methods Using Sealed Classes Using Abstract Classes Using Interfaces Extension Methods

Day 6
Operator Overloading Need of Operator Overloading Introduction to the Operators Operator Overloading File Handling and Serialization File I/O Operations Working with File, FileInfo, Directory, DirectoryInfo and DriveInfo Classes Streams String Readers and Writers Text Readers and Writers Stream readers and writers Introduction to Serailization XML Serialization Binary Serialization Attributes & Reflection Overview of Attributes Defining Custom Attributes Retrieving Attribute Values

Reflection Overview Viewing Type information Attribute Based programming - Accessing Attributes with Reflection

Day 7
Delegates and Events Creating and Using Delegates Creating and Using Generic Delegates Anonymous delegates Callback delegates Multicast delegates Lambda functions Defining and Using Events Custom Events Custom Event Handlers Event driven programming Working with Threads Understanding Threading Creating Threads Passing Data to Threads Returning Data from threads Managing Threads Problems with Threads Multithreading Synchronizing Threads

Advance Development
Day 1
Asynchronous Programming Asynchronous Programming Overview Beginning an Asynchronous Operation Ending an Asynchronous Operation Calling Asynchronous Methods Using Delegates Calling Synchronous Methods Asynchronously Asynchronous Delegates Programming Sample Asynchronous Programming Using IAsyncResult Blocking Application Execution by Ending an Asynchronous Operation. Blocking Application Execution Using an AsyncWaitHandle. Polling for the Status of an Asynchronous Operation. Using an AsyncCallback Delegate to End an Asynchronous Operation. Multithreaded Programming with the Event-based Asynchronous Pattern Event-based Asynchronous Pattern Overview Implementing the Event-based Asynchronous Pattern

Best Practices for Implementing the Event-based Asynchronous Pattern Deciding When to Implement the Event-based Asynchronous Pattern Walkthrough: Implementing a Component That Supports the Event-based Asynchronous Pattern Lazy Initialization Overview Basic Lazy Initialization Thread-Safe Initialization Exceptions in Lazy Objects Implementing a Lazy-Initialized Property Thread-Local Lazy Initialization Thread-Local Variables in Parallel.For and ForEach Using Lazy Initialization for Low-Overhead Scenarios Parallel Programming in the .NET Framework Task Parallel Library Data Structures for Parallel Programming Parallel Diagnostic Tools Custom Partitioners for TPL Task Factories Task Schedulers Lambda Expressions in TPL For Further Reading (Parallel Programming)

Day 2
Garbage Collection Fundamentals of Garbage Collection Garbage Collection and Performance Induced Collections Latency Modes Optimization for Shared Web Hosting Garbage Collection Notifications Application Domain Resource Monitoring Weak References Cleaning Up Unmanaged Resources Implementing a Dispose Method Finalize Methods and Destructors Overriding the Finalize Method Destructor Syntax in C# and C++ Using Objects That Encapsulate Resources Interoperability Understanding the need of Interoperability Interoperating with Unmanaged Code Advanced COM Interoperability Calling COM component from .Net Understanding RCW (Runtime Callable Wrapper) Calling .Net component from COM Understanding CCW (COM Callable Wrapper)

Embedding COM Interop Type Info Dynamic Language Runtime Overview Overview of DLR DLR Advantages DLR Architecture C# 5.0 New Features C# 5: Async and Await Inside Await Returning Tasks Exceptions Concurrent Work

ADO .Net, LINQ and Entity Framework

Day 1
Module 1: Data-Centric Applications and ADO.NET Design of Data-Centric Applications ADO.NET Architecture ADO.NET and XML Module 2: Connecting to Data Sources Choosing a .NET Data Provider Defining a Connection Managing a Connection Handling Connection Exceptions Connection Pooling Module 3: Performing Connected Database Operations Working in a Connected Environment Building Command Objects Executing Commands That Return a Single Value Executing Commands That Return Rows Executing Commands That Do Not Return Rows Using Transactions

Module 4: Building DataSets Working in a Disconnected Environment Building DataSets and DataTables Binding and Saving a DataSet Defining Data Relationships Modifying Data in a DataTable Sorting and Filtering Module 5: Reading and Writing XML with ADO.NET

Understanding XML Creating XSD Schemas Validating XML Understanding XSLT Loading Schemas and Data into DataSets Writing XML from a DataSet Module 6: Building DataSets from Existing Data Sources Configuring a DataAdapter to Retrieve Information Populating a DataSet Using a DataAdapter Configuring a DataAdapter to Update the Underlying Data Source Persisting Changes to a Data Source How to Handle Conflicts

Introduction To LINQ LINQ and Data Access Standard Query Operators Query Expressions Extensibility LINQ Variations o LINQ to Objects o LINQ to XML o LINQ to SQL o LINQ to Data Sets Functional Construction LINQ to XML Introduction XML Today Motivation for a new API System.XML.Linq Creating XML Saving XML Loading XML Processing XML Namespaces Traversal Query Operators Query Extensions Functional Construction Create and Query Demo Transformation Validation XPath

LINQ And C# Overview LINQ History Extension Methods Operators as Extension Methods Functional Programming with Lambdas Lambda Expression Essentials Constructing Lambda Expressions Invoking Lambda Expressions Expressions Expression Trees Query Expressions Comprehension Query Syntax Type Inference Anonymous Types Initializers Partial Methods LINQ to SQL Introduction to ORM LINQ to SQL Class Understanding Data Context LINQ to SQL Mapping Querying Data Using LINQ to SQL IEnumerable vs IQueryable LINQ Queries Anatomy of a Query Two Query Syntaxes Deferred Execution The let and into Keywords Grouping Nested Queries Joins Group Joins Sorting Composition Dynamic Queries

The Standard LINQ Operators Introduction Definition Filtering

Sorting Quantifiers Projection Partitioning Joining Grouping Conversions Concatenation Aggregation

Creating, Updating, and Deleting Using LINQ to SQL Creating a CRUD application using LINQ to SQL Inserting new Data using InsertOnSubmit() Understanding Update Attaching to DataContext Detaching from DataContext Deleting Data using DeleteOnSubmit()

Day 6 (Entity Framework)

Module/Lab Architecture and Data Access Technologies Building Entity Data Models Understanding o Database Design First o Model First o Code First Module/Lab Goal The goal of this module is to enable students to evaluate a variety of business cases, and then select an appropriate combination of data access technologies and tools most appropriate to each case. Students will learn about the roles of Entity Framework, Data Services, and ADO.NET for building and maintaining applications. They will also learn about the use of LINQ on top of these technologies to improve their productivity and the quality of their applications. The goal of this module is to enable students to use the tools provided with the Entity Framework to map the conceptual model used by the business logic of an application to the logical data model provided by a database.

Day 7
Module/Lab Querying Entity Data Creating, Updating, and Deleting Entity Data Handling Multi-User Scenarios by Using Object Services Module/Lab Goal

The goal of this module is to enable students to perform data modification (CUD) tasks through an entity data model. The goal of this module is to provide students with a deeper understanding of the function of the Object model implemented by EF works and the support provided by the Object Services API for addressing the issues faced by enterprise applications that have handle multiple concurrent users accessing the same data simultaneously. The goal of this module is to enable students to query an entity data model by using common methods such as LINQ to Entities, Entity SQL, and the classes in the EntityClient namespace.

Day 8
Module/Lab Building Optimized Solutions by Using Object Services Customizing Entities and Building Custom Entity Classes Using Persistent Ignorant Classes with the Entity Framework Module/Lab Goal The goal of this module is to describe best practices for designing and building a scalable, optimized data access layer by using Object Services. The goal of this module is to enable students to customize and extend entities with their own business logic, and to use advanced mappings and other techniques in the Designer and XML to shape the data model to their business and application requirements The goal of this module is to enable students to reuse existing business classes in a data access layer built by using the Entity Framework.

Day 1
Getting Started with Windows Communication Foundation Lessons Designing an Application to Be Part of a Service Oriented Architecture Overview of WCF Architecture Using a Language-Level Interface As a Service Contract Implementing a Simple WCF Service in Visual Studio 2010 Consuming a simple WCF service in Visual Studio 2010 Lab: Creating a Simple Service Creating a Simple WCF Service Calling the Simple WCF Service Configuring and Hosting WCF Services Lessons Programmatically Configuring a Managed Application to Host a WCF Service Programmatically Configuring a Managed Application to Call a WCF Service Defining Client and Service Settings by Using File-Based Configuration

Selecting a Hosting Option for a WCF Service Deploying a WCF Service Lab: Configure and Host a WCF Service Creating a Programmatically Configured Managed Application to Host a Service Calling a Service Hosted in a Managed Application by Using Programmatic Configuration Defining Service Settings by Using External Configuration Employing Different Hosting Options for a Service

Day 2
Endpoints and Behaviors Lessons Exposing WCF Services Over Different Endpoints Adding Behaviors to Services and Endpoints Interoperating with Non-WCF Web services Lab: Changing Service Endpoints and Behaviors Exposing Services by Using Different Bindings Adding Metadata Exchange to a Service Creating WCF Clients and Services That Interoperate with Non-WCF Web Services Debugging and Diagnostics Lessons Logging Messages Activity Tracing Lab: Message Logging and Activity Generating Logging Information for a Service Enabling End-to-End Tracing for a Service Designing and Defining Contracts Lessons Designing a Coherent and Cohesive WCF Service Interface Defining a Service Contract Defining Operations on a Service Defining a Data Contract Lab: Contracts for Services and Data Defining and Implementing a One-Way Operation Contract Passing Complex Data with a Data Contract Defining and Implementing a Callback Contract

Day 3
Handling Errors Lessons Relating .NET Exceptions to Service-Level Faults Using Faults in a Service Handling Faults and Exceptions on Clients Lab: Error Handling

Handling Unexpected Errors in a WCF Service Add Fault Handling to a WCF Service and the Service Contract

Improving WCF Service Quality Lessons Managing WCF Service Instances Managing Concurrency Issues Improving WCF Service Quality Lab: Improving WCF Service Quality Managing WCF Service Instances Managing Concurrency Issues Throttling Access to a WCF Service Passing Bulk Data Between a WCF Client and Service

Day 4
Working with Async WCF Service & Duplex Service Lessons Implement EAP on WCF Service Using SvcUtil Tool to generate Async Operations on the client side Async vs. Duplex Services Lab: Improving WCF Service Quality Creating and using Async Operations from WCF Service Implementing Transactions Lessons Overview of Transactions in a Service-Oriented Application Creating Transactional Service Operations Enabling the Flow of Transactions from Client to Service Lab: Implementing Transactions for a Service Controlling the Flow of a Transaction from Client to Service Forcing a Transaction to Start When a Service Operation Is Called

Day 5
Implementing WCF Security Lessons Overview of Security in WCF Applying Overall Security Requirements to a Binding Specifying Required Client and Service Credentials Working With Security Information Lab: Protecting a Service Applying Security for Internal Network Communication Applying Security for Internet Communication


Day 1
Module 1: Windows Client Application Design Lessons Windows Client Technologies Architectural Patterns Interoperability between Windows Forms and WPF Lab : Planning Windows Client Applications Identify Windows Client Technologies Choosing Design Patterns Lab Application Guided Walk-Through Module 2: Introduction to Visual Studio 2010 and WPF Version 4 Lessons Whats New in Visual Studio 2010? Whats New in WPF Version 4 Lab : Guided Tour of Visual Studio 2010 and XAML Guided tour of Visual Studio 2010 Guided tour of XAML Editor Module 3: Designing and Developing a User Interface Lessons Defining Page Layout Using Content Controls Using Item Controls Sharing Logical Resources in a Window Lab : Building a User Interface Choosing User Interface Controls Laying out the User Interface Creating and Using Resource Dictionaries

Day 2
Module 4: Taking Control of the User Interface Lessons Sharing Logical Resources in an Application Creating Consistent User Interfaces by Using Styles Changing the Appearance of Controls by Using Templates Handling Events and Commands Lab : Dynamically Controlling the User Interface Creating Styles Using Application Commands Adding Routed Events Creating a Custom Command Migrating a Custom Command

Module 5: Testing, Unit Testing, and Debugging Lessons WPF Testing Strategies Debugging XAML Providing User Feedback for Unhandled Exceptions Understanding Security Features Lab : Testing and Debugging WPF Applications Unit Testing Strategy Unit Testing WPF Applications Debugging Applications in Visual Studio 2010 Advanced Exception Handling Module 6: Simple Data Binding and Validation Lessons Overview of Data Binding Creating a Data Binding Implementing Property Change Notification Converting Data Validating Data Presenting Data at Design Time Lab : Data Binding Binding Controls Implementing Value Converters Validating Data Implementing Property Change Notifications

Day 3
Module 7: Data Binding to Collections Lessons Binding to Collections of Objects Using Collection Views Creating Master-Detail User Interfaces Using Data Templates Presenting Design Time Data Collections Lab : Data Binding to Collections Binding to Collections of Data Using Collection Views Creating Master-Detail User Interfaces Using Data Templates Module 8: Enhancing UI Responsiveness Lessons Implementing Asynchronous Processes Implementing Responsive User Interfaces Lab : Enhancing Application Performance Asynchronous Programming Strategy

Asynchronous Programming Parallelizing Tasks

Module 9: Integrating Localization and User Assistance Features Lessons Localization and Globalization Implementing User Assistance Features Providing User Accessibility Features Lab : Localizing a WPF Application Preparing for Localization for the LocBAML Approach Localizing Resources by Using LocBAML Preparing for Localization by Using Strongly Typed Resources Localizing Resources by Using Strongly Typed Resources Choosing a Localization Approach

Day 4
Module 10: WPF 2D Graphics, Multimedia, and Printing Lessons Displaying 2D Graphics Displaying Images Adding Multimedia to WPF Applications Creating and Printing Documents Lab : Drawing 2-D Graphics Identify the Appropriate Windows Client Technology Creating the Data Access Layer and User Interface Drawing Shapes, Painting with Brushes and Appling Effects Adding Images Module 11: Control Customization Lessons Overview of Control Authoring Creating User Controls Creating Custom Controls Managing Control Appearance by Using Visual States Integrating WPF and Windows Forms Lab : Building a User Control Identify the Approach Control Type Creating a User Control in WPF Adding a WPF Control to a Windows Forms Application Module 12: Attached Properties and Behaviors in WPF Lessons Implementing Attached Properties Implementing Drag-and-Drop User Interfaces Implementing Expression Blend Behaviors, Triggers and Actions Lab : Implementing Drag-and-Drop Operations Implementing Drag-and-Drop Operations

Implementing Expression Blend Behaviors

Day 5
Module 13: Animations in WPF Lessons Using Animations Using Triggers Implementing Data Visualizations Lab : Creating Animations Creating Animations Declaratively Creating Animations Dynamically Creating Routed Events Handling Routed Events Module 14: Application State, Settings, and Lifecycle Lessons Creating Application Settings Consuming Application Settings Creating Custom Configuration Sections Lab : Creating a Settings Dialog Creating Application and User Setting by Using Visual Studio Creating a Dialog Window Reading and Writing Settings Consuming Settings Properties Module 15: Configure and Deploy Windows Client Applications Lessons Deployment Options Deploying a Standalone WPF Application Deploying an XBAP Application Configuring Security Settings Lab : Deploying Applications Developing a Standalone Installer Configuring a ClickOnce Deployment Updating a ClickOnce Deployment


ASP .Net
Day 1
Module 1: Exploring ASP.NET Web Applications in Microsoft Visual Studio 2010 Lesson 1: Introduction to the .NET Framework Introduction to Microsoft .NET Benefits of the .NET Framework Components of the .NET Framework Visual Studio 2010: The Tool for .NET Development Lesson 2: Overview of ASP.NET What Is ASP.NET? Components of ASP.NET Web Applications Multimedia: ASP.NET Dynamic Compilation Execution Model Lesson 3: Overview of the Lab Application Demonstration: Exploring the .NET Framework Demonstration: Determining the Advantages of Using Visual Studio 2008 SP1 Demonstration: Viewing the Components of an ASP.NET 4.0 Web Application Project Module 2: Creating Web Applications by Using Microsoft Visual Studio 2010 and Microsoft .NET-Based Languages Lesson 1: Consideration of Language Features of Visual Basic Features of Visual C# Scenarios for Mixed-Language Environments Considerations for Choosing Between Visual Basic and Visual C# for an Application Lesson 2: Overview of Visual Studio 2010 Advantages of Using Visual Studio 2010 Available Project Templates Visual Studio 2010 Start Page & Other Windows Lesson 3: Creating a Simple Web Application Web Application Development Process Web Application Project Files and Folders Web Site Project Files and Folders Choosing Between a Web Site or Web Application Project Web Application Files Demonstration: How To Create a Simple Web Application Project

Module 3: Creating a Microsoft ASP.NET Web Form Lesson 1: Creating Web Forms What Is a Web Form? How To Create a Web Form Lesson 2: Adding and Configuring Server Controls in a Web Form What Is a Server Control?

Types of Server Controls Saving View State Adding and Configuring HTML Server Controls Adding and Configuring Web Server Controls Discussion: Selecting the Appropriate Server Control

Day 2
Module 4: Adding Functionality to a Microsoft ASP.NET Web Form Lesson 1: Working with Code-Behind Files Methods for Implementing Code Mixed Code and Inline Code Code-Behind Files Using Code-Behind Files Lesson 2: Handling Server Control Events What Are Event Handlers? What Are Client-Side Event Handlers? What Are Server-Side Event Handlers? Multimedia: How Client-Side and Server-Side Event Handlers Are Processed Creating Server-Side Event Handlers Demonstration: How To Create Client-Side Event Handlers Working with Web Server Controls by Using Event Handlers Lesson 3: Creating Classes and Components by Using Visual Studio 2010 What Are Types, Components, and Classes? Creating a Component Demonstration: How To Create a Class in Visual Studio 2010 Adding Member Variables and Constants to a Class Adding Properties and Methods to a Class Adding Class Constructors Accessing Components in an ASP.NET Web Form Lesson 4: Handling Page Events Page Event Life Cycle Multimedia: The PostBack Process Handling Page.IsPostBack Events Demonstration: How To Handle Page Events

Module 5: Implementing Master Pages and User Controls Lesson 1: Creating Master Pages What Are Master Pages? Creating a Master Page What Are Content Pages? Creating a Content Page What Are Nested Master Pages? Runtime Behavior of Master Pages Adding a Master Page to an Existing Web Application Project

Discussion: Advantages of Master Pages Lesson 2: Adding User Controls to an ASP.NET Web Form What Are User Controls? Advantages and Disadvantages of Using User Controls Converting a Web Form to a User Control Adding a User Control to a Web FormList the content to be addressed in the lesson. Module 6: Validating User Input Lesson 1: Overview of User Input Validation What Is Input Validation? Client-Side and Server-Side Validation Lesson 2: ASP.NET Validation Controls Overview of ASP.NET Validation Controls Basic ASP.NET Validation Controls RegularExpressionValidator Control CustomValidator Control Combining Validation Controls Adding Validation Controls to a Web Form Positioning and Configuring Validation Controls on a Web Form Lesson 3: Validating Web Forms Implementing the ValidationSummary Control Programmatically Validate Web Forms

Day 3
Module 7: Debugging Microsoft ASP.NET Web Applications Lesson 1: Tracing in ASP.NET What Is Tracing? Tracing a Web Application The TraceContext Class Lesson 2: Debugging in ASP.NET What Is Debugging? Gathering Debugging Information at Run-time The Debug Class Debugging a Web Application Remote Debugging Module 8: Managing Data in an ASP.NET 4.0 Web Application Lesson 1: Overview of ADO.NET What Is ADO.NET? The ADO.NET Object Model Lesson 2: Connecting to a Database Creating a Connection Facilitating Data Transport Between Clients and Servers Lesson 3: Managing Data

Retrieving Simple Data Retrieving Non-Simple Data Manipulating Data Binding Data to Server Controls by Using the IDE

Day 4
Module 9: Managing Data Access Tasks by Using LINQ Lesson 1: Overview of LINQ What Is LINQ? What Is LINQ to XML? What Is LINQ to SQL? Lesson 2: Managing XML Data by Using LINQ to XML Querying XML Data by Using LINQ to XML Working with XML Data by Using LINQ to XML Displaying LINQ to XML Data Lesson 3: Managing SQL Data by Using LINQ to SQL Querying SQL Data by Using LINQ to SQL Working with SQL Data by Using LINQ to SQL Displaying LINQ to SQL Data Module 10: Managing Data by Using ASP.NET Dynamic Data Lesson 1: Overview of ASP.NET Dynamic Data What Is ASP.NET Dynamic Data? Dynamic Data Project Infrastructure ASP.NET Dynamic Data Scaffolding ASP.NET Dynamic Data Templates ASP.NET Dynamic Data Routing Lesson 2: Applying ASP.NET Dynamic Data Demonstration: How To Create an ASP.NET Dynamic Data Web Site Demonstration: How To Add ASP.NET Dynamic Data to an Existing Web Site Adding Dynamic Behavior to ASP.NET Databound Controls Lesson 3: Customizing ASP.NET Dynamic Data Applications Creating a Dynamic Data Page Template Demonstration: How To Create a Dynamic Data Field Template Customizing Dynamic Data Scaffolding

Day 5
Module 11: Creating a Microsoft ASP.NET AJAX Application Lesson 1: Introduction to ASP.NET AJAX What Is Asynchronous JavaScript and XML? What Is ASP.NET AJAX? Architecture of ASP.NET with AJAX Lesson 2: Creating an ASP.NET AJAX Application by Using the ASP.NET AJAX Extensions

What Are ASP.NET AJAX Extensions? ASP.NET AJAX Server Controls Demonstration: Implementing the UpdatePanel Control Managing Partial-Page Updates Lesson 3: Extending an Application by Using the ASP.NET AJAX Control Toolkit Overview of the ASP.NET AJAX Control Toolkit Accessing the ASP.NET AJAX Control Toolkit Demonstration: Implementing an ASP.NET AJAX Extender Control Overview of ASP.NET AJAX Control Toolkit Controls Module 12: Consuming Web Services Lesson 1: Overview of Web Services What Is Web Service? Why Use Web Services? Windows Communication Foundation Lesson 2: Locating Web Services Locating Web Service by Using UDDI Locating Web Service by Using DISCO Files Adding Web Reference by Using Visual Studio 2008 SP1 Lesson 3: Calling Web Services Calling Web Service by Using HTTP What Is a Proxy? Steps for Calling Web Service Web Service Error Handling

Day 6
Module 13: Managing State in Web Applications Lesson 1: State Management What Is State Management? Types of State Management Server-Side State Management Client-Side State Management Lesson 2: ASP.NET Profiles What Are ASP.NET Profiles? Using ASP.NET Profiles Lesson 3: ASP.NET Caching What is ASP.NET Caching? Using ASP.NET Caching Module 14: Configuring and Deploying a Microsoft ASP.NET Web Application Lesson 1: Configuring an ASP.NET Web Application Overview of Configuration Files Configuring ASP.NET by Using Machine.config Configuring ASP.NET by Using web.config

Configuration Inheritance Demonstration: Configuration Inheritance Web Site Administration Tool Retrieving Data from web.config Writing Data to web.config

Lesson 2: Deploying an ASP.NET Web Application Web Application Deployment Deploying a Web Application by Using the Copy Web Site Tool Deploying a Web Application by Using the Publish Web Site Utility Sharing Assemblies in the Global Assembly Cache

ASP .Net MVC 4

Day 1
Module 1: Exploring ASP.NET MVC 4 Lessons: Overview of Microsoft Web Technologies Overview of ASP.NET 4.5 Introduction to ASP.NET MVC 4 Lab: Exploring ASP.NET MVC 4 Exploring a Photo Sharing Application Exploring a Web Pages Application Exploring a Web Forms Application Exploring an MVC Application Module 2: Designing ASP.NET MVC 4 Web Applications. Lessons: Planning in the Project Design Phase Designing Models, Controllers, and Views Lab: Designing ASP.NET MVC 4 Web Applications Planning Models Planning Controllers Planning Views Architecting an MVC Application Module 3: Developing ASP.NET MVC 4 Models Lessons: Creating MVC Models


Working with Data

Developing ASP.NET MVC 4 Models Creating an MVC Project and Adding a Model Creating a New SQL Azure Database in Visual Studio Adding Properties and Methods to MVC Models Using Display and Edit Annotations in MVC Models

Day 2
Module 4: Developing ASP.NET MVC 4 Controllers Lessons: Writing Controllers and Actions Writing Action Filters Lab :

Developing ASP.NET MVC 4 Controllers Adding an MVC Controller and Writing the Actions Writing the Action Filters in a Controller Using the Photo Controller

Module 5: Developing ASP.NET MVC 4 Views Lessons: Creating Views with Razor Syntax Using HTML Helpers Reusing Code in Views Lab :

Developing ASP.NET MVC 4 Views Adding a View for Photo Display Adding a View for New Photos Creating and Using a Partial View Adding a Home View and Testing the Views

Module 6: Testing and Debugging ASP.NET MVC 4 Web Applications Lessons: Unit Testing MVC Components Implementing an Exception Handling Strategy Lab: Testing and Debugging the ASP.NET MVC 4 Web Applications Performing Unit Tests Configuring Exception Handling

Day 3
Module 7: Structuring ASP.NET MVC 4 Web Applications Lessons: Analyzing Information Architecture Configuring Routes Creating a Navigation Structure Lab : Structuring ASP.NET MVC 4 Web Applications Using the Routing Engine Building Navigation Controls Module 8: Applying Styles to ASP.NET MVC 4 Web Applications Lessons: Using Template Views Applying CSS to an MVC Application Creating an Adaptive User Interface Lab:

Applying Styles to ASP.NET MVC 4 Web Applications Using Template Views Applying a Consistent Look and Feel to an MVC Application Adapting Webpages for Different Browsers

Module 9: Building Responsive Pages in ASP.NET MVC 4 Web Applications Lessons: Using AJAX and Partial Page Updates Implementing a Caching Strategy Lab: Building Responsive Pages in ASP.NET MVC 4 Web Applications Using Partial Page Updates Configuring ASP.NET Caches

Day 4
Module 10: Using JavaScript and jQuery for Responsive MVC 4 Web Applications Lessons: Rendering and Running JavaScript Code Using jQuery and jQueryUI

Lab : Using JavaScript and jQuery for Responsive MVC 4 Web Applications Using jQuery to Respond to Users Using jQueryUI to Build a User Interface Module 11: Controlling Access to ASP.NET MVC 4 Web Applications Lessons: Implementing Authentication and Authorization Assigning Roles and Membership Lab:

Controlling Access to ASP.NET MVC 4 Web Applications Configuring Authentication Controlling Access to Resources Providing User Account Facilities

Module 12: Building a Resilient ASP.NET MVC 4 Web Application Lessons: Developing Secure Sites State Management Lab: Building a Resilient ASP.NET MVC 4 Web Application Storing User Preferences Using User Preferences in the Photo Gallery

Day 5
Module 13: Using Windows Azure Web Services in ASP.NET MVC 4 Web Applications Lessons: Introduction to Windows Azure Designing and Writing Windows Azure Services Consuming Windows Azure Services in a Web Application Lab: Using Windows Azure Web Services in ASP.NET MVC 4 Web Applications Creating and Coding a Windows Azure Service Consuming Data from a Windows Azure Service Module 14: Implementing Web APIs in ASP.NET MVC 4 Web Applications Lessons: Developing a Web API


Calling a Web API from Mobile and Web Applications

Implementing Web APIs in ASP.NET MVC 4 Web Applications Developing a Web API in MVC 4 Adding Routes and Controllers to Handle REST Requests Calling RESTful services from Client-Side Code

Module 15: Handling Requests in ASP.NET MVC 4 Web Applications Lessons: Using HTTP Modules and HTTP Handlers Using Web Sockets Lab: Handling Requests in ASP.NET MVC 4 Web Applications Writing a Web Handler that Uses Web Sockets Module 16: Deploying ASP.NET MVC 4 Web Applications Lessons: Deploying Web Applications Deploying MVC 4 Applications Lab: Deploying ASP.NET MVC 4 Web Applications Deploying an Application to Windows Azure Testing the Completed Application