Exclusive
Visual Studio 2008

Introduction to Object Oriented Programming using Microsoft Visual Studio 2008
(Microsoft Training Course: 6367) - 3 days - £1700 exc VAT



> Target Audience
This course will enable attendees to start designing and developing object-oriented applications using Visual Studio 2008. It is intended for programmers who have programming experience in a professional environment and want to learn how to develop well conceived and implemented object-oriented programming applications.
> Course outline
  1. Getting Started with Object-Oriented Programming
  2. Implementing Classes, Properties and Methods
  3. Implementing Inheritance, Abstraction, and Polymorphism
  4. Implementing Interfaces
  5. Designing Object-Oriented Structures
  6. Implementing Delegates, Events, and Exceptions
  7. Designing Object Collaboration
  8. Deploying Components and Class Libraries


Module 1: Getting Started with Object-Oriented Programming
  • This module provides fundamental knowledge required before getting started with object-oriented development. It also reviews Visual Studio 2008 features.
  • Introduction to Object-Oriented Programming
  • Creating Projects in Visual Studio 2008
  • Coding in Visual Studio 2008
  • Productivity Features in Visual Studio 2008
  • Debugging Visual Studio Applications
  • Lab: Getting Started with Object-Oriented Development in Visual Studio 2008
Skills
  • Describe what makes an object-oriented program different than a procedural based program.
  • List influencing factors that affect successful object oriented development.
  • Describe the overall design goals of an object-oriented application.
  • Explain how Visual Studio and .NET support developing object-oriented applications.
  • Describe the various project types supported by Visual Studio 2008 and when to use them.
  • Evaluate when to use Web site and Web application projects.
  • Describe the primary folders/file types included in each project.
  • Describe how .NET establishes and references .NET data types.
  • Create and manage basic programming structures and control flows within the Visual Studio 2008 IDE.
  • Describe Visual Studio 2008 productivity enhancements.
  • Use editing features such as edit marks, code snippets and refactoring in Visual Studio 2008.
  • Create code comments.
  • Generate documentation from code comments.
  • Troubleshoot coding errors using the debugging interface.
  • Test for business logic errors during design time.
top
Module 2: Implementing Classes, Properties and Methods
  • This module explains classes and their importance in the basic structure of an object-oriented application.
  • Creating Classes
  • Implementing Properties within a Class
  • Implementing Methods within a Class
  • Using Classes, Properties and Methods
  • Lab: Implementing Classes with Properties and Methods in Visual Studio 2008
Skills
  • Create a class structure within an object-oriented application.
  • Describe the relationship between classes, properties, methods and objects.
  • Describe the object instantiation process.
  • Create properties within class structures to maintain class specific data within Visual Studio projects.
  • Control access to properties.
  • Simplify property creation syntax by using default properties.
  • Create value type and reference type based properties.
  • Define the syntax of a basic method.
  • Use value and reference types as parameters and as return types of a method.
  • Create overloaded methods.
  • Control access to methods.
  • Control class construction using constructors.
  • Create objects from classes.
  • Access the properties of a class instance.
  • Invoke the methods of a class instance.
  • Invoke a shared method of a class instance.
top
Module 3: Implementing Inheritance, Abstraction, and Polymorphism
  • This module explains how to implement inheritance, abstraction and polymorphism to reduce code duplication. It also describes how to create structures that emphasize code reusability.
  • Introduction to Inheritance and Abstraction
  • Implementing Inheritance and Abstraction
  • Introduction to Polymorphism
  • Implementing a Polymorphic Structure
  • Lab: Implementing Inheritance and Abstraction
Skills
  • Explain how to reduce code duplication by using inheritance and abstraction.
  • Explain how to increase code reuse by using inheritance and abstraction.
  • Identify the impact of inheritance on class structures.
  • Write code to create an inherited class.
  • Write code to create an abstract class.
  • Manage the relationship between a base class and a derived class.
  • Manage the construction of inherited class structure.
  • Explain the importance of implementing dynamic code.
  • Explain how polymorphism can create dynamic code at runtime within inherited class structures.
  • Explain the importance of decoupling inherited class functionality from runtime control code.
  • Explain how polymorphism can simplify the code required by the runtime portion of the application.
  • Identify uses of polymorphism within a business scenario.
  • Write code to create and use a polymorphic structure.
  • Create a polymorphic solution that reduces control code logic.
  • Create a polymorphic solution that decouples class dependencies.
top
Module 4: Implementing Interfaces
  • This module explains how to implement interfaces to establish common relationships between classes, reduce code dependencies, and facilitate code standardization.
  • Introduction to Interfaces
  • Implementing a Custom Interface
  • Lab: Implementing Interfaces
Skills
  • Explain the importance of reducing code dependencies.
  • Explain how dependencies between classes can be reduced by implementing interfaces.
  • Explain the importance of code standardization.
  • Explain how code standardization can be increased through implementing interfaces.
  • Identify uses of interfaces within a business scenario.
  • Create an interface.
  • Write code to implement an interface.
  • Use an interface to access the functionality within a class.
  • Use an interface with a polymorphic class structure.
