C# 5.0 Programmer's Reference

250 ❘ CHAPTER 11 OOP Concepts
You could probably replace all those methods with a single DrawShape method that draws and outlines
or fills various kinds of shapes depending on the parameters that it received. That would make the code
harder to understand because you would have to carefully study the parameters in a specific call to figure
out what it was doing. By using separate methods, the class makes the code obvious. If the program
calls DrawRectangle, it is drawing a rectangle.
Don’t Overgeneralize
Creating methods that try to do too much is sometimes called the “kitchen sink”
approach because the method contains everything “including the kitchen sink.”
Sometimes it’s easy to slip into this approach by trying to generalize a method
unnecessarily.
For example, suppose you need a method to print an invoice. Some other part of the
program needs to print an employee timesheet. Because they both involve printing,
you might try to make a single method to do both. That’s probably a mistake. The
two tasks both involve printing and may require common printer setup code, but
they don’t have much in common logically. (The fact that you might want to name
the method something confusing like PrintInvoiceOrTimeSheet is a hint that the
method is being asked to do too much.)
A better approach would be to make separate PrintInvoice and PrintTimeSheet
methods. If they share a lot of common code, then you can move that code into a
PrintMethods class that handles printing details. For example, that class might
provide SelectPrinter, InitializePrinter, and FinishPrinting methods.
When you are working on the PrintInvoice method, you will be focused on
printing, so calling SelectPrinter, InitializePrinter, and FinishPrinting
makes sense.
When other pieces of code need to print an invoice, they simply call PrintInvoice
and the details of setting up the printer are hidden.
Making methods perform a single, tightly focused task can be a difficult concept for beginning
programmers. Adding more features seems like it would give developers more power, so you might
think it would make their jobs easier. However, it often makes development more confusing and
difficult. Instead of thinking in terms of giving the developer more power, you should think about
the fact that this approach gives the developer more things to worry about and more ways to make
mistakes. Ideally, you should not expose any more features than the developer actually needs.
Inheritance
Inheritance lets you derive a child class from a parent class. The child class inherits all the properties,
methods, and events defined by the parent class. It can then modify, add to, or subtract from
the parent class. Making a child class inherit from a parent class is also called deriving the child
class from the parent, and subclassing the parent class to form the child class.
www.it-ebooks.info