C# - Softwareschil, aanroepen functie andere thread

[korgakos]

Beste medeTweakers!,

Ik heb een programma die ik kan aansturen met verschillende functies geschreven in c++

Hiervoor heb ik DLL geschreven omdat de taal waar ik het in schrijf C# is.

Tot nu toe werkt alles, ik kan een instantie vna het programma opstarten, ik kan alle instructies uitvoeren etc.

Maar nu is er een instructie (import) die een file moet importeren met miljoenen regels, wat op zijn beurt weer ellendenlang duurt.. (lees 60+ sec)
en nu voel je het aankomen, dan gaat uiteraard de UI zichzelf locken..

Mijn eerste solution was, om gewoon alle instructies vanuit een backgroundworker te doen, dit werkte prima, maar niet geheel naar mijn wens.

Wat ik nu wil:

Ik wil graag vanuit de UI, functies kunnen aanroepen (bijvoorbeeld het opstarten van het programma etc) en vanuit een aparte thread wil ik die `import` functie aanroepen.

Kan ik (en hoe) dit realiseren?


Ik heb de volgende test gedaan:
2 dll's gemaakt, en via de een het programma opstarten en via een functie de pointer achterhalen van "pApp"
om via een ander dll de volgende functie aan te roepen:

pApp->ShowWindow(flag);

Dit werkte, maar wanneer ik dit ga doen in een andere thread,lukt dit op geen enkele manier
(die mij bekend is..)

Schijnbaar gaat dit niet lukken vanuit een andere thread dan waar het programma aangeroepen is.

Weet iemand hier een oplossing voor? Of een andere manier op hoe ik dit beter kan doen?

Overigens kleine info:
Ik ben pas enkele weken geleden begonnen met C#, dus ik weet nog niet geheel van alle mogelijkheden af.

Mvg

Erwin

[Danot]

