Men zou het vreemd kunnen vinden om op het moment dat er een nieuwe versie van Visual Objects verschenen is, te beginnen met een aantal artikelen over VB.NET. Persoonlijk zie ik echter de talen naast elkaar staan. In VO kan ik nog steeds naar volle tevredenheid snel applicaties ontwikkelen voor het Windows platform, maar .NET is wel een raamwerk dat meer en meer zijn intrede doet in softwareomgevingen. De komende jaren blijf ik werken met Visual Objects, al was het alleen maar omdat ik er niet aan moet denken mijn class library te moeten herschrijven.
In de afgelopen periode heeft Jan Timmer een goed beeld gegeven van de mogelijkheden die C# biedt en de verschillen die tussen de talen VO en C# bestaan. In deze artikelen wil ik proberen zijn voorbeeld te volgen en tonen wat met VB mogelijk is. Omdat de .NET class library zo’n wezenlijk deel uitmaakt van het ontwikkelen in VB, zal ik proberen de verschillen tussen VB en VO aan te geven, wetend dat we daarmee eigenlijk appels met peren vergelijken. Een zelfde opzet geldt voor de IDE, waarbij Visual Studio als uitgangspunt genomen wordt.
Basics
In de documentatie van VB staat dat in .NET alles een object is, dus ook de standaard typen als string, date en de numerieke waarden. In Visual Objects is dit niet het geval. Naast de mogelijkheid om objecten te definiëren zijn de standaardtypen niet te beschouwen als objecten. Omdat alles een object is in VB is het eerste voorbeeld een functie. De functie is eenvoudig, maar laat wel direct een aantal overeenkomsten en verschillen zien.
Function Bereken(ByVal intGetal1, ByVal intGetal2,_
ByVal strActie)
Dim intResult
Select Case strActie
Case "+"
intResult = intGetal1 + intGetal2
Case "-"
intResult = intGetal1 - intGetal2
Case "*"
intResult = intGetal1 * intGetal2
Case Else
intResult = -999
End Select
Return intResult
End Function
Allereerst is het natuurlijk verrassend dat we een functie kunnen maken in VB. Als alles een object is, wat is een functie dan? Een methode die niet bij een object hoort. Waarschijnlijk is dit toegevoegd vanuit compatibiliteit met oudere versies van VB. Houd er wel rekening mee dat function (net als sub als procedure) gebruikt wordt om methods te implementeren. De programmacode laat zien dat we de variabelen en parameters niet perse hoeven te voorzien van een type. Ook dat heeft denk ik weer te maken met de compatibiliteit naar oudere versies. Het is een werkwijze die niet aan te bevelen is.
In de documentatie van VB staat dat in .NET alles een object is, dus ook de standaard typen
Verder is te zien dat parameters voorzien kunnen worden van het ByVal steekwoord. Dit houdt in dat de parameter bij aanroep By Value wordt meegegeven aan de functie; dus in het begin van de functie wordt een kopie gemaakt van de waarde. De waarde van de parameter in de aanroepende functie blijft dus gelijk, ook als in de functie de waarde wijzigt. In de voorbeeldtoepassing is te zien hoe de andere werkwijze in z’n werk gaat via het ByRef (By Reference) steekwoord.
Als laatste onderdeel van dit voorbeeld wil ik het Select Case statement noemen. De opzet is duidelijk anders dan het DO CASE statement in VO. Persoonlijk vind ik de werkwijze in VO krachtiger, omdat je meer vrijheid hebt. Zo kun je met meerdere variabelen werken en in VB is dit niet mogelijk. Wel is het eenvoudig mogelijk om items in de case te combineren met een verkorte notatie.
Vanzelfsprekend is het beter om de functies wel van een type te voorzien. Dat geldt zowel in VO als in VB, ook al bieden beide omgevingen de mogelijkheden om het niet te doen. Een aanroep ziet er dan als volgt uit:
Function BerekenTyped(_
ByVal intGetal1 As Integer,_
ByVal intGetal2 As Integer,_
ByVal strActie As String) As String
Dim intResult As Integer
...
In het volgende codevoorbeeld wordt getoond hoe de andere basis statements er uit zien in VB. Ook hierbij is duidelijk te zien dat er wel verschillen zijn, maar dat ze minimaal zijn. Wel is het altijd even schakelen op het moment dat je overstapt van VO naar VB: “endif” en “end if” is een veelgemaakte tikfout. Gelukkig attenderen beide IDE’s je op deze tikfout. In dit voorbeeld plakken we een aantal items aan elkaar op basis van een while en een for loop.
Function MaakLoop(ByVal intGetal As Integer,_
ByVal strType As String) As String
Dim strResult As String
Dim intTeller As Integer
strResult = ""
intTeller = 1
If strType = "WHILE" Then
While intTeller < intGetal
strResult = strResult.Concat(strResult, "while " &_
Convert.ToString(intTeller) & vbCrLf).ToUpper
intTeller += 1
End While
End If
If strType = "FOR" Then
For intTeller = 1 To intGetal
strResult = strResult.Concat(strResult, "for " &_
Convert.ToString(intTeller) & vbCrLf).ToUpper
Next
End If
Return strResult
End Function
De loops zijn rechttoe rechtaan. In de code is echter wel een aantal aspecten te zien dat duidelijk verschilt ten opzichte van VO. Zoals reeds gesteld is alles een object in VB. In deze code is dit duidelijk te zien. De functie Upper in VO is in VB een sub ToUpper op het object string.
Verder kun je zien dat de taal uit gaat van strong typing
Verder kun je zien dat de taal uit gaat van strong typing. Dat is te zien aan de aanroep van de klasse Convert met de methode ToString. Deze methode is overloaded voor de verschillende datatypen. Een andere bijzonderheid is, dat we om de methode ToString aan te roepen op de klasse Convert niet eerst een object hoeven aan te maken van de klasse. Hier gaan we in een volgend artikel naar kijken, als objectoriëntatie aan de orde komt.
Een laatste opmerking over deze code is, dat het .NET raamwerk net als het klassemodel van Visual Objects ontzettend rijk is aan functionaliteit. Helaas worden er niet altijd dezelfde termen gebruikt als je als VO ontwikkelaar gewend bent. Maar het loont wel altijd de moeite om even een zoekpoging te wagen in de help van het .NET Framework. In de afbeelding zie je de interactie in het raamwerk.
Fig. 1: .NET Framework SDK Documentatie
Je ziet hierin een concept van .NET dat voor een VO programmeur onbekend is. Het raamwerk is ingedeeld in namespaces. Dit kun je vergelijken met de inhoudsopgave van een boek. Een namespace zorgt ervoor dat je snel naar de gewenste programmacode kunt navigeren. Aardig is dat de helpfile op een soortgelijke wijze is ingedeeld. Het is aan te raden dat, als je met VB aan de slag gaat, je meteen begint met namespaces, omdat ze het mogelijk maken een logische indeling van je code te maken.
Tot slot
In dit artikel is ingegaan op de basis elementen van VB. In komende artikelen zullen we verder gaan met object oriëntatie en reflectie. Bij dit artikel hoort een voorbeeld toepassing die als ZIP file te vinden is op de SDGN website. Ben je geinteresseerd geraakt in VB, kijk dan ook eens in de sectie VB van de SDGN site. Daarnaast is natuurlijk Microsoft een goede bron van informatie.