Learn: in:
» back to Search Results

Course rating of 0 Vendor rating of 4


This 3-day instructor led course will enable attendees to start designing & developing object-oriented applications using Visual Studio 2008. Learn object-oriented concepts including classes, methods, properties, inheritance, & interfaces.


 
Course Outline
This three-day instructor led course will enable attendees to start designing and developing object-oriented applications using Visual Studio 2008. Attendees will learn object-oriented concepts including classes, methods, properties, inheritance, and interfaces. Also they will learn how to identify opportunities to use these concepts in design, and how to implement these object-oriented concepts using Visual Studio 2008.

Audience Profile The target audience for this course is lower-intermediate level programmers who have a minimum of three months programming experience in a professional environment and want to learn how to use Visual Basic or C# to develop well conceived and implemented object-oriented programming applications.

At Course Completion After completing this course, students will be able to:
    * Describe the fundamentals of getting started with 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 to implement the internal functionality of a class.
    * Implement inheritance, abstraction and polymorphism to reduce code duplication.
    * Create structures that emphasize code reusability.
    * Implement interfaces to establish “common” relationships between classes, reduce code dependencies, and facilitate code.
    * Create an object-oriented structure design from a business problem.
    * Create object-oriented structures based on their knowledge of classes, properties, methods, inheritance, and interfaces.
    * Create and use delegates, events and exceptions to establish interclass communications.
    * Design class interactions based on a set of business requirements.
    * Design class interactions using methods, events, delegates and exceptions.
    * Evaluate techniques to improve their own 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.

Course Outline 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.
Lessons
    * 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
Selecting Project Type based on Business Scenario
Creating the Solution and Projects
Adding Code to the Solution
Adding Comments to the Solution
Using the Debugger Interface to Debug the Solution
Adding a Test Project

After completing this module, students will be able to:
    * 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.
    * Create folders and files for the project types included in the 6367A lab application.
    * Describe the primary folders/file types included in each project.
    * Describe how .NET establishes and references .NET data types.
    * Create data types used within the lab application.
    * Manage data types used within the lab application.
    * Create basic programming structures and control flows within the Visual Studio 2008 IDE.
    * 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.

Module 2: Implementing Classes, Properties and Methods This module explains classes and their importance in the basic structure of an object-oriented application. It also add properties and methods to implement the internal functionality of a class.
Lessons
    * 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
    * Creating a Class Structure
    * Adding Properties to a Class Structure
    * Adding Methods to a Class Structure
    * Instantiating and Using a Class within an Application
    * Implementing a Shared Method

After completing this module, students will be able to:
    * Create a class structure within an object-oriented application.
    * Describe the relationship between classes, properties and methods.
    * Describe the relationship between classes and objects.
    * Describe the instantiation process of an object.
    * 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.

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.
Lessons
    * Introduction to Inheritance and Abstraction
    * Implementing Inheritance and Abstraction
    * Introduction to Polymorphism
    * Implementing a Polymorphic Structure

Lab : Implementing Inheritance and Abstraction
    * Implementing Inheritance within the Class Structures
    * Implementing Abstraction within the Class Structures
    * Implementing Polymorphism within the Lab Application

After completing this module, students will be able to:
    * Explain how to reduce code duplication can be reduced by using inheritance and abstraction.
    * Explain how to increase code reuse can be increased 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 a polymorphic structure.
    * Write code to use a polymorphic structure.
    * Create a polymorphic solution that reduces control code logic.
    * Create a polymorphic solution that decouples class dependencies.

Module 4: Implementing Interfaces This module explains how to implement interfaces to establish common relationships between classes, reduce code dependencies, and facilitate code standardization.
Lessons
    * Introduction to Interfaces
    * Implementing a Custom Interface

Lab : Implementing Interfaces
    * Defining a Custom Interface
    * Implementing a Custom Interface
    * Implementing a System Defined Interface
    * Implementing Polymorphism Using Interfaces

After completing this module, students will be able to:
    * 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.
    * Describe commonly used system-defined interfaces.
    * Write code to implement an interface.
    * Use an interface to access the functionality within a class.
    * Use an interface with a polymorphic class structure.

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 their knowledge of classes, properties, methods, inheritance, and interfaces. And last, the students will review and refine their designs.
Lessons
    * 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
    * Creating a Draft Class Diagram from the Business Scenario
    * Adding Properties and Methods to the Class Diagram
    * Adding Inheritance to the Class Diagram
    * Adding Interfaces to the Class Diagram\
    * Refining the Design

