diff --git a/src/NetEvolve.Extensions.Hosting.WinForms/IHostBuilderExtensions.cs b/src/NetEvolve.Extensions.Hosting.WinForms/IHostBuilderExtensions.cs
index 68ec520..15e7ae6 100644
--- a/src/NetEvolve.Extensions.Hosting.WinForms/IHostBuilderExtensions.cs
+++ b/src/NetEvolve.Extensions.Hosting.WinForms/IHostBuilderExtensions.cs
@@ -6,11 +6,7 @@
 using Microsoft.Extensions.Hosting;
 using NetEvolve.Extensions.Hosting.WinForms.Internals;
 
-#if NET8_0_OR_GREATER
-/// <summary>
-/// Extension methods for <see cref="IHostBuilder"/> or <see cref="IHostApplicationBuilder"/> to configure Windows Forms Lifetime.
-/// </summary>
-#elif NET7_0
+#if NET7_0_OR_GREATER
 /// <summary>
 /// Extension methods for <see cref="IHostBuilder"/> or <see cref="HostApplicationBuilder"/> to configure Windows Forms Lifetime.
 /// </summary>
@@ -68,13 +64,14 @@ public static IHostBuilder UseWindowsForms<TApplicationContext>(
         return builder.ConfigureServices(services =>
         {
             services = contextFactory is null
-                ? services.AddSingleton<TApplicationContext>()
-                : services.AddSingleton(sp => contextFactory.Invoke(sp));
+                ? services.AddSingleton<ApplicationContext, TApplicationContext>()
+                : services.AddSingleton<ApplicationContext, TApplicationContext>(sp =>
+                    contextFactory.Invoke(sp)
+                );
 
             _ = services
-                .AddSingleton<ApplicationContext, TApplicationContext>()
-                // Default WindowsForms services
-                .AddWindowsFormsLifetime(configure);
+            // Default WindowsForms services
+            .AddWindowsFormsLifetime(configure);
         });
     }
 
@@ -115,7 +112,7 @@ public static IHostBuilder UseWindowsForms<TApplicationContext, TStartForm>(
         );
     }
 
-#if NET7_0
+#if NET7_0_OR_GREATER
     /// <summary>
     /// Enables Windows Forms support, builds and starts the host with the specified <typeparamref name="TStartForm"/>,
     /// then waits for the host to close the <typeparamref name="TStartForm"/> before shutting down.
@@ -160,13 +157,14 @@ public static HostApplicationBuilder UseWindowsForms<TApplicationContext>(
         ArgumentNullException.ThrowIfNull(builder);
 
         var services = contextFactory is null
-            ? builder.Services.AddSingleton<TApplicationContext>()
-            : builder.Services.AddSingleton(sp => contextFactory.Invoke(sp));
+            ? builder.Services.AddSingleton<ApplicationContext, TApplicationContext>()
+            : builder.Services.AddSingleton<ApplicationContext, TApplicationContext>(sp =>
+                contextFactory.Invoke(sp)
+            );
 
         _ = services
-            .AddSingleton<ApplicationContext>(sp => sp.GetRequiredService<TApplicationContext>())
-            // Default WindowsForms services
-            .AddWindowsFormsLifetime(configure);
+        // Default WindowsForms services
+        .AddWindowsFormsLifetime(configure);
 
         return builder;
     }
@@ -206,96 +204,4 @@ public static HostApplicationBuilder UseWindowsForms<TApplicationContext, TStart
         return builder;
     }
 #endif
