### Integrate SilkierQuartz in ASP.NET Core

Source: https://context7.com/iotsharp/silkierquartz/llms.txt

Full integration example including Program.cs host configuration, Startup.cs service registration, and a sample IJob implementation.

```csharp
// Program.cs
using Microsoft.Extensions.Hosting;
using SilkierQuartz;

public class Program
{
    public static void Main(string[] args)
    {
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder => webBuilder.UseStartup<Startup>())
            .ConfigureSilkierQuartzHost()
            .Build()
            .Run();
    }
}

// Startup.cs
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Quartz;
using SilkierQuartz;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddRazorPages();

        services.AddSilkierQuartz(
            options =>
            {
                options.VirtualPathRoot = "/scheduler";
                options.UseLocalTime = true;
                options.EnableEdit = true;
            },
            auth =>
            {
                auth.AccessRequirement = SilkierQuartzAuthenticationOptions.SimpleAccessRequirement.AllowAnonymous;
            }
        );

        // Register jobs
        services.AddQuartzJob<HealthCheckJob>("HealthCheck", group: "Monitoring")
                .AddQuartzJob<DataExportJob>("DataExport", durability: true, group: "Exports")
                .AddQuartzJob<CleanupJob>("Cleanup", group: "Maintenance");
    }

    public void Configure(IApplicationBuilder app)
    {
        app.UseStaticFiles();
        app.UseRouting();
        app.UseAuthentication();
        app.UseAuthorization();
        app.UseSilkierQuartz();

        // Configure triggers
        app.UseQuartzJob<HealthCheckJob>(
            TriggerBuilder.Create()
                .WithSimpleSchedule(x => x.WithIntervalInMinutes(5).RepeatForever())
                .WithDescription("Health check every 5 minutes"));

        app.UseQuartzJob<DataExportJob>(
            TriggerBuilder.Create()
                .WithCronSchedule("0 0 1 * * ?")
                .WithDescription("Daily export at 1 AM"));

        app.UseQuartzJob<CleanupJob>(
            TriggerBuilder.Create()
                .WithCronSchedule("0 0 3 ? * SUN")
                .WithDescription("Weekly cleanup on Sunday at 3 AM"));

        app.UseEndpoints(endpoints => endpoints.MapRazorPages());
    }
}

// HealthCheckJob.cs
using Quartz;
using System.Threading.Tasks;

public class HealthCheckJob : IJob
{
    private readonly IHealthCheckService _healthService;

    public HealthCheckJob(IHealthCheckService healthService)
    {
        _healthService = healthService;
    }

    public async Task Execute(IJobExecutionContext context)
    {
        var results = await _healthService.CheckAllServicesAsync();
        foreach (var result in results)
        {
            Console.WriteLine($"Service: {result.Name}, Status: {result.Status}");
        }
    }
}
```

--------------------------------

### Install SilkierQuartz via NuGet

Source: https://github.com/iotsharp/silkierquartz/blob/master/README.md

Use the Package Manager Console to add the SilkierQuartz package to your project.

```powershell
PM> Install-Package SilkierQuartz
```

--------------------------------

### Configure Services in Startup.cs

Source: https://github.com/iotsharp/silkierquartz/blob/master/index.html

Add SilkierQuartz services to the dependency injection container in the `ConfigureServices` method of `Startup.cs`.

```csharp
public void ConfigureServices(IServiceCollection services)
{
    services.AddSilkierQuartz();
}
```

--------------------------------

### Configure Middleware in Startup.cs

Source: https://github.com/iotsharp/silkierquartz/blob/master/index.html

Configure the SilkierQuartz middleware pipeline in the `Configure` method of `Startup.cs`, specifying options like virtual path and date/time formats.

```csharp
public void Configure(IApplicationBuilder app)
{
    app.UseSilkierQuartz(new SilkierQuartzOptions()
                {
                    Scheduler = scheduler,
                    VirtualPathRoot = "/SilkierQuartz",
                    UseLocalTime = true,
                    DefaultDateFormat = "yyyy-MM-dd",
                    DefaultTimeFormat = "HH:mm:ss"
                });
}
```

