Basic Level .NET Programmer Certification
The Visual Studio .NET Integrated Development Environment and .NET Programming Languages: C#, VB.NET (2 Days)
• Visual Studio .NET Integrated Development Environment (IDE) Overview
• Menu Bar and Toolbar Features
• Visual Studio .NET Windows Overview
• Solution Explorer Features, Buttons on the Solution Explorer Window
• Toolbox Window, Customizing the Toolbox
• Properties Window Features and Buttons
• Class View Window Features
• Object Browser Window Features
• Task List Window Features
• Document Windows
• Using Local and Online Help
• Using the Editor (IntelliSense, Split the Editing Window, Find/Replace, Block Comment/UnComment)
• Creating Projects and Solutions
• Brief Introduction to the Software Development Process (A Software Development Life Cycle that Includes Interviews, Business Requirements, Functional Requirements, Design, Implementation, Testing, Deployment)
• Windows Form Project Creation from SDLC Documentation
• Drag and Drop Form Controls (Label, Textbox, Button)
• Creating and Handling Form and Control Events (Form Load and Button Click)
• Setting Versions of a Solution
• Files Produced by the Project
• Single and Multiple Project Solutions
• Working with Controls (Setting Tab Order, Set the Font Property, Manipulating Groups of Controls, Formatting Controls)
• Creating and Handling Control Events
• Microsoft .NET Namespaces
• Creating Custom Namespaces
A simple program lab that includes the SDLC steps above to create a Windows Form application implementing a very simple online phone call log business process.
Object Oriented Programming and Design (Uses C# and VB.NET) (3 Days)
Overview of Visual Basic .NET and C# Object-Oriented Programming in .NET Framework:
• .NET Object Fundamentals
• Creating and Compiling the Component
• Namespaces
• Using a Component
• Application Domains
• Contexts
• Assemblies
• Intermediate Language
• The Global Assembly Cache
• System Namespaces
• Class Anatomy
• Member Variables
• Properties
• Methods
• Access Modifiers
• Passing Parameters
• Value Types
• Creation and Destruction
• Delegates and Events
• Design Considerations
A lab is needed that demonstrates the key concepts presented above in a scenario that illustrates simple steps in an SDLC: an interview, business requirements, and functional requirements.
Object-Orientation
• Generalization and Specialization
• Inheritance
• Containment and Data Hiding
• Polymorphism
• Overloading
• Overriding
• Substitution
• Interfacing .NET
• Private Implementation
• Versioning
• Interfaces Versus Abstract Base Classes
• Interfaces in .NET
A lab is needed that demonstrates the key concepts presented above in a scenario that illustrates simple steps in an SDLC: an interview, business requirements, and functional requirements.
Design Considerations
• Exception Handling Objects
• The Basics of Exception Handling
• An Unhandled Exception Handler
• The StackTrace Object
• Resuming Code
• Retrying Code
• Performance Counters
• Object Inspection
• Reflection
• Runtime Type Discovery
• Dynamic Type Loading
• Attributes
• Custom Attributes
• Passing Objects as Parameters
• Streams
• Readers and Writers
• Serialization
• Schema Definition Tool
• Custom Serialization
• NetworkStream
A lab is needed that demonstrates the key concepts presented above in a scenario that illustrates simple steps in an SDLC: an interview, business requirements, and functional requirements.
.
Application Database Access Techniques: ADO.NET with SQL Server (2 Days)
Introduction to SQL Server and Management Studio
• Installing and Setting up SQL Server Express Edition and Management Studio
• Understanding how to use Management Studio to Set Up Databases
• Introduction to Relational Databases, Tables, Primary Keys, Foreign Keys, Indexing, and Constraints
• Writing Database Queries in the Query Analyzer
• Manipulating Database Data with Queries
• Writing and Executing Simple Select, Insert, Update, and Delete Stored Procedures with Parameters
• Introduction to XML
• Understanding SQL Server Transactions
• Creating a Simple Entity-Relationship Diagram with Management Studio
A lab is needed that demonstrates the key concepts presented above in a scenario that illustrates simple steps in an SDLC: an interview, business requirements, and functional requirements.
Introduction to ADO.NET
• Overview of the ADO.NET Objects
• Making Connections
• Executing Commands and Stored Procedures
• Creating and Passing Parameters
• Using Data Readers
• Using Datasets and Data Adapters
• SQL Server Exception Handling
• Executing Select, Insert, and Update Stored Procedures with ADO.NET
• Handling Exceptions specific to Data Access
• Working with Events
• Working with Text and Binary Data
• Creating and Using an ADO.NET Data Access Layer Class
• Accessing data and filling forms in simple Windows Forms Applications
• Accessing Data and Filling Web Forms in simple ASP.NET Applications
A lab is needed that demonstrates the key concepts presented above in a scenario that illustrates simple steps in an SDLC: an interview, business requirements, and functional requirements.
Option 1: Beginning Application Design, Implementation, Unit Testing, and Deployment: Web Forms (3 Days)
• Introduction to ASP.NET Web Programming with Visual Studio .NET
• Creating Web Forms Applications from Business and Functional Requirements
• Working with Web Objects, Properties, and Events
• Creating a User Interface Compliant with Federal and State Standards
• Storing and Retrieving Data with ADO.NET Web Applications
• Catching and Correcting Errors
• Maintaining Security
• Building and Deploying Web Applications in Layers and Assemblies
• Creating Custom Web Controls
• Optimizing Web Applications with Caching
• Formatting Web Application Output
• Providing Help
• Globalizing Web Applications
• Working with Form Objects and Events
• HTML Controls, Properties, and Events
• Server Controls, Properties, and Events
• User Controls, Properties, and Events
• Validating User Input at the UI and Business Logic Layers
• Formatting with Cascading Style Sheets
• Event Handling in ASP.NET Forms and Components
• Error Handling of Exceptions
• Handling State: Session, Application, and Data Storage
• Unit Testing and Debugging Web Applications
• Introduction to Data Binding in ASP.NET
• Introduction to Web Forms Programming With Class Layers (User Interface Layer, Business Logic Layer, Data Access Layer)
• Creating and Accessing Web Configuration and Resource Files
• Introduction to Web Services
• Creating a Simple Web Service
• Introduction to JavaScript and ASP.NET AJAX
• Web Application Deployment
• Introduction to IIS
Labs are needed that demonstrate the key concepts presented above in a scenario that illustrates simple steps in an SDLC: an interview, business requirements, functional requirements, design, and programming.
Option 2: Beginning Application Design, Implementation, Unit Testing, and Deployment: Windows Forms (3 Days)
• Introduction to Windows Programming with Visual Studio .NET
• Creating Windows Forms Applications from Business and Functional Requirements
• Working with Windows Forms Events and Properties
• Creating a User Interface Compliant with Federal and State Standards
• Storing and Retrieving Data with ADO.NET Windows Applications
• Catching and Correcting Errors
• Maintaining Security
• Building and Deploying Windows Applications in Layers and Assemblies
• Creating Custom Controls
• Windows Forms and the Multiple Document Interface
• Formatting Windows Application Output
• Providing Help
• Federal and State Standards and Windows Applications
• Working with Form Objects and Events
• HTML Controls, Properties, and Events
• Server Controls, Properties, and Events
• User Controls, Properties, and Events
• Validating User Input at the UI and Business Logic Layers
• Formatting Windows Forms and Controls
• Event Handling in ASP.NET Forms and Controls
• Error Handling of Exceptions
• Unit Testing and Debugging Windows Applications
• Introduction to Data Binding in Windows Forms
• Introduction to Windows Forms Programming With Class Layers (User Interface Layer, Business Logic Layer, Data Access Layer)
• Creating and Accessing Windows Configuration and Resource Files
• Introduction to Windows Services
• Creating a Simple Windows
• Introduction to Smart Client Applications
• Introduction to Visual Studio Tools for Office
• Windows Application Deployment
Labs are needed that demonstrate the key concepts presented above in a scenario that illustrates simple steps in an SDLC: an interview, business requirements, and functional requirements.
Intermediate Level .NET Programmer Certification:
Object-Oriented Patterns (C# and VB.NET) (3 Days):
• Introduction and History of Distributed Application Patterns
• Interface Patterns (Adapter, Façade, Composite , Bridge)
• Responsibility Patterns (Singleton , Observer, Mediator, Proxy, Chain of Responsibility, Flyweight)
• Construction Patterns (Builder, Factory Method, Abstract Factory, Prototype, Memento)
• Operation Patterns (Template Method, State, Strategy, Command, Interpreter)
• Extension Patterns (Introducing Extensions, Decorator, Iterator, Visitor)
• Application Patterns: Model View Controller, Model View Presenter
Labs are needed that demonstrate the key concepts presented above in a scenario that illustrates simple steps in an SDLC: an interview, business requirements, and functional requirements.
.NET Application Security (Includes Threat Modeling) (3 Days):
• Understanding Basic Threat Terminology: Asset, Threat, Vulnerability, Attack (or Exploit), and Countermeasure.
• Introduction to Threats and Countermeasures: Identifies and illustrates the various threats facing the network, host, and application layers. Using the threat modeling process allows identification of the threats that are relevant to a .NET application. This sets the stage for identifying effective countermeasures. This part includes: Web Application Security Fundamentals, Threats and Countermeasures, Threat Modeling.
• Designing Secure Web Applications: Provides the guidance needed to design Web applications securely. This section identifies the concepts, principles, and techniques that are used during an application design. This part includes: Design Guidelines for Secure Web Applications, and Architecture and Design Review.
• Building Secure Web Applications: Helps apply the secure design practices and principles covered in the previous part to create a solid and secure implementation. This section promotes learning defensive coding techniques that make .NET code and applications resilient to attack. This section also presents an overview of the .NET Framework security landscape so that programmers are aware of the numerous defensive options and tools that are at their disposal. This part includes: .NET Security Fundamentals, Building Secure Assemblies, Code Access Security in Practice, Using Code Access Security with ASP.NET, Building Secure ASP.NET Pages and Controls, Building Secure Serviced Components, Building Secure Web Services, and Building Secure Data Access.
• Securing Your Host and Application: Shows how to apply security configuration settings to secure the interrelated network, host, and application levels. Rather than applying security randomly, the programmer should learn the reasons for the security recommendations. This part includes: Securing a Web Server, Securing an Application Server, Securing a Database Server, Securing ASP.NET Applications and Web Services, and Hosting Multiple ASP.NET Applications.
• Assessing Your Security: This section should show a developer how to evaluate code, designs, and deployed applications for potential vulnerabilities. This section includes: Code Review, and Deployment Review.
• Microsoft Security Checklists: Contains task-based checklists which are printable quick-reference sheets to help turn information into action. This section includes the following checklists: Architecture and Design Review, Security Review for Managed Code, Securing ASP.NET, Securing Enterprise Services, Securing Web Services, Securing Data Access, Securing a Web Server, and Securing a Database Server.
Labs are needed that demonstrate the key concepts presented above in a scenario that illustrates simple steps in an SDLC: an interview, business requirements, and functional requirements.
Application Standards, Best Practices, and Performance Optimization (5 Days)
• Balancing performance with quality-of-service (QoS) requirements: Balancing application performance requirements with other QoS attributes such as security and maintainability. This section presents Microsoft design guidelines for application performance.
• Identifying and evaluating performance issues: Using performance modeling early in the design process to help evaluate design decisions against the objectives before committing time and resources. This section includes identifying performance objectives, performance modeling, team workload, and performance metrics such as maximum execution time and resource utilization (e.g., CPU, memory, disk I/O, and network I/O).
• Performing architecture and design reviews: Review the design of an application in relation to the targeted deployment environment, any constraints that might be imposed, and the defined performance goals. Use the categories that are defined by the performance and scalability frame promoted by this guide to help partition the analysis of an application and to analyze the approach taken for each area. The categories represent key areas that frequently affect application performance and scalability. Use the categories to organize and prioritize areas for review.
• Choosing a deployment topology: Identify the requirements and constraints that exist between the application and infrastructure. This precedes choosing appropriate architectures and helps resolve conflicts between application and infrastructure architecture early in the software development process. This section covers a layered design that includes presentation, business, and data access logic that makes it easier for the developer to scale an application and improve maintainability.
• Designing for required performance and scalability: Using tried and tested design principles with a focus on the critical areas where the correct approach is essential and where mistakes are often made. This section should show how to use the categories o help organize and prioritize performance issues. Categories include data structures and algorithms, communication, concurrency, resource management, coupling and cohesion, and caching and state management.
• Passing data across the tiers: Prioritize performance, maintenance, and ease of development when you select an approach. Custom classes allow a developer to implement efficient serialization. This section should also cover using structures if you can to avoid implementing serialization or XML for interoperability and flexibility with precautions since XML is verbose and can require considerable parsing effort. This section also includes using a DataReader object to render data as quickly as possible, but not passing DataReader objects between layers because they require an open connection. This section should discuss DataSet options for flexibility and caching data across requests, but DataSet and Typed DataSet objects are expensive to create and serialize. This section finally covers passing objects, generics, and lists between layers.
• Choosing between service orientation and object orientation. When designing distributed applications, choosing among services, object-orientation, or a hybrid of both can be a difficult choice. This section summarizes the key differences between object orientation and service orientation.
• Improving Managed Code Performance: Conducting performance reviews of managed code. This section should cover performance issues when designing efficient types and thread safe classes, properties, and inheritance.
• Managing memory efficiently: Writing code to help the garbage collector do its job efficiently. This section should also include minimizing hidden allocations, avoiding the promotion of short-lived objects, pre-allocating memory, chunking memory, and forcing garbage collections.
• Using multithreading in .NET applications: Minimizing thread creation and using the self-tuning thread pool for multithreaded work. This section should also cover avoiding the creation threads on a per-request basis and the use Thread.Abort or Thread.Suspend. Make sure that you appropriately tune the thread pool for ASP.NET applications and for Web services. For more information, see "How to tune the ASP.NET thread pool" later in this document.
• Cleaning up resources: Releasing resources as soon as an application is finished with them. This section covers using “finally” blocks or the C# “using” statement to make sure that resources are released even if an exception occurs. It also discusses calling Dispose (or Close) on any disposable object that implements the IDisposable interface. The section should also include using finalizers on classes that hold on to unmanaged resources across client calls. It should also include using the Dispose pattern to help ensure that you implement Dispose functionality and finalizers (if they are required) correctly and efficiently.
• Handling exceptions: Writing code that avoids unnecessary exceptions. This section should cover using finally blocks to guarantee resources are cleaned up when exceptions occur (e.g., closing database connections in a finally block). It also covers exception handling best practices for layered or n-tiered applications and services.
• Working with strings efficiently : Using excessive string concatenation results in many unnecessary allocations that create extra work for the garbage collector. This section covers the use of the “StringBuilder” when creating complex string manipulations and concatenating strings multiple times.
• Improving Data Access Performance: This section covers improving data access performance by minimizing processing on the server and at the client and minimizing the amount of data passed over the network. This section should also include using database connection pooling to share connections across requests and keeping transactions as short as possible to minimize lock durations and to improve concurrency. The topic should cover paging records for grids in web and Windows applications.
• Caching data and other objects: Caching ASP.NET data by using the Cache API, by using output caching, or by using partial page fragment caching. This section should cover the consideration necessary for an appropriate caching policy that identifies the data for caching, the place for caching, and updating the cache.
• Measuring performance: Measuring performance early in the application design phase using tools such as System Monitor, network monitoring tools such as Netmon, profiling tools such as CLR Profiler, SQL Profiler, SQL Query Analyzer, and application instrumentation to collect metrics for measuring, This section also covers Quality Assurance measurements such as load testing and other performance testing.
Labs and demonstrations are needed that demonstrate the key concepts presented above in a scenario that illustrates the non-functional, technical best-practices for application performance.
.NET Applications Reporting Technologies (3 Days):
Introduction SQL Server Reporting Services
• Overview of SQL Server Reporting Services Features
• Reporting Services Architecture
• Reporting Services Terminology
• Reporting Services Editions
• Reporting Services Installation
Creating Reports
• Breakdown of Reporting Services
• Shared Data Sources for Reporting Services
• Creating Reports from Requirements
Calculations and Formatting
• Creating Expressions
• Using the Global Collections
• Formatting Items
• Conditional Formatting
Grouping and Sorting
• Creating Groups
• Calculating Totals and Percentages
• Interactive Sorting
• Creating Drill-Down Reports
Report Parameters
• Creating Report Parameters
• Creating Drop-Down Parameters
• Multi-Valued Parameters
• Debugging Parameter Issues
Creating Matrix Reports and Charts
• Creating a Basic Matrix Report
• Matrix Subtotals
• Creating a Basic Chart
• Exploring the Charting Possibilities
Managing Reporting Services
• Deploying Reports and Data Sources
• Exporting Reports and Printing
• Using the Web-Based Report Manager
• Using SQL Server Management Studio-based Reporting Services Manager
Reporting Services Security
• Reporting Services Security
• Securing Access to Reports
• Data Source Security for Reporting Services
Programming Reporting Services
• The Many Reporting Services APIs
• Integrating Reporting Services into Applications using URL Access
• Using the Reporting Services Web Service
Advanced Reporting Services Programming
• Using the Reporting Services Web Service
• Working with Custom Assemblies
Snapshots and Subscriptions
• Caching and Snapshots
• Creating Standard Subscriptions
• Creating Data-Driven Subscriptions
• Managing Subscriptions
Ad-Hoc Reporting with Report Builder
• The Report Builder Architecture
• Creating Report Model Projects
• Running Report Builder
Labs are needed that demonstrate the key concepts presented above in a scenario that illustrates simple steps in an SDLC: an interview, business requirements, and functional requirements for lab reports.
Advanced Level .NET Programmer Certification:
Windows Communication Foundation (WCF) (5 Days):
• Introduction to WCF: WCF Basic Terminology and Key Concepts; Address, Binding and Contract, WCF Services and Clients, IIS Hosting, Windows Activations Services, and WCF Architecture Details.
• Addresses and Bindings: Addresses, Bindings, Message Exchange Patterns, Configuring Bindings, Interoperating with ASMX Web Services, Hosting in a Console Application, Channel Factories, and Multiple Endpoints.
• Service Contracts: Defining Service Contracts (Interfaces), Defining Operation Contracts, Services with Multiple Contracts, Contract Inheritance, and Operation Overloading.
• Instance Management: Using Per-Call Services, Using Per-Session Services, Using Singleton Services, and Configuring Behaviors.
• Data Contracts: Implementing Data Contracts, Mapping Data Contracts to Objects, Serialization, Arrays and Generic Collections, Enums, and Versioning Data Contracts.
• Configuration Management: Using the Service Configuration Utility to configure the service.
• Advanced Service Contracts: Versioning Service Contracts, Implementing Message Exchange Patterns, One-way Contracts, Duplex Contracts, and Asynchronous Proxies.
• Handling Errors: Faults And Exceptions, Generating And Handling Faults, and Fault Contracts.
• WCF Transports: HTTP and TCP Transport Protocols, Advantages and Disadvantages of the Protocols.
• WCF Best Practices: Recommended WCF Best Practices for Performance, Transactions, and Security.
Labs are needed that demonstrate the key concepts presented above in a scenario that illustrates simple steps in an SDLC: an interview, business requirements, and functional and non-functional requirements.
Windows Workflow Foundation (WF) (5 Days):
• Introduction to Windows Workflow Foundation: Key Terminology, WF Architecture, and Visual Modeling of Business Processes.
• Creating and Hosting Workflows: Create State Machine Workflows, Create Sequential Workflows, Select Workflow Authoring Mode, Host a Workflow and Designer in an Application or a Service, Initialize (Passing Parameters) and Manage the Workflow Life Cycle, and Modify a Workflow at Runtime.
• The Major Workflow Activities: CallExternalEventActitivity, CodeActivity. ConditionedActivityGroup, DelayActivity, EventDrivenActivity, EventHandlersActivity, FaultHandlerActivity, HandleExternalEventActivity, IfElseActivity, IfElseBranchActivity, ListenActivity, ParallelActivity, PolicyActivity, SequenceActivity, SetStateActivity, StateActivity, StateFinalizationActivity, StateInitializationActivity, SuspendActivity, TerminateActivity, ThrowActivity, and WhileActivity.
• Creating and Configuring Custom Activities: Create custom activities, Create custom composite activities, Define custom activity layout, Add dependency properties, Communicate with the host from a custom activity, and Customize activity serialization.
• Applying Rules and Conditions: Write rule sets, Define rule chaining, priority, and property dependency, Change rules at runtime, Execute rule sets, Implement conditional branching logic.
• Managing Transactions and Compensations: Create and manage transactional workflows, Create and handle compensations, Enlist batch process in a transaction, Perform exception handling, and Handle cancellations.
• Creating and Managing Runtime Services: Create a runtime service, Hydrate and dehydrate workflows, Persist workflows, Track workflows, and Monitor workflows.
• Communicate with Workflows: Handle Events from the Host, Call Methods on the Host, Local Communications, Consume Services from a Workflow, and Expose a Workflow as a WCF Service, Send and Receive Activities.
• Use Framework 3.5 with Send and Receive Activities: Using WF-WCF combined services self-hosted or hosted in a WCF, Communicating with WCF Send and Receive Activities, Maintaining Context Channels, and WF/WCF Conversations.
• Labs are needed that demonstrate the key concepts presented above in a scenario that illustrates simple steps in an SDLC: an interview, business requirements, and functional and non-functional requirements.
Labs are needed that demonstrate the key concepts presented above in a scenario that illustrates simple steps in an SDLC: an interview, business requirements, and functional and non-functional requirements.
Option 1: Advanced Programming: Framework 3.5 New Language Features, Windows Presentation Foundation, Expression, and Silverlight (5 Days):
• Advanced C# 3.0 and VB.NET Language Options: Includes indexers, dynamic binding, delegation, events, generics, iterators, partial types, implicitly typed local variables, extension methods, Lambda expressions, expression trees, anonymous types, queries, and query expressions and the conventions used to implement these techniques.
• Windows Presentation Foundation (WPF): Details how WPF works and the various ways to use it within .NET applications. Section should cover programming with WPF in C# and VB.NET, and introduce the various class libraries that make up the framework. This section should also introduce the Extensible Application Markup Language (XAML), and show how to combine it with procedural code to build applications that can be deployed to the desktop or hosted in the browser. The topic should cover the new WPF data binding system to hierarchies of objects (master/detail). Demonstrations should be shown for browser-based and Windows WPF applications.
• Silverlight: Includes the building of Windows Vista and Silverlight 2.0 applications by using the new XML-based XAML. This section should also cover application layouts, controls, styles, resources, events, properties, dynamic content, custom components and the application model including navigation and window management. The developer also should be introduced to the new Microsoft Expression Blend tool, and learn how this differs from the desktop WPF that uses desktop tools but can run on non-Windows platforms.
Labs are needed that demonstrate the key concepts presented above in a scenario that illustrates simple steps in an SDLC: an interview, business requirements, and functional and non-functional requirements.
Option 2: Visual Studio Tools for Office (VSTO) and Smart Client Windows Applications (3 Days):
• Introduction to Office Programming: Office Object Models, Properties, Methods and Events, and The Significance of Primary Interop Assemblies.
• Introduction to Office Solutions: Office Automation Executables, Office Add-Ins, and Code Behind a Document.
• Office Programming in .NET: Programming Excel, Working with Excel Events, Working with Excel Objects, Programming Word, Working with Word Events, Working with Word Objects, Programming Outlook, Working with Outlook Events, Working with Outlook Objects.
• The VSTO Programming Model: VSTO Extensions to Word and Excel Objects, Dynamic Controls, and VSTO Extensions to Word and Excel Object Models.
• Using Windows Forms in VSTO: Adding Windows Forms Controls to Your Document, Writing Code Behind a Control, The Windows Forms Control Hosting Architecture, Properties Merged from OLEObject or OLEControl, Adding Controls at Runtime, Working with an ActionsPane, Working with the ActionsPane Control.
• Working with Smart Tags in VSTO: Creating Document-Level Smart Tags with VSTO, and Creating Application-Level Smart Tags.
• VSTO Data Programming: Creating a Data-Bound Customized Spreadsheet with VSTO, Creating a Data-Bound Customized Word Document with VSTO, Datasets, Adapters, and Data Sources.
• Server Data Scenarios: Populating a Document with Data on the Server, Using ServerDocument and ASP.NET, The ServerDocument Object Model.
• .NET Code Security: Code Access Security Versus Role-Based Security, Code Access Security in .NET, Code Origination Location, Strong Names, Publisher Certificates, Trusting the Document, and Deploying Policy to User Machines.
• Deployment: VSTO Prerequisites, Deploying to an Intranet Shared Directory or Web Site, Editing Manifests, and Creating Setup Packages.
Labs are needed that demonstrate the key concepts presented above in a scenario that illustrates simple steps in an SDLC: an interview, business requirements, and functional requirements.
Option 3: Visual Studio Team Systems for Advanced Software Developers (Includes Team Foundation Server, Continuous Integration, Deployment, Advanced Testing) (3 Days):
• Introduce VSTS with an overview of licensing and architecture
• Use VSTS to enforce best practices of software development
• Understand the VSTS tools and how and where they fit into the project lifecycle
• Learn how VSTS can be configured to use different software methodologies
• Use graphical modeling tools to create a system design and validate deployment
• Employ test-driven development to produce robust code
• See source control and Team Foundation Server code check-in and check-out
• Learn how to manage testing and track bugs
• Set up a project portal to access all project documentation
• Practice Deployment and Maintenance
• Learn about Team Foundation Server extensibility and Team Foundation Reporting
• Set up Team Projects and Process Template Customization
• Understand Team Foundation Version Control and Team Foundation Build
• Introduce the various VSTS versions and features: Team Edition for Software Architects, Team Edition for Software Developers, and Team Edition for Software Testers
• Create and manage a software project, design a project, generate a code framework, and build a deployment plan, manage test cases, enforce policies and business practices across the project, and customize VSTS to accommodate existing development practices.
Labs are needed that demonstrate the key concepts presented above in a scenario that illustrates simple steps in an SDLC: an interview, business requirements, and functional and non-functional requirements.
Option 4: AJAX, JavaScript, JSON and AJAX Controls for Rich Client Web Applications (3 Days):
• Introduction to AJAX
• History of Web Applications
• The User Experience
• JavaScript Fundamentals
• Overview of JavaScript Object-Oriented Programming with JSON
• The XMLHttpRequest object
• ASP.NET AJAX Overview
• Typical ASP.NET Application
• Introducing the UpdatePanel
• Display Synchronous and Asynchronous Call Progress with the UpdateProgress Control
• An Introduction to AJAX Architecture
• The Client Side
• The Server Side
• The Microsoft Client Library for AJAX
• Adding AJAX to a Site
• Using the Script Manager
• Partial Page Rendering
• Using the AJAX Control Toolkit
• Extender Controls
• Accordion Control
• Rating Control
• ReorderList Control
• TabContainer Control
• Control Tookit Extenders
• Client Side Development
• Application Services
• Forms Authentication
• User Profiling Services
• Making Remote Method Calls
• Designing the Server API for Remote Calls
• Consuming Web Services with Soap Messages with Web Service Calls
• Consuming Web Services with JSON Messages
• Page Method Calls to WCF Services
Labs are needed that demonstrate the key concepts presented above in a scenario that illustrates simple steps in an SDLC: an interview, business requirements, and functional requirements.