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.
Located outside our service areas? No problem. We also offer this course in the Live
Online format. If you prefer face-to-face interaction, we offer hotel/airfare packages that are extremely inexpensive. Quite often, we bundle the hotel stay into the cost of the class for no extra charge.
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
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
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
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
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.
