50211 : Creating Object-Oriented Solutions Using C#

Code: 50211
Category: Microsoft Visual Studio | .NET Development
Course duration: 4 days
Price:

50211 : Creating Object-Oriented Solutions Using C#

About this Course
Working with an object-oriented language is a must have skill in today's business world. Most introductory language courses focus on the syntax, libraries, and tools of the language but fail to explain the most important aspect: How to effectively use the language to solve business problems.
This four-day instructor-led course provides students with the knowledge, principles and skills to design software solutions using Visual C# and Microsoft Visual Studio. Along the way, you will use the tools, learn the syntax, and gain experience with the core libraries that you will use every day in your development. The course is heavily hands-on, and provides the students ample opportunity to practice using the knowledge and skills in the context of creating an application. Students will be exposed to principles and best practices for creating maintainable, extensible software. Improving's instructors brings real-world experience and insight to the classroom, and students walk away with knowledge, experience, and references to enhance retention.
Audience Profile
This course is intended for developers with some prior programming experience who are interested in learning to program well using C# and Microsoft.NET.
At Course Completion
After completing this course, students will be able to:
  • Explain Coupling and Cohesion
  • Use polymorphism to create flexible solutions
  • Explain the concepts of generalization and specialization
  • Understand when to and [more importantly] when not to use inheritance
  • Implement inheritance and use interfaces in C#
  • Assign responsibilities to classes to make the solution flexible, extensible, and maintainable
  • Select candidate objects and classes
  • Define classes, methods, and properties
  • Group classes into namespaces and assemblies
  • Debug and troubleshoot a .NET application
  • Create unit tests using Microsoft MSTest testing framework
  • Create Visual Studio Solutions and Projects
  • Manage project and library references in Visual Studio
  • Use ADO.NET to connect to a database
  • Create a basic Windows Forms or WPF application
  • Create a basic ASP .NET web page

Course Outline

Module 1: Using Visual Studio

This module walks students through the basic features of Visual Studio.NET 2010, giving them the necessary foundation necessary to get started with their class project.

Lab : Exploring Visual Studio

After completing this module, students will be able to:
  • Create a Solution.
  • Create a Console Project.
  • Create a Library Project.
  • Create an Unit Test.
  • Create a Class.
  • Create a Main method.
  • Debug an application.
  • Set breakpoints in your code.
  • Set exception breakpoints.
  • Attach to a running project.
  • Reference another project.
  • Reference a third-party library.
  • Write text to the console.
  • Use an if statement.

Module 2: Control Structures

This module explains all the control structures available in C#, such as operators, expressions, and switch statements.

Lessons

  • Comparison Operators and Boolean Expressions
  • If-Else Statements
  • Switch-Case Statements
  • Ternary Operator
  • Is Operator

Lab : Control Structures

After completing this module, students will be able to use:
  • Comparison Operators and Boolean Expressions.
  • If-Else Statements.
  • Switch-Case Statements.
  • Ternary Operator.
  • Is Operator.

Module 3: Object Orientation

This module introduces all the object-orientation concepts that will be used throughout the course.

Lessons

  • Attributes
  • Composition
  • Encapsulation
  • Association
  • Aggregation
  • Inheritance
  • Abstraction
  • Responsibility
  • Messaging
  • Polymorphism
  • Collaboration
  • Interfaces

Lab : Object-Oriented Concepts

After completing this module, students will be able to describe the following object-oriented concepts:
  • Attributes.
  • Composition.
  • Encapsulation.
  • Association.
  • Aggregation.
  • Inheritance.
  • Abstraction.
  • Responsibility.
  • Messaging.
  • Polymorphism.
  • Collaboration.
  • Interfaces.

Module 4: Test-Driven Development

This module introduces all the object-orientation concepts that will be used throughout the course.

Lessons

  • Automated Unit Testing
  • Unit Testing Components
  • Test-Driven Development
  • TDD Mantra – Red, Green, Refactor
  • Behavior-Driven Development

Lab : TDD Calculator

  • Create a Solution
  • Implement a failing test
  • Make test pass
After completing this module, students will be able to:
  • Create Automated Unit Tests.
  • Describe Test-Driven Development.
  • Follow the TDD Mantra – Red, Green, Refactor.
  • Describe Behavior-Driven Development.

Module 5: Defining Classes

This module gradually introduces all the components of a C# Class by building one step-by-step.

Lessons

  • Class Definition
  • Access Modifiers
  • Fields
  • Properties
  • Methods
  • Main Method
  • Static Members
  • Variables
  • Instantiating Classes
  • Constructors
  • The ‘this’ Keyword
  • Namespaces
  • Types and Variables

Lab : Blog – Post an Entry

  • Implement a Test for ‘Post an Entry’
  • Make Test Pass
After completing this module, students will be able to:
  • Create a class, the fundamental unit of compilation for .NET.

Module 6: Guard Clauses and Throwing Exceptions

This module explains the basics of throwing exceptions and what happens to the call stack when an exception is thrown.

Lessons

  • Exceptions
  • Throw statements
  • Guard clauses

Lab : Blog – Guard Clauses

  • Validate input by adding a guard clause
After completing this module, students will be able to:
  • Create Exceptions.
  • Throw Exceptions.
  • Validate Parameters through Guard Clauses.

Module 7: Arrays and Iteration

This module introduces arrays in the context of iteration and the different ways to loop.

Lessons

  • Arrays
  • Iteration Statements (for, while, do)

Lab : Blog – Arrays and Iteration

  • Create a post with categories
  • BONUS Step – Params Keyword
  • Reading posts
After completing this module, students will be able to:
  • Create Arrays.
  • Use the for, foreach, while, and do iteration statements.

Module 8: Lists

