API Deklarationen in VB und Vba

Computer: Software & Programmierung Visual Basic
#1

Hallo Wissende,

ich glaub die C-Leute lagern sowas aus in einer Header Datei wie xyz.h oder so.

Alle Codes die ich bisher sah in VB/Vba machen das nicht, da steht im Modul immer brav oben die ganzen API-Deklarationen und das können ganz schön viele sein und wenn da noch mit DefType spezielle Variablen generiert werden oder bei Key-Auswertung die ganzen Hexcodes für die Keys aufgelistet werden, so wird das irre lang.

Meist ist dann der eigentliche Code der nachher kommt relativ viel kleiner.

Kann man nun diese APIdeklaratinoenen in ein eigenes Modul auslagern und trotzdem die APIs benutzen?

Sicher ich kann es probieren, einfach das Private weg usw.

Das Ergebnis hilft mir aber leider nicht weiter.
Geht es so nicht will ich wissen wie es denn wenn überhaupt anders geht.
Funktioniert dies so bin ich mißtrauisch genug geworden um vorher zu fragen, ob es mal in itgendeiner Konstellation falsche Ergebnisse oder sonstwas bringen sollte.

Denn mir gibt da schwer zu denken daß ich noch nie so derart ausgelagerte API-Deklarationen sah, wird also wohl ein Grund dahinterstecken.

Wie gesagt, Private weg und testen kann ich selbst.

Danke ^ Gruß
Reinhard

#2

Hallo Reinhard,

Wie gesagt, Private weg und testen kann ich selbst.

ja, Private durch Public ersetzen, ab in ein Modul, funktioniert.

Wenn Du dann in der Deklaration nachlesen möchtest, welcher Wert wohin kommt, musst Du das Modul öffnen. Das ist aber auch der einzige Nachteil.

Gruß Rainer

#3

Hallo Rainer,

Wie gesagt, Private weg und testen kann ich selbst.

ja, Private durch Public ersetzen, ab in ein Modul,
funktioniert.

okay, danke.

Das ist aber auch der einzige Nachteil.

Genau sowas bzw. das wollte ich wissen.

Gruß
Reinhard

#4

Hallo Reinhard,

ich glaub die C-Leute lagern sowas aus in einer Header Datei
wie xyz.h oder so.

Nein! Die beanannten Datei sind sogenannte Header Dateien. Sie enthalten Function und Proceduren soweit ich weiss. Einbinden tust du diese mittels Include. Der Präprozessor macht beim kompilieren nichts anderes, als die Include Zeile entfernen und dafür den gesammten Source aus der Header Datei einpflegen.

Nehmen wir mal an, du hast in der Header Datei eine Function XYZ.

Im Program rufst du nun die Function XYZ auf, dann schimpft der Compiler rum, weil er XYZ nicht kennt. Also importierst du die HeaderDatei wo ja die Function xyz vorhanden ist. Ergo schimpft der Compiler nicht mehr! Beim Compilieren wiederrum entfernt er die Zeile und schreibt den Source von der Header Datei direkt in dein Program. Also die Function XYZ :wink:

Alle Codes die ich bisher sah in VB/Vba machen das nicht, da
steht im Modul immer brav oben die ganzen API-Deklarationen
und das können ganz schön viele sein und wenn da noch mit
DefType spezielle Variablen generiert werden oder bei
Key-Auswertung die ganzen Hexcodes für die Keys aufgelistet
werden, so wird das irre lang.

Richtig, Dafür sind Module auch da :wink:
Mit DefType wäre ich sehr vorsichtig, denn da bekommst du unwahrscheinlich schnell einen Bock in dein Program, wo du Stunden mit suchen vebringen kannst *grins*

Bsp.

\*puh wie war das ...

Defbyte A-K

Private Sub Test
Dim I as Integer
For I=1 to 1000
Next
End Sub

Sollte meines Erachtens entweder gar nicht starten oder einen Fehler bringen weil du I zweimal declariert hast!

Meist ist dann der eigentliche Code der nachher kommt relativ
viel kleiner.

