Visual Basic 2012 Voorbeelden
   

visual basic 2012 broncode voorbeelden

Blijf op de hoogte van de recente aanpassingen op vbvoorbeelden!

Microsoft Visual Studio 2012Microsoft Developers Network - Visual BasicMicrosoft .NET Framework

9.9. Nut van OOP

Print Email Deel op Twitter Deel op Facebook

Dit artikel is gepubliceerd op maandag 15 oktober 2012 op vbvoorbeelden, bezoek de website voor een recente versie van dit artikel of andere artikels.

Stel dat we een eenvoudige applicatie moeten opstellen waarin we leningen leningen kunnen beheren.
Een lening is voor deze eerste applicatie een bepaald bedrag (amount) die aan een bepaalde intrest (intrestRate) wordt uitgeleend.
In de applicatie wensen we leningen te kunnen toevoegen, verwijderen en van een lening de totale afbetaling (totalPayment) te kunnen bepalen.

Dan kunnen we hiervoor volgende applicatie Client1 creëren :
Visual Basic 2012 Broncode - Codevoorbeeld 252
Module Client1
    Dim count As Integer
    Dim capacity As Integer = 16
    Dim loans(1, capacity - 1) As Decimal
    Sub Main()
        ' add three loan-datagroups to collection :
        AddLoan(1000, 5)
        AddLoan(5000, 10)
        AddLoan(10000, 2)
        ' remove the second loan-datagroup from the collection :
        RemoveLoan(1)
        ' get total payments for all loans :
        For index As Integer = 0 To count - 1
            Dim amount As Decimal = loans(0, index)
            Dim intrestRate As Decimal = loans(1, index)
            Console.WriteLine(GetTotalPayment(amount, intrestRate))
        Next
        '
        Console.ReadLine()
    End Sub
    Sub AddLoan(ByVal amount As Decimal, ByVal intrestRate As Decimal)
        If count = capacity Then
            capacity *= 2
            ReDim Preserve loans(1, capacity - 1)
        End If
        loans(0, count) = amount
        loans(1, count) = intrestRate
        count += 1
    End Sub
    Sub RemoveLoan(ByVal index As Integer)
        Dim shiftIndex As Integer
        For shiftIndex = index To count - 2
            loans(0, shiftIndex) = loans(0, shiftIndex + 1)
            loans(1, shiftIndex) = loans(1, shiftIndex + 1)
        Next
        loans(0, shiftIndex) = 0
        loans(1, shiftIndex) = 0
        count -= 1
    End Sub
    Function GetTotalPayment(ByVal amount As Decimal, _
                             ByVal intrestRate As Decimal) As Decimal
        GetTotalPayment = amount * (1 + intrestRate / 100)
    End Function
End Module
Console Application Output
1050,00
10200,00
Indien we om deze applicatie op te zetten kiezen voor een object-geörienteerde aanpak, kunnen we volgende klasse Loan creëren :
Visual Basic 2012 Broncode - Codevoorbeeld 253
Class Loan
    Public Property Amount As Decimal
    Public Property IntrestRate As Decimal
    Public Function GetTotalPayment() As Decimal
        GetTotalPayment = Amount * (1 + IntrestRate / 100)
    End Function
End Class
In deze klasse verzamelen we de informatie die voor een lening wordt bijgehouden (Amount en IntrestRate) samen met het nodig gedrag, namelijk het berekenen van het totale afbetalingsbedrag (TotalPayment).

Naast deze klasse Loan waarvan instanties/objecten een voorstelling zijn van één lening, kunnen we ook een collectietype Loans creëren.  Hiervan zijn objecten een voorstelling van een verzameling van leningen :
Visual Basic 2012 Broncode - Codevoorbeeld 254
Class Loans
    Private _Count As Integer
    Private _Capacity As Integer = 16
    Private _Items(_Capacity - 1) As Loan
    Public Sub Add(ByVal item As Loan)
        If Count = _Capacity Then
            _Capacity *= 2
            ReDim Preserve _Items(_Capacity - 1)
        End If
        _Items(Count) = item
        _Count += 1
    End Sub
    Public Sub RemoveAt(ByVal index As Integer)
        Dim shiftIndex As Integer
        For shiftindex = index To Count - 1
            _Items(shiftindex) = _Items(shiftindex + 1)
        Next
        _Items(shiftIndex) = Nothing
        _Count -= 1
    End Sub
    Public ReadOnly Property Count() As Integer
        Get
            Count = _Count
        End Get
    End Property
    Default Public ReadOnly Property Item(ByVal index As Integer) As Loan
        Get
            Item = _Items(index)
        End Get
    End Property