After completing this module, students will be able to:
    * 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.
    * Diagram an initial class structure to fulfill business requirements.
    * Identify the properties and methods based on business requirements.
    * Diagram properties and methods to fulfill business requirements.
    * Describe approaches of designing inherited class structures based on business requirements.
    * Identify inherited class structures based on business requirements.
    * Add inherited structures to the proposed class diagram.
    * Critique the methods and property placement within the new class diagram.
    * Modify the methods and property placement within the new class diagram.
    * Describe approaches of designing interface structures from business requirements.
    * Identify interfaces based on business requirements.
    * Modify the class diagram to include interfaces.
    * Determine if a proposed design meets the business requirements.
    * Determine if a proposed design follows the principals of object-oriented application design.
    * Determine the effect of future usage on the completed class diagram.

Module 6: Implementing Delegates, Events, and Exceptions This module explains how to create and use delegates, events and exceptions to establish interclass communications.
Lessons
    * Introduction to Delegates
    * Implementing Delegates
    * Introduction to Events
    * Implementing Events
    * Introduction to Exceptions
    * Implementing Exceptions

Lab : Implementing Delegates, Events
    * Implementing a Delegate
    * Implementing a Custom Event
    * Implementing an Event Handler for System Events

Lab : Implementing Exceptions
    * Implement Custom Exceptions
    * Managing System Exceptions

After completing this module, students will be able to:
    * Explain the importance of interclass communications.
    * Describe the delegate model.
    * Explain how the delegate model can decouple class dependencies and increase code reusability.
    * Identify uses of delegates within a business scenario.
    * 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.
    * Apply the syntax used to handle a system-generated exception within a class.
    * Apply the syntax used to create a custom exception.
    * Apply the syntax used to throw a custom exception.
    * Implement a solution that uses exceptions to mitigate runtime errors.

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.
Lessons
    * Introduction to Class Interactions
    * Adding Interactions to a Design
    * Evaluating the Design
    * Introduction to Patterns

Lab : Designing Object-Oriented Collaboration
    * Design Interactions Using Methods
    * Design Interactions Using Events, Delegates, and Exceptions
    * Evaluating and Refining the Design
    * Evaluating a Pattern

After completing this module, students will be able to:
    * 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.
    * Determine the best communication method between classes given a business requirement.
    * Diagram class interactions.
    * Determine the overall effectiveness of the design in meeting the business requirements.
    * Evaluate the overall design against object-oriented design best practices.
    * Critique the design using evaluation techniques.
    * Describe design patterns and their importance to object-oriented design.
    * Determine the applicability of a design pattern to a business scenario.
    * Apply a design pattern to an existing solution.

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.
Lessons
    * 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
    * Creating a Component/Class Library
    * Deploying the Application
    * Updating the Component/Class Library
    * Deploying an Updated Component/Class Library

After completing this module, students will be able to:
    * Explain the importance of creating deployable units of software.
    * Describe the software development lifecycle with respect to upgrading and maintenance.
    * Determine uses of components and class libraries given a business scenario.
    * Prepare an application to use component/class libraries.
    * Create a component/class library.
    * Deploy a component/class library.
    * Manage versioning within an application using a component/class library.
    * Describe best practices for deploying component/class libraries.
    * Identify code that maximizes component/class library usage.
    * Explain how a component/class library meets best practices.

