バックグラウンドワーカーには制限はありますか？テクニカルまたはコモンセンス

Question

Program.csには以下の方法があり、Syncing 5 SQLデータベースとセントラルサーバーがあります。それぞれが別のものから分離されているので、私はプログラムの読み込み時間をすべて同じ時間に動かすことによってスピードアップすると考えました。

残念ながら、それは非常に薄れています。ローカルDBはSQLExpress 2005で、中央DBはSQL Server Standard 2005です。

これらのいずれかの接続数には制限がありますか？バックグラウンドワーカーは、一度に多くの人を動かすことができますか？私はこれを行うためのより雄弁な方法があると確信しています、私はそれらを（参照してください）が好きです。

これはProgram.csの中で）私がメイン（でこれを呼び出す方法です - 私は一つだけを使用>

if(IsSqlAvailable()) SyncNow();

---

internal static void SyncNow() 
    { 



      #region ConnectDB Merge Sync Background Thread 

      BackgroundWorker connectBW = new BackgroundWorker 
              { 
               WorkerReportsProgress = false, 
               WorkerSupportsCancellation = true 
              }; 
      connectBW.DoWork += new DoWorkEventHandler(connectBW_DoWork); 
      if (connectBW.IsBusy != true) 
       connectBW.RunWorkerAsync(); 

      #endregion 

      #region aspnetDB Merge Sync Background Thread 

      BackgroundWorker aspBW = new BackgroundWorker 
             { 
              WorkerReportsProgress = false, 
              WorkerSupportsCancellation = true 
             }; 
      aspBW.DoWork += new DoWorkEventHandler(aspBW_DoWork); 
      if (aspBW.IsBusy != true) 
       aspBW.RunWorkerAsync(); 

      #endregion 

      #region MatrixDB Merge Sync Background Thread 

      BackgroundWorker matrixBW = new BackgroundWorker 
              { 
               WorkerReportsProgress = false, 
               WorkerSupportsCancellation = true 
              }; 
      matrixBW.DoWork += new DoWorkEventHandler(matrixBW_DoWork); 
      if (matrixBW.IsBusy != true) 
       matrixBW.RunWorkerAsync(); 

      #endregion 



      #region CMODB Merge Sync Background Thread 

      BackgroundWorker cmoBW = new BackgroundWorker 
             { 
              WorkerReportsProgress = false, 
              WorkerSupportsCancellation = true 
             }; 
      cmoBW.DoWork += new DoWorkEventHandler(cmoBW_DoWork); 
      if (cmoBW.IsBusy != true) 
       cmoBW.RunWorkerAsync(); 

      #endregion 

      #region MemberCenteredPlanDB Merge Sync Background Thread 

      BackgroundWorker mcpBW = new BackgroundWorker 
             { 
              WorkerReportsProgress = false, 
              WorkerSupportsCancellation = true 
             }; 
      mcpBW.DoWork += new DoWorkEventHandler(mcpBW_DoWork); 
      if (mcpBW.IsBusy != true) 
       mcpBW.RunWorkerAsync(); 

      #endregion 

    } 

    static void mcpBW_DoWork(object sender, DoWorkEventArgs e) 
    { 
     BackgroundWorker worker = sender as BackgroundWorker; 
     try 
     { 
      MergeRepl mcpMergeRepl = new MergeRepl(SystemInformation.ComputerName + "\\SQLEXPRESS", "WWCSTAGE", "MemberCenteredPlan", "MemberCenteredPlan", "MemberCenteredPlan"); 
      mcpMergeRepl.RunDataSync(); 
      areAllInSync += 1; 
     } 
     catch (Exception) 
     { 
      if (worker != null) worker.CancelAsync(); 
     } 
    } 

    static void cmoBW_DoWork(object sender, DoWorkEventArgs e) 
    { 
     BackgroundWorker worker = sender as BackgroundWorker; 
     try 
     { 
      MergeRepl cmoMergeRepl = new MergeRepl(SystemInformation.ComputerName + "\\SQLEXPRESS", "WWCSTAGE", "CMO", "CMO", "CMO"); 
      cmoMergeRepl.RunDataSync(); 
      areAllInSync += 1; 
     } 
     catch (Exception) 
     { 
      if (worker != null) worker.CancelAsync(); 
     } 
    } 

    static void connectBW_DoWork(object sender, DoWorkEventArgs e) 
    { 
     BackgroundWorker worker = sender as BackgroundWorker; 
     try 
     { 
      MergeRepl connectMergeRepl = new MergeRepl(SystemInformation.ComputerName + "\\SQLEXPRESS", "WWCSTAGE", "CONNECT", "Connect", "Connect"); 
      connectMergeRepl.RunDataSync(); 
      areAllInSync += 1; 
     } 
     catch (Exception) 
     { 
      if (worker != null) worker.CancelAsync(); 
     } 
    } 

    static void matrixBW_DoWork(object sender, DoWorkEventArgs e) 
    { 
     BackgroundWorker worker = sender as BackgroundWorker; 
     try 
     { 
      MergeRepl matrixMergeRepl = new MergeRepl(SystemInformation.ComputerName + "\\SQLEXPRESS", "WWCSTAGE", "MATRIX", "MATRIX", "MATRIX"); 
      matrixMergeRepl.RunDataSync(); 
      areAllInSync += 1; 
     } 
     catch (Exception) 
     { 
      if (worker != null) worker.CancelAsync(); 
     } 
    } 

    static void aspBW_DoWork(object sender, DoWorkEventArgs e) 
    { 
     BackgroundWorker worker = sender as BackgroundWorker; 
     try 
     { 
      MergeRepl aspnetdbMergeRepl = new MergeRepl(SystemInformation.ComputerName + "\\SQLEXPRESS", "WWCSTAGE", "aspnetdb", "aspnetdb", "aspnetdb"); 
      aspnetdbMergeRepl.RunDataSync(); 
      areAllInSync += 1; 
     } 
     catch (Exception) 
     { 
      if (worker != null) worker.CancelAsync(); 
     } 

    } 