top
Module 5: Designing Object-Oriented Structures
  • This module explains the process of creating an object-oriented structure design from a business problem. It also describes how to create object-oriented structures based on knowledge of classes, properties, methods, inheritance, and interfaces.
  • Establishing Classes from Business Requirements
  • Adding Inheritance to the Design
  • Adding Interfaces to the Design
  • Reviewing and Refining the Design
  • Lab: Designing Object-Oriented Structures
Skills
  • Review the goals of object-oriented design.
  • Describe approaches to create an object-oriented design based on business requirements.
  • Create a class diagram to document the design.
  • Identify classes based on business requirements.
  • Identify the properties and methods based on business requirements.
  • Describe approaches of designing inherited class structures based on business requirements.
  • Add inherited structures to the proposed class diagram.
  • Modify the methods and property placement within the new class diagram.
  • Describe approaches of designing interface structures from business requirements.
  • Modify the class diagram to include interfaces.
  • Determine the effect of future usage on the completed class diagram.
top
Module 6: Implementing Delegates, Events, and Exceptions
  • This module explains how to create and use delegates, events and exceptions to establish interclass communications.
  • Introduction to Delegates
  • Implementing Delegates
  • Introduction to Events
  • Implementing Events
  • Introduction to Exceptions
  • Implementing Exceptions
  • Lab: Implementing Delegates, Events
  • Lab: Implementing Exceptions
Skills
  • Explain the importance of interclass communications.
  • Describe the delegate model.
  • Explain how the delegate model can decouple class dependencies and increase code reusability.
  • Define the syntax required to implement a delegate within a class.
  • Define the syntax required to use a delegate from a calling class.
  • Use delegates to establish interclass communications.
  • Describe the system event model and its importance to object-oriented applications.
  • Describe the benefits of creating custom events within an object-oriented application.
  • Identify appropriate uses of system and custom events.
  • Apply the syntax required to create a system event handler within a class.
  • Apply the syntax required to create a custom event.
  • Apply the syntax required to create a custom event handler.
  • Describe the exception model used within .NET applications.
  • Explain how exception management can help mitigate runtime errors within an application.
  • Describe differences in object-oriented exception management versus procedural-based exception management.
  • Identify uses of exception management given a business scenario.
  • Implement a solution that uses exceptions to mitigate runtime errors.
top
Module 7: Designing Object Collaboration
  • This module explains how to design collaborations between classes by using methods, events, exceptions and delegates. It also introduces sequence diagrams as a way of documenting and planning class interactions.
  • Introduction to Class Interactions
  • Adding Interactions to a Design
  • Evaluating the Design
  • Introduction to Patterns
  • Lab: Designing Object-Oriented Collaboration
Skills
  • Define design goals to create class interactions.
  • Identify differences between events, exceptions, delegates and direct method invocation to implement an interaction design.
  • Describe evaluation approaches and criteria to determine if a design is effective in solving a business problem.
  • Determine interaction boundaries within an object-oriented design to decouple class structures.
  • Organize an application to decouple dependencies between code.
  • Diagram class interactions.
  • Evaluate the overall design against object-oriented design best practices.
  • Critique the design using evaluation techniques.
  • Apply a design pattern to an existing solution.
top
Module 8: Deploying Components and Class Libraries
  • This module explains how to create and maintain updatable units of software by deploying components and class libraries. It also describes how to maintain an application without redeploying the entire application.
  • Introduction to Components and Class Libraries
  • Deploying a Component/Class Library
  • Best Practices for Deploying a Component/Class Library
  • Lab: Deploying Components and Class Libraries
Skills
  • Explain the importance of creating deployable units of software.
  • Describe the software development lifecycle with respect to upgrading and maintenance.
  • Prepare an application to use component/class libraries.
  • Create and deploy a component/class library.
  • Manage versioning within an application using a component/class library.
  • Identify code that maximizes component/class library usage.
top
> Pre-Requisites
Before attending this course, students must have the following pre-requisites:
  • Understand the principles of software development.
  • An understanding of scripting techniques.
  • Hands-on experience creating and implementing script code.
  • A fundamental understanding of the .NET Framework.
  • An understanding of the Visual Studio IDE (Integrated Development Environment).
  • Hands-on experience using a version of Visual Studio .NET.
> Purpose
After completing the course, students will be able to describe the fundamentals of object-oriented development and review Visual Studio 2008 features; describe classes and their importance in the basic structure of an object-oriented application; add properties and methods; implement inheritance, abstraction and polymorphism; create structures that emphasize code reusability; implement interfaces; create an object-oriented structure design; create object-oriented structures; create and use delegates, events and exceptions; design class interactions; evaluate techniques to improve design; evaluate a design pattern and determine its applicability to a business scenario; create and maintain updatable units of software by deploying components and class libraries; maintain an application without deploying the entire application.