C# Academy · Pelajaran

Proyek Worker Service

Buat Worker Service mandiri, konfigurasikan DI dan logging, lalu deploy sebagai Windows Service atau daemon Linux.

Proyek Worker Service adalah pelajaran C# Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar C# Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus C# Academy mencakup 4 pelajaran total.

Apa Itu Worker Service?

Worker Service adalah templat proyek .NET untuk membangun aplikasi latar belakang yang berjalan lama — tanpa server web dan tanpa titik akhir HTTP. Worker Service merupakan host ringan yang sangat sesuai untuk pemroses antrean, tugas terjadwal, dan layanan bergaya daemon.

Membuat Worker Service

Gunakan templat CLI untuk membuat kerangka proyek Worker Service. Templat ini menghasilkan Program.cs minimal dan kelas Worker.cs yang mewarisi BackgroundService.

# Create a new Worker Service project
dotnet new worker -n OrderProcessor

# Generated structure:
# OrderProcessor/
#   Program.cs       — host configuration
#   Worker.cs        — your BackgroundService subclass
#   appsettings.json

Program.cs pada Worker Service

Program.cs yang dihasilkan menggunakan Generic Host. Anda mengonfigurasi DI, pencatatan log, konfigurasi, dan mendaftarkan worker — sama seperti pada ASP.NET Core, tetapi tanpa server web.

using Microsoft.Extensions.Hosting;

var builder = Host.CreateApplicationBuilder(args);

// Register services
builder.Services.AddDbContext<AppDbContext>(opt =>
    opt.UseSqlServer(builder.Configuration.GetConnectionString("Default")));

builder.Services.AddScoped<IOrderRepository, OrderRepository>();
builder.Services.AddHostedService<OrderProcessorWorker>();

var host = builder.Build();
host.Run();

Kelas Worker

Warisi BackgroundService dan implementasikan ExecuteAsync. Host memanggilnya saat dimulai dan meneruskan token pembatalan yang dipicu saat penghentian.

public class OrderProcessorWorker : BackgroundService
{
    private readonly IServiceScopeFactory _factory;
    private readonly ILogger<OrderProcessorWorker> _logger;

    public OrderProcessorWorker(
        IServiceScopeFactory factory,
        ILogger<OrderProcessorWorker> logger)
    {
        _factory = factory;
        _logger  = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        while (!ct.IsCancellationRequested)
        {
            using var scope = _factory.CreateScope();
            var repo = scope.ServiceProvider.GetRequiredService<IOrderRepository>();
            var pending = await repo.GetPendingAsync(ct);
            foreach (var order in pending)
                await ProcessOrderAsync(order, ct);
            await Task.Delay(TimeSpan.FromSeconds(10), ct);
        }
    }

    private Task ProcessOrderAsync(Order o, CancellationToken ct) =>
        Task.Delay(100, ct); // placeholder
}

Konfigurasi & DI pada Worker

Worker Service mendukung sistem konfigurasi .NET secara lengkap — pengaturan aplikasi, variabel lingkungan, dan rahasia pengguna. Suntikkan IConfiguration atau opsi yang bertipe kuat.

builder.Services.Configure<WorkerSettings>(
    builder.Configuration.GetSection("Worker"));

public class OrderProcessorWorker : BackgroundService
{
    private readonly WorkerSettings _settings;

    public OrderProcessorWorker(IOptions<WorkerSettings> opts, ...)
        => _settings = opts.Value;

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        while (!ct.IsCancellationRequested)
        {
            // ...
            await Task.Delay(_settings.PollIntervalSeconds * 1000, ct);
        }
    }
}

Pencatatan Log pada Worker Service

Generic Host mengonfigurasi pencatatan log secara otomatis. Gunakan ILogger<T> untuk pencatatan log terstruktur. Dalam produksi, konfigurasikan Serilog, Application Insights, atau penyedia lainnya.

// Add Serilog to a Worker Service
builder.Host.UseSerilog((ctx, logConfig) =>
    logConfig
        .ReadFrom.Configuration(ctx.Configuration)
        .WriteTo.Console()
        .WriteTo.Seq(ctx.Configuration["Seq:ServerUrl"]!));

// Structured logging in the worker:
_logger.LogInformation("Processing {Count} orders at {Time}",
    orders.Count, DateTimeOffset.UtcNow);
