कॉलबैक

Question

के साथ इनो सेटअप से कॉल सी # डीएलएल मेरे पास एक चल रही इनो सेटअप स्क्रिप्ट है, जिसमें मैं शेरलॉक सॉफ्टवेयर द्वारा innocallback.dll का उपयोग करता हूं।

यह डीएलएल मेरी प्रक्रिया को लपेटता है ताकि इसे सी # डीएलएल में पारित किया जा सके।

मैं इस डीएलएल का उपयोग नहीं करना चाहता, मैं सीधे अपने निर्यात किए गए सी # विधि को कॉल करना चाहता हूं और कॉलबैक प्रक्रिया को पास करना चाहता हूं।

मेरा प्रश्न है:

मैं अपने सी # DLL करने के लिए अपने Inno सेटअप प्रक्रिया (@mycallback) पारित कर सकते हैं ताकि मैं अपने delegate/UnmanagedFunctionPointer के रूप में उपयोग कर सकते हैं?

जैसा कि मैंने कहा था कि यह कोड काम करता है, लेकिन मैं जितना संभव हो सके बाहरी डीएलएल के रूप में उपयोग करना चाहता हूं।

यहाँ मेरी कोड है:

Inno सेटअप स्क्रिप्ट

type 
    TTimerProc=procedure(); 
    TProgressCallback=procedure(progress:Integer); 
    
function WrapProgressProc(callback:TProgressCallback; paramcount:integer):longword; 
    external 'wrapcallback@files:innocallback.dll stdcall'; 

function Test(callback:longword): String; 
    external 'Test@files:ExposeTestLibrary.dll stdcall'; 

var 
    endProgram : Boolean; 

procedure mycallback(progress:Integer); 
begin 
    MsgBox(IntToStr(progress), mbInformation, MB_OK);  
    if progress > 15 then 
    begin 
    endProgram := True; 
    end 
end; 
   
function InitializeSetup:boolean; 
var 
    progCallBack   : longword; 
    callback       : longword; 
    msg            : longword; 
    msg2           : widestring; 
begin 
    endProgram := False; 
    progCallBack:= WrapProgressProc(@mycallback,1); //Our proc has 1 arguments 
    Test(progCallBack); 
    result:=true; 
end; 

और ये मेरे सी # कोड

public class TestClass 
{ 
    [UnmanagedFunctionPointer(CallingConvention.StdCall)] 
    public delegate void ReportProgress(uint progress); 

    public static ReportProgress m_reportProgess; 
    static uint m_iProgress; 
     
    [DllExport("Test", CallingConvention = CallingConvention.StdCall)] 
    static int Test(ReportProgress rProg) 
    { 
        m_iProgress = 0; 
        m_reportProgess = rProg; 
        System.Timers.Timer pTimer = new System.Timers.Timer(); 
        pTimer.Elapsed += aTimer_Elapsed; 
        pTimer.Interval = 1000; 
        pTimer.Enabled = true; 
        GC.KeepAlive(pTimer); 
        return 0; 
    } 

    static void aTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e) 
    { 
        m_iProgress++; 
        m_reportProgess(m_iProgress); 
    } 
} 

Answer 1

रैपिंग के उपयोग ड्रॉप करने का कोई तरीका नहीं है InnoCallback लाइब्रेरी क्योंकि आप कॉलिंग कन्वेंशन के साथ कॉलबैक प्रक्रिया को परिभाषित नहीं कर सकते हैं इनो सेटअप में अपनी पसंद का, न ही आप अपने सी # लाइब्रेरी में register कॉलिंग कन्वेंशन (डेल्फी कंपाइलर के लिए विशिष्ट) के साथ कॉलबैक परिभाषित कर सकते हैं।

इस सीमा के कारण आपको बाहरी पुस्तकालय का उपयोग करना होगा, जो आपके लाइब्रेरी का उपभोग कर सकते हैं (इनोकॉलबैक stdcall का उपयोग करता है) के साथ एक फ़ंक्शन में इनो सेटअप से कॉलबैक विधि को लपेटता है।

तो, यदि आप अपनी भाषा को ऐसी भाषा में लिख रहे थे जो डेल्फी के register कॉलिंग सम्मेलन का समर्थन करता है तो आप क्या पूछ रहे हैं। जिज्ञासा से बाहर, डेल्फी में आप जैसे लिख सकते हैं:

library MyLib; 

type 
    TMyCallback = procedure(IntParam: Integer; StrParam: WideString) of object; 

procedure CallMeBack(Callback: TMyCallback); stdcall; 
begin 
    Callback(123, 'Hello!'); 
end; 

exports 
    CallMeBack; 

begin 
end. 

और Inno सेटअप तो में (किसी भी रैपिंग पुस्तकालय के बिना):

[Setup] 
AppName=My Program 
AppVersion=1.5 
DefaultDirName={pf}\My Program 

[Files] 
Source: "MyLib.dll"; Flags: dontcopy 

[Code] 
type 
    TMyCallback = procedure(IntParam: Integer; StrParam: WideString); 

procedure CallMeBack(Callback: TMyCallback); 
    external 'CallMeBack@files:mylib.dll stdcall'; 

procedure MyCallback(IntParam: Integer; StrParam: WideString); 
begin 
    MsgBox(Format('IntParam: %d; StrParam: %s', [IntParam, StrParam]), 
    mbInformation, MB_OK); 
end; 

procedure InitializeWizard; 
begin 
    CallMeBack(@MyCallback); 
end;