--------------------------------

### Register SilkierQuartz Services in Startup

Source: https://context7.com/iotsharp/silkierquartz/llms.txt

Use AddSilkierQuartz to configure options, authentication, and scheduler settings, and register jobs using AddQuartzJob.

```csharp
using Microsoft.Extensions.DependencyInjection;
using SilkierQuartz;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddRazorPages();

        services.AddSilkierQuartz(
            // Configure SilkierQuartz options
            options =>
            {
                options.VirtualPathRoot = "/quartz";
                options.UseLocalTime = true;
                options.DefaultDateFormat = "yyyy-MM-dd";
                options.DefaultTimeFormat = "HH:mm:ss";
                options.EnableEdit = true;
                options.ProductName = "My Scheduler";
                options.CronExpressionOptions = new CronExpressionDescriptor.Options()
                {
                    DayOfWeekStartIndexZero = false // Quartz uses 1-7
                };
            },
            // Configure authentication options
            authenticationOptions =>
            {
                authenticationOptions.UserName = "admin";
                authenticationOptions.Password = "securepassword";
                authenticationOptions.AccessRequirement = SilkierQuartzAuthenticationOptions.SimpleAccessRequirement.AllowOnlyUsersWithClaim;
                authenticationOptions.SilkierQuartzClaim = "SilkierQuartzManage";
                authenticationOptions.SilkierQuartzClaimValue = "Authorized";
            },
            // Configure Quartz.NET scheduler factory options
            stdSchedulerFactoryOptions =>
            {
                stdSchedulerFactoryOptions["quartz.scheduler.instanceName"] = "SilkierQuartzScheduler";
                stdSchedulerFactoryOptions["quartz.threadPool.threadCount"] = "10";
            }
        );

        // Manually register jobs
        services.AddQuartzJob<HelloJob>(nameof(HelloJob))
                .AddQuartzJob<DataSyncJob>(nameof(DataSyncJob), durability: true, group: "DataJobs");
    }
}
```

--------------------------------

### Configure SilkierQuartz Host

Source: https://context7.com/iotsharp/silkierquartz/llms.txt

Enable the Quartz.NET hosted service by calling ConfigureSilkierQuartzHost on the IHostBuilder.

```csharp
using Microsoft.Extensions.Hosting;
using SilkierQuartz;

public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
            })
            .ConfigureSilkierQuartzHost(); // Enable Quartz hosted service
```

--------------------------------

### Configure Host in Program.cs

Source: https://github.com/iotsharp/silkierquartz/blob/master/index.html

Modify the `CreateHostBuilder` method in `Program.cs` to include the SilkierQuartz host configuration.

```csharp
public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                })
             .ConfigureSilkierQuartzHost();
     }
```

--------------------------------

### Configure SilkierQuartz in ASP.NET Core

Source: https://github.com/iotsharp/silkierquartz/blob/master/README.md

Integration steps for Program.cs and Startup.cs to enable the SilkierQuartz middleware.

```csharp
   public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                })
             .ConfigureSilkierQuartzHost();
     }
```

```csharp
public void ConfigureServices(IServiceCollection services)
{
    services.AddSilkierQuartz();
}

public void Configure(IApplicationBuilder app)
{
    /* Optional for authentication
    app.UseAuthentication();
    app.AddSilkierQuartzAuthentication();
    app.UseAuthorization();
    */
    app.UseSilkierQuartz(new SilkierQuartzOptions()
                {
                    Scheduler = scheduler,
                    VirtualPathRoot = "/SilkierQuartz",
                    UseLocalTime = true,
                    DefaultDateFormat = "yyyy-MM-dd",
                    DefaultTimeFormat = "HH:mm:ss"
                    /* Optional for authentication
                    AccountName = "Your User Name",
                    AccountPassword = "Your User Password",
                    IsAuthenticationPersist = false
                    */
                });
}
```