_logger.LogError(ex, "Failed to process order {OrderId}", order.Id);

Menjalankan sebagai Layanan Windows

Gunakan UseWindowsService() untuk menjalankan Worker sebagai Layanan Windows. Layanan akan dimulai dan dihentikan bersama OS serta tetap berjalan setelah pengguna keluar dari sistem.

// dotnet add package Microsoft.Extensions.Hosting.WindowsServices

builder.Services.AddWindowsService(options =>
    options.ServiceName = "OrderProcessor");

// Build and publish:
// dotnet publish -c Release -o ./publish

// Install as Windows Service:
// sc create OrderProcessor binpath="C:\services\publish\OrderProcessor.exe"
// sc start OrderProcessor

Menjalankan sebagai Daemon Systemd Linux

Gunakan UseSystemd() untuk mengintegrasikan aplikasi dengan systemd di Linux. Layanan menerima sinyal penghentian yang tepat dan terintegrasi dengan pencatatan log journald.

// dotnet add package Microsoft.Extensions.Hosting.Systemd

builder.Services.AddSystemd();

// Systemd unit file: /etc/systemd/system/orderprocessor.service
// [Unit]
// Description=Order Processor Worker
// [Service]
// Type=notify
// ExecStart=/usr/bin/dotnet /app/OrderProcessor.dll
// Restart=always
// [Install]
// WantedBy=multi-user.target

// Commands:
// sudo systemctl enable orderprocessor
// sudo systemctl start orderprocessor
// sudo journalctl -u orderprocessor -f

Menjalankan di Docker

Worker Service sangat sesuai untuk kontainer Docker — pemetaan port tidak diperlukan; cukup jalankan proses dalam perulangan hingga kontainer berhenti.

# Dockerfile
FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
WORKDIR /src
COPY . .
RUN dotnet publish -c Release -o /app

FROM mcr.microsoft.com/dotnet/runtime:9.0
WORKDIR /app
COPY --from=build /app .
ENTRYPOINT ["dotnet", "OrderProcessor.dll"]

# docker-compose.yml:
# services:
#   worker:
#     build: .
#     environment:
#       - ConnectionStrings__Default=Server=db;...
#     depends_on: [db]

Dunia Nyata: Worker Ringkasan Email

Worker lengkap yang mengirim ringkasan email harian dengan membaca data dari basis data dan mengirimkannya melalui layanan email.

public class EmailDigestWorker : BackgroundService
{
    private readonly IServiceScopeFactory _factory;
    private readonly ILogger<EmailDigestWorker> _log;

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        // Run daily at midnight UTC
        while (!ct.IsCancellationRequested)
        {
            var now = DateTime.UtcNow;
            var next = now.Date.AddDays(1); // next midnight
            await Task.Delay(next - now, ct);

            using var scope = _factory.CreateScope();
            var mailer = scope.ServiceProvider.GetRequiredService<IDigestMailer>();

            try   { await mailer.SendDailyDigestsAsync(ct); }
            catch (Exception ex) { _log.LogError(ex, "Digest failed"); }
        }
    }
}

Pemeriksaan Singkat

Apa perbedaan utama antara proyek Worker Service dan proyek ASP.NET Core Web API?

Ringkasan: Proyek Worker Service

Inti pembelajaran:

Worker Service = Generic Host + BackgroundService, tanpa server web
Dukungan penuh untuk DI, pencatatan log, dan konfigurasi — hanya tanpa HTTP
UseWindowsService() untuk penerapan sebagai Layanan Windows
UseSystemd() untuk daemon Linux dengan integrasi journald
Terapkan dalam kontainer Docker untuk pemrosesan latar belakang cloud-native
Selalu gunakan IServiceScopeFactory untuk dependensi dengan cakupan di dalam worker

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Proyek Worker Service” gratis?

Ya — teks lengkap “Proyek Worker Service” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus C# Academy, upgrade ke CoddyKit PRO. Kursus C# Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Proyek Worker Service”?

Buat Worker Service mandiri, konfigurasikan DI dan logging, lalu deploy sebagai Windows Service atau daemon Linux. Kamu berlatih C# Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai C# Academy?

Tidak diperlukan pengalaman sebelumnya. C# Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Proyek Worker Service” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran C# Academy ini?

Ya. Setiap pelajaran C# Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke C# Academy