eXtreme .NET: Introducing eXtreme Programming Techniques to .NET Developers [Electronic resources] نسخه متنی

1.

Open the Currency Converter solution in Visual Studio.

2.

Examine the code and the form. Notice that it is a very simple program with a basic form. Things to notice include the following:

All the functionality occurs in the form code.

There are no tests.

There is not much else to it!

3.

First we need some tests. We cannot refactor without validating we have not changed behavior. This presents a dilemma: There are no tests to start with, so how do we know we are not refactoring a bug? Also all the code is tightly tied into the GUI; this makes it hard to test and write tests for. Should we move the code away from the GUI first, or should we attempt to write some clever tests to test the code in the GUI layer? As with many real-world scenarios, we are going to compromise. We will write tests for the code we are going to extract from the GUI layer. Then we will get the tests to pass as we move the code. First we need to add a reference to NUnit in the References section, so right-click References, select Add Reference, and browse for the Nunit.Framework.dll file.

4.

We will create a test fixture class to hold our tests. Right-click the project and select Add / Add Class from the pop-up menu. We will name this class ConvertTests.cs.

5.

Edit the class code so that it uses the Nunit.Framework namespace, and add the TestFixture attribute to the class.

using System;
using NUnit.Framework;
namespace CurrencyConverterCS
{
[TestFixture]
public class ConvertTests
{
}
}

6.

Now we can start writing some tests. The first test will be a breadth test that enables us to start refactoring some functionality with the confidence that we haven't broken anything.

[Test]
public void ConversionBreadth()
{
decimal result;
decimal amount;
CurrencyType fromCur;
CurrencyType toCur;
amount = 100.0M;
fromCur = CurrencyType.US;
toCur = CurrencyType.US;
result = MainForm.CurrencyConvert(amount,
fromCur, toCur);
Assert.AreEqual(100.0M, result,
"US to US should be no change");
fromCur = CurrencyType.UK;
toCur = CurrencyType.UK;
result = MainForm.CurrencyConvert(amount,
fromCur, toCur);
Assert.AreEqual(100.0M, result,
"UK to UK should be no change");
fromCur = CurrencyType.AUS;
toCur = CurrencyType.AUS;
result = MainForm.CurrencyConvert(amount,
fromCur, toCur);
Assert.AreEqual(100.0M, result,
"AUS to AUS should be no change");
decimal expected;
fromCur = CurrencyType.US;
toCur = CurrencyType.AUS;
result = MainForm.CurrencyConvert(amount,
fromCur, toCur);
expected = amount * 2;
Assert.AreEqual(expected, result,
"US to AUS is incorrect");
fromCur = CurrencyType.UK;
toCur = CurrencyType.AUS;
result = MainForm.CurrencyConvert(amount,
fromCur, toCur);
expected = amount / 0.5M * 2;
Assert.AreEqual(expected, result,
"UK to AUS is incorrect");
}

7.

As you have probably worked out, this won't compile. We have added a new enumerated type called CurrencyType and are calling a method on the MainForm that doesn't exist. We need to go back to the MainForm and create these. In the MainForm above the class, we add the CurrencyType enum.

public enum CurrencyType
{
US,
AUS,
UK,
}

8.

Next we add the CurrencyConvert method to the MainForm code. We need to make it static or shared so that it can be accessed from the test code. This isn't ideal, but we can work on refactoring away from that later.

public static decimal CurrencyConvert(decimal amount,
CurrencyType fromCur, CurrencyType toCur)
{
return 0;
}

9.

Now you can compile and run the test. It will fail because the method has no body. We need to move the body from the button click.

public static decimal CurrencyConvert(decimal amount,
CurrencyType fromCur, CurrencyType toCur)
{
decimal converted = 0.0M;
decimal initial = 0.0M;
initial = amount;
converted = initial;
if (fromCur == CurrencyType.UK)
{
converted = initial / UKInUS;
}
else if(fromCur == CurrencyType.AUS)
{
converted = initial / AusInUS;
}
if (toCur == CurrencyType.UK)
{
converted = converted * UKInUS;
}
else if(toCur == CurrencyType.AUS)
{
converted = converted * AusInUS;
}
return converted;
}

10.

This will not compile because the UKInUS and AusInUS variables are not static, so we need to change the declaration of these, too.

private static decimal AusInUS = 2;
private static decimal UKInUS = 0.5M;

11.

