Man kan ju som bekant importera funktioner från en DLL och använda dessa som om de vore skrivna i ens egen kod. Vidare kan man man till en DLL exportera både funktioner och variabler (och klasser) från åtminstone C++ men även andra språk. Men hur gör man för att importera _variabler_ till ett VB-projekt?

En funktion importeras ju typ såhär:

private declare function func1 Lib "minDLL.dll" Alias "vad_func1_hette_där_den_exporterades_ifrån" (argument) as datatyp

Vad blir alltså mostvarande rad om jag vill importera en variabel istället, eller går det inte?

Tacksam för svar! /Jocke

Jag känner inte till någon sätt att göra detta.
Kan du berätta varför du vill dela minne mellan dll'n och vb?

I DLL:en som jag skapat i C finns en funktion och en variabel exporterade.
Variabeln är en "intern statusvariabel" som talar om hur långt exekveringen av funktionen hunnit. Tänkte använda detta till att fylla i en progress bar i VB där jag alltså har hela GUI:t.

Naturligtvis kan denna information hämtas med ett funktionsanrop men eftersom man kan exportera variabler (i alla fall från C/C++) till en DLL och dessutom importera dessa till C/C++ så tyckte jag att det borde gå att göra även i VB. Om sedan denna variabel kunde kopplas (på ngt sätt som jag inte funderat något djupare på) direkt till en textlabel (eller till progressbar:ens value-egenskap) så skulle man på så sätt få statusen uppdaterad utan att behöva fråga hela tiden med nån timerfunktion.

Det låter som om en CallBack funktion vore mer lämplig. Att du skickar en funktionspekar in till din funktion vilket sköter uppdatering av progressbaren.
Du har möjlighet att skicka funktionspekar till funktioner med hjälp av AddessOf operatorn i vb.

Jag håller med Andreas, en callbackfunktion är nog det smidigaste och smartaste i det här fallet (om jag har fattat dig rätt).

Här är ett exempel på hur callbacks implementeras i C men behandlas av VB:

C:

/* Callback definition. */
typedef void (CALLBACK *PROGRESSPROC)(float); /* float/int */

void WINAPI StartaJobbet(/* dina parametrar här */, PROGRESSPROC pCallback)
{
float progress=0.f;

/* Gör någonting... */

/* Uppdatera variabeln. */
progress+=10.f;

/* Kalla callbackproceduren i VB... */
pCallback(progress);
}

VB:

Private Declare Sub StartaJobbet Lib "MinDLL.dll" (..., ByVal pCallback As Long)

Public Sub MinCallback(ByVal progress As Single)
ProgressBar1.Value = progress
End Function

Private Sub Command1_Click()
StartaJobbet ..., AddressOf MinCallback
End Sub

Glöm dock inte att placera MinCallback i en modul. Det finns andra sätt att implementera callbacks på, men jag tycker detta sättet är simpelt och bekvämt, passar samt för mig i de flesta fallen. Notera även att koden ovan är otestad.

Lycka till!;)

Jag håller med om att ett funktionsanrop är snyggare och säkrare än att dela minne via en exporterad variabel. Jag har dock en fråga, kanske en dum sådan:

Detta med Callback, hur funkar det? Det verkar på din kod ovan som att jag i min dll kan köra funktionen som uppdaterar data i VB? Alltså istället för att behöva ha en timer i vb som periodiskt frågar dll:en (via en exporterad funktion) om status så kan jag alltså från den kod som körs i dll:en välja att uppdatera statusen när jag vill, är det rätt uppfattat?

@Joakim
Ja, det är rätt uppfattat. Fördelen är bl a att du inte behöver fråga efter förändringar då det med callback blir din dll som talar om för dig när det skett en förändring.

VB sidan:
Till din DLL funktion skickar du en funktionspekar med AddressOf operatorn till den VB funktion som uppdaterar din status.

DLL sidan:
Funktionen har en funktionspekare som en av sina parametrar. När den vil uppdatera status så anropar du denna funktionspekar.

VB Sidan:
Funktionen som skickades som parameter kommer att anropas. Du kan skicka med parametrar till funktionen. T. Ex. Tal om vilken post av hur många du är på. VB funktionen i ditt program känner till hur statusen skall uppdareas. D.v.s. Ökar på din progressbar.
VB funktionen retunerar

DLL sidan:
Fortsätter, upprepar anrop till callback funktionen.
Och avslutar till slut.

VB Sidan:
DLL funktionen du anropade returnerar nu och fortsätter på nästa sats efter funktionsanropet till DLL'n .

Joakim:

Callbacks är ett väldigt smidigt sätt att notifiera om hur processen (jobbet) fortlöper. Du kan givetvis inkludera något annat i callbackproceduren så som ett ID som talar om för moderprogrammet vad som just nu sker (läser filer, parse:ar filen, sparar filen osv). Exempel (byggande på föregående kod):

C:

/* Callback definition. */
typedef void (CALLBACK *PROGRESSPROC)(int,float);

void WINAPI StartaJobbet(/* dina parametrar här */, PROGRESSPROC pCallback)
{
float progress=0.f;

/* Gör någonting... */

/* Uppdatera variabeln. */
progress+=10.f;

/* Kalla callbackproceduren i VB... */

/* Nu läser vi data... */
pCallback(0,progress);

/* Nu analyserar vi data... */
pCallback(1,progress); */

/* Nu sparar vi data... */
pCallback(2,progress);
}

VB:

Private Declare Sub StartaJobbet Lib "MinDLL.dll" (..., ByVal pCallback As Long)

Public Sub MinCallback(ByVal id As Long, ByVal progress As Single)
Select Case id
Case 0
Label1.Caption = "Läser data..."
Case 1
Label1.Caption = "Analyserar data..."
Case 2
Label1.Caption = "Sparar data..."
End Select

' Uppdatera även progressbaren.
ProgressBar1.Value = progress
End Function

Private Sub Command1_Click()
StartaJobbet ..., AddressOf MinCallback
End Sub

Min poäng är att callbacks är extremt användbara. De är ett utmärkt sätt att exempelvis uppdatera GUI:n med bl a progressvärdet och statusen, precis som i en vanlig "Event" (händelse) i VB. Hoppas du "get the picture".:)