[C#] Argumenten doorgeven aan een thread

[G F0rce 1]

Het komt er eigenlijk op neer dat ik zoiets WIL doen:

C#:

new Thread( new ThreadStart( MyFunction( "Fritsje", 7 ) ) );

Ik probeer dus een argument mee te geven aan een Thread.

De oplossing die ik nu heb zal waarschijnlijk wel werken maar is erg omslachtig waarschijnlijk... Ik zoek dus een nette/correcte oplossing.
De oplossing die ik nu ingedachte heb is het volgende:

C#:

public class FormMain : System.Windows.Forms.Form
{
    private string argument1;
    private int argument2;

    public void Test()
    {
        argument1 = "Fritsje";
        argument2 = 7;
        new Thread( new ThreadStart( MyEeeeuhFunction ) );
    }
    
    
    void MyEeeeuhFunction()
    {
        myFunction(argument1,argument2);
    }
    
    void myFunction(filename, data)
    {
        FileInfo f = new FileInfo( filename );
        StreamWriter st = f.CreateText();
        st.Write( data );
        st.Close();
    }
}

Zoals gezegt, lijkt me dit niet de beste oplossing voor een probleem. Google helpt me vandaag niet en de search hier leverde ook al weinig relevants op. Misschien dat iemand van julie mij de goede richting in kan helpen, alvast bedankt!

[ Voor 3% gewijzigd door G F0rce 1 op 25-08-2005 17:20 ]

[whoami]

Kijk eens naar het 'task pattern'

[rml]whoami in "[ C#] button.Show() vanuit anderen Thread"[/rml]

Wat je dus doet, is een class aanmaken, die je een Run method heeft.
Die class start een bepaalde taak op een andere thread, en je kan je argumenten dus aan een object van die 'Task' doorgeven:

code:

MyTask t = new MyTask ("bliep", "blop", "melp");
t.Run()

oid.

[ Voor 49% gewijzigd door whoami op 25-08-2005 17:25 ]

[netvor]

Ik weet niet precies hoe het in C# werkt, maar op veel andere platformen (zoals posix threads en volgens mij ook MFC) kan je bij het starten van een thread een enkele parameter doorgeven. Wil je meer dan een parameter doorgeven dan zet je die in een struct (of object) en geef je vervolgens een pointer naar die struct (of object) aan je thread.

Misschien helpt dit je op weg.

[Verwijderd]

imp schreef op donderdag 25 augustus 2005 @ 17:24:
Ik weet niet precies hoe het in C# werkt, maar op veel andere platformen (zoals posix threads en volgens mij ook MFC) kan je bij het starten van een thread een enkele parameter doorgeven. Wil je meer dan een parameter doorgeven dan zet je die in een struct (of object) en geef je vervolgens een pointer naar die struct (of object) aan je thread.

Misschien helpt dit je op weg.

In C# start je een thread met een ThreadStart() delegate, en die omschrijft een functie zonder parameters, dus dat gaat niet werken.

[MSalters]

Een ThreadStart delegate lijkt me het object wat je nodig hebt
( Voor alle duidelijkheid: een ThreadStart delegate is toch een object wat onder andere het type ThreadStart heeft? In C# : Een type afgeleid van ThreadStart heeft? )

[whoami]

MSalters schreef op donderdag 25 augustus 2005 @ 17:33:
Een ThreadStart delegate lijkt me het object wat je nodig hebt
( Voor alle duidelijkheid: een ThreadStart delegate is toch een object wat onder andere het type ThreadStart heeft? In C# : Een type afgeleid van ThreadStart heeft? )

Een ThreadStart is een delegate (zie het als een functie pointer).
Een delegate geeft aan hoe de method signature er moet uitzien, en de constructor van de Thread class neemt een ThreadStart delegate als argument.
ThreadStart definieert dan weer een method zonder argument, en afaik kan je niet inheriten van delegates.

[Korben]

Verwijderd schreef op donderdag 25 augustus 2005 @ 17:31:
[...]

In C# start je een thread met een ThreadStart() delegate, en die omschrijft een functie zonder parameters, dus dat gaat niet werken.

Er is ook een ParameterizedThreadStart delegate, waarbij je dus wél een enkele parameter kunt meegeven. De methode van whoami, het Task-pattern, is echter veel eleganter.

[Woy]

MSalters schreef op donderdag 25 augustus 2005 @ 17:33:
Een ThreadStart delegate lijkt me het object wat je nodig hebt
( Voor alle duidelijkheid: een ThreadStart delegate is toch een object wat onder andere het type ThreadStart heeft? In C# : Een type afgeleid van ThreadStart heeft? )

Een delegate is een defenitie voor een Function Pointer. En je kan idd niet van een delegate inheriten

wat whoami zegt is idd het handigst

C#:

public class Task
{
    private int _a;
    private int _b;

    public Task( int a, int b )
    {
        _a = a;
        _b = b;
    }

    public void Run()
    {
        Thread thread = new Thread( new ThreadStart( task.DoSomething ) );
        thread.Start();
    }

    private void DoSomething()
    {
        //Do something with a & b
    }
}

Task task = new Task( 1, 2 );
task.Run();

[Verwijderd]

Korben schreef op vrijdag 26 augustus 2005 @ 04:24:
[...]
Er is ook een ParameterizedThreadStart delegate, waarbij je dus wél een enkele parameter kunt meegeven. De methode van whoami, het Task-pattern, is echter veel eleganter.

Hey, die ben ik nog nooit tegengekomen. Altijd handig om te weten

[whoami]

In de MSDN staat er trouwens nog een andere manier om dit tot stand te brengen:

Creeër een class die een 'run' method heeft, en die de data meeneemt, en maak dan een thread die die run method uitvoert:

code:

public class MyProc
{

      int a, b;

     public MyProc( int a, int b )
     {
           this.a = a;
           this.b = b;
     }

     public void Run()
     {
         // Do something.
     }

}

code:

public void button_click( object sender, EventArgs e )
{
      MyProc p = new MyProc(1, 2);
      Thread t = new Thread( new ThreadStart(p.Run));
      t.Start();
}

Echter, als je ook voortgang van je thread wilt zien, of data oid wilt terugkrijgen, dan blijf ik bij m'n eerste oplossing.

Die ParametrizedThreadStart vind ik trouwens niet zo direct. Is dit enkel in .NET 2.0 ?

[Verwijderd]

whoami schreef op vrijdag 26 augustus 2005 @ 10:12:
[...]
Die ParametrizedThreadStart vind ik trouwens niet zo direct. Is dit enkel in .NET 2.0 ?

Dat lijkt er wel op:

quote: http://www.findarticles.c...vs/is_200505/ai_n13638086

What's New in Whidbey Threads

Whidbey has added some methods, classes, and functionality to threading support in .NET. Here are the most significant additions.

The ThreadPool class has added SetMaxThreads(int workerThreadCount, int ioThreadCount), so now we can set the maximum thread count for the thread pool. In previous versions of the .NET Framework, the number of threads in a thread pool was fixed at 25 times the number of processors. Now you have the flexibility to set your own thread pool size. Use it wisely!

Whidbey adds a ParametrizedThreadStart class to System.Threading. ParameterizedThreadStart allows a passing parameter to start a method of a thread, without requiring you to write additional code.

Finally, the .NET Framework has semaphores! There is now a Semaphore class that provides exactly the same functionality as did semaphores in the Win32 API.

Ik vond het al gek dat ik hem nog nooit gezien had.

[G F0rce 1]

Ik gooi het op de oplossing van whoami/MSDN.
De Task class dus.

Dit is in ieder geval de oplossing wat de meest duidelijke en overzichtelijke code oplevert!

Bedankt allen.

[ Voor 6% gewijzigd door G F0rce 1 op 26-08-2005 15:46 ]