Additional Reading To help you prepare for this class, review the following resources:
    * Visual Studio 2005 Class Designer
    * Default Project Templates in Visual Studio
    * Web Application Projects Overview
    * Value Types in the Common Type System
    * Type Fundamentals
    * System.Collections.Generic Namespace
    * IConvertible Interface
    * XML Documentation Comments (C# Programming Guide)
    * Using branching statements to control code execution
    * Using looping statements to iterate through collections or repeat steps until a specified condition is met
    * Identifying syntax and logic errors
    * Accessing and managing data from a data source
Prerequisites & Certificates
Pre-Requisites

Before attending this course, students must have: * An understanding of the problem-solving techniques that apply to software development * An understanding of the following principles of software development: modern software development models typical phases of a software development lifecycle concepts of event-driven programming concepts of object-oriented programming creating use-case diagrams designing and building a user interface developing a structured application * A basic understanding of the following scripting techniques Web scripting techniques Macro scripting techniques Windows scripting techniques * Hands-on experience creating and implementing script code * A fundamental understanding of the .NET Framework - specifically, the purpose, function, and features of following .NET Framework components: the Common Language Runtime the .NET Framework class library * A conceptual understanding of the following .NET Framework topics: Common Type System - identifies the types supported by the common language runtime Metadata and Self-Describing Components - the .NET Framework simplifies component interoperation by allowing compilers to emit additional declarative information, or metadata, into all modules and assemblies Cross-Language Interoperability - managed objects created in different programming languages can interact with one another Assemblies in the Common Language Runtime - the concept of assemblies, which are collections of types and resources that form logical units of functionality (assemblies are the fundamental units of deployment, version control, reuse, activation scoping, and security permissions) Application Domains - application domains provide isolation between applications Runtime Hosts - the runtime hosts supported by the .NET Framework, including ASP.NET, Internet Explorer, and shell executables * A basic understanding of the Visual Studio IDE (Integrated Development Environment) * Hands-on experience using a version of Visual Studio .NET to achieve the following: Declaring and initializing typed variables using the Camel case naming convention Using arithmetic, relational, and logical operators in code statements

Certificates offered


Cancellation Policy
10 business day cancellation policy. if the course is confirmed and the student cancels within 10 days of the course, then they get charged and apply a credit for future courses. If they cancel outside of 10 business days, then there are no charges at all.
Map & Reviews
CTE Solutions
[ View Provider's Profile ]

Reviews
 

This course has not yet been rated by one of our members.

If you have taken a course through this vendor please log into your account and leave feedback for this vendor. You will be helping ensure our members get directed to the best training facilities.

Here are some reviews of the training vendor.
I realize that we are constantly dealing with technology, but I still think for a registration fee of almost $3,000, that a hardcover book should be included. I know that the option to print the book on a one-time basis exists.
Reviewed by 2016
no
Reviewed by 2016
The instructor was very knowledgeable and answered all questions. Jarod did an excellent job presenting.
Reviewed by 2015
The room was cold. I had to sit next to the space heater. It would be good to tell future patrons to dress warmly AHEAD of time. No suprises.
Reviewed by 2015
He was great and offered his contact info for further questions.
Reviewed by 2015
Howard was a fantastic instructor and the course was exactly what I required.
Reviewed by 2014
The trainer was excellent - the course exceeded my expectations.
Reviewed by 2014
This course provides an excellent overview and a bit of practice on the various functions of SharePoint 2013. I was disappointed at the number of exceedingly long breaks given after each module. I would have preferred less break time and more content to the course. Having never taken a SharePoint course with another provider, I don't know if this is the norm with all providers of just this one in particular.
Reviewed by 2014
I ranked the "Use of Technology" low because for Users who were remote the VM's that were setup were a little wonky. Could be very slow at times and then sometimes they needed to be refreshed to work properly with the lab. In some instances we couldn't follow along as replication would not occur fast enough and we would have our lab cut short (for us remote Users).
Reviewed by 2014
The instructor was good at remembering to acknowledge the online students even though he was facing a classroom of students also.
Reviewed by 2014
Insructor was not so good with the live examples. Also the handouts was not so useful
Reviewed by 2013
The trainer was excellent, very knowledgeable and had a lot of valuable experience to share. The problem was that there were way too many workshops that took too long and interfered with getting the maximum benefit from the instructor and the course.
Reviewed by 2013
This was quite informative. It was a great opportunity to have ‘real life’ discussions with certified PMs. The instructor had excellent examples and was able to share his PM experiences with us with concrete examples. In addition, this was a great opportunity to network with private sector/public sector PMs and develop a better appreciation of PM on both sides of the fence. Cheers, CL
Reviewed by 2013
no
Reviewed by 2013
I did not like the video format
Reviewed by 2013
As a remote attendee, it appeared the instructor paid attention to the "Attendee" and "Chat" windows only a few times throughout the day, so I was not confident that he would see if I sent a message or raised my hand during the course.
Reviewed by 2013
The chairs were not very comfortable and the material contained spelling and grammatical error (a few but still)as well as repetition of words.
Reviewed by 2013
Was a bit slow the last 1/2 day. Of course, for some, this was the last of a 4 day course (not just 2 days).
Reviewed by 2013
I really enjoyed the course and I learned a lot. The pace was excellent.
Reviewed by 2013
good!
Reviewed by 2013
The room was excellent on its own - less distraction and no noise around you. There was no direction to the room when I walked in and therefore was not sure if I was heading in the right direction. We were not provided with the direction that there was coffee and fridge on the 3rd floor, and the bathroom floor was dirty.
Reviewed by 2012
This course was great, very informative, had Lionel as instructor and he was also very good.
Reviewed by 2012
Instructor was eager to assist but lacked subject matter expertise. Course time management was very poor. Content provided could have been delivered effectively in a one day course.
Reviewed by 2012
Good Course, good trainer. All questions addressed equally and in a timely professional manner.
Reviewed by 2011
The course content was interesting; however, the instructor didn't have enough knowledge about Microsoft Sharepoint 2010 Development and wasn't able to answer questions without google search. In the future CTE needs to make sure the instructors have real on-hands experience and are highly trained in the technologies they are supposed be teaching.
Reviewed by 2011
need-to-train-a-group-banner

This course currently does not have any dates scheduled. Please call 1-877-313-8881 to enquire about future dates or scheduling a private, in house course for your team.

This page has been viewed 1246 times.