End Class
In deze klasse Loans zit alle nodige functionaliteit, zoals het toevoegen ( Add) en verwijderen (RemoveAt) van elementen (Loan objecten).

De applicatie die nu een verzameling van leningen moet beheren kan nu gebruik maken van bovenstaande twee klassen :
Visual Basic 2012 Broncode - Codevoorbeeld 255
Module Client2
    Sub Main()
        ' create some new loans
        Dim loan1 As New Loan With {.Amount = 1000, .IntrestRate = 5}
        Dim loan2 As New Loan With {.Amount = 5000, .IntrestRate = 10}
        Dim loan3 As New Loan With {.Amount = 10000, .IntrestRate = 2}
        ' create new loan-collection
        Dim loans1 As New Loans
        ' add created loans to collection
        loans1.Add(loan1)
        loans1.Add(loan2)
        loans1.Add(loan3)
        ' remove the second loan-datagroup from the collection
        loans1.RemoveAt(1)
        ' get total payments for all loans :
        For index As Integer = 0 To loans1.Count - 1
            Console.WriteLine(loans1.Item(index).GetTotalPayment())
        Next
        '
        Console.ReadLine()
    End Sub
End Module
Console Application Output
1050,00
10200,00
Bemerk hoe eens je beschikt over bovenstaande twee klassen, het erg eenvoudig is om de nodige applicatie (Client2) op te stellen.

Alle logica omtrent het bepalen van het totale afbetalingsbedrag zit omvat in de business intelligence klasse Loan, en kan van een Loan object simpelweg worden opgevraagd (via de GetTotalPayment method).

Alle logica omtrent het beheer (toevoegen item, item op index verwijderen, aantal items opvragen, item op index opvragen) zit omvat in de application logic klasse Loans.  Een collectietype voor het beheren van een verzameling van leningen.

De verzameling van de twee klassen en Client2 is misschien meer code, en initieel meer werk om op te stellen dan Client1, waar niet op een object-geörienteerde manier werd gewerkt.
Toch is het zo dat de applicatie zelf (Client2) eenvoudiger is dan onze eerste applicatie (Client1).  Indien er nu nog een applicatie nodig is voor het beheren van dergelijke leningen, dan kan men simpelweg deze klassen (Loan en Loans) herbruiken, zonder dat men al deze logica moet herhalen.
Indien we niet zouden beschikken over deze klassen, en we nu nog een applicatie voor leningen moeten ontwikkelen, zouden we opnieuw moeten definiëren hoe het totale afbetalingsbedrag wordt bepaald, en opnieuw moeten definiëren hoe deze collectie wordt beheerd (bijvoorbeeld wat te doen bij het toevoegen en verwijderen van een element).

De object-geörienteerde aanpak zal niet alleen de code beter structuren, maar zorgt dus duidelijk ook voor een veel betere vorm van herbruik van code.

Een ander belangrijk voordeel, die voortvloeit uit bovenstaand voordeel, is dat wijzigingen aan de business intelligence binnen een bepaal domein, veel eenvoudiger aan te brengen zijn binnen een object-geörienteerde constructie.

Stel bijvoorbeeld dat we nu van lening ook wensen bij te houden over hoeveel maanden de afbetaling wordt gespreid, en dan we dan ook het maandelijkse afbetalingsbedrag wensen te weten.