Now compile and run the test in the NUnit GUI (or console if you prefer); the test should pass.

12.

We can now call this new method from the button click event.

private void ConvertButton_Click
(object sender, System.EventArgs e)
{
decimal converted = 0.0M;
decimal initial = 0.0M;
CurrencyType fromCur = CurrencyType.US;
CurrencyType toCur = CurrencyType.US;
initial = Convert.ToDecimal(Amount.Text);
if (FromUK.Checked)
{
fromCur = CurrencyType.UK;
}
else if (FromAUS.Checked)
{
fromCur = CurrencyType.AUS;
}
if (ToUK.Checked)
{
toCur = CurrencyType.UK;
}
else if (ToAus.Checked)
{
toCur = CurrencyType.AUS;
}
converted = CurrencyConvert(initial, fromCur, toCur);
Result.Text = converted.ToString();
}

1.

Before we get started on the code in the new class, we will define some behaviors of the class in a test. This documents what we are expecting the class to do. Back in the ConvertTests class, we add a new method:

[Test]
public void ConvertTo()
{
ConvertibleCurrency currency;
decimal result;
decimal expected;
currency = new ConvertibleCurrency(
CurrencyType.US, 100.0M);
result = currency.ConvertTo(CurrencyType.US);
Assert.AreEqual(100.0M, result,
"US to US should be no change");
currency = new ConvertibleCurrency(
CurrencyType.AUS, 100.0M);
result = currency.ConvertTo(CurrencyType.UK);
expected = 100.0M / 2 * 0.5M;
Assert.AreEqual(expected, result,
"AUS to UK incorrect result");
}

2.

We have now defined the constructor of the new class and one method, so let's add those to the class.

public ConvertibleCurrency(CurrencyType type, decimal val)
{
}
public decimal ConvertTo(CurrencyType type)
{
decimal converted = 0.0M;
return converted;
}

3.

Compile and run the tests; the latest test will (as expected) fail. We need to implement the constructor and move the code from the MainForm static method into the class.

public class ConvertibleCurrency
{
private decimal amount;
private CurrencyType currency;
public ConvertibleCurrency(CurrencyType type, decimal val)
{
currency = type;
amount = val;
}
public decimal ConvertTo(CurrencyType type)
{
decimal converted = amount;
if (currency == CurrencyType.UK)
{
converted = converted / UKInUS;
}
else if(currency == CurrencyType.AUS)
{
converted = converted / AusInUS;
}
if (type == CurrencyType.UK)
{
converted = converted * UKInUS;
}
else if(type == CurrencyType.AUS)
{
converted = converted * AusInUS;
}
return converted;
}
}

4.

The code will not compile yet because the UKInUS and AusInUS variables cannot be reached from this class; they need to be moved into the class, but they no longer need to be static.

private decimal AusInUS = 2;
private decimal UKInUS = 0.5M;

5.

Now compile and run the tests; they should pass. We are now ready to use this class from the MainForm code.

6.

Change the CurrencyConvert method in the MainForm as follows.

public static decimal CurrencyConvert(decimal amount,
CurrencyType fromCur, CurrencyType toCur)
{
decimal converted = 0.0M;
ConvertibleCurrency currency =
new ConvertibleCurrency(fromCur, amount);
converted = currency.ConvertTo(toCur);
return converted;
}

7.

You can also delete the UKInUS and AusInUS variables from the MainForm code. These variables are now declared and used in the ConvertibleCurrency class.

8.

Now would also be a good time to move the CurrencyType enum declaration into the ConvertibleCurrency class file.

9.

Compile the project and run the tests. The tests should pass, and the program should still function as before. We have encapsulated the behavior of the currency converter into a class and reduced the functionality in the GUI. This helps with testing and with porting the program to another user interface such as the Web.

1.

Now compile and run the tests again; they should pass. The program should still function as before.

2.

We can now turn our attention to the code in the ConvertibleCurrency class. The if-else blocks of code that convert the amount to U.S. dollars and then to the currency requested look like good candidates for extraction. We'll start by taking the block that converts the amount to U.S. dollars and create a method called ConvertToUS.

private decimal ConvertToUS()
{
decimal converted = 0.0M;
converted = amount;
if (currency == CurrencyType.UK)
{
converted = converted / UKInUS;
}
else if (currency == CurrencyType.AUS)
{
converted = converted / AusInUS;
}
return converted;
}

Then replace the code in the ConvertTo function so it looks like this:

