"Go" multithreading Summary in C # for absolute novice C #

There are about 4 ways to do this:
Dispatcher, asynchronous delegate, manual multithreading, BackgroundWorker, There is also a dispatchertimer, is a timer.

Where dispatcher is the same as DispatcherTimer, it is used to simulate multi-threading by arranging task priorities in the main thread, so the substance is single-threaded

, so it is not advisable to use them for heavy load operations. When calling asynchronously, use Dispatcher.invoke (AddItem, image);

BackgroundWorker will go to the thread pool to grab a thread as a worker, switch back to the UI thread after the work is done, call the task you defined to complete the process.

Sorrento Each time a value is calculated, the worker is used. ReportProgress (PercentComplete) notifies the callback function and can update the UI in the callback function. Special

Not suitable for scenarios where you need to update a completed percentage.

These can all be combined with data binding.

① asynchronous delegate or manual multithreading
Asynchronous Delegate : Supports callback at end of thread (the first parameter of the BeginInvoke method), but does not support disconnected threads outside, and is used to update the UI.

Manual Threading : Supports external thread break (Thread.Abort method), but it is not easy to get the return value of the function. In addition, the UI cannot be updated. Because the Windows

The form uses a single-threaded apartment (STA) model, as is the case with WPF forms, the STA model means that Windows can be created on any thread, but once the window is created

The thread cannot be switched, and all function calls to it must occur on its creation thread. In particular, be careful in registering event callback functions.

usage of delegate:

[C-sharp] View plaincopy

1. public class Mydelegatetest
2. {
3. Step 1, declaring the delegate object
4. Public delegate bool MyDelegate (string name);
6. This is the method we want to pass, which has the same parameters and return value types as the MyDelegate
7. public static bool Mydelegatefunc (string name)
8. {
9. Console.WriteLine ("Hello, {0}", name);
10. return ture;
11. }
13. public static Voidmain ()
14. {
15. Step 2, create the delegate object
16. MyDelegate MD = new MyDelegate (MYDELEGATETEST.MYDELEGATEFUNC);
18. Step 3, call delegate
19. Console.WriteLine ("Result is {0}", MD ("sam1111"));
20. }
21. }

This method of invocation, like invoke with the delegate object, is a synchronous call that blocks the current thread. Asynchronous calls require the use of BeginInvoke:

[C-sharp] View plaincopy

2. Class Program
4. {
6. private static int NewTask (int ms)
8. {
10. Console.WriteLine ("Task Start");
12. Thread.Sleep (MS);
14. Random random = new random ();
16. int n = random. Next (10000);
18. Console.WriteLine ("Mission Accomplished");
20. return n;
22. }
26. Private delegate int newtaskdelegate (int ms);
28. static void Main (string[] args)
30. {
32. Newtaskdelegate task = NewTask;
34. IAsyncResult AsyncResult = task. BeginInvoke (+, NULL, NULL); EndInvoke method will be blocked 2
38. Seconds
40. Do Something Else
42. int result = task. EndInvoke (AsyncResult);
44. Console.WriteLine (result);
46. }
48. }

The BeginInvoke here is an asynchronous call that returns immediately after the run, without causing the current thread to block. But in this routine, because the NewTask

In Sleep 2 seconds, if the do Something else time does not have 2 seconds, EndInvoke will still cause the current thread to block because it waits for

NewTask execution is complete.

Can you not call EndInvoke and let it end by itself? Not very good. Because a BeginInvoke and EndInvoke must be called in pairs. Even if you do not need to return

return value, but EndInvoke still must be called, otherwise it may cause a memory leak because it is leveraging the thread pool resource. Secondly, we often call EndInvoke

To get the return value of the function.

If the BeginInvoke is used for polling, EndInvoke cannot be returned, then a variable can be used to control it:
In my application scenario, a wrapper class is defined:

[C-sharp] View plaincopy

2. Class Isnetworkavailabledelegate
4. {
6. Private Isnetworkavailablewrapper _available;
8. Private delegate void MyDelegate ();
10. Private MyDelegate _dele;
12. Private IAsyncResult _result;
14. private bool _running = true;
18. private void Tryconnect ()
20. {
22. while (this._running)
24. {
26. Try
28. {
30. Ping _ping = new Ping ();
32. if (_ping. Send ("www.baidu.com"). Status = = ipstatus.success)
34. This._available. Isnetworkavailable = true;
36. Else
38. This._available. Isnetworkavailable = false;
42. }
44. Catch
46. {
48. This._available. Isnetworkavailable = false;
50. }
52. Thread.Sleep (500);
54. }
56. }
58. Public Isnetworkavailabledelegate (Isnetworkavailablewrapper available)
60. {
62. This._available = available;
64. This._dele = new MyDelegate (this. Tryconnect);
66. This._result = This._dele. BeginInvoke (null, NULL);
68. }
72. public void EndInvoke ()
74. {
76. This._running = false;
78. This._dele. EndInvoke (This._result);
80. }
82. }