Kijk eens naar MSDN Using Threading (C# Programming Guide). Hiermee zou je uit de voeten moeten kunnen.

Volgens mij hoef je niet 2 dlls te maken. Gewoon de dll aanspreken vanuit je C#-thread. Je GUI draait dan op een andere thread.

[korgakos]

Danot schreef op dinsdag 01 december 2009 @ 11:28:
Kijk eens naar MSDN Using Threading (C# Programming Guide). Hiermee zou je uit de voeten moeten kunnen.

Volgens mij hoef je niet 2 dlls te maken. Gewoon de dll aanspreken vanuit je C#-thread. Je GUI draait dan op een andere thread.

Maar zoals ik al zei had ik al een "thread" gebruikt (backgrounworker)
of zie ik het verkeerd?

ik zou graag direct vanuit de UI de functies willen aanroepen, maar de import functie wil ik vanuit een aparte thread doen, aangezien dit de enige is die lang duurt

[edit]
Of bedoel je het stuk, multithread?

[ Voor 3% gewijzigd door korgakos op 01-12-2009 11:32 ]

[Verwijderd]

Ik begrijp je post niet helemaal, maar mijn interpretatie is dat je problemen krijgt in de trand van CrossThread exceptions, klopt dat?
Je UI draait in een aparte thread, de main, data die bij een andere thread hoort (je backgroundworker) hebben daar niet zonder meer toegang toe, je zult aan de slag moeten met delegates om het thread boundary probleem op te lossen.

[ Voor 6% gewijzigd door Verwijderd op 01-12-2009 11:35 ]

[D-Raven]

Je kunt je type die je in je backgroundworker hebt ingeladen, teruggeven aan de UI thread. Zie de documentatie van de backgroundworker over hoe je resultaten uit je DoWork delegate kunt marshallen naar je UI thread.

Hint: RunWorkerCompleted event..

[korgakos]

Nou toen ik vanuit de backgroundworker alle functies uitvoerde die communiceerden met het aan te sturen programma, toen kreeg ik wel eens CrossThread exceptions.
Die kreeg ik wel uiteindelijk weg maar ik vond dit geen mooie oplossing

Daarom wou ik de functies gewoon in de UI laten draaien, behalve de timeconsuming functies (import functie)
deze wil ik apart in een losse thread draaien.

Alleen weet ik niet hoe ik dit moet realiseren

edit:
ik moet wel zeggen dat hier snel gereageerd word, thumbs up !

[ Voor 8% gewijzigd door korgakos op 01-12-2009 11:44 ]

[korgakos]

Misschien verduidelijkt dit het:

De c++ code in de dll file die ervoor zorgt dat het programma zich opstart:

C++:

// initialize COM Library
    CoInitialize (NULL);
    // create Application object
    // note: on successful creation, an instance of PGApp will be launched
    // on the server machine
    hr = CoCreateInstance (CLSID_PGApplication, NULL,
    CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER,
    IID_IPGApplication, (void**)&pApp);

    assert(SUCCEEDED(hr));
    hr = pApp->ShowWindow( 0 ); 

    // obtain System object
    hr = pApp->GetSystem(&pTmp);
    assert(SUCCEEDED(hr));
    hr = pTmp->QueryInterface(IID_IPGSystem, (void **)&pSystem);
    assert(SUCCEEDED(hr));
    pTmp->Release();
    // … use objects here
    // release objects
    // note: after the Application object is released, the instance of PGApp that
    // was launched at creation will terminate

De functies vanaf dit punt gebruiken dan of pApp of pSystem.
Dus ik dacht van als ik nu een functie maakt die deze 2 retourneert, en dan via een IntPtr in C# binnen haalt, en dan weer terug stuurt naar een andere functie. en dan een functie aanroept, dacht ik dat het misschien zou lukken om via een andere thread een functie aan te roepen, maar dat lukte niet

C#:

public class PGApp_COM
{
[ComImport, Guid("6173E342-AABF-4698-A9BD-AC964F609668")]
public class CoInitializeEx
{
}

[ComImport, Guid("6173E341-AABF-4698-A9BD-AC964F609668"), InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
public interface IPGApplication
{
void ShowWindow(long i);
[return: MarshalAs(UnmanagedType.Interface)]
object GetSystem();
}
[ComImport, Guid("00000000-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
public interface IDispatch 
{
[return: MarshalAs(UnmanagedType.IDispatch)]
object QueryInterface(Guid guid);
}

[ComImport, Guid("6173E343-AABF-4698-A9BD-AC964F609668"), InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
public interface IPGSystem
{
int GetModuleCount();
int GetModuleSerialNumber(
int ModuleIndex);



void AcquireModules(
int SerialNumber0,
int SerialNumber1,
int SerialNumber2,
int SerialNumber3);

void ReleaseAllModules();

int GetAcquiredModuleCount();

[return: MarshalAs(UnmanagedType.BStr)]
string GetAcquiredModuleProperties(
int ModuleIndex);

[return: MarshalAs(UnmanagedType.BStr)]
string GetSWVersion();

void LoadSystem(
[In, MarshalAs(UnmanagedType.BStr)] string SystemPath);

void SaveSystem(
[In, MarshalAs(UnmanagedType.BStr)] string SystemPath,
[In, MarshalAs(UnmanagedType.BStr)] string UserComment,
int SaveData);

void Import(
[In, MarshalAs(UnmanagedType.BStr)] string ImportFilePath,
int BlockNo);

void Export(
[In, MarshalAs(UnmanagedType.BStr)] string ExportFilePath,
long BlockNo,
long ExportType);

void Run();

void Stop();

void Advance();

void Step();

void Jump();

void SetRunTriggerSource(
int RunTriggerSource);

void SetHostRunTrigger();

int GetRunStatus();

bool IsPGBusy();

void SetClockMode(
int ClockMode);

void SetClockPeriod(
double Period);

void SetClockFrequency(
double Frequency);

void SetReferenceClockSource(
int Source);

void SetInputClockThreshold(
double Threshold);

void SetInputClockFilterPeriod(
int FilterPeriod);

void SetInputClockInvert(
int Invert);

void SetInputClockDelay(
double Delay);

void SetDiscontinuousClock(
int DiscontinuousClock);

void SetEventThreshold(
double Threshold);

void SetEventFilterPeriod(
int FilterPeriod);

void SetEventModeForAdvance(
int EventMode);

void SetEventModeForJump(
int EventMode);

void SetRunMode(
int RunMode);

void SetHiZOnStop(
int HiZOnStop);

int GetProbeType(
int ModulePos,
int ProbeIndex);

void SetOutputLevel(
int ModulePos,
int ProbeIndex,
double Level);

void SetDataDelay(
int ModulePos,
int ProbeIndex,
int ByteIndex,
double Delay);

void SetDataDelay180(
int ModulePos,
int ProbeIndex,
int ByteIndex,
int Delay180);

void SetStrobeShape(
int ModulePos,
int ProbeIndex,
int StrobeShape);

void SetVarGroup(
int ModulePos,
int ProbeIndex,
int ChannelIndex,
int Group);

void SetVarHighLevel(
int ModulePos,
int ProbeIndex,
int ChannelIndex,
double HighLevel);

void SetVarLowLevel(
int ModulePos,
int ProbeIndex,
int ChannelIndex,
double LowLevel);

void SetVarSlewRate(
int ModulePos,
int ProbeIndex,
int ChannelIndex,
int SlewRate);

void SetVarDifferential(
int ModulePos,
int ProbeIndex,
int ChannelIndex,
int Differential);

void SetVarDelay(
int ModulePos,
int ProbeIndex,
int ChannelIndex,
double Delay);

void SetVarInhibitThreshold(
int ModulePos,
int ProbeIndex,
double Threshold);

void SetVarInhibitEnable(
int ModulePos,
int ProbeIndex,
int Enable);

void SetSignalInput(
int InputSource);

void SetSignalOutput(
int OutputDest);

void InvertSignalOutput(
int Invert);

object GetGroupNames(); //VARIANT RETURN TYPE!

int GetGroupSize(
[In, MarshalAs(UnmanagedType.BStr)] string GroupName);

[return: MarshalAs(UnmanagedType.BStr)]
String GetProbeChannelNames(
[In, MarshalAs(UnmanagedType.BStr)] string GroupName);

void SetDACSingle(
int ModulePos,
int ProbeIndex,
int Single);

void SetDACBipolar(
int ModulePos,
int ProbeIndex,
int DACInx,
int Bipolar);

void SetDACFilter(
int ModulePos,
int ProbeIndex,
int DACInx,
int Filter);

void DeleteAllBlocks();

int AddBlock(
int VectorCount,
[In, MarshalAs(UnmanagedType.BStr)] string BlockName);

void DeleteAllSequenceLines();

int AddSequenceLine(
[In, MarshalAs(UnmanagedType.BStr)] string p_sLabel,
[In, MarshalAs(UnmanagedType.BStr)] string p_sWaitFor,
[In, MarshalAs(UnmanagedType.BStr)] string p_sBlockName,
int p_nRepeatCount,
[In, MarshalAs(UnmanagedType.BStr)] string p_sJumpIf,
[In, MarshalAs(UnmanagedType.BStr)] string p_sJumpTo,
int p_nSignalValue);

void DeleteAllEvents();

int AddEvent(
[In, MarshalAs(UnmanagedType.BStr)] string p_sEventName,
[In, MarshalAs(UnmanagedType.BStr)] string p_sEventDef);

int UpdateSystemView();
} 
}

[ Voor 66% gewijzigd door korgakos op 16-12-2009 16:59 ]

[Verwijderd]

- ReportProgress (aangeboden door BackgroundWorker)
- Delegates/events

[korgakos]

Verwijderd schreef op dinsdag 01 december 2009 @ 11:46:
- ReportProgress (aangeboden door BackgroundWorker)
- Delegates/events

oke dan ga ik me even hierin verdiepen

Delegates and Events in C# / .NET

thx alvast

[korgakos]

Ik heb nu via een delegate het volgende gedaan:

C#:

  public void MyFunc()
        {
            PGApp_dll.library.ShowApplication(1);

        }
        delegate void SimpleDelegate();
        private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            SimpleDelegate myDelegate = new SimpleDelegate(MyFunc);

            myDelegate();
            
        }

en dan via een knopje de backgroundworker laten runnen,
als ik step into doe zie ik dat de functie PGApp_dll.library.ShowApplication(1); wordt uitgevoerd maar er gebeurd niks...(het programma zou uit hidden mode moeten komen..)

Hierna lukt het ook niet meer via de UI het programma aan te sturen, dan krijg ik een exception

[ Voor 9% gewijzigd door korgakos op 01-12-2009 13:18 ]

[Woy]

offtopic:
Ik heb het topic niet helemaal gelezen, maar zet je code a.u.b. even in [code=c#] code hier \[\] tags, dan is het een stuk beter leesbaar

[korgakos]

offtopic:
ok thx, ik heb het aangepast

[ Voor 96% gewijzigd door korgakos op 01-12-2009 13:29 ]

[korgakos]

is het misschien zo dat omdat ik
CoInitialize gebruik bij het opstarten van het programma ?

Initializes the COM library on the current thread and identifies the concurrency model as single-thread apartment

[pedorus]

Uit het laatste stukje code blijkt dat je de .NET BackgroundWorker en delegates nog niet helemaal snapt. Het aanroepen van de mainThread die de BackgroundWorker gebruikt moet gebeuren in de events RunWorkerCompleted en ProgressChanged, waarbij je de laatste aanroept met ReportProgress. Verder bestaat je SimpleDelegate al, dat is namelijk Action, en hoef je geen new() te gebruiken. En wat je nu doet, is eigenlijk gewoon hetzelfde als gelijk MyFunc aanroepen.

Alternatief kun je ook Invoke() gebruiken.

[korgakos]

Hmm oke, nu raak ik helemaal in de war?

de RunWorkerCompleted-event treed pas op als de backgroundworker "klaar" is, maar ik wil niet in die event het importeren doen. Want dan gaat de UI weer freezen ?

Kunje misschien een voorbeeld geven, dat helpt stukken sneller, thx


Invoke voert de functie toch uit in de thread waar hij inzit? dus dat is handig voor Crossthread problemen, maar dat is niet wat ik nodig heb?!

[ Voor 23% gewijzigd door korgakos op 01-12-2009 15:11 ]

[pedorus]

Het lijkt me toch niet zo moeilijk om een voorbeeld en/of uitleg te hebben, want dat staat gewoon in de documentatie?
http://msdn.microsoft.com...del.backgroundworker.aspx

[farlane]

CoInitialize moet sowieso in elke thread worden aangeroepen, dus in een functie initializen en daarna vanuit een andere thread een COM call doen is een no-go.

[ Voor 5% gewijzigd door farlane op 01-12-2009 15:22 ]

[korgakos]

Volgens mij, is hier sprake van een misverstand..

Ik snap best wat je met een backgroundworker kunt doen.
Maar het lukt niet om de import functie uit de dll uit te voeren vanuit de backgroundworker als ik niet ook vanuit de backgroundworker de funcite start heb aangeroepen

De import functie schijnt alleen te werken als ik hem in de thread uitvoer waar ik de "start"-functie heb aangeroepen om het programma te starten.

Doe ik echter de import functie in de backgroundworker, dan komt er geen exception, geen error, hij loopt er vrolijk overheen..

Met de reportprogress en runworkercompleted heb ik niet veel te maken, aangezien ik die niet nodig heb hiervoor..
even vorige reactie lezen

[korgakos]

farlane schreef op dinsdag 01 december 2009 @ 15:22:
CoInitialize moet sowieso in elke thread worden aangeroepen, dus in een functie initializen en daarna vanuit een andere thread een COM call doen is een no-go.

Moet ik dan een uninitialize uitvoeren in mainthread voordat ik een initialize aanroep in de backgroundworker?
Of hoe zit die sequence in elkaar?
En waar moet ik dan nog meer opletten?

-----------

Volgens mij moet ik dit gebruiken in de dll :

C++:

CoInitializeEx(NULL,COINIT_MULTITHREADED);

Alleen werkt het nog niet, ik laat nog van me weten:)
-------------------
Getinstance perhaps?.

[ Voor 19% gewijzigd door korgakos op 01-12-2009 15:55 ]

[roy-t]

korgakos schreef op dinsdag 01 december 2009 @ 11:58:
Ik heb nu via een delegate het volgende gedaan:

C#:

  public void MyFunc()
        {
            PGApp_dll.library.ShowApplication(1);

        }
        delegate void SimpleDelegate();
        private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            SimpleDelegate myDelegate = new SimpleDelegate(MyFunc);

            myDelegate();
            
        }

en dan via een knopje de backgroundworker laten runnen,
als ik step into doe zie ik dat de functie PGApp_dll.library.ShowApplication(1); wordt uitgevoerd maar er gebeurd niks...(het programma zou uit hidden mode moeten komen..)

Hierna lukt het ook niet meer via de UI het programma aan te sturen, dan krijg ik een exception

Je kunt niet myDelegate(); doen maar je moet:

C#:

form.Invoke(myDelegate); 

doen

[pedorus]

Ehh, tsja, als de importfunctie niet door jou valt aan te passen, en zo is geschreven dat het alleen met een thread werkt, dan gaat dit nooit werken natuurlijk. In andere gevallen maakt het hele DLL-verhaal weinig uit.

Overigens vind ik het schema trouwens gek:
eigen c# programma->eigen c++ dll->com-interface(?) naar c++ applicatie in zijn eigen thread(?)
Wat staat er in die c++ dll wat niet in c# kan? Of was er al veel c++-code beschikbaar ofzo? Waar worden de threads geinitialiseerd? In welke thread(s) worden windows messages afgehandeld/staan messageloops? Wil je dat de messageloop van je eigen programma door blijft gaan, zodat de UI blijft werken, of bedoel je de UI van het third party programma?

korgakos schreef op dinsdag 01 december 2009 @ 15:32:
Volgens mij moet ik dit gebruiken in de dll :

C++:

CoInitializeEx(NULL,COINIT_MULTITHREADED);

Als ik het goed snap doe je nu in c++ een CoInitalize in een .NET-Thread. Dat moet niet zo, zie hier.

[korgakos]

Hmm ja ik heb die c++ code genomen omdat deze al gegeven was en ik nog nooit met comobjecten heb gewerkt en weet hoe ze in elkaar zitten..
Ik had geen zin om het geheel in c++ te doen, dus deed ik het op deze manier met c#
Zoals je misschien al merkt zijn veel dingen die ik nu doe nieuw voor me, maar goed dit is mijn stageopdracht, ik heb eigenlijk al een werkend programma maar ik wil het iets netter doen.

Ik ben nu bezig om de com in c# te doen.
Tot nu toe werkt het openen en het verbergen al, blijkt best simpel te zijn!

edit:
Niet verwacht dat het omschrijven van c++ com-code naar C# zo easy ging :)!

[ Voor 7% gewijzigd door korgakos op 02-12-2009 09:27 ]

[korgakos]

OKe lui, Consider dit als opgelost


Ik heb nu dus in plaats van een DLL te gebruiken (van c++) deze functies omgeschreven in C# en doe nu de COM-afhandelingen in C#.

Als iemand hetzelfde ooit nodig heeft:

http://msdn.microsoft.com/en-us/library/aa645736%28VS.71%29.aspx

Deze "tutorial" bied gewoon ALLES wat je nodig hebt..

Nu nog even de mensen bedanken voor het wijzen naar de goede richting, ik zat dus helemaal verkeerd te denken (en misschien te moeilijk)

Thx!