NeverendingShift.Hangfire

using NeverendingShift.Hangfire;

// Program.cs or Startup.cs
services.AddHangfirePerformingContextAccessor();

services.AddHangfire((sp, config) =>
{
    config
        .UseSqlServerStorage("YourConnectionString")
        .UsePerformingContextAccessor(sp);
});

services.AddHangfireServer();

using NeverendingShift.Hangfire;

// Global.asax.cs or App_Start
var accessor = new PerformingContextAccessor();

GlobalConfiguration.Configuration
    .UseSqlServerStorage("YourConnectionString")
    .UsePerformingContextAccessor(accessor);

// Make accessor available to your jobs (e.g., via a static property or DI container)
JobHelper.PerformingContextAccessor = accessor;

using NeverendingShift.Hangfire;

// Register in your container
builder.RegisterType<PerformingContextAccessor>()
    .As<IPerformingContextAccessor>()
    .SingleInstance();

builder.RegisterType<PerformingContextAccessorFilter>()
    .SingleInstance();

// Configure Hangfire
var accessor = container.Resolve<IPerformingContextAccessor>();
GlobalConfiguration.Configuration
    .UseSqlServerStorage("YourConnectionString")
    .UsePerformingContextAccessor(accessor);

public class DataProcessingJob
{
    private readonly IPerformingContextAccessor _contextAccessor;

    public DataProcessingJob(IPerformingContextAccessor contextAccessor)
    {
        _contextAccessor = contextAccessor;
    }

    public async Task ProcessAsync(string dataId)
    {
        // Report progress
        _contextAccessor.SetProgress(0, "Starting...");
        
        // Get job information
        var jobId = _contextAccessor.GetCurrentJobId();
        _contextAccessor.WriteLine($"Processing data {dataId} in job {jobId}");

        await Step1();
        _contextAccessor.SetProgress(33, "Step 1 complete");

        await Step2();
        _contextAccessor.SetProgress(66, "Step 2 complete");

        await Step3();
        _contextAccessor.SetProgress(100, "Complete!");
        
        _contextAccessor.WriteLine("Processing complete", ConsoleTextColor.Green);
    }
}

public async Task ProcessRecordsAsync(List<Record> records)
{
    var total = records.Count;
    
    for (int i = 0; i < total; i++)
    {
        await ProcessRecord(records[i]);
        
        var progress = (int)((i + 1) / (double)total * 100);
        _contextAccessor.SetProgress(progress, $"Processed {i + 1}/{total}");
    }
}

public async Task ProcessOrderAsync(int orderId)
{
    var startTime = DateTime.UtcNow;
    
    // Store custom parameters that persist with the job
    _contextAccessor.SetJobParameter("OrderId", orderId);
    _contextAccessor.SetJobParameter("StartTime", startTime);
    
    await ProcessOrder(orderId);
    
    var duration = DateTime.UtcNow - startTime;
    _contextAccessor.SetJobParameter("Duration", duration.TotalSeconds);
    _contextAccessor.SetJobParameter("Status", "Completed");
}

public class SharedService
{
    private readonly IPerformingContextAccessor _contextAccessor;

    public async Task DoWorkAsync()
    {
        if (_contextAccessor.IsInJobContext())
        {
            // Running in Hangfire - use Hangfire console
            _contextAccessor.Current.WriteLine("Processing work item");
            _contextAccessor.SetProgress(50);
        }
        else
        {
            // Running outside Hangfire - use regular logging
            Console.WriteLine("Processing work item");
        }
        
        await ProcessWork();
    }
}

public async Task ProcessWorkflowAsync()
{
    // Store data in context items (scoped to this job execution)
    _contextAccessor.SetItem("WorkflowId", Guid.NewGuid());
    _contextAccessor.SetItem("StartTime", DateTime.UtcNow);
    
    await Step1(); // Can access items from nested methods
    await Step2();
    await Step3();
    
    // Retrieve stored data
    var workflowId = _contextAccessor.GetItem<Guid>("WorkflowId");
    var startTime = _contextAccessor.GetItem<DateTime>("StartTime");
    var duration = DateTime.UtcNow - startTime;
    
    _contextAccessor.WriteLine($"Workflow {workflowId} completed in {duration.TotalSeconds:F2}s");
}

private async Task Step1()
{
    var workflowId = _contextAccessor.GetItem<Guid>("WorkflowId");
    _contextAccessor.WriteLine($"Step 1 for workflow {workflowId}");
    await Task.Delay(100);
}

public interface IPerformingContextAccessor
{
    PerformingContext Current { get; set; }
}

// Get current job ID
string GetCurrentJobId(this IPerformingContextAccessor accessor)

// Report progress (0-100)
void SetProgress(this IPerformingContextAccessor accessor, int value, string message = null)

// Store custom job parameter
void SetJobParameter(this IPerformingContextAccessor accessor, string name, object value)

// Retrieve job parameter
T GetJobParameter<T>(this IPerformingContextAccessor accessor, string name)

// Check if in job context
bool IsInJobContext(this IPerformingContextAccessor accessor)

// Get job creation time
DateTime? GetJobCreatedAt(this IPerformingContextAccessor accessor)

// Context items (scoped storage)
void SetItem(this IPerformingContextAccessor accessor, object key, object value)
T GetItem<T>(this IPerformingContextAccessor accessor, object key)
IDictionary<object, object> GetItems(this IPerformingContextAccessor accessor)

// ✅ Good - use dependency injection
public MyJob(IPerformingContextAccessor contextAccessor) { }

// ❌ Bad - don't create instances directly
var accessor = new PerformingContextAccessor();

// ✅ Good - check if in job context
if (_contextAccessor.IsInJobContext())
{
    _contextAccessor.WriteLine("Running in Hangfire");
}

// ❌ Bad - assumes context exists
_contextAccessor.Current.WriteLine("This may throw!");

// ✅ Good - use extension methods
_contextAccessor.SetProgress(50, "Half done");
var jobId = _contextAccessor.GetCurrentJobId();

// ❌ Less ideal - direct property access
_contextAccessor.Current?.SetJobParameter("Progress", 50);

// ✅ Thread-safe PerformingContext access
BackgroundJob.Enqueue(() => SomeMethodAsync());
BackgroundJob.Enqueue(() => SomeMethodAsync());