To be completely asynchronous with the current thread, you can use the second parameter of BeginInvoke to set a callback function after the function executes:

[C-sharp] View plaincopy

1. Private delegate int mydelegate (int a);
2. private int method (int a)
3. {
4. Thread.Sleep (10000);
5. Console.WriteLine (a);
6. return 100;
7. }
8. private void methodcompleted (IAsyncResult asyncResult)
9. {
10. if (AsyncResult = = null) return;
11. TextBox1.Text = (asyncresult.asyncstate as MyDelegate). EndInvoke (AsyncResult). ToString ();
12. }
13. private void Button1_Click (object sender, EventArgs e)
14. {
15. MyDelegate my = method;
16. IAsyncResult AsyncResult = My. BeginInvoke (methodcompleted, my);
17. }

This allows the current thread to feel no more waiting at all.

Sometimes, however, the current thread wants to take advantage of the time the function executes, and then do something else after the function is done, using the WaitOne method: Reverse telecommuting.

[C-sharp] View plaincopy

2. Class Program
4. {
6. public delegate int Binaryopdelegate (int x, int y);
8. static void Main (string[] args)
10. {
12. Console.WriteLine ("* * * * * Async Delegate Invocation * * * * * *);
16. Print out the ID of the executing thread.
18. Console.WriteLine ("Main () invoked on thread {0}.",
20. THREAD.CURRENTTHREAD.MANAGEDTHREADID);
24. Invoke Add () on a secondary thread.
26. Binaryopdelegate B = new Binaryopdelegate (ADD);
28. IAsyncResult Iftar = B.begininvoke (ten, ten, NULL, NULL);
32. This message would keep printing until
34. The Add () method is finished.
36. Wait for asynchronous delegate execution to complete with WaitOne
38. while (!iftar.asyncwaithandle.waitone (), True)
40. {
42. Console.WriteLine ("Doing more work in Main ()!");
44. }
48. Obtain the result of the ADD ()
50. Method is ready.
52. int answer = B.endinvoke (Iftar);
54. Console.WriteLine ("Ten + Ten is {0}.", answer);
56. Console.ReadLine ();
58. }
62. #region Very Slow addition ...
64. static int Add (int x, int y)
66. {
68. Print out the ID of the executing thread.
70. Console.WriteLine ("Add () invoked on thread {0}.",
72. THREAD.CURRENTTHREAD.MANAGEDTHREADID);
74. Simulate an act that takes a long time
76. Pause to simulate a lengthy operation.
78. Thread.Sleep (5000);
80. return x + y;
82. }
84. #endregion
86. }

(PS: Using lambda syntax can also write very good sentences:)

[C-sharp] View plaincopy

1. action<object> action= (obj) =>method (obj);
2. Action. BeginInvoke (obj,ar=>action. EndInvoke (AR), null);

In fact, it can be more direct:

[C-sharp] View plaincopy

1. New Action<object> ((obj) = method (obj)). BeginInvoke (ar=>action. EndInvoke (AR), null);

）

The main function of the Invoke method is to help you invoke the method specified by the delegate on the UI thread. The Invoke method first checks the thread that made the call (that is, the current thread

is not a UI thread, if it is, directly executes the method that the delegate points to, if not, it switches to the UI thread, and then executes the method that the delegate points to.

Calls to the manual thread:
The typical notation is:

[C-sharp] View plaincopy

1. public class Procclass
2. {
3. private string procparameter = "";
4. private string result = "";
5. Public Procclass (string parameter)
6. {
7. Procparameter = parameter;
8. }
9. public void ThreadProc ()
10. {
11. }
12. }
13. Procclass ThreadProc = new Procclass ("Use thread class");
14. Thread thread = new Thread (new ThreadStart (Threadproc.threadproc));
15. Thread. IsBackground = true;
16. Thread. Start ();

Because a function called by thread can only be parameterless and has no return value, it is usually wrapped in a class.

If a thread needs to be interruptible, it also has to deal with the UI:

[C-sharp] View plaincopy

2. public class Procclass
4. {
6. private string procparameter = "";
8. Private form1.outdelegate Delg = null;
10. Public Procclass (string parameter, Form1.outdelegate Delg)
12. {
14. Procparameter = parameter;
16. This.delg = Delg;
18. }
20. public void ThreadProc ()
22. {
24. Delg. BeginInvoke ("Use Procclass.threadproc ()", NULL, NULL);
26. }
28. }
30. Procclass ThreadProc = new Procclass ("Use Thread class", New Outdelegate (Outtext));
32. Thread thread = new Thread (new ThreadStart (Threadproc.threadproc));
34. Thread. IsBackground = true;
36. Thread. Start ();

"Go" multithreading Summary in C # for absolute novice C #