--------------------------------

### Configure Job Triggers in Startup

Source: https://context7.com/iotsharp/silkierquartz/llms.txt

Use UseQuartzJob to define simple, cron, or daily interval triggers for registered jobs. Supports single or multiple trigger configurations.

```csharp
using Microsoft.AspNetCore.Builder;
using Quartz;
using System;
using System.Collections.Generic;

public void Configure(IApplicationBuilder app)
{
    app.UseSilkierQuartz();

    // Single trigger with simple schedule
    app.UseQuartzJob<HelloJob>(
        TriggerBuilder.Create()
            .WithSimpleSchedule(x => x.WithIntervalInSeconds(30).RepeatForever())
    );

    // Multiple triggers for one job
    app.UseQuartzJob<DataSyncJob>(new List<TriggerBuilder>
    {
        TriggerBuilder.Create()
            .WithSimpleSchedule(x => x.WithIntervalInMinutes(5).RepeatForever()),
        TriggerBuilder.Create()
            .WithCronSchedule("0 0 2 ? * SAT *"), // Every Saturday at 2 AM
        TriggerBuilder.Create()
            .WithDailyTimeIntervalSchedule(x => x
                .OnEveryDay()
                .StartingDailyAt(TimeOfDay.HourAndMinuteOfDay(8, 0))
                .EndingDailyAt(TimeOfDay.HourAndMinuteOfDay(17, 0))
                .WithIntervalInHours(1))
    });

    // Trigger builder function
    app.UseQuartzJob<ReportJob>(() =>
    {
        var triggers = new List<TriggerBuilder>();
        triggers.Add(TriggerBuilder.Create()
            .WithCronSchedule("0 0 6 * * ?") // Daily at 6 AM
            .WithDescription("Morning report trigger"));
        return triggers;
    });
}
```

--------------------------------

### Implement a Basic Quartz.NET Job

Source: https://context7.com/iotsharp/silkierquartz/llms.txt

Create a class implementing IJob to define task logic. Use IJobExecutionContext to access the MergedJobDataMap for job-specific parameters.

```csharp
using Quartz;
using System;
using System.Threading.Tasks;

public class HelloJob : IJob
{
    public Task Execute(IJobExecutionContext context)
    {
        Console.WriteLine($"Hello from job at {DateTime.Now}");

        // Access job data map values
        var dataMap = context.MergedJobDataMap;
        if (dataMap.ContainsKey("message"))
        {
            Console.WriteLine($"Message: {dataMap.GetString("message")}");
        }

        return Task.CompletedTask;
    }
}
```

--------------------------------

### Configure OWIN Middleware for Silkier Quartz

Source: https://github.com/iotsharp/silkierquartz/blob/master/index.html

Add the SilkierQuartz OWIN middleware to your Startup.cs file to enable web management tools for Quartz.NET. Ensure you have access to the default scheduler instance.

```csharp
public void Configuration(IAppBuilder app)
{
    app.UseSilkierQuartz(new SilkierQuartzOptions()
    {
        Scheduler = StdSchedulerFactory.GetDefaultScheduler().Result
    });
}
```

--------------------------------

### Inject Dependencies into Quartz Jobs

Source: https://context7.com/iotsharp/silkierquartz/llms.txt

Use constructor injection for services registered in the DI container. Ensure the job is registered via AddQuartzJob in Startup.cs.

```csharp
using Microsoft.Extensions.Options;
using Quartz;
using System;
using System.Threading.Tasks;

public class InjectSampleJob : IJob
{
    private readonly AppSettings _settings;
    private readonly ILogger<InjectSampleJob> _logger;

    public InjectSampleJob(IOptions<AppSettings> options, ILogger<InjectSampleJob> logger)
    {
        _settings = options.Value;
        _logger = logger;
    }

    public Task Execute(IJobExecutionContext context)
    {
        _logger.LogInformation($"Job executed with setting: {_settings.ConnectionString}");
        return Task.CompletedTask;
    }
}

// In Startup.cs ConfigureServices:
services.Configure<AppSettings>(Configuration.GetSection("AppSettings"));
services.AddQuartzJob<InjectSampleJob>(nameof(InjectSampleJob));
```

