Understanding Modern .NET Worker Services

The evolution of Windows Services from VB.NET 3.0 to .NET 8 mirrors the broader transformation in software development. In the VB.NET days, creating a Windows Service was like navigating a labyrinth. Developers wrestled with Visual Studio Service templates, meticulously crafted service installer classes, and managed XML configurations in App.config files. The deployment process hinged on InstallUtil.exe, a temperamental command-line tool that demanded specific permissions. Even basic tasks like implementing a FileSystemWatcher required complex setups within Windows Forms applications.

Enter .NET 8, and the landscape has dramatically simplified. Modern .NET has eliminated these complexities, offering native Windows Service support without the need for installer classes. The rigid XML configurations have given way to intuitive JSON in appsettings.json. Built-in dependency injection, familiar to Java developers from Spring, has transformed how we structure services, enhancing maintainability and testing.

This evolution represents more than just technical advancement—it reflects a fundamental shift in development philosophy. By removing unnecessary complexity, .NET 8 allows developers to focus on writing clean, efficient code that solves real problems, rather than wrestling with infrastructure concerns.

What's Different From The Old Days

Then vs Now

1. Old Way (VB.NET 3.0)

   • Windows Forms Applications
   • Windows Services created through Visual Studio Service template
   • App.config for settings
   • InstallUtil.exe for installation
   • Manual service installer classes
   • System.IO.FileSystemWatcher in a form

2. New Way (.NET 8)

   • No more InstallUtil.exe needed
   • No more service installer classes needed
   • appsettings.json instead of App.config
   • Built-in dependency injection (like Spring if you used Java)
   • Native Windows Service support

The New Structure Explained

Program.cs (Think of this as your old Main() method)

// Old VB.NET way:
// Public Sub Main()
//     ServiceBase.Run(New MyService())
// End Sub

// New .NET way:
var builder = Host.CreateApplicationBuilder(args);
builder.Services.AddHostedService<Worker>();
var host = builder.Build();
host.Run();

Worker.cs (This is like your old Service1.vb)

// Old VB.NET way:
// Public Class Service1
//     Inherits ServiceBase
//     Private WithEvents FileWatcher As FileSystemWatcher

// New .NET way:
public class Worker : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        // Your service code here
    }
}

Configuration (Replacing App.config)

// Old VB.NET way:
// <appSettings>
//     <add key="WatchFolder" value="C:\WatchFolder"/>
// </appSettings>

// New .NET way (appsettings.json):
{
  "WatchSettings": {
    "FolderPath": "C:\\WatchFolder",
    "FileFilter": "*.txt"
  }
}

Installation Comparison

Old Way (VB.NET 3.0):

' Required installer classes
Public Class ProjectInstaller
    Inherits System.Configuration.Install.Installer
End Class

' Installation command
installutil.exe MyService.exe

New Way (.NET 8):

# One command does it all
sc.exe create "TSVAutomation" binpath= "C:\Path\To\TSVAutomation.exe" start= auto

File Watching Comparison

Old Way (VB.NET 3.0):

Private WithEvents FileWatcher As New FileSystemWatcher
Private Sub SetupWatcher()
    FileWatcher.Path = "C:\WatchFolder"
    FileWatcher.Filter = "*.txt"
    FileWatcher.EnableRaisingEvents = True
End Sub

Private Sub FileWatcher_Created(sender As Object, e As FileSystemEventArgs)
    ' Handle new file
End Sub

New Way (.NET 8):

private FileSystemWatcher? _watcher;
public override Task StartAsync(CancellationToken cancellationToken)
{
    _watcher = new FileSystemWatcher
    {
        Path = _watchPath,
        Filter = _fileFilter,
        EnableRaisingEvents = true
    };
    _watcher.Created += OnFileCreated;
    return base.StartAsync(cancellationToken);
}

Key Differences to Remember

1. No More Project Installers

   • Old: Required special installer classes
   • New: Just use sc.exe commands

2. Configuration

   • Old: XML-based App.config
   • New: JSON-based appsettings.json

3. Service Development

   • Old: Heavy ServiceBase inheritance
   • New: Lightweight BackgroundService class

4. Deployment

   • Old: InstallUtil.exe + manual setup
   • New: dotnet publish + sc.exe commands

Quick Start Steps

1. Create project:

   Old: File -> New -> Windows Service
   New: Create Worker Service template

2. Configure settings:

   Old: Edit App.config
   New: Edit appsettings.json

3. Build:

   Old: Build Solution
   New: dotnet publish --configuration Release

4. Install:

   Old: installutil.exe MyService.exe
   New: sc.exe create "ServiceName" binpath= "path\to\exe"

Common VB.NET to Modern .NET Translations

1. Event Handlers

   ' Old VB.NET
   Private Sub FileWatcher_Created(sender As Object, e As FileSystemEventArgs)

   // New .NET
   private void OnFileCreated(object sender, FileSystemEventArgs e)

2. Configuration Reading

   ' Old VB.NET
   Dim watchPath As String = ConfigurationManager.AppSettings("WatchFolder")

   // New .NET
   string watchPath = configuration.GetValue<string>("WatchSettings:FolderPath")

Remember: The fundamental concepts haven't changed - you're still creating a Windows Service that watches for files. The main differences are in the setup, configuration, and deployment process.