AaVBA - Geen BB

Deze tutorial leert je over klasmodules in VBA. Je leert wat ze zijn en hoe je ze kunt gebruiken.

VBA-klassemodules - Inleiding

Wanneer u modules in de Visual Basic Editor (VBE) invoegt om uw code in te voeren, is het u misschien opgevallen dat u ook een zogenaamde 'Klasse-module' kunt invoegen.

Klasmodules versus modules

De klassenmodules werken op een heel andere manier dan de gewone modules, omdat ze het maken van een Component Object Model (COM) vergemakkelijken, die vervolgens binnen uw normale VBA-code kan worden gebruikt

In feite maakt u een object dat op dezelfde manier werkt als een ingebouwd Excel-object zoals 'Werkbladen'. In het werkbladobject hebt u een aantal eigenschappen en methoden waarmee u het aantal werkbladen in een werkmap of elke individuele naam van een werkblad of tal van andere informatie kunt krijgen

Wanneer u op deze manier een nieuw object maakt, maakt u een bouwsteen die overal binnen VBA kan worden gebruikt. Het object heeft een aantal eigenschappen en methoden waartoe uw VBA-code overal in de werkmap toegang heeft zonder dat u de code steeds opnieuw hoeft te schrijven.

Naast het verwijzen naar uw nieuwe object vanuit een standaard VBA-module, kunt u het ook gebruiken in de code achter een UserForm dat deel uitmaakt van uw aangepaste toepassing

U kunt het ook gebruiken waar u Active X-besturingselementen op een werkblad hebt geplaatst, zoals een opdrachtknop of een vervolgkeuzelijst. Deze besturingselementen gebruiken allemaal VBA en uw nieuwe object kan eenvoudig worden opgenomen in de gebeurteniscode voor deze besturingselementen.

U kunt uw object ook omzetten in een Excel-invoegtoepassing. Uw object is automatisch beschikbaar voor andere gebruikers die die invoegtoepassing hebben geladen. Dit voegt uw eigen meerlaagse architectuur toe aan uw Excel-toepassing

Excel is een toepassing met meerdere niveaus. Er is de clientserviceslaag, die het werkelijke werkbladvenster aanstuurt waarmee de gebruiker bekend is. Het Excel-objectmodel is de volgende laag eronder. Druk op F2 in een VBA-module en je zult het enorme aantal objecten en leden van die objecten kunnen zien die de motor van Excel zijn. Merk op dat uw nieuwe object hier ook wordt weergegeven.

Ten slotte, onder dit alles, heb je de dataservices-laag die alle gegevens bevat die je in de werkbladen en cellen hebt ingevoerd. Excel ontsluit dit met behulp van het Excel Object-model.

Door een klassenmodule te maken, kunt u de Excel-objectmodule uitbreiden met uw eigen aangepaste objecten en leden

In dit artikel wordt uitgelegd hoe u een eenvoudige hiërarchie van objecten maakt met behulp van klassenmodules.

Voordelen van het gebruik van klasmodules

1. U kunt een robuuste bouwsteen ontwikkelen die in een willekeurig aantal verschillende Excel-toepassingen kan worden gebruikt
2. Als het eenmaal grondig is getest, kunt u erop vertrouwen dat het altijd de juiste resultaten produceert op dezelfde manier als de ingebouwde Excel-objecten
3. Als er elders in de toepassing wijzigingen worden aangebracht in de code, blijft het nieuwe object op dezelfde manier werken
4. U kunt uw nieuwe object in andere Excel-toepassingen gebruiken als een invoegtoepassing
5. De objecten kunnen opnieuw worden gebruikt in andere toepassingen en helpen bij het debuggen

Nadelen van het gebruik van klasmodules

1. Ze kunnen moeilijk te maken en te begrijpen zijn.
2. Naamgevingsconventies zijn erg belangrijk omdat dit is wat u zult zien wanneer u uw object in een normale module gebruikt.
3. Als je nog niet eerder een klasmodule hebt gemaakt, kunnen ze moeilijk te begrijpen zijn en is er een steile leercurve
4. Onmogelijk om tijdens runtime wijzigingen aan te brengen - u moet het project opnieuw instellen.
5. Als eigenschappen en privévariabelen dezelfde naam hebben, kunnen er oneindige lussen optreden die tot fouten leiden

Een klasmodule invoegen

Selecteer Invoegen | Class Module uit het VBE-menu (Visual Basic Editor). De nieuwe Class Module zal automatisch ‘Class 1’ heten, maar dit moet direct veranderd worden in de naam die je voor je object gaat gebruiken

