Foundations of Object-Oriented Programming Using .NET 2.0 Patterns

This book is an explanation of design patterns as applied to the .NET 2.0 Framework. Some of the patterns are from Design Patterns: Elements of Reusable Object-Oriented Software, and others are from other sources. The focus of this book is not to explicitly define the patterns, but to illustrate the patterns in the context of using them with a programming language like C#, because the original design patterns were illustrated using C++, and there are major differences between that language and .NET and C#.

Why Patterns?
You might be wondering, “Why this book, and why patterns?” Oddly enough, the idea occurred to me while training some students on how to use design patterns. The students were doing their exercises, and I saw one student in particular write code in which the base type was a class and not an interface. I asked him why he was writing code like that, and his response was, “Because that is what I have been doing all this time.” The student’s method was wrong, but his response revealed an interesting perspective: why use an interface when a base class is good enough? Right then, it hit me like a ton of bricks: object-oriented programming, or OOP, can be easier understood when one is first taught patterns.

When learning traditional OOP techniques, you are taught about shapes, squares, and other abstract topics. You learn about how a class is responsible for its own data, and how classes implement responsibilities. The problem with this form of learning is that it explains object-oriented programming, but it does not explain how to solve a problem with concrete solutions. For example, how do you instantiate a type, pass its references to another class, and persist that information to a medium? The problem with traditional object-oriented programming is that it gives vague guidance in implementing a solution.

Patterns are different in that they give you a predefined form of what to do and when. Consider it as follows: you want to learn how to bake a cake. You know a cake is made of flour, eggs, milk, baking powder, and perhaps a few additional ingredients, yet not all cakes are equal. Add too much baking powder, and your cake will rise too much. Add too many eggs, and your cake will taste like an omelet. Object-oriented programming is like baking a cake: you know the ingredients, and know what the ingredients do, but have no idea of the proportion of the ingredients or steps to make a cake. Just as a good recipe will help you turn your ingredients into a delicious cake, patterns will help you convert your code into efficient programs.

TABLE OF CONTENT:
Chapter 1 Essentials of Object-Oriented Programming
Chapter 2 Logging, Errors, and Test-Driven Development
Chapter 3 Defining the Foundation
Chapter 4 Application Architecture
Chapter 5 Implementing Component Groupings
Chapter 6 Writing Algorithms
Chapter 7 Efficient Code
Chapter 8 Data Persistence
Chapter 9 Refactoring to Patterns

Download Here

Password: ganelon