-
-#if NET8_0_OR_GREATER
-    /// <summary>
-    /// Enables Windows Forms support, builds and starts the host with the specified <typeparamref name="TStartForm"/>,
-    /// then waits for the host to close the <typeparamref name="TStartForm"/> before shutting down.
-    /// </summary>
-    /// <typeparam name="TStartForm">Form with which the application is to be started.</typeparam>
-    /// <param name="builder">The <see cref="IHostApplicationBuilder"/> to configure.</param>
-    /// <param name="configure">The action to be executed for the configuration of the <see cref="WindowsFormsOptions"/>.</param>
-    /// <returns><see cref="IHostApplicationBuilder"/> with enabled Windows Forms support.</returns>
-    public static IHostApplicationBuilder UseWindowsForms<TStartForm>(
-        this IHostApplicationBuilder builder,
-        Action<WindowsFormsOptions>? configure = null
-    )
-        where TStartForm : Form
-    {
-        ArgumentNullException.ThrowIfNull(builder);
-
-        _ = builder
-            .Services.AddSingleton<TStartForm>()
-            .AddSingleton(sp => new ApplicationContext(sp.GetRequiredService<TStartForm>()))
-            // Default WindowsForms services
-            .AddWindowsFormsLifetime(configure);
-
-        return builder;
-    }
-
-    /// <summary>
-    /// Enables Windows Forms support, builds and starts the host with the specified <typeparamref name="TApplicationContext"/>,
-    /// then waits for the host to close the <typeparamref name="TApplicationContext"/> before shutting down.
-    /// </summary>
-    /// <typeparam name="TApplicationContext"></typeparam>
-    /// <param name="builder">The <see cref="IHostApplicationBuilder"/> to configure.</param>
-    /// <param name="contextFactory">The <see cref="ApplicationContext"/> factory.</param>
-    /// <param name="configure">The action to be executed for the configuration of the <see cref="WindowsFormsOptions"/>.</param>
-    /// <returns><see cref="IHostApplicationBuilder"/> with enabled Windows Forms support.</returns>
-    public static IHostApplicationBuilder UseWindowsForms<TApplicationContext>(
-        this IHostApplicationBuilder builder,
-        Func<IServiceProvider, TApplicationContext>? contextFactory = null,
-        Action<WindowsFormsOptions>? configure = null
-    )
-        where TApplicationContext : ApplicationContext
-    {
-        ArgumentNullException.ThrowIfNull(builder);
-
-        var services = contextFactory is null
-            ? builder.Services.AddSingleton<TApplicationContext>()
-            : builder.Services.AddSingleton(sp => contextFactory(sp));
-
-        _ = services
-            .AddSingleton<ApplicationContext>(sp => sp.GetRequiredService<TApplicationContext>())
-            // Default WindowsForms services
-            .AddWindowsFormsLifetime(configure);
-
-        return builder;
-    }
-
-    /// <summary>
-    /// Enables Windows Forms support, builds and starts the host with the specified <typeparamref name="TApplicationContext"/>,
-    /// which is created by the <paramref name="contextFactory"/> function, then waits for the host to close the <typeparamref name="TApplicationContext"/> before shutting down.
-    /// </summary>
-    /// <typeparam name="TApplicationContext"></typeparam>
-    /// <typeparam name="TStartForm">Form with which the application is to be started.</typeparam>
-    /// <param name="builder">The <see cref="IHostApplicationBuilder"/> to configure.</param>
-    /// <param name="contextFactory">The <see cref="ApplicationContext"/> factory.</param>
-    /// <param name="configure">The action to be executed for the configuration of the <see cref="WindowsFormsOptions"/>.</param>
-    /// <returns><see cref="IHostApplicationBuilder"/> with enabled Windows Forms support.</returns>
-    public static IHostApplicationBuilder UseWindowsForms<TApplicationContext, TStartForm>(
-        this IHostApplicationBuilder builder,
-        Func<IServiceProvider, TStartForm, TApplicationContext> contextFactory,
-        Action<WindowsFormsOptions>? configure = null
-    )
-        where TApplicationContext : ApplicationContext
-        where TStartForm : Form
-    {
-        ArgumentNullException.ThrowIfNull(builder);
-        ArgumentNullException.ThrowIfNull(contextFactory);
-
-        _ = builder
-            .Services.AddSingleton<TStartForm>()
-            .AddSingleton(sp =>
-            {
-                var startForm = sp.GetRequiredService<TStartForm>();
-                return contextFactory(sp, startForm);
-            })
-            .AddSingleton<ApplicationContext>(sp => sp.GetRequiredService<TApplicationContext>())
-            // Default WindowsForms services
-            .AddWindowsFormsLifetime(configure);
-
-        return builder;
-    }
-#endif
 }