U wijzigt de naam in het eigenschappenvenster waar de pijl naar wijst. Je typt gewoon je nieuwe naam in, en dit zal veranderen in de Class Modules collectie

Als het venster Eigenschappen niet zichtbaar is, selecteer dan Bekijken | Eigenschappen in het VBE-menu of druk op F4

Roep je nieuwe klasmodule 'MyItem' en dubbelklik op de naam in de boomstructuur in de Projectverkenner om het codevenster ervoor weer te geven.

Een objectitem maken

In dit voorbeeld wordt een object op het hoogste niveau gemaakt met de naam 'MyItems' met een lidobject eronder met de naam 'MyItem' dat de individuele gegevens voor elk item bevat. Eenmaal gemaakt, werkt het op dezelfde manier als een ingebouwd Excel-object. Er is bijvoorbeeld een object met de naam 'Werkbladen' dat een verzameling is van elk werkblad in uw werkmap. Er is ook een object met de naam 'Blad' dat elk afzonderlijk werkblad in uw werkmap vertegenwoordigt en alle eigenschappen en methoden voor elk werkblad bevat. Dit object heeft betrekking op het verzamelobject ‘Werkbladen’.

U kunt door de verzameling 'Werkbladen' bladeren en elk 'Blad' om de beurt bekijken. Op dezelfde manier kunt u door de 'MyItems'-collectie bladeren en de eigenschappen bekijken die u in het 'Myitem'-lid hebt gemaakt.

Het eerste dat u moet doen, is het subobject maken voor het ledenniveau dat de werkelijke items in de verzameling van het object op het hoogste niveau zal bevatten. Dit is het equivalent van de leden (bijvoorbeeld naam, zichtbaar, aantal) binnen het object 'Blad' in Excel. Deze code wordt ingevoerd in de klassenmodule genaamd 'MyItem'

Klasse-modules hebben eigenschappen en methoden. Eigenschappen zijn in feite als variabelen, in die zin dat ze waarden van gegevens bevatten zoals variabelen, en methoden zijn als subroutines of functies.

In het subobject gaan we twee eigenschappen voor het object maken - Item en Detail

In eerste instantie moeten twee tekenreeksvariabelen worden gedeclareerd om de waarden voor de eigenschappen vast te houden:

12	Privé mItem als stringPrivé mDetail als string

Deze moeten worden gedeclareerd in het gedeelte Verklaringen bovenaan de code voor de klassenmodule, zodat ze in alle subroutines in de module kunnen worden gebruikt

Ze moeten unieke namen krijgen om ze te onderscheiden van de eigenschappen die we gaan maken, dus er is een 'm' (voor lid) voor elke naam geplaatst.

De variabelen zijn gedeclareerd als Private, zodat ze niet kunnen worden gezien door iedereen die het object gebruikt. Het zijn werkvariabelen voor gebruik binnen de objectcode en zijn er niet als onderdeel van het uiteindelijke object.

De volgende stap is het instellen van een code om toegang te geven tot de twee eigenschappen. Dit doet u door middel van een Property Let- en een Property Get-verklaring per woning. Deze moeten Openbaar zijn, anders heeft het object op het hoogste niveau geen zichtbare eigenschappen

123456789101112131415

Public Property Let Item (vdata As String)mItem = vdataEigenschap beëindigenOpenbaar eigendom Item () ophalen als tekenreeksArtikel = mArtikelEigenschap beëindigenOpenbaar eigendom Let Detail (vdata As String)mDetail = vdataEigenschap beëindigenOpenbaar eigendom Details ophalen () als tekenreeksDetail = mDetailEigenschap beëindigen

Deze code creëert de middelen om waarden te lezen en te schrijven naar de twee eigenschappen (Item en Detail) met behulp van de twee privévariabelen die zijn gedefinieerd in het declaratiegedeelte van de module.

De parameter ‘vdata’ wordt gebruikt om gegevens door te geven aan de betreffende eigenschap.

Het is belangrijk dat elke eigenschap een 'Let'- en 'Get'-statement heeft en dat de eigenschapsnaam in elk geval hetzelfde is. U kunt twee verschillende eigenschappen krijgen als u ze verkeerd spelt - een waaruit u kunt lezen en een waarnaar u kunt schrijven!

