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

    Public Property termA() As Integer
            Return term1
        End Get

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

    Public Property termB() As Integer
            Return term2
        End Get

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

    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")

    totalAddition.termA = TextBox1.Text.Trim        'Object.Proprieté
    totalAddition.termB = TextBox2.Text.Trim        'Object.Proprieté

    Label2.Text = totalAddition.additioner(totalAddition.termA, totalAddition.termB)

End Sub

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



1 Answer 1


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 AdditionTerm( _
        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
        '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. :)


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.