Bij de niet object-geörienteerde aanpak (zoals Client1) moeten we overal doorgeen de applicatie wijzigingen hiervoor aanbrengen.
We moeten de interne opslagstructuur (de loans array) aanpassen, en de AddLoan en RemoveLoan implementaties aanpassen.  Daarnaast moeten we in de applicatie ook de business intelligence voor het bepalen van het maandelijkse afbetalingsbedrag (GetMonthlyPayment) gaan definiëren :
Visual Basic 2012 Broncode - Codevoorbeeld 256
Module Client3
    Dim count As Integer
    Dim capacity As Integer = 16
    Dim loans(2, capacity - 1) As Decimal
    Sub Main()
        ' add three loan-datagroups to collection
        AddLoan(1000, 5, 24)
        AddLoan(5000, 10, 10)
        AddLoan(10000, 2, 24)
        ' remove the second loan-datagroup from the collection
        RemoveLoan(1)
        ' get total and monthly payments for all loans :
        For index As Integer = 0 To count - 1
            Dim amount As Decimal = loans(0, index)
            Dim intrestRate As Decimal = loans(1, index)
            Dim monthDuration As Integer = loans(2, index)
            Console.WriteLine(GetTotalPayment(amount, intrestRate) & " " & _
                          GetMonthlyPayment(amount, intrestRate, monthDuration))
        Next
        '
        Console.ReadLine()
    End Sub
    Sub AddLoan(ByVal amount As Decimal, ByVal intrestRate As Decimal, _
                ByVal monthDuration As Integer)
        If count = capacity Then
            capacity *= 2
            ReDim Preserve loans(2, capacity - 1)
        End If
        loans(0, count) = amount
        loans(1, count) = intrestRate
        loans(2, count) = monthDuration
        count += 1
    End Sub
    Sub RemoveLoan(ByVal index As Integer)
        Dim shiftIndex As Integer
        For shiftIndex = index To count - 2
            loans(0, shiftIndex) = loans(0, shiftIndex + 1)
            loans(1, shiftIndex) = loans(1, shiftIndex + 1)
            loans(2, shiftIndex) = loans(2, shiftIndex + 1)
        Next
        loans(0, shiftIndex) = 0
        loans(1, shiftIndex) = 0
        loans(2, shiftIndex) = 0
        count -= 1
    End Sub
    Function GetTotalPayment(ByVal amount As Decimal, _
                             ByVal intrestRate As Decimal) As Decimal
        GetTotalPayment = amount * (1 + intrestRate / 100)
    End Function
    Function GetMonthlyPayment(ByVal amount As Decimal, _
                           ByVal intrestRate As Decimal, _
                           ByVal monthDuration As Integer) As Decimal
        GetMonthlyPayment = GetTotalPayment(amount, intrestRate) / monthDuration
    End Function
End Module
Console Application Output
1050,00 43,75
10200,00 425,00
Doorheen de volledige applicatie waren wijzigingen noodzakelijk om die relatief kleine uitbreiding van de business intelligence te voorzien.
De onderhoudbaarheid van onze niet object-geörienteerde aanpak is dus niet bepaald hoog.

Indien we deze uitbreiding aan de business intelligence in onze object-geörienteerde aanpak aanbrengen is de impact veel kleiner.
We breiden de klasse Loan uit met de nodige extra kenmerken ( MonthDuration) en het nodige gedrag (GetMonthlyPayment).

Onderstaande Partial Class Loan is een uitbreiding op bovenstaande klasse Loan.
Visual Basic 2012 Broncode - Codevoorbeeld 257
Partial Class Loan
    Public Property MonthDuration As Integer
    Public Function GetMonthlyPayment() As Decimal
        GetMonthlyPayment = GetTotalPayment() / MonthDuration
    End Function
End Class
Alle informatie en logica omtrent een lening was reeds gecentraliseerd in het type Loan.  De uitbreiding van de business intelligence voor een lening kan dan ook simpelweg in dit type worden aangebracht.

Ook de aanpassingen nodig in de client zijn minimaal.  Bij creatie van de Loan objecten specifiëren we nu ook de looptijd van de lening (door ook de property MonthDuration in te stellen.  Bij het afdrukken van de informatie van de leningen uit de collectie, vragen we nu ook het maandelijkse afbetalingsbedrag op (via GetMonthlyPayment) :
Visual Basic 2012 Broncode - Codevoorbeeld 258
Module Client4
    Sub Main()
        ' create some new loans
        Dim loan1 As New Loan With {.Amount = 1000, .IntrestRate = 5, _
                                    .MonthDuration = 24}
        Dim loan2 As New Loan With {.Amount = 5000, .IntrestRate = 10, _
                                    .MonthDuration = 10}
        Dim loan3 As New Loan With {.Amount = 10000, .IntrestRate = 2, _
                                    .MonthDuration = 24}
        ' create new loan-collection
        Dim loans1 As New Loans
        ' add created loans to collection
        loans1.Add(loan1)
        loans1.Add(loan2)
        loans1.Add(loan3)
        ' remove the second loan-datagroup from the collection
        loans1.RemoveAt(1)
        ' get total payments for all loans :
        For index As Integer = 0 To loans1.Count - 1
            Console.WriteLine(loans1.Item(index).GetTotalPayment() & " " & _
                              loans1.Item(index).GetMonthlyPayment())
        Next
        '
        Console.ReadLine()
    End Sub
End Module
Console Application Output
1050,00 43,75
10200,00 425,00
Je merkt dat de onderhoudbaarheid van de object-geörienteerde aanpak vele malen beter is.

Dit artikel is gepubliceerd op maandag 15 oktober 2012 op vbvoorbeelden, bezoek de website voor een recente versie van dit artikel of andere artikels.