--------------------------------

### Configure Automatic Job Discovery with SilkierQuartzAttribute

Source: https://context7.com/iotsharp/silkierquartz/llms.txt

Decorate job classes with SilkierQuartzAttribute to enable automatic registration. Supports manual-only jobs and detailed interval scheduling.

```csharp
using Quartz;
using SilkierQuartz;
using System;
using System.Threading.Tasks;

// Auto-register job running every 5 seconds
[SilkierQuartz(5, Group = "example", Description = "Sample auto-discovered job",
    TriggerDescription = "Runs every 5 seconds", TriggerGroup = "AutoTriggers")]
public class HelloJobAuto : IJob
{
    public Task Execute(IJobExecutionContext context)
    {
        Console.WriteLine($"Auto job executed at {DateTime.Now}");
        return Task.CompletedTask;
    }
}

// Manual job (no automatic trigger)
[SilkierQuartz(Manual = true)]
public class ManualOnlyJob : IJob
{
    public Task Execute(IJobExecutionContext context)
    {
        Console.WriteLine("Manual job triggered");
        return Task.CompletedTask;
    }
}

// Job with detailed interval configuration
[SilkierQuartz(0, 1, 30, 0, 0, "DetailedJob", "TimedJobs", "Runs every 1.5 hours")]
// Parameters: days, hours, minutes, seconds, milliseconds, identity, group, description
public class DetailedIntervalJob : IJob
{
    public Task Execute(IJobExecutionContext context)
    {
        return Task.CompletedTask;
    }
}
```

--------------------------------

### Implement Custom Execution History Store in C#

Source: https://context7.com/iotsharp/silkierquartz/llms.txt

Implement IExecutionHistoryStore to persist job execution history in a database. Requires EF Core or similar ORM for data access.

```csharp
using Quartz.Plugins.RecentHistory;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

// Custom execution history store implementation
public class DatabaseExecutionHistoryStore : IExecutionHistoryStore
{
    public string SchedulerName { get; set; }

    public async Task<ExecutionHistoryEntry> Get(string fireInstanceId)
    {
        // Retrieve entry from database
        return await _dbContext.ExecutionHistory
            .FirstOrDefaultAsync(e => e.FireInstanceId == fireInstanceId);
    }

    public async Task Save(ExecutionHistoryEntry entry)
    {
        // Save entry to database
        _dbContext.ExecutionHistory.Add(entry);
        await _dbContext.SaveChangesAsync();
    }

    public async Task Purge()
    {
        // Remove old entries (e.g., older than 30 days)
        var cutoff = DateTime.UtcNow.AddDays(-30);
        var oldEntries = _dbContext.ExecutionHistory
            .Where(e => e.ActualFireTimeUtc < cutoff);
        _dbContext.ExecutionHistory.RemoveRange(oldEntries);
        await _dbContext.SaveChangesAsync();
    }

    public async Task<IEnumerable<ExecutionHistoryEntry>> FilterLast(int limit)
    {
        return await _dbContext.ExecutionHistory
            .OrderByDescending(e => e.ActualFireTimeUtc)
            .Take(limit)
            .ToListAsync();
    }

    public async Task<IEnumerable<ExecutionHistoryEntry>> FilterLastOfEveryJob(int limitPerJob)
    {
        // Group by job and take last N per job
        return await _dbContext.ExecutionHistory
            .GroupBy(e => e.Job)
            .SelectMany(g => g.OrderByDescending(e => e.ActualFireTimeUtc).Take(limitPerJob))
            .ToListAsync();
    }

    public async Task<IEnumerable<ExecutionHistoryEntry>> FilterLastOfEveryTrigger(int limitPerTrigger)
    {
        return await _dbContext.ExecutionHistory
            .GroupBy(e => e.Trigger)
            .SelectMany(g => g.OrderByDescending(e => e.ActualFireTimeUtc).Take(limitPerTrigger))
            .ToListAsync();
    }

    public async Task<int> GetTotalJobsExecuted() =>
        await _dbContext.JobStats.Select(s => s.TotalJobsExecuted).FirstOrDefaultAsync();

    public async Task<int> GetTotalJobsFailed() =>
        await _dbContext.JobStats.Select(s => s.TotalJobsFailed).FirstOrDefaultAsync();

    public async Task IncrementTotalJobsExecuted()
    {
        var stats = await _dbContext.JobStats.FirstAsync();
        stats.TotalJobsExecuted++;
        await _dbContext.SaveChangesAsync();
    }

    public async Task IncrementTotalJobsFailed()
    {
        var stats = await _dbContext.JobStats.FirstAsync();
        stats.TotalJobsFailed++;
        await _dbContext.SaveChangesAsync();
    }
}
```