This module introduces Lists as a better alternative to Arrays (from the previous module).

Lessons

  • The problem with Arrays
  • ArrayList
  • Generics
  • Iteration Statements with Lists

Lab : Blog – Extending to a Blog Site

  • Host multiple blogs
  • Find posts by category of blog
  • BONUS Step – Indexers
  • Find site posts by category
  • Comment on a post
After completing this module, students will be able to:
  • Describe the differences between Arrays and Lists.
  • Use Generics.
  • Loop through Lists.

Module 9: Interfaces

This module introduces Interfaces, as a way to achieve polymorphism, by first demonstrating common uses of popular C# interfaces before showing how to define your own.

Lessons

  • Implementing an Interface
  • Defining Interfaces
  • Naming Convention
  • Properties, Methods, and Events

Lab : Interfaces

  • Demonstration of the “Extract Interface” Refactoring in Visual Studio
After completing this module, students will be able to:
  • Achieve polymorphism through the use of interfaces.
  • Define custom interfaces.
  • Implement multiple interfaces in a class.

Module 10: Delegates

This module introduces Delegates as a way to define and execute a method in a polymorphic fashion without modifying the class.

Lessons

  • Defining Delegates
  • Delegates as Parameters
  • Anonymous
  • System.Delegate
  • System.MulticastDelegate
  • Static methods

Lab : Delegates

  • Refactor to Delegates
  • BONUS step – Lambda Expressions
  • Refactoring to Visitor pattern
After completing this module, students will be able to:
  • Reference methods through Delegates.
  • Anonymously declare Delegates.
  • Reference local variables from Delegates.

Module 11: Events

This module introduces C# Events as a mechanism for decoupling objects.

Lessons

  • Declaring Events
  • Registering interest in an Event
  • Observer pattern

Lab : Events

  • Subscribe to Blog
After completing this module, students will be able to:
  • Register for Events.
  • Declare a custom Event.
  • Describe how Events in C# provide looser coupling.

Module 12: Generalization, Specialization, and Inheritance using C#

This module spends some quality time modeling and exploring different examples of inheritance, both good and bad.

Lessons

  • Generalization, Specialization
  • 100% Rule, Is-A Rule, LSP
  • Constructor Chaining
  • Virtual, abstract, override, sealed, interface, base, this, protected
  • UML representations

Lab : Blog – Inheritance

  • Include Comments in search results
  • Refactor
  • Implement Feature
After completing this module, students will be able to:
  • Distinguish when inheritance should be used (or not used).
  • Define virtual, abstract, override, sealed, interface, base, this, protected.
  • Chain Constructors

Module 13: Assigning Resposibilities

This module addresses proper responsibility assignment across objects by introducing several important principles and rules.

Lessons

  • Coupling
  • Cohesion
  • Indirection
  • Law of Demeter
  • Expert
  • Stability and Variability
After completing this module, students will be able to:
  • Tell between good and bad responsibility assignment.
  • Apply principles for better responsibility assignment.

Module 14: Custom Iterators

This module is a quick introduction to custom iterators, IEnumerable and the yield statement.

Lessons

  • Custom Iterators
  • IEnumerable
  • The yield statement

Lab : IENUMERABLE

  • Create EntryList for Blog
After completing this module, students will be able to:
  • Do selective iteration using custom iterators

Module 15: IDisposable

This module touches on IDisposable and why you would want to use it.

Lessons

  • .NET memory model
  • The using statement
  • IDisposable pattern
  • Finalization Queue
After completing this module, students will be able to:
  • Better understand the .NET memory model.
  • Use IDisposable and the using statement to manage streams and memory.

Module 16: Handling Exceptions

This module expands on handling exceptions, which were covered briefly in an earlier chapter.

Lessons

  • try
  • catch
  • finally
  • throw
After completing this module, students will be able to:
  • Effectively handle exceptions using try, catch, finally, and throw.
  • Identify some common mistakes that are made when handling exceptions.

Module 17: File I/O

This module introduces some basic File I/O in .NET.

Lessons

  • FileStream
  • StreamReader
  • StreamWriter

Lab : Blog – Exporting the Blog

  • Save Blog to file as CSV
After completing this module, students will be able to:
  • Read and write data to a file on the local file system.

Module 18: XML Serialization

This module provides a brief introduction to XML Serialization in .NET.

Lessons

  • XML Serializer
  • Serialization attributes

Lab : Blog – Exporting the Blog

  • Export Blog as XML
After completing this module, students will be able to:
  • Use the XML Serializer to export and import their object to and from XML.
  • Identify some different attributes and settings for XML Serialization.

Module 19: Modeling Domains using UML

This module gets in to a little more detail on communicating designs using the Unified Modeling Language (UML).

Lessons

  • Classes
  • Attributes and Methods
  • Access Modifiers
  • Associations
  • Navigability
  • Cardinality / Multiplicity

Lab : Improve Models

  • Study existing models
  • Improve models
After completing this module, students will be able to:
  • Use UML to communicate designs

Module 20: Modeling Smells and Refactorings

This module is designed to start a discussion on looking for and finding problems in models.

Lessons

  • Coupling and Cohesion
  • Refactorings
  • Smells

Lab : Refactoring

  • Identify smells in the current implementation
  • Apply refactorings
After completing this module, students will be able to:
  • Identify smells in a model.
  • Match smells to refactorings.

Module 21: On Process

This module touches on iterative and agile processes and practices while exploring how they are such a great match with object-oriented technologies.

Lessons

  • Waterfall SDLC
  • Scrum
  • Iterative/Incremental Development
  • Test-Drive Development
After completing this module, students will be able to:
  • Point out the benefits of iterative and incremental development.

50211

Course Reviews

No reviews found for this course.

Be the first to write a review