Een keer definieren en daarna terugkoppelen (Berekeningen)

Status
Niet open voor verdere reacties.
S

Systeempje

Gebruiker
Lid geworden
8 sep 2009
Berichten
149
Beste,

Ik heb heel vaak het volgende stukje in mijn VBA bij gebeurtenis na bijwerken.
Code: 
Me.[Personeel_totaal].Value = Val(Me.[Personeel_uren].Value) * Val(Me.[Personeel_tarief].Value)
Me.[Transport_totaal].Value = Val(Me.[Transport_uren].Value) * Val(Me.[Transport_tarief].Value)
Me.[Inkopen_totaal].Value = Val(Me.[Inkopen_uren].Value) * Val(Me.[Inkopen_tarief].Value)
Me.[Huur_totaal].Value = Val(Me.[Huur_uren].Value) * Val(Me.[Huur_tarief].Value)
Me.[Veiligheid_totaal].Value = Val(Me.[Veiligheid_uren].Value) * Val(Me.[Veiligheid_tarief].Value)
Me.[vrijveld1_totaal].Value = Val(Me.[vrijveld1_uren].Value) * Val(Me.[vrijveld1_tarief].Value)
Me.[vrijveld2_totaal].Value = Val(Me.[vrijveld2_uren].Value) * Val(Me.[vrijveld2_tarief].Value)

Kan ik dit ook 1x definieren en later bij verschillende gebeurtenissen naar dit stukje verwijzen? Stel dat er ooit iets verander in een formule dan moet ik dit 10x veranderen.
 
Laatst bewerkt:
Ja, maak er een apart subje van en verwijs daar naar.


Dus
Code: 
  Sub even_eruit
  Me.[Personeel_totaal].Value = Val(Me.[Personeel_uren].Value) *   Val(Me.Personeel_tarief].Value) 
  Me.[Transport_totaal].Value = Val(Me.[Transport_uren].Value) * Val(Me.Transport_tarief].Value)
  Me.[Inkopen_totaal].Value = Val(Me.[Inkopen_uren].Value) * Val(Me.Inkopen_tarief].Value)
  Me.[Huur_totaal].Value = Val(Me.[Huur_uren].Value) * Val(Me.[Huur_tarief].Value)
  Me.[Veiligheid_totaal].Value = Val(Me.[Veiligheid_uren].Value) * Val(Me.Veiligheid_tarief].Value)
  Me.[vrijveld1_totaal].Value = Val(Me.[vrijveld1_uren].Value) * Val(Me.vrijveld1_tarief].Value)
  Me.[vrijveld2_totaal].Value = Val(Me.[vrijveld2_uren].Value) * Val(Me.vrijveld2_tarief].Value)
end sub


Sub Hoofdsub
   <allerlei activiteiten>
    even_eruit
   <allerlei activiteiten>
    even_eruit
   <allerlei activiteiten>
    even_eruit
end sub
 
Snap hem deels maar....
Wil hem bijvoorbeeld bovenaan in mijn VBA zetten en deze altijd kunnen raadplegen.
Dat gebeurt hier niet volgens mij?

Hier gebeurt het in een gebeurtenis of heb ik het mis?
 
Laatst bewerkt:
Als je zo'n blok altijd wilt kunnen gebruiken, moet je er een functie van maken op een apart Moduleblad. Als de code op een formuliermodule staat, werkt hij alleen op dat formulier.

Code: 
Private Function evenRekenen()
  Me.[Personeel_totaal].Value = Val(Me.[Personeel_uren].Value) *   Val(Me.Personeel_tarief].Value) 
  Me.[Transport_totaal].Value = Val(Me.[Transport_uren].Value) * Val(Me.Transport_tarief].Value)
  Me.[Inkopen_totaal].Value = Val(Me.[Inkopen_uren].Value) * Val(Me.Inkopen_tarief].Value)
  Me.[Huur_totaal].Value = Val(Me.[Huur_uren].Value) * Val(Me.[Huur_tarief].Value)
  Me.[Veiligheid_totaal].Value = Val(Me.[Veiligheid_uren].Value) * Val(Me.Veiligheid_tarief].Value)
  Me.[vrijveld1_totaal].Value = Val(Me.[vrijveld1_uren].Value) * Val(Me.vrijveld1_tarief].Value)
  Me.[vrijveld2_totaal].Value = Val(Me.[vrijveld2_uren].Value) * Val(Me.vrijveld2_tarief].Value)
End Function

Code: 
Sub cmdRekenen_Click()
   'Wat er moet gebeuren
    Call EvenRekenen
   'En de rest
end sub
Overigens is jouw code dermate specifiek, dat die waarschijnlijk alleen maar op één formulier werkt.
 