public decimal ConvertTo(CurrencyType type)
{
decimal converted = ConvertToUS();
if (type == CurrencyType.UK)
{
converted = converted * UKInUS;
}
else if(type == CurrencyType.AUS)
{
converted = converted * AusInUS;
}
return converted;
}

Compile and run the tests to validate we haven't broken anything.

3.

We can do the same with the second if-else block by creating a function called ConvertFromUS.

private decimal ConvertFromUS(CurrencyType type,
decimal USAmount)
{
decimal converted = 0.0M;
converted = USAmount;
if (type == CurrencyType.UK)
{
converted = converted * UKInUS;
}
else if (type == CurrencyType.AUS)
{
converted = converted * AusInUS;
}
return converted;
}

4.

Again we need to change the code in the ConvertTo method so that it calls this new method.

public decimal ConvertTo(CurrencyType type)
{
decimal converted = ConvertToUS();
converted = ConvertFromUS(type, converted);
return converted;
}

5.

Compile and run the tests. The fact they work shows us we haven't made any changes to the functionality, even though we have changed the structure of the code in a fairly big way.

1.

We will start by using Replace Type Code with State/Strategy. The CurrencyType enumerated type can be replaced with a simple object hierarchy. We'll start by coding the hierarchy.

public abstract class BaseCurrency
{
public abstract decimal InUS
{
get;
}
}
public class USCurrency : BaseCurrency
{
public override decimal InUS
{
get{ return 1; }
}
}
public class UKCurrency : BaseCurrency
{
public override decimal InUS
{
get{ return 0.5M; }
}
}
public class AUSCurrency : BaseCurrency
{
public override decimal InUS
{
get{ return 2; }
}
}

2.

Check it compiles and the tests still run. They should because we haven't yet touched any of the code being called. We will do this now by replacing the use of the enumerated type in the CovertibleCurrency class with the class types we have just created.

public class ConvertibleCurrency
{
private decimal amount;
private BaseCurrency currency;
public static decimal CurrencyConvert(decimal amount,
BaseCurrency fromCur, BaseCurrency toCur)
{
decimal converted = 0.0M;
ConvertibleCurrency currency =
new ConvertibleCurrency(fromCur, amount);
converted = currency.ConvertTo(toCur);
return converted;
}
public ConvertibleCurrency(BaseCurrency type, decimal val)
{
currency = type;
amount = val;
}
public decimal ConvertTo(BaseCurrency type)
{
decimal converted = ConvertToUS();
converted = ConvertFromUS(type, converted);
return converted;
}
private decimal ConvertToUS()
{
decimal converted = 0.0M;
converted = amount / currency.InUS;
return converted;
}
private decimal ConvertFromUS(BaseCurrency type,
decimal USAmount)
{
decimal converted = 0.0M;
converted = USAmount * type.InUS;
return converted;
}
}

3.

Pay careful attention to what has changed in the ConvertibleCurrency class. The if-else statements have disappeared through the use of the hierarchy. The replacement of the enumerated type with a hierarchy has enforced a better code base. The two member variables AusInUS and UKInUS are no longer needed; they have also been deleted.

If we now compile this project, we should find all the places that call the class that also need to be changed; this will be in the MainForm and in the tests. The tests are an area of the code where we need to tread especially carefully. Changing the test code could cause us to inadvertently break one of the tests. The methods in the test code should now read as follows.

[Test]
public void ConversionBreadth()
{
decimal result;
decimal amount;
BaseCurrency fromCur;
BaseCurrency toCur;
amount = 100.0M;
fromCur = new USCurrency();
toCur = new USCurrency();
result = ConvertibleCurrency.CurrencyConvert(amount,
fromCur, toCur);
Assert.AreEqual(100.0M, result,
"US to US should be no change");
fromCur = new UKCurrency();
toCur = new UKCurrency();
result = ConvertibleCurrency.CurrencyConvert(amount,
fromCur, toCur);
Assert.AreEqual(100.0M, result,
"UK to UK should be no change");
fromCur = new AUSCurrency();
toCur = new AUSCurrency();
result = ConvertibleCurrency.CurrencyConvert(amount,
fromCur, toCur);
Assert.AreEqual(100.0M, result,
"AUS to AUS should be no change");
decimal expected;
fromCur = new USCurrency();
toCur = new AUSCurrency();
result = ConvertibleCurrency.CurrencyConvert(amount,
fromCur, toCur);
expected = amount * 2;
Assert.AreEqual(expected, result,
"US to AUS is incorrect");
fromCur = new UKCurrency();
toCur = new AUSCurrency();
result = ConvertibleCurrency.CurrencyConvert(amount,
fromCur, toCur);
expected = amount / 0.5M * 2;
Assert.AreEqual(expected, result,
"UK to AUS is incorrect");
}
[Test]
public void ConvertTo()
{
ConvertibleCurrency currency;
decimal result;
decimal expected;
currency = new ConvertibleCurrency(
new USCurrency(), 100.0M);
result = currency.ConvertTo(new USCurrency());
Assert.AreEqual(100.0M, result,
"US to US should be no change");
currency = new ConvertibleCurrency(
new AUSCurrency(), 100.0M);
result = currency.ConvertTo(new UKCurrency());
expected = 100.0M / 2 * 0.5M;
Assert.AreEqual(expected, result,
"AUS to UK incorrect result");
}