diff --git a/tests/NetEvolve.Extensions.Hosting.WinForms.Tests.Integration/IHostBuilderExtensionsTests.cs b/tests/NetEvolve.Extensions.Hosting.WinForms.Tests.Integration/IHostBuilderExtensionsTests.cs
new file mode 100644
index 0000000..54022d8
--- /dev/null
+++ b/tests/NetEvolve.Extensions.Hosting.WinForms.Tests.Integration/IHostBuilderExtensionsTests.cs
@@ -0,0 +1,290 @@
+namespace NetEvolve.Extensions.Hosting.WinForms.Tests.Integration;
+
+using System;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Xunit;
+
+public class IHostBuilderExtensionsTests
+{
+    [Fact]
+    public async Task UseWindowsForms_IHostBuilder_StartForm_ConfigureNull_Expected()
+    {
+        using var host = Host.CreateDefaultBuilder().UseWindowsForms<TestForm>().Build();
+
+        await host.StartAsync();
+
+        var provider = host.Services.GetService<IFormularProvider>()!;
+        var mainForm = await provider.GetMainFormularAsync();
+
+        do
+        {
+            // This test runs too fast for the handle to be created.
+            // Therefore, we have to slow down a little.
+            await Task.Delay(15);
+        } while (!mainForm.IsHandleCreated);
+
+        Assert.NotNull(mainForm);
+        _ = Assert.IsType<TestForm>(mainForm);
+
+        await host.StopAsync();
+    }
+
+    [Fact]
+    public async Task UseWindowsForms_IHostBuilder_StartForm_ConfigureFine_Expected()
+    {
+        using var host = Host.CreateDefaultBuilder()
+            .UseWindowsForms<TestForm>(options =>
+            {
+                options.EnableConsoleShutdown = true;
+                options.EnableVisualStyles = false;
+            })
+            .Build();
+
+        await host.StartAsync();
+
+        var provider = host.Services.GetService<IFormularProvider>()!;
+        var mainForm = await provider.GetMainFormularAsync();
+
+        do
+        {
+            // This test runs too fast for the handle to be created.
+            // Therefore, we have to slow down a little.
+            await Task.Delay(15);
+        } while (!mainForm.IsHandleCreated);
+
+        Assert.NotNull(mainForm);
+        _ = Assert.IsType<TestForm>(mainForm);
+
+        await host.StopAsync();
+    }
+
+    [Fact]
+    public async Task UseWindowsForms_IHostBuilder_ApplicationContext_Expected()
+    {
+        using var host = Host.CreateDefaultBuilder()
+            .UseWindowsForms<TestApplicationContext>()
+            .Build();
+
+        await host.StartAsync();
+
+        var provider = host.Services.GetService<IFormularProvider>()!;
+        var mainForm = await provider.GetMainFormularAsync();
+
+        do
+        {
+            // This test runs too fast for the handle to be created.
+            // Therefore, we have to slow down a little.
+            await Task.Delay(15);
+        } while (!mainForm.IsHandleCreated);
+
+        Assert.NotNull(mainForm);
+        _ = Assert.IsType<TestForm>(mainForm);
+
+        await host.StopAsync();
+    }
+
+    [Fact]
+    public async Task UseWindowsForms_IHostBuilder_ApplicationContextFactory_Expected()
+    {
+        using var host = Host.CreateDefaultBuilder()
+            .UseWindowsForms(sp => new TestApplicationContext(new TestForm()))
+            .Build();
+
+        await host.StartAsync();
+
+        var provider = host.Services.GetService<IFormularProvider>()!;
+        var mainForm = await provider.GetMainFormularAsync();
+
+        do
+        {
+            // This test runs too fast for the handle to be created.
+            // Therefore, we have to slow down a little.
+            await Task.Delay(15);
+        } while (!mainForm.IsHandleCreated);
+
+        Assert.NotNull(mainForm);
+        _ = Assert.IsType<TestForm>(mainForm);
+
+        await host.StopAsync();
+    }
+
+    [Fact]
+    public async Task UseWindowsForms_IHostBuilder_AdvancedFactory_Expected()
+    {
+        using var host = Host.CreateDefaultBuilder()
+            .UseWindowsForms<TestApplicationContext, TestForm>(
+                (sp, form) => new TestApplicationContext(form)
+            )
+            .Build();
+
+        await host.StartAsync();
+
+        var provider = host.Services.GetService<IFormularProvider>()!;
+        var mainForm = await provider.GetMainFormularAsync();
+
+        do
+        {
+            // This test runs too fast for the handle to be created.
+            // Therefore, we have to slow down a little.
+            await Task.Delay(15);
+        } while (!mainForm.IsHandleCreated);
+
+        Assert.NotNull(mainForm);
+        _ = Assert.IsType<TestForm>(mainForm);
+
+        await host.StopAsync();
+    }
+
+#if NET7_0_OR_GREATER
+    [Fact]
+    public async Task UseWindowsForms_HostApplicationBuilder_StartForm_ConfigureNull_Expected()
+    {
+        var builder = Host.CreateApplicationBuilder();
+        _ = builder.UseWindowsForms<TestForm>();
+        using var host = builder.Build();
+
+        await host.StartAsync();
+
+        var provider = host.Services.GetService<IFormularProvider>()!;
+        var mainForm = await provider.GetMainFormularAsync();
+
+        do
+        {
+            // This test runs too fast for the handle to be created.
+            // Therefore, we have to slow down a little.
+            await Task.Delay(15);
+        } while (!mainForm.IsHandleCreated);
+
+        Assert.NotNull(mainForm);
+        _ = Assert.IsType<TestForm>(mainForm);
+
+        await host.StopAsync();
+    }
+
+    [Fact]
+    public async Task UseWindowsForms_HostApplicationBuilder_StartForm_ConfigureFine_Expected()
+    {
+        var builder = Host.CreateApplicationBuilder();
+        _ = builder.UseWindowsForms<TestForm>(options =>
+        {
+            options.EnableConsoleShutdown = true;
+            options.EnableVisualStyles = false;
+        });
+        using var host = builder.Build();
+
+        await host.StartAsync();
+
+        var provider = host.Services.GetService<IFormularProvider>()!;
+        var mainForm = await provider.GetMainFormularAsync();
+
+        do
+        {
+            // This test runs too fast for the handle to be created.
+            // Therefore, we have to slow down a little.
+            await Task.Delay(15);
+        } while (!mainForm.IsHandleCreated);
+
+        Assert.NotNull(mainForm);
+        _ = Assert.IsType<TestForm>(mainForm);
+
+        await host.StopAsync();
+    }
+
+    [Fact]
+    public async Task UseWindowsForms_HostApplicationBuilder_ApplicationContext_Expected()
+    {
+        var builder = Host.CreateApplicationBuilder();
+        _ = builder.UseWindowsForms<TestApplicationContext>();
+        using var host = builder.Build();
+
+        await host.StartAsync();
+
+        var provider = host.Services.GetService<IFormularProvider>()!;
+        var mainForm = await provider.GetMainFormularAsync();
+
+        do
+        {
+            // This test runs too fast for the handle to be created.
+            // Therefore, we have to slow down a little.
+            await Task.Delay(15);
+        } while (!mainForm.IsHandleCreated);
+
+        Assert.NotNull(mainForm);
+        _ = Assert.IsType<TestForm>(mainForm);
+
+        await host.StopAsync();
+    }
+
+    [Fact]
+    public async Task UseWindowsForms_HostApplicationBuilder_ApplicationContextFactory_Expected()
+    {
+        var builder = Host.CreateApplicationBuilder();
+        _ = builder.UseWindowsForms(sp => new TestApplicationContext(new TestForm()));
+        using var host = builder.Build();
+
+        await host.StartAsync();
+
+        var provider = host.Services.GetService<IFormularProvider>()!;
+        var mainForm = await provider.GetMainFormularAsync();
+
+        do
+        {
+            // This test runs too fast for the handle to be created.
+            // Therefore, we have to slow down a little.
+            await Task.Delay(15);
+        } while (!mainForm.IsHandleCreated);
+
+        Assert.NotNull(mainForm);
+        _ = Assert.IsType<TestForm>(mainForm);
+
+        await host.StopAsync();
+    }
+
+    [Fact]
+    public async Task UseWindowsForms_HostApplicationBuilder_AdvancedFactory_Expected()
+    {
+        var builder = Host.CreateApplicationBuilder();
+        _ = builder.UseWindowsForms<TestApplicationContext, TestForm>(
+            (sp, form) => new TestApplicationContext(form)
+        );
+        using var host = builder.Build();
+
+        await host.StartAsync();
+
+        var provider = host.Services.GetService<IFormularProvider>()!;
+        var mainForm = await provider.GetMainFormularAsync();
+
+        do
+        {
+            // This test runs too fast for the handle to be created.
+            // Therefore, we have to slow down a little.
+            await Task.Delay(15);
+        } while (!mainForm.IsHandleCreated);
+
+        Assert.NotNull(mainForm);
+        _ = Assert.IsType<TestForm>(mainForm);
+
+        await host.StopAsync();
+    }
+#endif
+
+#pragma warning disable CA1812
+#pragma warning disable S2094 // Classes should not be empty
+    private sealed class TestApplicationContext : ApplicationContext
+    {
+        public TestApplicationContext()
+#pragma warning disable CA2000 // Dispose objects before losing scope
+            : this(new TestForm()) { }
+#pragma warning restore CA2000 // Dispose objects before losing scope
+
+        public TestApplicationContext(Form form)
+            : base(form) { }
+    }
+
+    private sealed class TestForm : Form { }
+#pragma warning restore S2094 // Classes should not be empty
+#pragma warning restore CA1812
+}