Laatst bewerkt:
Juist werkt!!

Maar hoe gebruik ik de Call als hij in een aparte module staat?
Een aparte module is wel handig denk ik..
 
Op dezelfde manier alleen moet je er in een module een Public Function van maken in plaats van een Private Function
 
Oke.....

Maar ik heb nu dit onder een gebeurtenis.
Code: 
Private Sub Personeel_tarief_AfterUpdate()
    Call bereken_personeel_totaal
End Sub

in de module heb ik dit:
Code: 
lo
Public Function bereken_personeel_totaal()
  Me.[Personeel_totaal].Value = Val([B]Me[/B].[Personeel_uren].Value) * Val(Me.[Personeel_tarief].Value)
End Function

Enkel werk dit niet hij blijft bij de 2e ME hangen als ik de fout opvraag... hij zie de Public funtion dus wel want hij open de module

Dit stukje werkte wel toen ik hem zonder macro gebruikte als Private Function, de call werkte toen perfect.

Vreemd?
 
Laatst bewerkt:
Met Me verwijs je in een formulier-module naar het formulier. In een algemene module werkt dat niet. Je kunt als oplossing b.v de functie aanpassen door een argument mee te geven

Function bereken_personeel_totaal(f As Form)
f.[Personeel_totaal]= Val(f.[Personeel_uren]) * Val(f.[Personeel_tarief])
End Function

De functie roep je dan aan met
Private Sub Personeel_tarief_AfterUpdate()
Call bereken_personeel_totaal(me)
End Sub

Opmerking:
In een algemene module neem je functies en subroutines op die vanaf verschillende 'posities' in je db moeten worden gebruikt. In dit geval lijkt mij dat niet het geval, en zou je beter de functie in de formulier-module zetten (hoef je ook niets aan te passen)
 
Oke je vervang me eigenlijk door iets anders niks meer niks minder.

Alleen nu gebruik je f maar je moet elke keer een andere letter of woord gebruiken neem ik aan?

Me Me kan je wel verwijzen naar een formulier maar niet andersom begrijp ik??
 
Me gebruik je als je iets wilt aanroepen vanuit een formulier of rapport bijvoorbeeld. Code die je op een formulier maakt, hoort bij dat specifieke formulier, en kun je niet op een ander formulier aanroepen. Vandaar dat je met Me. ziet wat er op dat formulier aan objecten staat.
Zet je code in een algemene module, dan staat de focus (zeg maar voor het gemak) niet meer op het formulier, je hebt tenslotte een andere module geactiveerd. Vandaar dat je het formulier als parameter mee moet geven met de call opdracht.
In het voorbeeld: Call bereken_personeel_totaal(me).
In de functie heb je met f As Form een variabele van het type formulier gedefinieerd, die de letter f heeft gekregen. Dat mag uiteraard elke naam zijn die je wilt, zolang het een geldige naam is. Je mag dezelfde naam in meerdere functies definiëren, al schiet je daar niet zo veel mee op als je de ene routine de andere laat aanroepen. Zelf doe ik dat op voorhand niet, en ik denk dat de meesten wel aparte variabelenamen gebruiken in de verschillende functies. Er zit namelijk geen voordeel in het gebruiken van steeds dezelfde variabelenaam, hooguit nadelen.
 
Hoi,

Klopt bedankt.
Ik gebruik echter nog steeds (me) zie ik, wat is daar de logica van?
Code: 
De functie roep je dan aan met
Private Sub Personeel_tarief_AfterUpdate()
Call bereken_personeel_totaal(me)
End Sub

Daarnaast gebruik ik Function zie ik en geen Public Function, wat is daar de logica van?

Code: 
Function bereken_personeel_totaal(f As Form)
f.[Personeel_totaal]= Val(f.[Personeel_uren]) * Val(f.[Personeel_tarief])
End Function
 
In de aanroep van de functie moet je een variabele meegeven, anders doet de functie het niet. Je hebt immers bij de definitie een variabele f vastgelegd.
Die variabele moet van het type formulier zijn, vanwege f as Form
En dat doe je dus met Me. Meestal gebruik je Me in combinatie met een punt om een object van het formulier op te vragen. Me zonder punt vertegenwoordigt in dit geval het formulier.

Tweede vraag: Als je een functie definieert, kun je dat specfiek doen als een Private Function, of een Public Function. De standaard van Access is Public, dus als je dat woord weglaat, en alleen Function gebruikt, dan is-tie dus automatisch Public.
 
Oke, ik snap hem

Ik gebruik de module om een goed overzicht te houden in de standaard VBA, verder gebruik ik de module niet. Of dit logisch en handig is weet ik niet.

Laatste vraagje tot hier:
Kun je in een function een function aanroepen?