Om te helpen bij het maken van deze code, kunt u Insert | . gebruiken Procedure in het VBE-menu om een ​​codeskelet te maken dat de initiële code maakt voor de eigenschappen 'Get' en 'Let' voor een bepaalde eigenschapsnaam

Hierdoor wordt een pop-upvenster weergegeven waarin u de naam van de eigenschap typt en 'Eigenschap' selecteert op de keuzerondjes:

Klik op 'OK' en de skeletcode wordt toegevoegd aan de klassenmodule:

1234567

Openbaar eigendom Krijg MyProperty() als variantEigenschap beëindigenOpenbaar eigendom Let MyProperty (ByVal vNewValue As Variant)Eigenschap beëindigen

Dit voorkomt fouten over namen van eigenschappen. U voegt eenvoudig uw code toe tussen de statements 'Public Property' en 'End Property'.

U hebt nu een object met de naam 'MyItem' dat alle gegevens voor deze oefening bevat.

Moe van het zoeken naar voorbeelden van VBA-codes? Probeer AutoMacro!

Een collectie maken

De volgende stap is het maken van een object op het hoogste niveau als een verzamelingsobject om toegang te geven tot de eigenschappen die u hebt ingesteld in het object 'MyItem'

Nogmaals, u moet een werkobject definiëren om als verzamelingsobject te fungeren, op dezelfde manier waarop u de twee tekenreeksvariabelen in het 'MyItem'-object hebt gedefinieerd.

1	Privé-items als verzameling

Nogmaals, dit moet een unieke naam hebben, daarom staat er een 'm' (lidobject) voor de naam, en het wordt ook als 'Privé' gedeclareerd zodat het niet verschijnt wanneer het nieuwe object wordt gemaakt gebruikt

Vervolgens moet u de Class_Initialize-code invullen. Dit wordt uitgevoerd wanneer u het object voor het eerst in uw code gebruikt en het bepaalt welke waarden in het object worden geladen

U kunt toegang krijgen tot deze subroutine door 'Klasse' te selecteren in de eerste vervolgkeuzelijst en 'Initialiseren' in de tweede vervolgkeuzelijst van het modulevenster

12345678910

Private Sub Class_Initialize()Dim object als mijn itemStel mItems = Nieuwe collectie inVoor n = 1 tot 3Stel objItem = Nieuw MijnItem inobjItem.Item = Werkbladen ("Blad1"). Bereik ("a" & n). WaardeobjItem.Detail = Werkbladen ("Blad1"). Bereik ("b" & n). WaardemItems.Add objItemVolgende nrEinde sub

De code stelt een object in met de naam 'objItem' met behulp van de definitie van 'MyItem' die we eerder als een klassenmodule hebben gebouwd.

Vervolgens wordt een nieuwe verzameling gemaakt op basis van het eerder gedefinieerde 'mItems'-object

Het doorloopt de waarden op Blad1 van de werkmap en plaatst ze in de eigenschappen die we hebben gemaakt voor het 'MyItem'-object. Merk op dat wanneer u 'objitem' gebruikt, er een vervolgkeuzelijst verschijnt met de twee eigenschappen, precies alsof u een ingebouwd Excel-object gebruikt.

Het item-object wordt vervolgens toegevoegd aan het verzamelingsobject dat nu alle gegevens in de eigenschapswaarden bevat.

De invoergegevens hoeven niet uit een werkblad te worden gehaald. Het kunnen statische waarden zijn, of het kan afkomstig zijn van een verbinding met een database zoals Microsoft Access of SQL Server, of het kan afkomstig zijn van een ander werkblad.

U moet dan een openbare functie toevoegen met de naam 'Item'

123	Public Function Item (index As Integer) As MyItemStel item in = mItems.Item (index)Functie beëindigen

Hiermee kunt u naar individuele objecten binnen het collectieobject verwijzen met hun indexnummer. Deze functie geeft een ‘spiegel’ van wat er in de ‘mMyItems’ collectie op de achtergrond gebeurt.

U moet ook een eigenschap met de naam 'Count' toevoegen, zodat uw code kan vaststellen hoeveel 'MyItem'-objecten zich in de 'MyItems'-verzameling bevinden, mocht u er doorheen willen bladeren.

123	Openbaar eigendom Get Count() zo langAantal = mItems.AantalEigenschap beëindigen

In dit geval heb je alleen een 'Get'-eigenschap nodig omdat deze alleen-lezen is. Het gebruikt de mItems-verzameling omdat hierin al een count-eigenschap is ingebouwd.

