# Building a very basic calculator

I have been a VB developer for couple of years, but strictly using functional programming paradigms — I just started using object-oriented paradigms a few days ago, and want some advice on how to improve.

I'm writing a small calculator application in order to understand VB.NET object-oriented principles. The program is (currently) working perfect the way I've done it (following some books and tutorials), and I want to get some response on how I'm doing regarding following OOP principles, paradigms and practices.

The program flow is pretty simple, and as follows:

1. The user enters the first number to add;
2. The user enters the second number to add;
3. The user clicks on the "calculate" button;
4. The UI (through Label2) updates to show the result;

The code is mostly done through the main class Cls_addition:

Public Class Cls_addition

'Variable de Classe
Private term1 As Integer
Private term2 As Integer
Private resultat As Long

'Properties
Public Property termA() As Integer
Get
Return term1
End Get

Set(ByVal value As Integer)
term1 = value
End Set
End Property

Public Property termB() As Integer
Get
Return term2
End Get

Set(ByVal value As Integer)
term2 = value
End Set
End Property

'Methods
Public Function additioner(ByVal term1 As Integer, ByVal term2 As Integer) As Long
resultat = term1 + 0 + term2
Return resultat
End Function

End Class

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click

Dim totalAddition As New Cls_addition           'Creation d'un obejct (creation nouvelle instance d'un obeject a l'aide du mot clé "New")

End Sub


And I have also attached a picture of the form itself:

Welcome to the world of OOP — hopefully there are a few things we can teach you. ;)

I'm going to show you an alternative implementation first, to help you see how OOP truly should be used, then I'll discuss your specific issues.

When building a calculator it's hard to effectively build something dynamic, you are always concerned about how things should relate (for example, how do we represent $a+b+c$, as $(a + b) + c$, as $a + (b + c)$, or some other way?), but it's often easiest if you consider each term and operation on it's own.

Let's take $+$, for example, we should have two terms: a left and a right. But what is a term?

A term can be any of the following:

• A value ($1$, for example);
• Another expression / operation ($a + b$, for example);

What do they have in common? They all have a Value property. So, in order to represent this we start with an interface:

Public Interface ITerm
Property Value As Double
End Interface


Pretty simple, and we'll define a ConstantTerm:

Public Class ConstantTerm
Implements ITerm

Public Sub New(value As Double)
Me.Value = value
End Sub

Public Property Value As Double Implements ITerm.Value
End Class


So far so good, we have a ConstantTerm which is just set to a value, so we can now build an AdditionTerm:

Public Class AdditionTerm
Implements ITerm

Public Sub New(left As ITerm, right As ITerm)
Me.Value = left.Value + right.Value
End Sub

Public Property Value As Double Implements ITerm.Value
End Class


So now, to do our math, we just need to do:

Dim result As Double = _
New ConstantTerm(CDbl(TextBox1.Text.Trim)), _
New ConstantTerm(CDbl(TextBox2.Text.Trim))).Value


But even better: this sets us up for success later when we want to add a SubtractionTerm:

Public Class SubtractionTerm
Implements ITerm

Public Sub New(left As ITerm, right As ITerm)
Me.Value = left.Value - right.Value
End Sub

Public Property Value As Double Implements ITerm.Value
End Class


And it also sets us up for parsing things later on down the road. (Since we don't care about values, we only care about terms, a parser just has to define a term as it goes and supply them as arguments to the next term.)

Regarding your specific code, there are a few things to take note of:

• In .NET we pretty much always try to name classes, interfaces, enums, and properties PascalCase — instead of Cls_addition we would use ClsAddition;
• When you set totalAddition.TermA and TermB, you should try to use a safer parsing system, via {NumericType}.TryParse:

Dim value As Integer = 0
If Integer.TryParse(TextBox1.Text.Trim(), value) Then
'Parse was successful
Else
'Show the user an error message, perhaps
End If

• Always name things what they mean, and not what they are: TextBox1 is a bad name, it should be firstTermInput, etc.;

• More recent versions of VB.NET support automatically-implemented properties, such as Property TermA As Integer, instead of manually specifying a Getter and Setter;

Overall, good start, and I hope you continue to learn and improve as you experiment and continue. :)