Użycie webbackgrounder nuget w MVC do uruchomienia zadania tła przez długi czas

Question

Potrzebuję wykonać zadanie w tle, więc jakie jest moje zadanie? Mam tabelę, która przechowuje kwotę najmu każdego klienta, więc muszę obliczyć cenę czynszu w każdym miesiącu po konkretnym datetime ackf, więc googleed go i znalazłem kawałek kodu, który (to jest nuget o nazwie webbackgrounder) dodałem to do mojego rozwiązania i daje mi tę część kodu do wykonania mojego zadania:

using System; 
using System.Threading; 
using System.Threading.Tasks; 

    namespace WebBackgrounder.DemoWeb 
    { 
     public class SampleJob : Job 
     { 
      public SampleJob(TimeSpan interval, TimeSpan timeout) 
       : base("Sample Job", interval, timeout) 
      { 
      } 

      public override Task Execute() 
      { 
       return new Task(() => Thread.Sleep(3000)); 
      } 
     } 
    } 

Chcę wiedzieć, w jaki sposób mogę zaprogramować moje zadanie?

Więcej szczegółów: Here

znalazłem this article ale w rzeczywistości nie wiem, mogę używać tej metody do longtime ?? Pozdrawiamy.

wszelkie pomysły zostaną docenione.

Answer 1

Należy również dodać klasę do folderu App_Start aplikacji, która uruchomi zadanie i zarządza jego życiem. Można zobaczyć tu przykład ... https://github.com/NuGet/WebBackgrounder/tree/master/src/WebBackgrounder.DemoWeb

Oto kod z aplikacji demonstracyjnej

using System; 
using Elmah; 
using WebBackgrounder.Jobs; 

[assembly: WebActivator.PostApplicationStartMethod(typeof(WebBackgrounder.DemoWeb.App_Start.WebBackgrounderSetup), "Start")] 
[assembly: WebActivator.ApplicationShutdownMethod(typeof(WebBackgrounder.DemoWeb.App_Start.WebBackgrounderSetup), "Shutdown")] 

namespace WebBackgrounder.DemoWeb.App_Start 
{ 
    public static class WebBackgrounderSetup 
    { 
     static readonly JobManager _jobManager = CreateJobWorkersManager(); 

     public static void Start() 
     { 
      _jobManager.Start(); 
     } 

     public static void Shutdown() 
     { 
      _jobManager.Dispose(); 
     } 

     private static JobManager CreateJobWorkersManager() 
     { 
      var jobs = new IJob[] 
      { 
       new SampleJob(TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(20)), 
       /* new ExceptionJob(TimeSpan.FromSeconds(15)), */ 
       new WorkItemCleanupJob(TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(5), new WorkItemsContext()) 
      }; 

      var coordinator = new WebFarmJobCoordinator(new EntityWorkItemRepository(() => new WorkItemsContext())); 
      var manager = new JobManager(jobs, coordinator); 
      manager.Fail(ex => Elmah.ErrorLog.GetDefault(null).Log(new Error(ex))); 
      return manager; 
     } 
    } 
} 

Jednak uważam, że to prostsze wystarczy użyć części Webbackgrounder że potrzebne następująco. Umieść tę klasę w folderze App_Start

using System; 
using BombaySapphireCds.Jobs; 
using Elmah; 

[assembly: WebActivator.PostApplicationStartMethod(typeof(BombaySapphireCds.App_Start.PodMonitorConfig), "Start")] 
[assembly: WebActivator.ApplicationShutdownMethod(typeof(BombaySapphireCds.App_Start.PodMonitorConfig), "Shutdown")] 

namespace BombaySapphireCds.App_Start 
{ 
    public static class PodMonitorConfig 
    { 
     private static PodMonitorJob m_job; 

     public static void Start() 
     { 
      m_job = new PodMonitorJob(TimeSpan.FromSeconds(20)); 
     } 

     public static void Shutdown() 
     { 
      m_job.Dispose(); 
     } 
    } 
} 

i klasy do wykonania właściwej pracy ... (umieścić ten gdziekolwiek chcesz)

using System; 
using System.Threading; 
using System.Threading.Tasks; 

namespace BombaySapphireCds.Jobs 
{ 
    public class PodMonitorJob : IDisposable 
    { 
     private CancellationTokenSource m_cancel; 
     private Task m_task; 
     private TimeSpan m_interval; 
     private bool m_running; 

     public PodMonitorJob(TimeSpan interval) 
     { 
      m_interval = interval; 
      m_running = true; 
      m_cancel = new CancellationTokenSource(); 
      m_task = Task.Run(() => TaskLoop(), m_cancel.Token); 
     } 

     private void TaskLoop() 
     { 
      while (m_running) 
      { 
       // 
       // Do monitoring work here. 
       // 

       Thread.Sleep(m_interval); 
      } 
     } 

     public void Dispose() 
     { 
      m_running = false; 

      if (m_cancel != null) 
      { 
       try 
       { 
        m_cancel.Cancel(); 
        m_cancel.Dispose(); 
       } 
       catch 
       { 
       } 
       finally 
       { 
        m_cancel = null; 
       } 
      } 
     } 
    } 
} 

Answer 2

ten stał się nowym standardem dla realizacji zadań na tle sieć. Jest to pakiet NuGet i nazywa się HangFire - https://github.com/HangfireIO/Hangfire. Zadania te utrzymują się nawet poza recyklingiem.