U hebt nu een object (MyItems) met een volledige hiërarchie gedefinieerd door het object 'MyItem'

Om het geheel te laten werken, moet u nu een werkblad (Sheet1) met gegevens vullen, zodat de routine Class Initialize dit in het object kan verzamelen

Uw spreadsheet zou er als volgt uit moeten zien:

Uw nieuwe object gebruiken

U kunt uw Collection-object (MyItems) nu gebruiken binnen een standaard Excel VBA-module. Voer de volgende code in:

12345678

Subtest_object()Dim MyClass als nieuwe MyItems, n als geheel getalMsgBox MyClass.CountVoor n = 1 Naar MyClass.CountMsgBox MyClass.Item(n).ItemMsgBox MyClass.Item(n).DetailVolgende nrEinde sub

Deze code maakt een object met de naam 'MyClass' aan op basis van het verzamelingsobject dat u hebt gemaakt met de naam 'MyItems'. Dit activeert de routine 'Initialiseren' die alle gegevens van het werkblad naar het object extraheert.

Het geeft het aantal items in de collectie weer en doorloopt vervolgens de collectie met de tekst 'Artikel' en de tekst 'Detail'. U zult merken dat wanneer u naar het object 'MyClass' in uw code verwijst, u een lijst ziet met de twee lideigenschappen die helpen bij het toevoegen van de juiste eigenschap.

Als u de waarde van een cel in de invoergegevens op het werkblad wijzigt, wordt dit automatisch bijgewerkt in de verzameling wanneer u de bovenstaande code opnieuw uitvoert, aangezien wanneer u het object dimensioneert, de initialisatieroutine wordt uitgevoerd en alle nieuwe gegevens worden opgehaald

Als u het woord 'Static' gebruikt in plaats van 'Dim', wordt de initialisatieroutine niet uitgevoerd en blijven de oude waarden behouden, zolang de code continu wordt uitgevoerd. Als de gegevens in de spreadsheet veranderen, wordt dit niet weerspiegeld in het object

1234567

Subtest_Static()Statische Myclass As New MyItems, n As IntegerVoor n = 1 Naar Mijnklasse.AantalMsgBox Mijnklasse.Item(n).ItemMsgBox Myclass.Item(n).DetailVolgende nrEinde sub

Samenvatting van het maken van een object met behulp van een klassenmodule

Zoals je hebt gezien, is het maken van een hiërarchie van klassenmodules om als object te gebruiken nogal ingewikkeld, zelfs voor een structuur die zo eenvoudig is als het hier gegeven voorbeeld. De ruimte om fouten te maken is enorm!

Het heeft echter enorme voordelen om uw code eleganter en gemakkelijker leesbaar te maken. Het is ook gemakkelijker te delen met andere Excel-toepassingen en -ontwikkelaars door er een invoegtoepassing van te maken.

In dit voorbeeld van hoe u een object maakt om gegevens op te slaan, zou het een normale benadering zijn om een ​​multidimensionale array te maken om de spreadsheetgegevens met meerdere kolommen te bevatten, en u zou een regel code schrijven om elk element bij te werken of te lezen in de reeks. Dit zou waarschijnlijk behoorlijk rommelig worden en er zouden gemakkelijk fouten kunnen worden gemaakt bij het aanpakken van de verschillende elementen.

Met uw nieuwe object kunt u er eenvoudig naar verwijzen en de leden die u eronder hebt gemaakt om de gegevens op te slaan.

Ook als de gegevens in de spreadsheet veranderen (of in een gekoppelde database als u deze als gegevensbron binnen uw klassenmodule hebt gebruikt) wanneer u de 'Dim'-instructie gebruikt, wordt de initialisatieroutine aangeroepen en worden de gegevens onmiddellijk bijgewerkt . U hoeft geen code te schrijven om uw array opnieuw te vullen.

Een klassenmodule gebruiken om een ​​variabele repository te maken

Wanneer u VBA-code schrijft, gebruikt u overal variabelen, allemaal met verschillende reikwijdten. Sommige kunnen alleen worden gedefinieerd voor een bepaalde procedure, andere voor een bepaalde module en sommige kunnen globale variabelen zijn die overal in de toepassing kunnen worden gebruikt

U kunt een klassenmodule maken die een groot aantal variabelen bevat en omdat het een object is, kan het overal in uw code worden gebruikt, zelfs op een gebruikersformulier of in een Active X-besturingselement dat u op een werkblad hebt geplaatst.