Richtig :smile:
Am besten ist es ein Modul anzulegen mit dem Namen vbAPI
Dortrein halt alle Declarationen und Konstanten. Beide als Public und im Program dann nur die API aufrufen :smile:

Kann man nun diese APIdeklaratinoenen in ein eigenes Modul
auslagern und trotzdem die APIs benutzen?

Ja, wenn sie als Public declariert sind!

Sicher ich kann es probieren, einfach das Private weg usw.

Das Ergebnis hilft mir aber leider nicht weiter.

Geht es so nicht will ich wissen wie es denn wenn überhaupt
anders geht.

Am besten wie ich es schrieb in ein Modul und fertig :smile:

Funktioniert dies so bin ich mißtrauisch genug geworden um
vorher zu fragen, ob es mal in itgendeiner Konstellation
falsche Ergebnisse oder sonstwas bringen sollte.

Jups das klappt :smile:

Denn mir gibt da schwer zu denken daß ich noch nie so derart
ausgelagerte API-Deklarationen sah, wird also wohl ein Grund
dahinterstecken.

Schau mal in die FAQ wo der Source ist, wie man Steuerelemente erstellt XP Button :wink:

Wie gesagt, Private weg und testen kann ich selbst.

Private durch Public ersetzen!

Übrigens wie man eine API unter c++ etc declariert weiss ich auch nicht. Aber unter VB.NET gibt es zwei wege. Einer davon kommt Dir sicher bekannt vor :wink: Auch wirst du sehen das es an Schreibarbeit nichts spart. Also unter .NET die gleichen Probleme wie unter VB6.

Bsp.

'Variante 1:
Private Declare Function RegisterHotKey Lib "user32" ( \_
 ByVal Hwnd As IntPtr, \_
 ByVal ID As Integer, \_
 ByVal Modifiers As Integer, \_
 ByVal Key As Integer) As Integer
Variante 2:
 \_
Public Shared Function RegisterHotKey( \_
 ByVal Hwnd As IntPtr, \_
 ByVal ID As Integer, \_
 ByVal Modifiers As Integer, \_
 ByVal Key As Integer) As Integer
End Function

in .NET hast du natürlich auch noch die Möglichkeit dem Framework beim Aufruf der API noch weitere Parameter mitzugeben :wink:
Das schaut dann so aus

 \_
Public Shared Function MeineFunktion( \_
 ByVal Param1 As Integer)
End Function

MfG Alex

Danke ^ Gruß

Reinhard

#5

Hallo Alex,

ich glaub die C-Leute lagern sowas aus in einer Header Datei
wie xyz.h oder so.

Nein! Die beanannten Datei sind sogenannte Header Dateien.
Sie enthalten Function und Proceduren soweit ich weiss.
Einbinden tust du diese mittels Include. Der Präprozessor
macht beim kompilieren nichts anderes, als die Include Zeile
entfernen und dafür den gesammten Source aus der Header Datei
einpflegen.

? das ist doch genau was ich sagte/meinte, im eigentlichen Codemodul schreiben sie oben halt rein binde api.h ein und fertig.

Warum ich angefragt habe ist ja nur, bzw. hat den Hintergrund, mich stört es halt ungemein, wenn ich ein Modul sehe und von den obersten 10-60 Zeilen nix habe weile das nur gebündelte Deklarationen sind, erst dann kommt der eigentliche Code.

Könnte man die Deklarationen unterhalb des Codes machen hätte ich gar nicht gefragt *vielleicht*

Nehmen wir mal an, du hast in der Header Datei eine Function
XYZ.
Im Program rufst du nun die Function XYZ auf, dann schimpft
der Compiler rum, weil er XYZ nicht kennt. Also importierst du
die HeaderDatei wo ja die Function xyz vorhanden ist. Ergo
schimpft der Compiler nicht mehr! Beim Compilieren wiederrum
entfernt er die Zeile und schreibt den Source von der Header
Datei direkt in dein Program. Also die Function XYZ :wink:

Ja, so wird es sein und so stelle ich mir das auch vor, eine kompilierte Exe, äh das war jetzt irgendwie Verdopplung, oder gibts auch unkompilierte exe? :smile:, müße sollte soviel wie möglich in sich haben um zu funktionieren, überall.

