only CalculateTaxToPay（） assigns the data member。 The purpose of the data member is to provide information about the operation CalculateTaxToPay（） without giving the exact details of the operation。 The idea behind _calculatedTaxable and the declaration of CalculateTaxToPay（） is to provide a mechanism where the derived class does not need to calculate things again。 Consider the example of a country where； if your taxable ine is above 400 currency units； a surtax of 10 currency units is calculated。 You don’t know what your taxable ine is until the function CalculateTaxToPay（） is executed； and that function returns only the total payable taxes。 So how do you know if you should apply the surtax in this situation？ One solution is to reverse calculate the payable taxes； but that would involve quite a few additional steps。 An easier solution is to write some code in the base class method of CalculateTaxToPay（） that stores the taxable ine so the subclass has access to it。 The original implementation of CalculateTaxToPay（） does not consider a surtax； so the derived class must contain that functionality。 Since CalculateTaxToPay（） can be overridden without the data member _calculatedTaxable； the derived class would need to implement the functionality in the base class to calculate whether or not the surtax applies。 Following is an sample derived class implementation of the tax engine for such a situation； stored in a namespace called Surtax； to distinguish it from the base functionality。 Namespace Surtax Friend Class TaxEngine Inherits BaseTaxEngine Public Overrides Function CalculateTaxToPay（ByVal account As ITaxAccount） _ As Double Dim taxToPay As Double = MyBase。CalculateTaxToPay（account） If _calculatedTaxable 》 400 Then taxToPay = taxToPay ＋ 10 End If Return taxToPay End Function Public Overrides Function CreateTaxAccount（） As ITaxAccount Throw New Exception（〃The method or operation is not implemented。〃） End Function End Class End Namespace In the implementation of CalculateTaxToPay（）； we replace the Overridable keyword with Overrides； implying that the functionality of TaxEngine replaces the functionality of BaseTaxEngine。 Since our fictional country calculates the basic tax similarly to most countries； the functionality of BaseTaxEngine。CalculateTaxToPay（） can be used。 Thus； the first line of TaxEngine。 CalculateTaxToPay（） is MyBase。CalculateTaxToPay（）； meaning the base class （BaseTaxEngine） method CalculateTaxToPay（） is called。 …………………………………………………………Page 199…………………………………………………………… CH AP T E R 7 ■ L E AR N IN G AB O U T CO M P O N E N TS AN D C L AS S H I E R AR C HI E S 177 Calling the base class results in calculating a basic tax to pay amount。 We need to figure out if a surtax applies； and that is where the protected data member _calculatedTaxable es into play。 Having called BaseTaxEngine。CalculateTaxToPay（）； the data member _calculatedTaxable is assigned and contains the amount that is being taxed。 Thus； TaxEngine。CalculateTaxToPay（） can make a decision if more than 400 currency units have been earned。 And if so； then the vari able taxToPay is incremented with another 10 currency units。 Had _calculatedTaxable not existed； TaxEngine。CalculateTaxToPay（） would have needed to call the base class functionality to get the basic tax rate； and then recalculate the taxable monies to figure out if the surtax applied。 ■Note When you use Overrides with methods； you are saying that you need something special。 This does not imply that the base class functionality will be called。 It implies that you might call the base class functionality and perform some additional operations。 Thus； when designing base class functionality； it is important to track calculations or operations using protected data members。 The data members avoid having derived classes perform the same operations multiple times； slowing down the application and avoiding potential errors。 USING NAMESPACES Namespaces are used to define classes； interfaces； and structures that belong together。 In this chapter’s example； there is an American tax engine； a Swiss tax engine； and so on。 For organizational purposes； each should have its own namespace。 Sometimes you might even create a custom assembly for each set of inter face implementations； but you would still need to create a namespace。 Creating a namespace is independent of the fact of whether or not you create a separate assembly。 In the examples； I use namespaces like Surtax and Canada。 Whenever you create a class or a module； or some other type； you can embed the type within the namespace。 Then to use the newly defined namespaces in code pieces that are not part of the namespace； use the Imports keyword。 Abstracting Instantiations with Factories Take a good look at the scope declaration of the tax engine shown earlier and pare it with the scope declaration for the ITaxEngine interface。 What you will notice is that ITaxEngine is declared as Public scope； as is BaseTaxEngine； and TaxEngine is declared as Friend。 Going back to our project structure； this scope declaration implies that any reference to LibTax will see the interface ITaxEngine and BaseTaxEngine； but not TaxEngine。 For example； the following