--------------------------------

### Enable SilkierQuartz Middleware

Source: https://context7.com/iotsharp/silkierquartz/llms.txt

Add the UseSilkierQuartz middleware in the application pipeline to enable the management UI.

```csharp
using Microsoft.AspNetCore.Builder;

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthentication();
    app.UseAuthorization();

    // Enable SilkierQuartz web management UI
    app.UseSilkierQuartz();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapRazorPages();
    });
}
```

--------------------------------

### Configure SilkierQuartz Options

Source: https://context7.com/iotsharp/silkierquartz/llms.txt

Customize the web UI, date/time formats, branding, and job data map handlers via AddSilkierQuartz.

```csharp
using SilkierQuartz;
using SilkierQuartz.TypeHandlers;

services.AddSilkierQuartz(options =>
{
    // Virtual path where SilkierQuartz UI is accessible
    options.VirtualPathRoot = "/scheduler";
    options.BasePath = "/";

    // Date/time display settings
    options.UseLocalTime = true;
    options.DefaultDateFormat = "yyyy-MM-dd";
    options.DefaultTimeFormat = "HH:mm:ss";

    // Branding customization
    options.Logo = "Content/Images/custom-logo.png";
    options.ProductName = "My Job Scheduler";
    options.CustomStyleSheet = "css/custom-scheduler.css";
    options.CustomFavicon = "favicon/scheduler.ico";

    // Enable/disable editing through web UI
    options.EnableEdit = true;

    // Cron expression description options
    options.CronExpressionOptions = new CronExpressionDescriptor.Options()
    {
        DayOfWeekStartIndexZero = false,
        Use24HourTimeFormat = true
    };

    // Add custom type handlers for job data map
    options.StandardTypes.Add(new EnumHandler<DayOfWeek>() { Name = "DayOfWeek" });
});
```

--------------------------------

### Register Job Details Manually in C#

Source: https://context7.com/iotsharp/silkierquartz/llms.txt

Use AddQuartzJobDetail to register pre-configured job details with full control over job settings like identity, description, and persistence.

```csharp
using Microsoft.Extensions.DependencyInjection;
using Quartz;

services.AddQuartzJobDetail(() =>
    JobBuilder.Create<EmailJob>()
        .WithIdentity("EmailJob", "Notifications")
        .WithDescription("Sends scheduled email notifications")
        .StoreDurably(true)
        .RequestRecovery(true)
        .DisallowConcurrentExecution()
        .PersistJobDataAfterExecution()
        .UsingJobData("smtpServer", "smtp.example.com")
        .UsingJobData("maxRetries", 3)
        .Build()
);

services.AddQuartzJobDetail(
    JobBuilder.Create<BackupJob>()
        .WithIdentity("BackupJob", "Maintenance")
        .StoreDurably(true)
        .Build()
);
```

--------------------------------

### Configure Authentication

