public class SingaporeTaxCalculationStrategy : TaxCalculationStrategyBase
{
// Default constructor
public SingaporeTaxCalculationStrategy()
{
}

// Singapore may use tax calculation
// formula different from Japan
public override void CalculateTax()
{
base.orderInfo.TaxAmount =
base.orderInfo.OrderAmount * 10 / 100;
}
}

public class TaxCalculatorFactory
{
// Context objects uses this static method
// to create a specific tax calculator.
public static TaxCalculationStrategyBase
CreateTaxCalculator()
{
TaxCalculationStrategyBase calculator = null;

// We can retrieve a tax calculator name by using
// an application configuration file.
string calculatorName =
System.Configuration.ConfigurationSettings.AppSettings
["TaxCalculator"];

// We can add appropriate case statements
// to new calculators.
switch (calculatorName)
{
case "Japan":
calculator = new JapanTaxCalculationStrategy();
break;
case "Singapore":
calculator =
new SingaporeTaxCalculationStrategy();
break;
// Add more case statements here.
// case "Philippine":
// calculator =
// new PhilippineTaxCalculationStrategy();
// break;
}

return calculator;
}
}

public class TaxCalculatorFactory
{
public static TaxCalculationStrategyBase
CreateTaxCalculator()
{
// We assume the calculator class is located in
// the same assembly as the client.
// But we can easily load it from any assembly.
Assembly assembly = Assembly.GetExecutingAssembly();

// App.config: ["TaxCalculatorName"] values -
// "TaxCalculators.SingaporeTaxCalculatorStrategy"
string className =
System.Configuration.ConfigurationSettings.AppSettings
["TaxCalculatorName"];

// Use reflection to create an instance.
// Make sure that we cast the result of the
// CreateInstance method.
TaxCalculationStrategyBase calculator;
calculator =
(TaxCalculationStrategyBase)
assembly.CreateInstance(className);

return calculator;
}
}

public class OrderInfo
{
// Default Constructor
public OrderInfo()
{
}

// Context class contains or knows only
// the abstract class but has no knowledge
// of any concrete strategy classes.
protected TaxCalculationStrategyBase calculator;

// Provides a method to set a strategy
public void SetTaxCalculationStrategy
(TaxCalculationStrategyBase calculator)
{
this.calculator = calculator;
}

// Client can call this method for tax computation.
public void CalculateTax()
{
// Use the factory to create calculator instance.
this.calculator =
TaxCalculatorFactory.CreateTaxCalculator();

// Set the context of the strategy.
// This type of assignment is often called
// dependency injection.
calculator.SetTaxableInfo(this);

// This effectively sets the TaxAmount property.
calculator.CalculateTax();
}

// Other properties of the context class.
private int orderNo;
public int OrderNo
{
get
{
return orderNo;
}
set
{
orderNo = value;
}
}

private double orderAmount;
public double OrderAmount
{
get
{
return orderAmount;
}
set
{
orderAmount = value;
}
}

private double taxAmount;

// This method will be called by the concrete strategy
// using dependency injection
// or otherwise also termed "inversion of control"
public double TaxAmount
{
get
{
return taxAmount;
}
set
{
taxAmount = value;
}
}

public double TotalAmount
{
get
{
return orderAmount + taxAmount;
}
}

public partial class OrderForm : Form
{
public OrderForm()
{
InitializeComponent();
}

private void calculateButton_Click
(object sender, EventArgs e)
{

// Instantiate the context object
OrderInfo orderInfo = new OrderInfo();

// Assign properties
orderInfo.OrderNo = 9999;
orderInfo.OrderAmount =
double.Parse(this.orderAmountTextBox.Text);

// Call tax calculation
orderInfo.CalculateTax();

// Show results.
this.lblOrderAmount.Text =
orderInfo.OrderAmount.ToString();
this.lblTaxAmount.Text =
orderInfo.TaxAmount.ToString();

}
}

* Design Patterns Elements of Reusable Object Oriented Software by Gamma, Helm, Johnson, Vlissides