C＃多线程设计示例 [英] C# Multi Thread Design Example

问题描述

我对C＃/ .Net比较新。我正在开发需要多线程的桌面应用程序。我想出了下面的模式作为基地。我想知道有没有人可以指出如何在编码，线程安全和高效率方面做得更好。

希望这是有意义的。 >

---

  public abstract class ThreadManagerBase 
 {
 //静态类变量
 
 private static ThreadManagerBase instance = null; 
 private static BackgroundWorker thread = null; 
 private static ProgressBarUIForm progress = null; 
 
 ///< summary> 
 ///创建此类的新实例。内部部分由派生类决定。 
 ///只有一个实例可以随时运行。应该只有主线程和这个线程。 
 ///< / summary> 
 public abstract static ThreadManagerBase NewInstance（）; 
 
 ///< summary> 
 ///清除实例。 
 ///< / summary> 
 public static void ClearInstance（）
 {
 instance = null; 
} 
 
 ///< summary> 
 ///使用某些预设初始化后台工作。 
 ///显示进度条。 
 ///< / summary> 
 private abstract static void InitializeThread（）
 {
 thread = new BackgroundWorker（）; 
 
 thread.WorkerReportsProgress = true; 
 thread.WorkerSupportsCancellation = true; 
 
 thread.DoWork + = new DoWorkEventHandler（thread_DoWork）; 
 thread.RunWorkerCompleted + = new RunWorkerCompletedEventHandler（thread_RunWorkerCompleted）; 
 thread.ProgressChanged + = new ProgressChangedEventHandler（thread_ProgressChanged）; 
 
 thread.RunWorkerAsync（）; 
 
 progress = new ProgressBarUIForm（）; 
 
 progress.EnableCancelButton = true; 
 
 progress.UserCanceled + = new EventHandlerCancelClicked（progress_UserCanceled）; 
 
 progress.ShowDialog（）; 
 
 thread.Dispose（）; 
 
 thread = null; 
} 
 
 private static void progress_UserCanceled（bool userCanceled）
 {
 thread.CancelAsync（）; 
} 
 
 private static void thread_ProgressChanged（object sender，ProgressChangedEventArgs e）
 {
 progress.SetProgressLevel = e.ProgressPercentage; 
 progress.SetProgressMessage = e.UserState.ToString（）; 
} 
 
 private static void thread_RunWorkerCompleted（object sender，RunWorkerCompletedEventArgs e）
 {
 progress.Close（）; 
 
 progress = null; 
} 
 
 private static void thread_DoWork（object sender，DoWorkEventArgs e）
 {
 ProcessWork（）; 
} 
 
 private abstract static void ProcessWork（）
 {
 //在这里做实际的东西。 
 //派生类将处理管道。 
} 
} 
  

解决方案

你不需要BackgroundWorker，除非你想要勺子，正常的线程是完全可以接受的，只要遵循规则。

I am relatively new to C#/.Net. I'm developing a desktop application that requires multi threading. I came up with the following pattern below as a base. I was wondering if anyone could point out how to make it better in terms of coding, being thread safe, and being efficient.

Hopefully this makes some sense.

---

public abstract class ThreadManagerBase
{
    // static class variables

    private static ThreadManagerBase instance = null;
    private static BackgroundWorker thread = null;
    private static ProgressBarUIForm progress = null;

    /// <summary>
    /// Create a new instance of this class. The internals are left to the derived class to figure out.
    /// Only one instance of this can run at any time. There should only be the main thread and this thread.
    /// </summary>
    public abstract static ThreadManagerBase NewInstance();

    /// <summary>
    /// Clears the instance.
    /// </summary>
    public static void ClearInstance()
    {
        instance = null;
    }

    /// <summary>
    /// Initializes the background worker with some presets.
    /// Displays progress bar.
    /// </summary>
    private abstract static void InitializeThread()
    {
        thread = new BackgroundWorker();

        thread.WorkerReportsProgress = true;
        thread.WorkerSupportsCancellation = true;

        thread.DoWork += new DoWorkEventHandler(thread_DoWork);
        thread.RunWorkerCompleted += new RunWorkerCompletedEventHandler(thread_RunWorkerCompleted);
        thread.ProgressChanged += new ProgressChangedEventHandler(thread_ProgressChanged);

        thread.RunWorkerAsync();

        progress = new ProgressBarUIForm();

        progress.EnableCancelButton = true;

        progress.UserCanceled += new EventHandlerCancelClicked(progress_UserCanceled);

        progress.ShowDialog();

        thread.Dispose();

        thread = null;
    }

    private static void progress_UserCanceled(bool userCanceled)
    {
        thread.CancelAsync();
    }

    private static void thread_ProgressChanged(object sender, ProgressChangedEventArgs e)
    {
        progress.SetProgressLevel = e.ProgressPercentage;
        progress.SetProgressMessage = e.UserState.ToString();
    }

    private static void thread_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        progress.Close();

        progress = null;
    }

    private static void thread_DoWork(object sender, DoWorkEventArgs e)
    {
        ProcessWork();
    }

    private abstract static void ProcessWork()
    {
        // do actuall stuff here.
        // the derived classes will take care of the plumbing.
    }
}

解决方案

You don't need a BackgroundWorker unless you want to be spoonfed, normal threads are perfectly acceptable, as long as you follow the rules.

这篇关于C＃多线程设计示例的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！