Source: https://context7.com/iotsharp/silkierquartz/llms.txt

Secure the SilkierQuartz interface using cookie authentication and custom access requirements.

```csharp
using Microsoft.AspNetCore.Authentication.Cookies;
using SilkierQuartz;

services.AddSilkierQuartz(
    options => { options.VirtualPathRoot = "/quartz"; },
    authenticationOptions =>
    {
        // Basic username/password authentication
        authenticationOptions.UserName = "admin";
        authenticationOptions.Password = "secure_password_123";

        // Authentication scheme
        authenticationOptions.AuthScheme = CookieAuthenticationDefaults.AuthenticationScheme;
        authenticationOptions.CookieName = "SilkierQuartz.Auth";

        // Access requirement levels:
        // AllowAnonymous - No authentication required
        // AllowOnlyAuthenticated - Any authenticated user
        // AllowOnlyUsersWithClaim - Users with specific claim
        authenticationOptions.AccessRequirement =
            SilkierQuartzAuthenticationOptions.SimpleAccessRequirement.AllowOnlyUsersWithClaim;

        // Claim-based authorization
        authenticationOptions.SilkierQuartzClaim = "SilkierQuartzAccess";
        authenticationOptions.SilkierQuartzClaimValue = "FullAccess";

        // Custom authentication logic
        authenticationOptions.Authenticate = (reqUserName, reqPassword, verifyUserName, verifyPassword) =>
        {
            // Custom validation logic
            return string.Equals(reqUserName, verifyUserName, StringComparison.OrdinalIgnoreCase) &&
                   string.Equals(reqPassword, verifyPassword, StringComparison.Ordinal);
        };
    }
);
```

--------------------------------

### Access Scheduler Programmatically

Source: https://context7.com/iotsharp/silkierquartz/llms.txt

Retrieve scheduler instances and perform job operations like pause, resume, or trigger using extension methods.

```csharp
using Microsoft.AspNetCore.Builder;
using Quartz;

public void Configure(IApplicationBuilder app)
{
    app.UseSilkierQuartz();

    // Get the default scheduler
    IScheduler scheduler = app.GetScheduler();

    // Get scheduler by name
    IScheduler namedScheduler = app.GetScheduler("MyScheduler");

    // Get all schedulers
    IReadOnlyList<IScheduler> allSchedulers = app.GetAllSchedulers();

    // Programmatic job operations
    var jobKey = new JobKey("MyJob", "MyGroup");

    // Pause a job
    scheduler.PauseJob(jobKey).Wait();

    // Resume a job
    scheduler.ResumeJob(jobKey).Wait();

    // Trigger a job immediately
    scheduler.TriggerJob(jobKey).Wait();

    // Check if job exists
    bool exists = scheduler.CheckExists(jobKey).Result;
}
```

--------------------------------

### Register CRON Jobs

Source: https://context7.com/iotsharp/silkierquartz/llms.txt

Use RegiserCRONJob within ConfigureServices to schedule jobs with specific CRON expressions and priorities.

```csharp
using Microsoft.Extensions.DependencyInjection;
using SilkierQuartz;
using SilkierQuartz.HostedService;

public void ConfigureServices(IServiceCollection services)
{
    services.UseQuartzHostedService(options =>
    {
        options["quartz.scheduler.instanceName"] = "MainScheduler";
    })
    .RegiserCRONJob<DailyReportJob>(jobOptions =>
    {
        jobOptions.Triggers = new List<TriggerOptions>
        {
            new TriggerOptions
            {
                CRONExpression = "0 0 8 * * ?", // Daily at 8 AM
                Priority = 10
            }
        };
    })
    .RegiserCRONJob<WeeklyCleanupJob>(jobOptions =>
    {
        jobOptions.Triggers = new List<TriggerOptions>
        {
            new TriggerOptions
            {
                CRONExpression = "0 0 0 ? * SUN", // Every Sunday at midnight
                Priority = 5
            }
        };
    });
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.