Alle Codes die ich bisher sah in VB/Vba machen das nicht, da
steht im Modul immer brav oben die ganzen API-Deklarationen
und das können ganz schön viele sein und wenn da noch mit
DefType spezielle Variablen generiert werden oder bei
Key-Auswertung die ganzen Hexcodes für die Keys aufgelistet
werden, so wird das irre lang.

Richtig, Dafür sind Module auch da :wink:

Schon, aber mich stört es halt wenn ich oben 40 Zeilen habe und unten erst die 20 Zeilen Code die mich eigentlich interessieren.

Das kann durchaus eine psychologische Macke von mir sein. Wenn ich Code teste, der zwar funktionieret aber noch macken hat, so schmeiß ich den ja nicht weg. Ich kopier den und füge ihn wieder ein.
Den unteren kommentiere ich aus oder bennen ihn kurz um.
Und bastle dann am oberen weiter.

Wie das andere machen, k.A. *Schulterzuck*

Mit DefType wäre ich sehr vorsichtig, denn da bekommst du
unwahrscheinlich schnell einen Bock in dein Program, wo du
Stunden mit suchen vebringen kannst *grins*

Danke für den Tipp.
Soll das jetzt bedeuten DefType nicht „auslagern“ in ein anderes Modul, deshalb kommt dann so ein „Bock“ oder meinst du etwas anderes?

*puh wie war das …

Tztz, so jung und schon Alzheimer, weißte wenigstens noch dessen Vornamen? *besorgt schau* *kicher*

Am besten ist es ein Modul anzulegen mit dem Namen vbAPI
Dortrein halt alle Declarationen und Konstanten. Beide als
Public und im Program dann nur die API aufrufen :smile:

Also diese Deftype auch oder nicht?

Denn mir gibt da schwer zu denken daß ich noch nie so derart
ausgelagerte API-Deklarationen sah, wird also wohl ein Grund
dahinterstecken.

Schau mal in die FAQ wo der Source ist, wie man
Steuerelemente erstellt XP Button :wink:

Ich wußt genau als ich deinen Namen las, ich brauch wieder einen Dometscher, so wie jezt bei diesem Satz *gg*

Übrigens wie man eine API unter c++ etc declariert weiss ich
auch nicht. Aber unter VB.NET gibt es zwei wege. Einer davon
kommt Dir sicher bekannt vor :wink: Auch wirst du sehen das es an
Schreibarbeit nichts spart. Also unter .NET die gleichen
Probleme wie unter VB6.

Die Schreibarbeit oder Reinkopierarbeit ist mir gleich, aber ich will ja API nur benutzen, wie alle anderen Befehle Funktionen in VB/Vba.
Daß die jetzt unterschiedlich sind spielt ja für das was ich will keine Rolle.

Bsp.: Ich will im Code den Befehl InStr(…) benutzen.
Könnte ja rein theoretisch sein Vb Funktionen brauchen so wie APIs Deklaration im Code.

Dann würd ja da auch „Oben“ stehen:
Private Declare Instr ALias …

Und das für jeden benutzten VB-Befehl, eieieiei, dann würd der Vorspann aber recht lang :frowning:

Ich bedanke mich für alle Antworten. Ich weiß jetzt mit viel mehr Sicherheit als wenn ich es einfach mal getestet hätte, ich kann die Deklarationen in ein anderes Modul auslagern. Das hilft mir.

Offen ist einzig noch das mit DefType. Da hat mich Alex verunsichert.

Gruß
Reinhard

#6

Hallo Reinhard,

? das ist doch genau was ich sagte/meinte, im eigentlichen
Codemodul schreiben sie oben halt rein binde api.h ein und
fertig.

Was in C halt das importieren der Header Dateien sind, ist in .Net zum Bsp. das importieren von Namensspace. In VB6 sind es halt die Runtimes, die du aber nicht angeben musst :wink:

Warum ich angefragt habe ist ja nur, bzw. hat den
Hintergrund, mich stört es halt ungemein, wenn ich ein Modul
sehe und von den obersten 10-60 Zeilen nix habe weile das nur
gebündelte Deklarationen sind, erst dann kommt der eigentliche
Code.

Es ist ein wenig nervig. Deswegen schrieb ich Dir auch. Hey lege Dir ein Modul zum Bsp. vbAPI an und schreibe dort alle Declarationen rein.
Den Source kannst du dann irgendwo anders im Proggi unterbringen und schon siehst du die ganzen Declarationen nicht! Selbst wenn Dich das stören sollte, dann schreibst du halt eine Wrapper DLL, wo du alle Definitionen rein machst und dann die zugehörigen Functionen / Subs. Die DLL kannst du dann in Dein Proggi einbinden und schon siehst du rein garnichts mehr :wink:

Könnte man die Deklarationen unterhalb des Codes machen hätte
ich gar nicht gefragt *vielleicht*

Also unter .NET geht das. Da spielt es keine Rolle wo man die Declaration macht, so lange sie nur in der Klasse sind!

Ja, so wird es sein und so stelle ich mir das auch vor, eine
kompilierte Exe, äh das war jetzt irgendwie Verdopplung, oder
gibts auch unkompilierte exe? :smile:, müße sollte soviel wie
möglich in sich haben um zu funktionieren, überall.

Owei nun hast du etwas angeschnitten *grins*
Also …
Ein Program wird unter VB mit der Version bis 6 durch das kompilieren in einen MaschinenCode übersetzt. Das Resultat daraus ist halt die EXE Datei, was Deine erste Frage nun beantwortet. In .NET ist das ein wenig anders. Dort wird durch das kompilieren der Source in einen sogeannten IL Source übersetzt. Der Prozessor dagegen kann aber mit dem „Code“ nichts anfangen. Aber genau da kommt dann das Framework ins Spiel! Dieser übersetzt Dir den IL Code in MaschinenCode den Dein Prozessor ausführen kann. Warum das alles? Jeder Prozessor hat eine Befehlssatz den er interpretieren kann. In diesen werden programme übersetzt die bis zur Version 6 von VB geschrieben wurden! Klingt komfortable ist aber nicht performant genug. Das Framework wird bei der Installation an den Prozessor angepasst, somit wird dann auch der IL Code an den Prozessor angepasst, was zur Folge hat das die Programme etwas schneller laufen :smile:

Aber Reinhard das ist eine Thematik, worüber ich Tage lang schreiben könnte. Aber vom Prinzip her, hast du ja verstanden was ich meinte :smile:

Schon, aber mich stört es halt wenn ich oben 40 Zeilen habe
und unten erst die 20 Zeilen Code die mich eigentlich
interessieren.

Dann schreibe die Declarationen in ein Modul. Und in diesem Modul schreibst du NUR die Declarationen rein. In ein anderes Modul dann halt die Aufrufe :smile: Dann siehst du sie nicht. Und wenn Dich das stört, dann schreibe Dir halt die Wrapper DLL und binde diese ein.

Das kann durchaus eine psychologische Macke von mir sein.
Wenn ich Code teste, der zwar funktionieret aber noch macken
hat, so schmeiß ich den ja nicht weg. Ich kopier den und füge
ihn wieder ein.

Also entweder der Source klappt oder er hat Fehler *grins* Beides zur gleichen Zeit geht nicht!

Den unteren kommentiere ich aus oder bennen ihn kurz um.

Warum? Ändern so das er läuft!

Und bastle dann am oberen weiter.

Beim compilieren werden zwar alle Kommentare entfernt aber in der Hochsprache steht er da und das finde ich dreimal nerviger als ein paar Declarationen, wobei diese auch ihren Sinn haben.

Wie das andere machen, k.A. *Schulterzuck*

Gleich richtig schreiben oder den Fehlerhaften Source korrigieren!

Soll das jetzt bedeuten DefType nicht „auslagern“ in ein
anderes Modul, deshalb kommt dann so ein „Bock“ oder meinst du
etwas anderes?