Answer 1

「フレークさ」が何であるか、具体的にどのように表現する必要がありますか。これを正しく理解していれば、エージェントのサポートが不足しているRMOクラスで手動でマージレプリケーションを実行しようとしています。

SQL Expressは1つのスケジューラのみをサポートしているため、複数のワーカー（保留中のリクエスト）を追加することで大きな違いはなく、実行可能なキューに積み重なり、 CPUを実行します。

第2に、私が使用していると思われるRMOレプリケーションクラスが複数の並列インスタンスで同期をサポートしているかどうかわからないので、dbごとに1つのBackgroundWorker（私はRMOのエキスパートではありません）。全体の混乱はちょうどこのように書き換えることができることを始めて、私はこれを言うことは非常に申し訳ありませんが、あなたのコードは私の目を傷つけるために

Answer 2

。

私は、長時間実行されているタスクを実行してUIを応答可能に保つためにBackgroundWorkerがあることを確認します。

複数のスレッドが必要な場合は、ThreadPoolを使用します。

Answer 3

まあ、...

：

 internal static void SyncNow() 
     { 
      CreateWorker(new MergeRepl(SystemInformation.ComputerName + "\\SQLEXPRESS", "WWCSTAGE", "aspnetdb", "aspnetdb", "aspnetdb")); 
      //etc... 
     } 

     private static void CreateWorker(MergeRepl repl) 
     { 
      BackgroundWorker connect = new BackgroundWorker { WorkerReportsProgress = false, WorkerSupportsCancellation = true }; 
      connect.DoWork += new DoWorkEventHandler(DoWork); 

      if (connect.IsBusy != true) 
       connect.RunWorkerAsync(repl); 
     } 

     private static void DoWork(object sender, DoWorkEventArgs e) 
     { 
      BackgroundWorker worker = sender as BackgroundWorker; 
      try 
      { 
       MergeRepl aspnetdbMergeRepl = e.Argument as MergeRepl; 
       aspnetdbMergeRepl.RunDataSync(); 
       areAllInSync += 1; 
      } 
      catch (Exception) 
      { 
       if (worker != null) worker.CancelAsync(); 
      } 
     } 

次に、私はこれのようなもののためにThreadPoolを使用します。これは、特定の数のスレッドだけがこの種の作業を行うために生成されることを保証します。