Verwenden von Webbackgrounder nuget in MVC zum Ausführen von Hintergrundaufgaben für lange Zeit

Question

Ich muss eine Aufgabe im Hintergrund implementieren, also was ist meine Aufgabe? Ich habe eine Tabelle, die den Mietbetrag jedes Kunden speichert, so muss ich den Mietpreis in jedem Monat nach einer bestimmten datetime Ackf berechnen, so dass ich es googelte und ich fand ein Stück Code, der (ich nuget webbackgrounder) ich hinzugefügt habe es meine Lösung und es gibt mir diesen Teil des Codes meine Aufgabe zu bewältigen:

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)); 
      } 
     } 
    } 

ich wissen will, wie kann ich meine Aufgabe programmieren?

Weitere Details: Here

fand ich this article aber in Wirklichkeit weiß ich nicht, kann ich diese Methode für Langzeit verwenden ?? Mit freundlichen Grüßen.

alle Ideen werden geschätzt.

Answer 1

Sie müssen dem App_Start-Ordner Ihrer Anwendung auch eine Klasse hinzufügen, die den Job startet und dessen Lebensdauer verwaltet. Sie können ein Beispiel hier sehen ... https://github.com/NuGet/WebBackgrounder/tree/master/src/WebBackgrounder.DemoWeb

Hier ist der Code aus der Demo-Anwendung

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; 
     } 
    } 
} 

Allerdings fand ich es nur einfacher, die Teile von Webbackgrounder zu verwenden, die ich wie folgt benötigt. Diese Klasse im App_Start Ordner

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(); 
     } 
    } 
} 

und die Klasse die eigentliche Arbeit zu tun ... (setzen Sie diese überall Sie mögen)

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

Dies ist der neue Standard für die Hintergrundaufgabenausführung hat dich auf das Netz. Es ist ein NuGet-Paket und es heißt HangFire - https://github.com/HangfireIO/Hangfire. Die Aufgaben bleiben auch nach dem Apppool-Recycling bestehen.