ik heb bijvoorbeeld 10 functions die ik apart gebruik maar soms wil ik ze ook alle 10 gebruiken.
 
Dat kan; hou daarbij wel in de gaten dat je alle variabelen die gebruikt onderweg niet kwijt raakt...
 
Ik heb nu dit verwerkt in het formulier niet in de module.
Het werkt, maar of hij nog makkelijker kan weet ik niet.

Code: 
Public Function bereken_personeel_totaal(bpt As Form)
    bpt.[Personeel_totaal] = Val(bpt.[Personeel_uren]) * Val(bpt.[Personeel_tarief])
End Function

Public Function bereken_transport_totaal(btt As Form)
    btt.[Transport_totaal] = Val(btt.[Transport_uren]) * Val(btt.[Transport_tarief])
End Function

Public Function bereken_inkopen_totaal(bit As Form)
    bit.[Inkopen_totaal] = Val(bit.[Inkopen_uren]) * Val(bit.[Inkopen_tarief])

    f.[Personeel_totaal]= Val(f.[Personeel_uren]) * Val(f.[Personeel_tarief])
End Function

Public Function bereken_huur_totaal(but As Form)
    but.[Huur_totaal] = Val(but.[Huur_uren]) * Val(but.[Huur_tarief])
End Function

Public Function bereken_veiligheid_totaal(bvt1 As Form)
    bvt1.[Veiligheid_totaal] = Val(bvt1.[Veiligheid_uren]) * Val(bvt1.[Veiligheid_tarief])
End Function

Public Function bereken_vrijveld1_totaal(bvt2 As Form)
    bvt2.[vrijveld1_totaal] = Val(bvt2.[vrijveld1_uren]) * Val(bvt2.[vrijveld1_tarief])
End Function

Public Function bereken_vrijveld2_totaal(bvt3 As Form)
    bvt3.[vrijveld2_totaal] = Val(bvt3.[vrijveld2_uren]) * Val(bvt3.[vrijveld2_tarief])
End Function

Public Function bereken_alles_totaal(bat As Form)
    Call bereken_personeel_totaal(Me)
    Call bereken_inkopen_totaal(Me)
    Call bereken_huur_totaal(Me)
    Call bereken_veiligheid_totaal(Me)
    Call bereken_vrijveld1_totaal(Me)
    Call bereken_vrijveld2_totaal(Me)
End Function

Code: 
Private Sub Form_Current()
Call bereken_totaal(Me)
End Sub

Netjes?


Slot vraag, dan kan dit topic op opgelost:

in het begin gebruik ik veel value maar later laten jullie die weg, wat doet deze niet of te veel?

Code: 
Me.[Personeel_totaal].Value = Val(Me.[Personeel_uren].Value) *   Val(Me.Personeel_tarief].Value) 

f.[Personeel_totaal]= Val(f.[Personeel_uren]) * Val(f.[Personeel_tarief])
 
Als het werkt, dan zou ik er verder niet teveel meer aan sleutelen. Op zich kun je alle losse berekenfunctie vervangen door één functie:

Code: 
Public Function Berekenen(Veld1 as String, Veld2 as String) as Double
    Berekenen = Val(Veld1) * Val(Veld2)
End Function

De aanroep op het formulier wordt dan:

Code: 
Call Berekenen(Me.Personeel_uren],Me.[Personeel_tarief])

Deze oplossing is dus een stuk simpeler, want je hebt maar één functie, die je voor alle velden kunt gebruiken. De functie zet je in een aparte module, en is onafhankelijk van het formulier te gebruiken, dus op alle formulieren bruikbaar.

De aanroep is nu met de twee velden op het formulier die de te berekenen waarden bevatten. De aanroep is dus op elke berekening anders. Je moet dus bij elke nieuwe berekening de veldnamen aanpassen.

Het laatste deel van de vraag is eigenlijk hetzelfde als een eerder antwoord: als je Me.[Personeel_tarief] in een aanroep of functie zet, beschouwt Access dat als de standaardaanroep. In dit geval is dat voor een object VALUE. Me.[Personeel_tarief] is dus hetzelfde als Me.[Personeel_tarief].Value, en daarom wordt Value vaak weggelaten. Voor de duidelijkheid zet ik het er meestal wel bij, zodat ik niet hoef na te denken over wat ik ook al weer opvraag.
 
Oke, opgelost.

Ja zoals ik het heb hoef je weinig te veranderen als er iets verander
ik u voorbeeld moet je meerdere dingen veranderen....

Ja het ene is netter het andere is makkelijker...
 
Laatst bewerkt:
Status
Niet open voor verdere reacties.
                    Steun ons                    

Nieuwste berichten

Terug
Bovenaan Onderaan