Nein, ich meinte auf DefType sprich DefInt, DefByte etc. ganz verzichten und stattdessen nur das nötigste mit ausschlagebenden Worten declarieren und viel als Parameter übergeben. Nicht so viel als Public definieren etc. Das kann schnell zu unerwünschten Effekten führen!

Tztz, so jung und schon Alzheimer, weißte wenigstens noch
dessen Vornamen? *besorgt schau* *kicher*

Ähmmm, ich würde jetzt pauschal sagen Adonis aber ich glaub Alois war er oder? :smiley:

Am besten ist es ein Modul anzulegen mit dem Namen vbAPI
Dortrein halt alle Declarationen und Konstanten. Beide als
Public und im Program dann nur die API aufrufen :smile:

Also diese Deftype auch oder nicht?

Nein auf DefType ganz verzichten! Warum willst du das bindend nutzen?
Irgendwo liesst Du dann eine Variable und siehst was ihr für ein Wert zugewiesen wird. Nun stehst du da und sagst Dir … Boar als was habe ich die denn definiert … und dann beginnst du zu suchen… Besser ist es die Variablen so zu definieren wie du sie brauchst und vor allen nur wann!

Ich wußt genau als ich deinen Namen las, ich brauch wieder
einen Dometscher, so wie jezt bei diesem Satz *gg*

Was konnte man denn daran nicht verstehen Reinhard? Schau ich habe zum Bsp. einen Dozenten, der mir gelegentlich hilft bei dem einen anderen Problem. Aber du musst mal die Antworten lesen, da legst du die Ohren an *grins* Er selber postet selten Source, er will halt das du selber drauf kommst. Ich dagegen versuche Dir das haarklein vorzukauen :smiley: Und wenn du mal etwas nicht verstehst, so sage dann halt einfach bescheid. Dann probiere ich es eben anders. Solange bis es klick gemacht hat :smile:

Die Schreibarbeit oder Reinkopierarbeit ist mir gleich, aber
ich will ja API nur benutzen, wie alle anderen Befehle
Funktionen in VB/Vba.

Das kannst du ja!
Zum Bsp. Du hast 2 Formulare. Diesen machen ihren Dienst und greifen auf ein paar Functionen zu. Also beide Formulare auf die selben Funktionen. Was bietet sich da an ? Ok, wir legen die Function in ein Modul und rufen Sie nur auf! In den Formularen oder auch in dem Modul greifst du wiederrum auf API’s zu. Was spricht dann gegen folgende Vorgehensweise

Form1 -\> Dein 1 Formular
Form2 -\> Dein 2 Formular
modAllgemein -\> Modul mit deinen allgemeinen Functionen
modDEc -\> Modul wo du nur Declarationen der API's rein machst

Wenn du dir nun den Source anschaust, so blicke einfach nicht in die modDec rein :smile: Schon siehst du keine Declaration mehr!

Daß die jetzt unterschiedlich sind spielt ja für das was ich
will keine Rolle.

Also in .NET schon. Je nachdem wie du sie declarierst kannst Du sie nicht in ein Modul packen :frowning:

Bsp.: Ich will im Code den Befehl InStr(…) benutzen.

Könnte ja rein theoretisch sein Vb Funktionen brauchen so
wie APIs Deklaration im Code.

Dann würd ja da auch „Oben“ stehen:

Private Declare Instr ALias …

Und das für jeden benutzten VB-Befehl, eieieiei, dann würd
der Vorspann aber recht lang :frowning:

Nicht wenn du ihn zum Bsp. in die modDec packen würdest und sie als Public Declarierst :wink:

Ich bedanke mich für alle Antworten. Ich weiß jetzt mit viel
mehr Sicherheit als wenn ich es einfach mal getestet hätte,
ich kann die Deklarationen in ein anderes Modul auslagern. Das
hilft mir.

Offen ist einzig noch das mit DefType. Da hat mich Alex
verunsichert.

So dann frage mal nocht bitte genauer nach, wo du nun unsicher bist Reinhard :smile: Aber antworten kann ich erst wieder am WE, da ich die Woche nun nach Chemnitz muss :s

Gruß

Reinhard

MfG Alex