Use the thread packaging class for multi-thread operations

Java uses interfaces to implement method callback. In. net, we can easily implement method callback through proxy.

Class class1
{

[Stathread]
Static void main (string [] ARGs)
{
Class1 c = new class1 ();
Threadwrapper Tw = new threadwrapper (New callback (C. printresult), 100 );
// Start the thread
Tw. Start ();
Console. Readline ();
}

// Print the result for callback
Public void printresult (INT result)
{
Console. writeline ("Result:" + result. tostring ());
}
}

// Callback proxy
Public Delegate void callback (int n );

Class threadwrapper
{
Public readonly thread mthread;

Private callback;

Private int N;

// Parameter 1: The callback proxy
// Parameter 2: value to be calculated
Public threadwrapper (callback, int Arg)
{
This. Callback = callback;
Threadstart mythreaddelegate = new threadstart (this. Run );
This. mthread = new thread (mythreaddelegate );
This. n = ARG;
}

// External interface of the thread
Public void start ()
{
This. mthread. Start ();
}

// Method to be called in the thread
Public void run ()
{
Int result = This. caculate (this. N );
Callback (result );
}

Private int caculate (int n)
{
Return N * 100;
}
}