C# Academy · Lekcja

Projekty Worker Service

Twórz samodzielne usługi Worker Service, konfiguruj DI i logowanie oraz wdrażaj je jako usługę Windows lub demon systemu Linux.

Projekty Worker Service to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C# Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C# Academy zawiera 4 lekcji w sumie.

Czym jest Worker Service?

Worker Service to szablon projektu .NET do tworzenia długotrwałych aplikacji działających w tle — bez serwera internetowego i endpointów HTTP. Jest to lekki host, idealny do procesorów kolejek, zaplanowanych zadań i usług działających w stylu demona.

Tworzenie projektu Worker Service

Użyj szablonu CLI, aby utworzyć szkielet projektu Worker Service. Wygeneruje on minimalny plik Program.cs oraz klasę Worker.cs dziedziczącą po 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 w Worker Service

Wygenerowany plik Program.cs korzysta z Generic Host. Konfiguruje wstrzykiwanie zależności, rejestrowanie, konfigurację i rejestruje workera — identycznie jak w ASP.NET Core, ale bez serwera internetowego.

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

Klasa Worker

Odziedzicz po BackgroundService i zaimplementuj ExecuteAsync. Host wywołuje tę metodę podczas uruchamiania i przekazuje token anulowania, który zostaje aktywowany podczas zamykania.

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
}

Konfiguracja i DI w workerach

Worker Services obsługują pełny system konfiguracji .NET — appsettings, zmienne środowiskowe i sekrety użytkownika. Wstrzyknij IConfiguration lub opcje o silnym typowaniu.

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

Rejestrowanie w Worker Services

Generic Host automatycznie konfiguruje rejestrowanie. Użyj ILogger<T> do rejestrowania strukturalnego. W środowisku produkcyjnym skonfiguruj Serilog, Application Insights lub innego dostawcę.

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

Uruchamianie jako usługa Windows

Użyj UseWindowsService(), aby uruchomić workera jako usługę Windows. Usługa jest uruchamiana i zatrzymywana razem z systemem operacyjnym oraz działa nadal po wylogowaniu użytkownika.

// 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

Uruchamianie jako demon Linux systemd

Użyj UseSystemd(), aby zintegrować aplikację z systemd w systemie Linux. Usługa otrzymuje prawidłowe sygnały zatrzymania i integruje się z rejestrowaniem 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

Uruchamianie w Dockerze

Worker Services doskonale nadają się do kontenerów Docker — nie trzeba mapować portów, wystarczy uruchomić proces w pętli do momentu zatrzymania kontenera.

# 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]

Praktyczny przykład: worker podsumowań e-mail

Kompletny worker wysyłający codzienne podsumowania e-mail, odczytujący dane z bazy danych i przekazujący je do usługi pocztowej.

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

Szybkie sprawdzenie

Jaka jest główna różnica między projektem Worker Service a projektem ASP.NET Core Web API?

Podsumowanie: projekty Worker Service

Najważniejsze informacje:

Worker Service = Generic Host + BackgroundService, bez serwera internetowego
Pełna obsługa DI, rejestrowania i konfiguracji — tylko bez HTTP
UseWindowsService() do wdrażania jako usługa Windows
UseSystemd() do uruchamiania demona Linux ze zintegrowanym journald
Wdrażaj w kontenerach Docker, aby realizować natywne dla chmury przetwarzanie w tle
W workerze zawsze używaj IServiceScopeFactory dla zależności Scoped

Często zadawane pytania

Czy lekcja „Projekty Worker Service” jest bezpłatna?

Tak — pełny tekst „Projekty Worker Service” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C# Academy, przejdź na CoddyKit PRO. Kurs C# Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Projekty Worker Service”?

Twórz samodzielne usługi Worker Service, konfiguruj DI i logowanie oraz wdrażaj je jako usługę Windows lub demon systemu Linux. Ćwiczysz C# Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C# Academy?

Nie wymagamy żadnego doświadczenia. C# Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Projekty Worker Service”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C# Academy?

Tak. Każda lekcja C# Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do C# Academy