Het extra voordeel is dat wanneer u naar uw variabele object verwijst, u een lijst ziet met alle variabelenamen die in het object worden bewaard, gesorteerd in oplopende volgorde.

Om een ​​repository aan te maken, moet je een nieuwe klassenmodule invoegen. Dit doe je met Invoegen | Klassenmodule uit het menu VB Editor

Verander de naam in 'MyVariables' met dezelfde methode als eerder besproken in dit artikel.

Voer de volgende code in:

12345678910111213141516

Privé mV als variantOpenbare eigendom Krijg variabele1() als variantVariabele1 = mVEigenschap beëindigenPubliek eigendom laat variabele1(ByVal vNewValue As Variant)mV = vNieuwe WaardeEigenschap beëindigenOpenbare eigendom Krijg variabele2() als variantVariabele1 = mVEigenschap beëindigenPubliek eigendom laat variabele2(ByVal vNewValue As Variant)mV = vNieuwe WaardeEigenschap beëindigen

Deze code stelt de eigenschappen 'Let' en 'Get' in voor twee variabelen ('Variable1' en 'Variable2'). De eigenschappen Let en Get zijn vereist voor elk van uw variabelen, zodat ze lezen / schrijven zijn

U kunt uw eigen namen voor de variabelen gebruiken in plaats van de voorbeeldnamen in deze code, en u kunt meer variabelen toevoegen, waarbij u ervoor zorgt dat elke nieuwe variabele een 'Let'- en 'Get'-statement heeft.

De privédeclaratie van de variabele 'mV' is om een ​​werkvariabele te maken die alleen binnen de klassenmodule wordt gebruikt om waarden over te dragen.

Om de variabele repository te gebruiken, voert u de volgende code in een standaardmodule in:

123456

Global VarRepo als nieuwe MyVariablesSub TestVariableRepository()MsgBox VarRepo.Variable1VarRepo.Variabele1 = 10MsgBox VarRepo.Variable1Einde sub

Deze code maakt een globale instantie van uw 'MyVariables'-object dat u hebt gemaakt. U hoeft deze aangifte maar één keer te doen vanaf elke plek in uw code.

De code geeft eerst de waarde van 'Variabele1' weer om aan te geven dat deze leeg is.

Een waarde van 10 wordt toegewezen aan 'Variabele1' en de nieuwe waarde binnen het object wordt vervolgens weergegeven om aan te tonen dat deze eigenschap nu deze waarde bevat.

Omdat de instantie van het object 'MyVariables' globaal is gedefinieerd, kunt u overal in uw code naar een van de gedefinieerde variabelen binnen het object verwijzen.

Dit heeft als groot voordeel dat als u uw variabelen overal in uw code wilt gebruiken, u slechts één globale variabele hoeft te definiëren, en vanaf dat moment kunnen alle variabelen vrij worden geopend en gewijzigd in uw hele code.

Geweldig product. AutoMacro schrijft niet alleen uw code, het leert u terwijl u bezig bent!" - Tony, VK

Kom meer te weten

Lees onze 900+ beoordelingen

Uw object veranderen in een invoegtoepassing

Tot nu toe bevindt de code voor het maken van objecten zich in uw werkmaptoepassing. Als u uw object echter wilt kunnen delen met andere ontwikkelaars of in andere eigen Excel-toepassingen, kunt u er een invoegtoepassing van maken

Om dit te doen, hoeft u alleen het bestand op te slaan als een invoegtoepassing. Selecteer Bestand | Opslaan als en er verschijnt een browservenster

Selecteer het bestandstype als Add-In (.xlam) in de vervolgkeuzelijst voor het bestandstype en klik op OK. Het bestand wordt standaard opgeslagen in de map Add-In, maar u kunt de locatie wijzigen.

U kunt het invoegtoepassingsbestand vervolgens opnemen in uw Excel-toepassingen, waardoor u de flexibiliteit heeft om uw nieuwe object te gebruiken

Om uw nieuwe invoegtoepassing in Excel op te nemen, klikt u op Bestand op het Excel-lint en klikt u vervolgens op Opties onder aan het linkerdeelvenster

Klik op 'Add-Ins' in het linkerdeelvenster in het pop-upvenster dat verschijnt. Onderaan het venster is een knop gemarkeerd met 'Go'

Klik hierop en er verschijnt een pop-upvenster 'Add-In'. Klik op 'Bladeren' en zoek vervolgens uw Add-In-bestand. U kunt dan in uw code naar uw object verwijzen.