Model--View/Controller
Enough theory. It's time to code! In this chapter, you will learn about the
most basic design pattern, the Model--View/Controller architecture (M-VC).
This lesson contains the complete source code of a Model class that encapsulates
the complex math required to do mortgage calculations. You will then create
a working Mortgage calculator as a Windows Form application. Finally, you
will reuse the Model class to create a working calculator as a Web Form
application. This is all working C# code that demonstrates the advantages
of using the
M-VC design pattern.
Model -- View/Controller Architecture
A design pattern is a recurring solution that simplifies the design process.
The thoughtful study of design patterns allows a developer to learn from
the pioneering work of others. The M-VC design pattern is most important,
I think, because it forces a programmer to completely rethink the approach
to designing an application. The reward is reusable code. Since this is
a hands on tutorial, I plan to show you how the M-VC architecture promotes
code reuse by migrating a Windows Form solution to a browser based solution
using a Web Form.
The Model -- View/Controller architecture is a modification of the Model --
View -- Controller architecture used in the SmallTalk language. In the SmallTalk
language, the application is divided into three parts. The Model encapsulates
the application logic or algorithms. The View draws the presentation. The Controller
responds to user or system events. The key concept is the separation of the
application logic from the presentation and event handling code. The Model
class is independent of the GUI and is ignorant of any implementation of the
GUI. A good Model class should be able to function as part of a console application
and support unit testing. In this chapter, you will build an application that
separates the complex mathematics of a mortgage calculator (Model) from the
presentation and event handling code (View/Controller). The code behind technique
of Web Form programming further contributes to the separation of the View (HTML
code) and Controller (code behind event handler) code.
There is no question that the complete separation of GUI code from the application
logic is a difficult concept for many to grasp. It can be a painful learning
experience as it forces a programmer to change the basic approach to application
design. Many will fight the process, dragged into the new world of OOP kicking
and screaming. But, when you see how much simpler a Model -- View/Controller
application is to maintain or migrate, you will _see_ the light. I promise.
The Model Class
The following code was adapted from our book "Visual Cafe for Java Explorer,
Database Development Edition" Brogden, Louie, Tittel, Coriolis, 1998.
The only real change from the Java version is the use of C#'s support for "properties." The
Model class implements the algorithms of a mortgage calculator. The fact that
the Java code was completely separate from the Java GUI greatly simplified
the reuse of this 1997 code in this C# Windows Form application!
In a nutshell, given three of four mortgage parameters (principal, interest,
period in months, payment), you can calculate the unknown parameter. Solving
for interest is not a trivial mathematical solution. I readily admit that I
had help solving that equation from my good friend, Dr. W. Carlini! The Model
class has an "Init" method that takes all four parameters needed
for a mortgage calculator. One and only one parameter must have a value of
zero. The zero parameter acts as a marker for the unknown value.
This class also demonstrates the use of two common programming idioms: the
use of a public "IsValid" function to return the internal state of
the object and the use of pre and post conditions to validate the input and
output of an algorithm.
Using IsValid()
Note that all of the actual calculations occur on a call to the "Init" method,
either directly or indirectly through the "args" constructor. If
the input parameters and result appear valid, the "target" variable
is set to a valid value. If the input parameters or result appear invalid,
the "target" variable is set to -1. A public function "IsValid" is
provided to the caller that returns the internal state of the object. The public
function "IsValid" encapsulates or hides the internal validation
logic. I would argue that the use of a public "IsValid" function
is a common and useful programming idiom.
Pre and Post Conditions
The downside of separating out the algorithm from the GUI, is that both the
Model class and the View/Controller class does input checking to insure runtime
reliability and useful user feedback. The Model class implements a common
programming construct, the use of pre and post conditions. In the Model class,
the "Init" method statically validates the input parameters before
passing them on to the DoAlgorithm method (pre-conditions). The algorithm
does not check for a divide by zero error, which is handled internally. After
the calculation is complete, the "DoAlgorithm" method validates
the result by calling Double.IsNaN (IsNotANumber) (post-conditions). The
decision to turn off pre and post conditions in the release build (no check
version) is beyond the scope of this tutorial.
The compulsive coder will note the the input validation scheme is not mathematically
correct, rejecting interest rates of greater than 100%. Apparently the twisted
class has a social agenda.
Complete Code Listing Model.cs
The downside of posting all of the code is that it goes on forever. Click
here to skip the code. You can come back later.
/// <summary>
/// Class Model.cs
/// jlouie 07.07.02
/// Adapted from Model.java
/// "Visual Cafe for Java Explorer, Database Development Edition"
/// William Brogden, Jeffrey A. Louie, and Ed Tittel, Coriolis, 1998, 585pp.
/// Supplied "as is"
/// No warranty is expressed or implied
/// This code is for instructional use only
/// </summary>
public class Model
{
// internal class constants, not "versionable"
private const int INVALID= -1; // flags error
private const int PRINCIPAL= 0;
private const int INTEREST= 1;
private const int MONTHS= 2;
private const int PAYMENT= 3;
private double[] arrayDb= new double[4];
private int target= INVALID;
private string message= "";
/* // uncomment to run console self test
// self test static method outputs state to console
static void ConsoleDebug(Model model)
{
if (model == null)
{
System.Console.WriteLine("Null object.");
return;
}
System.Console.WriteLine("Message: "+model.Message);
System.Console.WriteLine("Result: "+model.Result);
System.Console.WriteLine("Principal: "+model.Principal);
System.Console.WriteLine("Interest: "+model.Interest);
System.Console.WriteLine("Months: "+model.Months);
System.Console.WriteLine("Payment: "+model.Payment);
}
*/
/* // uncomment to run console self test
// self test
[STAThread]
static void Main()
{
// test internal consistency of algorithms
Model model= new Model(100000,8.5,360,0);
Model.ConsoleDebug(model); // payment = 768.9134584334
model.Init(0,8.5,360,768.9134584334);
Model.ConsoleDebug(model);
model.Init(100000,0,360,768.9134584334);
Model.ConsoleDebug(model);
model.Init(100000,8.5,0,768.9134584334);
Model.ConsoleDebug(model);
System.Console.ReadLine();
}*/
// no arg constructor
public Model(){;}
// arg constructor
public Model(double principal, double interest, int months, double
payment)
{
Init(principal, interest, months, payment);
}
// factored code, can be called after call to constructor
// allowing reuse of instance of class
// eg. object is _not_ immutable by design
public void Init(double principal, double interest, int months,
double payment)
{
// reset flags
target= INVALID;
message= "";
// store input into array of double
arrayDb[PRINCIPAL]= principal;
arrayDb[INTEREST]= interest;
arrayDb[MONTHS]= (double)months;
arrayDb[PAYMENT]= payment;
// validate input
// one, and only one, "value" must be zero --> target
int zeros= 0;
int tempTarget= INVALID;
for (int i=0; i<4; i++)
{
if (arrayDb[i] == 0)
{
zeros++;
tempTarget= i;
}
}
if (zeros>1)
{
message= "Too many zero parameters.";
return;
}
if (zeros == 0)
{
message= "One parameter must be zero.";
return;
}
// validate interest
if (interest > 100 || interest < 0)
{
message= "Invalid interest.";
return;
}
// validate months
if (months < 0)
{
message= "Invalid months.";
return;
}
// validate principal
if (principal < 0)
{
message= "Invalid principal.";
return;
}
// validate payment
if (payment < 0)
{
message= "Invalid payment.";
return;
}
// input parameters appear valid
target= tempTarget;
DoAlgorithm(target);
}
// the actual amortization algorithm
// m= P*i(1-(1+i)^-N)
// i=r/1200
// result= 0 --> marks error
private void DoAlgorithm(int target)
{
double result= 0;
double P= arrayDb[PRINCIPAL]; // principal
double i= arrayDb[INTEREST]/1200; // monthly percentage
rate
double N= arrayDb[MONTHS]; // loan period in months
double m= arrayDb[PAYMENT]; // monthly payment
if (target>= 0 && target< 4) // validate target
{
try
{
switch (target)
{
case PRINCIPAL:
// principal
result=
1+i;
result=
1/Math.Pow(result, N);
result=
((1-result)/i)*m;
break;
case INTEREST:
// annual interest
//
algorithm fails if N*m >= P !!
if
((N*m)<P)
{
throw
new ArithmeticException();
}
//
factor out Interest function, too long
result=
CalcInterest(P,N,m);
break;
case MONTHS:
// loan period
result=
(1-(P*i/m));
result=
Math.Log(result);
result=
-result/Math.Log((1+i));
break;
case PAYMENT:
// monthly payments
result=
1+i;
result=
1/Math.Pow(result,N);
result=
(P*i)/(1-result);
break;
//default:
//break;
}
}
catch
{
result= 0;
}
}
// validate result
if (Double.IsNaN(result))
{
result= 0;
}
if (result == 0)
{
message= "Input Error.";
}
else // valid result
{
arrayDb[target]= result;
}
}
// a complex iterative calculation for interest
// thanks to Dr. W. Carlini (and Newton)for the solution
// returns zero on error
// ASSERT (N*m)>=P
private double CalcInterest(double P, double N, double m)
{
double temp= (m/P), answer= (m/P), diff= 100, numerator=
0, denominator= 0,
accuracy= .00001;
int index, maxIterations= 1000;
try
{
for (index= 0; ((diff>accuracy) && (index<maxIterations));
index++)
{
temp= answer;
numerator= (P*temp/m)+Math.Pow((1+temp),-N)-1;
denominator= (P/m)-N*Math.Pow((1+temp),(-N-1));
// if (denominator ==0 ){throw new
ArithmeticException();}
answer= temp-(numerator/denominator);
diff= answer- temp;
if (diff<0)
{
diff= -diff;
}
}
answer *= 1200;
// validate answer
if ((answer<0) || Double.IsNaN(answer)
||
(index == maxIterations))
{
throw new ArithmeticException();
}
}
catch
{
answer= 0;
}
return answer;
}
// default target is -1 (INVALID)
public bool IsValid()
{
return ((target>=PRINCIPAL) && (target<=PAYMENT))
? true: false;
}
// Java "getter" code converted to C# get only properties
public double Result
{
get {
if (IsValid())
{
return arrayDb[target];
}
else
{
return 0.0;
}
}
}
public int Target
{
get
{
return target;
}
}
public string Message
{
get
{
return message;
}
}
public double Principal
{
get
{
if (IsValid())
{
return arrayDb[PRINCIPAL];
}
else
{
return 0.0;
}
}
}
public double Interest
{
get
{
if (IsValid())
{
return arrayDb[INTEREST];
}
else
{
return 0.0;
}
}
}
public double Months
{
get
{
if (IsValid())
{
return arrayDb[MONTHS];
}
else
{
return 0;
}
}
}
public double Payment
{
get
{
if (IsValid())
{
return arrayDb[PAYMENT];
}
else
{
return 0.0;
}
}
}
}
Creating a Windows Form Application
I fired up the Visual Studio IDE, dragged a few controls around and wired
up two event handlers. This is what I got:
You could certainly spiff up this application by adding radio buttons that
let the user select the target of the calculation. You could then disable the
appropriate input control, setting the value of the target control to zero.
Interestingly, the Parse method happily accepts embedded commas.
In the application you simply create an instance of the Model class:
private Model model= new Model();
You then call the appropriate Model methods and properties in the buttonCalculate
and buttonReset event handlers:
private void buttonCalculate_Click(object sender, System.EventArgs
e)
{
double principal= 0;
double interest= 0;
int months= 0;
double payment= 0;
bool isInputError= false;
// validate user input, must allow zero
try
{
principal= Double.Parse(textBoxPrincipal.Text);
if (principal<0)
{
throw new Exception();
}
}
catch
{
textBoxPrincipal.Text= "Invalid Input.";
isInputError= true;
}
try
{
interest= Double.Parse(textBoxInterest.Text);
if ((interest < 0) || (interest > 100))
{
throw new Exception();
}
}
catch
{
textBoxInterest.Text= "Invalid Input.";
isInputError= true;
}
try
{
months= Int32.Parse(textBoxPeriod.Text);
if (months <0)
{
throw new Exception();
}
}
catch
textBoxPeriod.Text= "Invalid Input.";
isInputError= true;
}
try
{
payment= Double.Parse(textBoxPayment.Text);
if (payment < 0)
{
throw new Exception();
}
}
catch
textBoxPayment.Text= "Invalid Input.";
isInputError= true;
}
if (isInputError)
{
return;
}
// valid user input
model.Init(principal,interest,months,payment);
if (model.IsValid())
{
textBoxPrincipal.Text= model.Principal.ToString();
textBoxInterest.Text= model.Interest.ToString();
textBoxPeriod.Text= model.Months.ToString();
textBoxPayment.Text= model.Payment.ToString();
textBoxMessage.Text= model.Message.ToString();
}
else
{
textBoxMessage.Text= model.Message.ToString();
ResetControls();
}
}
private void buttonReset_Click(object sender, System.EventArgs e)
{
textBoxMessage.Text= "";
ResetControls();
}
private void ResetControls()
{
textBoxPrincipal.Text= "";
textBoxInterest.Text= "";
textBoxPeriod.Text= "";
textBoxPayment.Text= "0";
textBoxPrincipal.Focus();
}
Creating a Web Form Application
Just to prove how easy it is to reuse the Model class, I then fired up the
IDE and built a browser based version of the mortgage calculator. Just
think. If your client suddenly wakes up one day and ask for a browser based
version
of your application, you won't be having a panic attack. By separating
out the application logic from the GUI (view and event handling code),
you are
prepared for code reuse.
Here is a snapshot of the browser based calculator:
Now it's your turn to do some coding. Just create a new Windows Form or Web
Form application and copy and paste the Model class into your project. You
will need to remove any embedded carriage returns that were added to the actual
code for easy HTML viewing. If you want to download the working projects, they
are available at http://www.geocities.com/jeff_louie/download.html
Hopefully, I have convinced you of the need to separate out your application
logic from the presentation and event handling code. I have reused the Model
code from a Java application in both a Windows Form and Web Form application.
Use this most basic design pattern, the Model -- View/Controller architecture.
It will grow on you!