C# Rendre un délégué disponible pour une classe

Question

J'aimerais mettre un délégué à la disposition d'une classe entière. Le but de ceci est de permettre à une méthode appelée d'une classe externe 'backgroundWorker de faire continuellement rapport à travers toutes ses méthodes (ExternalClass.Run(); appelle ExternalClass.Method2(); ExternalClass.Method3(); etc et ils ont tous besoin Pour envoyer plusieurs rapports de progression, il semble inefficace de devoir passer en permanence le délégué

J'ai essayé d'initialiser une instance du délégué de manière globale et de la définir pour qu'elle soit égale à l'instance transmise dans Run(); avoir à sa disposition, mais je suis donné une erreur qu'un objet nul ne peut être converti implicitement.

merci!

Je ne peux pas montrer le code Je travaille avec ce que je fais pas Je l'ai actuellement avec moi (c'est sur mon ordinateur portable) mais je vais essayer de mieux expliquer maintenant. PSEUDO-CODE:

class form1 : form { 
    backgroundWorker_doWork() 
    { 
     Class2.Run(); 
    } 

    backgroundWorker_OnProgressChange() 
    { 
     // do this 
    } 

} 


class class2{ 
    Run(){ 
    OtherMethod();ThirdMethod(); 
    } 

    OtherMethod(){ //need to call backgroundWorker.ReportProcess(int, string)} 
    ThirdMethod(){ //need to call backgroundWorker.ReportProcess(int, string)} 
} 

Je ne veux pas avoir à passer chaque fois est le point, je voudrais passer en quelque sorte à class2

Answer 1

Vous devez montrer votre code ne fonctionne pas et le message d'erreur exact. Il devrait être très bien - est ici un exemple:

using System; 

class Demo 
{ 
    private readonly Action action; 

    public Demo(Action action) 
    { 
     this.action = action; 
    } 

    public void FirstMethod() 
    { 
     Console.WriteLine("In first method"); 
     action(); 
    } 

    public void SecondMethod() 
    { 
     Console.WriteLine("In second method"); 
     action(); 
    } 
} 

class Test 
{ 
    static void Main() 
    { 
     Demo demo = new Demo(() => Console.WriteLine("Action called")); 

     demo.FirstMethod(); 
     demo.SecondMethod(); 
    } 
} 

Answer 2

Vous pouvez utiliser la fonction InvokeMethod d'un BackgroundWorker pour permettre au travailleur d'exécuter un délégué, par exemple ci-dessous (attend également l'Invoke pour terminer, que vous ne pouvez pas besoin):.

BackgroundWorker Fonction (C++ net)

BackgroundWorkerFunction() 
{ 
::IAsyncResult ^ThreadResult; 

SetTileCount_Delegate ^SetCountDel = gcnew SetTileCount_Delegate(this, &PartDetail::SetTileCount_Function); 

//RecordingContainer is the class I am invoking into 
ThreadResult = this->RecordingContainer->BeginInvoke(
    SetCountDel, ThisTest->RecordingsCache->Count); 

WaitForInvokeTimeOutOrCompletion(ThreadResult); 
} 




System::Void WaitForInvokeTimeOutOrCompletion(IAsyncResult ^ThreadResult) 
{ 
    if(ThreadResult == nullptr) return; 

    long SleepTotal = 0; 
    long SleepInterval = 100; 

    while ((SleepTotal <= 2000) && !ThreadResult->IsCompleted) 
    { 
     ThreadResult->AsyncWaitHandle->WaitOne(SleepInterval, false); 
     SleepTotal += SleepInterval; 
    } 
}