4.

In the MainForm code, the button click code should now look like this.

private void ConvertButton_Click
(object sender, System.EventArgs e)
{
decimal converted = 0.0M;
decimal initial = 0.0M;
BaseCurrency fromCur;
BaseCurrency toCur;
initial = Convert.ToDecimal(Amount.Text);
if (FromUK.Checked)
{
fromCur = new UKCurrency();
}
else if (FromAUS.Checked)
{
fromCur = new AUSCurrency();
}
else
{
fromCur = new USCurrency();
}
if (ToUK.Checked)
{
toCur = new UKCurrency();
}
else if (ToAus.Checked)
{
toCur = new AUSCurrency();
}
else
{
toCur = new USCurrency();
}
converted = ConvertibleCurrency.CurrencyConvert(
initial, fromCur, toCur);
Result.Text = converted.ToString();
}

5.

Notice that we have actually added an extra else condition to the if-else block. The fact that we have replaced the enum with a hierarchy means we no longer can have a default value; this is forcing our code to be more type safe. This lack of type safety might have been the cause of a bug in a later stage, but we have prevented this bug from being born.

6.

Compile and run the tests. We should be back to a working state and ready to move forward to the last step.

1.

Because we are now confident that we do not need the enumerated type anymore, we can delete it from the code. However, there is still a small whiff in the MainForm code. Although we've eliminated the if-else blocks of code in the ConvertibleCurrency class, they still linger in the button click method. To remove them, we can use the same hierarchy we have already created. We can also take advantage of a feature of the .NET Framework; if you bind a list of objects to a list box or a combo box, the box will display each object using its ToString method. We will therefore override the ToString method in our concrete currency type classes.

public class USCurrency : BaseCurrency
{
public override decimal InUS
{
get{ return 1; }
}
public override string ToString()
{
return "US$";
}
}
public class UKCurrency : BaseCurrency
{
public override decimal InUS
{
get{ return 0.5M; }
}
public override string ToString()
{
return "UK£";
}
}
public class AUSCurrency : BaseCurrency
{
public override decimal InUS
{
get{ return 2; }
}
public override string ToString()
{
return "AU$";
}
}

2.

Return to the MainForm in the design view and replace the From and To radio button groups with combo boxes (called fromCombo and toCombo), as shown in Figure 5-1.

3.

Double-click the form to generate the MainForm_Load method. In here we will create a list of the concrete currency types and bind them to the combo boxes.

private void MainForm_Load(object sender, System.EventArgs e)
{
ArrayList currencyList = new ArrayList();
currencyList.Add(new UKCurrency());
currencyList.Add(new USCurrency());
currencyList.Add(new AUSCurrency());
fromCombo.DataSource = currencyList;
toCombo.DataSource = currencyList.Clone();
}

4.

In the button click event, we now need to get the selected object from the combo boxes.

private void ConvertButton_Click
(object sender, System.EventArgs e)
{
decimal converted = 0.0M;
decimal initial = 0.0M;
BaseCurrency fromCur;
BaseCurrency toCur;
initial = Convert.ToDecimal(Amount.Text);
fromCur = fromCombo.SelectedItem as BaseCurrency;
toCur = toCombo.SelectedItem as BaseCurrency;
converted = ConvertibleCurrency.CurrencyConvert(initial,
fromCur, toCur);
Result.Text = converted.ToString();
}

5.

Compile and run the tests, and then do some manual testing to verify you have now created a working piece of software.