diff --git a/src/Http/Http.Extensions/src/HttpValidationProblemDetails.cs b/src/Http/Http.Extensions/src/HttpValidationProblemDetails.cs
index 5bab6886c72dc6ab70f53df389cd5dcbbe57c439..12ccd028babf088e63ede1772405f51ad29a0a6b 100644
--- a/src/Http/Http.Extensions/src/HttpValidationProblemDetails.cs
+++ b/src/Http/Http.Extensions/src/HttpValidationProblemDetails.cs
@@ -25,7 +25,7 @@ public class HttpValidationProblemDetails : ProblemDetails
     /// </summary>
     /// <param name="errors">The validation errors.</param>
     public HttpValidationProblemDetails(IDictionary<string, string[]> errors)
-        : this(new Dictionary<string, string[]>(errors, StringComparer.Ordinal))
+        : this(new Dictionary<string, string[]>(errors ?? throw new ArgumentNullException(nameof(errors)), StringComparer.Ordinal))
     {
     }
 
diff --git a/src/Http/Http.Results/src/Accepted.cs b/src/Http/Http.Results/src/Accepted.cs
index fed67811d4dcbf8009f4c9029a559223904cba5c..20d406d579e26b601b392e43c9cd127c2c284198 100644
--- a/src/Http/Http.Results/src/Accepted.cs
+++ b/src/Http/Http.Results/src/Accepted.cs
@@ -31,11 +31,6 @@ public sealed class Accepted : IResult, IEndpointMetadataProvider
     /// <param name="locationUri">The location at which the status of requested content can be monitored.</param>
     internal Accepted(Uri locationUri)
     {
-        if (locationUri == null)
-        {
-            throw new ArgumentNullException(nameof(locationUri));
-        }
-
         if (locationUri.IsAbsoluteUri)
         {
             Location = locationUri.AbsoluteUri;
@@ -59,6 +54,8 @@ public sealed class Accepted : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.AcceptedResult");
@@ -77,6 +74,8 @@ public sealed class Accepted : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(StatusCodes.Status202Accepted));
     }
 }
diff --git a/src/Http/Http.Results/src/AcceptedAtRoute.cs b/src/Http/Http.Results/src/AcceptedAtRoute.cs
index 96bf99aab6b9d1bff4dadde3dda5c24b947e472f..c67c0bd12c72e4f1b0aa7ead5cc34612c92d1f2b 100644
--- a/src/Http/Http.Results/src/AcceptedAtRoute.cs
+++ b/src/Http/Http.Results/src/AcceptedAtRoute.cs
@@ -57,6 +57,8 @@ public sealed class AcceptedAtRoute : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         var linkGenerator = httpContext.RequestServices.GetRequiredService<LinkGenerator>();
         var url = linkGenerator.GetUriByAddress(
             httpContext,
@@ -84,6 +86,8 @@ public sealed class AcceptedAtRoute : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(StatusCodes.Status202Accepted));
     }
 }
diff --git a/src/Http/Http.Results/src/AcceptedAtRouteOfT.cs b/src/Http/Http.Results/src/AcceptedAtRouteOfT.cs
index 4855b6e2c89a6a2b2a0e98565546abead1dd4584..e9269667f27c7d11231f8a9ce9eaf4507f8183db 100644
--- a/src/Http/Http.Results/src/AcceptedAtRouteOfT.cs
+++ b/src/Http/Http.Results/src/AcceptedAtRouteOfT.cs
@@ -68,6 +68,8 @@ public sealed class AcceptedAtRoute<TValue> : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         var linkGenerator = httpContext.RequestServices.GetRequiredService<LinkGenerator>();
         var url = linkGenerator.GetUriByAddress(
             httpContext,
@@ -95,6 +97,8 @@ public sealed class AcceptedAtRoute<TValue> : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(typeof(TValue), StatusCodes.Status202Accepted, "application/json"));
     }
 }
diff --git a/src/Http/Http.Results/src/AcceptedOfT.cs b/src/Http/Http.Results/src/AcceptedOfT.cs
index ebe84dbfe6f4a10a0fa4ff94882b2242ad2f2940..c648ac338206d57260e5db463944b826451ee06f 100644
--- a/src/Http/Http.Results/src/AcceptedOfT.cs
+++ b/src/Http/Http.Results/src/AcceptedOfT.cs
@@ -71,6 +71,8 @@ public sealed class Accepted<TValue> : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         if (!string.IsNullOrEmpty(Location))
         {
             httpContext.Response.Headers.Location = Location;
@@ -92,6 +94,8 @@ public sealed class Accepted<TValue> : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(typeof(TValue), StatusCodes.Status202Accepted, "application/json"));
     }
 }
diff --git a/src/Http/Http.Results/src/BadRequest.cs b/src/Http/Http.Results/src/BadRequest.cs
index 9dd3b161f1115ddc8bd9eba57d7a6e115fc6a070..74aba5eab7a48268a16f1c13a62d952452232061 100644
--- a/src/Http/Http.Results/src/BadRequest.cs
+++ b/src/Http/Http.Results/src/BadRequest.cs
@@ -29,6 +29,8 @@ public sealed class BadRequest : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.BadRequestObjectResult");
@@ -42,6 +44,8 @@ public sealed class BadRequest : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(StatusCodes.Status400BadRequest));
     }
 }
diff --git a/src/Http/Http.Results/src/BadRequestOfT.cs b/src/Http/Http.Results/src/BadRequestOfT.cs
index 097e3c8793c2146e4a49ff2569c9db8e6772cd8b..d8a0e5ac77e498d7df11a45873091f2fa784c7e7 100644
--- a/src/Http/Http.Results/src/BadRequestOfT.cs
+++ b/src/Http/Http.Results/src/BadRequestOfT.cs
@@ -38,6 +38,8 @@ public sealed class BadRequest<TValue> : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.BadRequestObjectResult");
@@ -54,6 +56,8 @@ public sealed class BadRequest<TValue> : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(typeof(TValue), StatusCodes.Status400BadRequest, "application/json"));
     }
 }
diff --git a/src/Http/Http.Results/src/ChallengeHttpResult.cs b/src/Http/Http.Results/src/ChallengeHttpResult.cs
index 1772c6f0d379fd0bc3ebde8113060cf2f628e037..23714ab133e77e6d6210a6cd56cb406951b04e6f 100644
--- a/src/Http/Http.Results/src/ChallengeHttpResult.cs
+++ b/src/Http/Http.Results/src/ChallengeHttpResult.cs
@@ -21,16 +21,6 @@ public sealed partial class ChallengeHttpResult : IResult
     {
     }
 
-    /// <summary>
-    /// Initializes a new instance of <see cref="ChallengeHttpResult"/> with the
-    /// specified authentication scheme.
-    /// </summary>
-    /// <param name="authenticationScheme">The authentication scheme to challenge.</param>
-    internal ChallengeHttpResult(string authenticationScheme)
-        : this(new[] { authenticationScheme })
-    {
-    }
-
     /// <summary>
     /// Initializes a new instance of <see cref="ChallengeHttpResult"/> with the
     /// specified authentication schemes.
@@ -41,17 +31,6 @@ public sealed partial class ChallengeHttpResult : IResult
     {
     }
 
-    /// <summary>
-    /// Initializes a new instance of <see cref="ChallengeHttpResult"/> with the
-    /// specified <paramref name="properties"/>.
-    /// </summary>
-    /// <param name="properties"><see cref="AuthenticationProperties"/> used to perform the authentication
-    /// challenge.</param>
-    internal ChallengeHttpResult(AuthenticationProperties? properties)
-        : this(Array.Empty<string>(), properties)
-    {
-    }
-
     /// <summary>
     /// Initializes a new instance of <see cref="ChallengeHttpResult"/> with the
     /// specified authentication scheme and <paramref name="properties"/>.
@@ -90,6 +69,8 @@ public sealed partial class ChallengeHttpResult : IResult
     /// <inheritdoc/>
     public async Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.ChallengeResult");
diff --git a/src/Http/Http.Results/src/Conflict.cs b/src/Http/Http.Results/src/Conflict.cs
index 12a639bba0e576f40a2ea4cec7d953da04297e60..fb3f1e51eb9af6aaebc513b3228caf1d37ab6bab 100644
--- a/src/Http/Http.Results/src/Conflict.cs
+++ b/src/Http/Http.Results/src/Conflict.cs
@@ -29,6 +29,8 @@ public sealed class Conflict : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.ConflictObjectResult");
@@ -42,6 +44,8 @@ public sealed class Conflict : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(StatusCodes.Status409Conflict));
     }
 }
diff --git a/src/Http/Http.Results/src/ConflictOfT.cs b/src/Http/Http.Results/src/ConflictOfT.cs
index f5fb98e193d63f7aff931a94f61d032b193ba7c0..a589c281d13b0f8ae36a8210fd131c02b976e44c 100644
--- a/src/Http/Http.Results/src/ConflictOfT.cs
+++ b/src/Http/Http.Results/src/ConflictOfT.cs
@@ -38,6 +38,8 @@ public sealed class Conflict<TValue> : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.ConflictObjectResult");
@@ -54,6 +56,8 @@ public sealed class Conflict<TValue> : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(typeof(TValue), StatusCodes.Status409Conflict, "application/json"));
     }
 }
diff --git a/src/Http/Http.Results/src/ContentHttpResult.cs b/src/Http/Http.Results/src/ContentHttpResult.cs
index fa765a137ee009392e42210e541083a71b983603..816879bc600c24ec3fc407d3ad6eb407234dda03 100644
--- a/src/Http/Http.Results/src/ContentHttpResult.cs
+++ b/src/Http/Http.Results/src/ContentHttpResult.cs
@@ -57,6 +57,8 @@ public sealed partial class ContentHttpResult : IResult
     /// <returns>A task that represents the asynchronous execute operation.</returns>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.ContentResult");
diff --git a/src/Http/Http.Results/src/Created.cs b/src/Http/Http.Results/src/Created.cs
index 0f94c05771d87b67f5b4bf8020e6f8ff24c8b714..4eb21037f7ad71264cf088e50bac8ab11aa2e99e 100644
--- a/src/Http/Http.Results/src/Created.cs
+++ b/src/Http/Http.Results/src/Created.cs
@@ -56,6 +56,8 @@ public sealed class Created : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.CreatedResult");
@@ -74,6 +76,8 @@ public sealed class Created : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(StatusCodes.Status201Created));
     }
 }
diff --git a/src/Http/Http.Results/src/CreatedAtRoute.cs b/src/Http/Http.Results/src/CreatedAtRoute.cs
index 7cb9b31f0b53e3f172ea8cad36d37f3b493fa554..490bfb126161b1b52c77b8c39ec51f2a8dcd3b10 100644
--- a/src/Http/Http.Results/src/CreatedAtRoute.cs
+++ b/src/Http/Http.Results/src/CreatedAtRoute.cs
@@ -57,6 +57,8 @@ public sealed class CreatedAtRoute : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         var linkGenerator = httpContext.RequestServices.GetRequiredService<LinkGenerator>();
         var url = linkGenerator.GetUriByRouteValues(
             httpContext,
@@ -84,6 +86,8 @@ public sealed class CreatedAtRoute : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(StatusCodes.Status201Created));
     }
 }
diff --git a/src/Http/Http.Results/src/CreatedAtRouteOfT.cs b/src/Http/Http.Results/src/CreatedAtRouteOfT.cs
index c4260b27f0a99d654a89c49ad4c3cb086b73c960..325c3fdc1cecb456f9d31bf094c842899fc6ebf1 100644
--- a/src/Http/Http.Results/src/CreatedAtRouteOfT.cs
+++ b/src/Http/Http.Results/src/CreatedAtRouteOfT.cs
@@ -68,6 +68,8 @@ public sealed class CreatedAtRoute<TValue> : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         var linkGenerator = httpContext.RequestServices.GetRequiredService<LinkGenerator>();
         var url = linkGenerator.GetUriByRouteValues(
             httpContext,
@@ -98,6 +100,8 @@ public sealed class CreatedAtRoute<TValue> : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(typeof(TValue), StatusCodes.Status201Created, "application/json"));
     }
 }
diff --git a/src/Http/Http.Results/src/CreatedOfT.cs b/src/Http/Http.Results/src/CreatedOfT.cs
index 5523c5f87a7c314747b068d29e0b0dd265f63620..8589c8bbcbb0ce9dbae82dbfcb3bdcf976b1d846 100644
--- a/src/Http/Http.Results/src/CreatedOfT.cs
+++ b/src/Http/Http.Results/src/CreatedOfT.cs
@@ -69,6 +69,8 @@ public sealed class Created<TValue> : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         if (!string.IsNullOrEmpty(Location))
         {
             httpContext.Response.Headers.Location = Location;
@@ -90,6 +92,8 @@ public sealed class Created<TValue> : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(typeof(TValue), StatusCodes.Status201Created, "application/json"));
     }
 }
diff --git a/src/Http/Http.Results/src/EmptyHttpResult.cs b/src/Http/Http.Results/src/EmptyHttpResult.cs
index ccdc3bd059849bdaf5c2ca0a38901ecf172c368b..459a17a22c153f7239140f7b8b340d2d9ec51bfe 100644
--- a/src/Http/Http.Results/src/EmptyHttpResult.cs
+++ b/src/Http/Http.Results/src/EmptyHttpResult.cs
@@ -21,6 +21,8 @@ public sealed class EmptyHttpResult : IResult
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         return Task.CompletedTask;
     }
 }
diff --git a/src/Http/Http.Results/src/FileContentHttpResult.cs b/src/Http/Http.Results/src/FileContentHttpResult.cs
index 960836b99479a6efabd097c450fefd94fed5a3a0..479726e79be6929095b9f26047ce5abeb0160e5a 100644
--- a/src/Http/Http.Results/src/FileContentHttpResult.cs
+++ b/src/Http/Http.Results/src/FileContentHttpResult.cs
@@ -106,6 +106,8 @@ public sealed partial class FileContentHttpResult : IResult
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.FileContentResult");
diff --git a/src/Http/Http.Results/src/FileStreamHttpResult.cs b/src/Http/Http.Results/src/FileStreamHttpResult.cs
index eff283d20d2d0cb09a0785534cc7093f51d9c7e6..092fd6e0e91588abb1928710667845d7f74e3a35 100644
--- a/src/Http/Http.Results/src/FileStreamHttpResult.cs
+++ b/src/Http/Http.Results/src/FileStreamHttpResult.cs
@@ -115,6 +115,8 @@ public sealed class FileStreamHttpResult : IResult
     /// <inheritdoc/>
     public async Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.FileStreamResult");
diff --git a/src/Http/Http.Results/src/ForbidHttpResult.cs b/src/Http/Http.Results/src/ForbidHttpResult.cs
index 5afdb53b85d27ed89446a06f2904dcd3d1eed7ae..2286e29fcb0afa762040276864b1107603d58ca1 100644
--- a/src/Http/Http.Results/src/ForbidHttpResult.cs
+++ b/src/Http/Http.Results/src/ForbidHttpResult.cs
@@ -21,16 +21,6 @@ public sealed partial class ForbidHttpResult : IResult
     {
     }
 
-    /// <summary>
-    /// Initializes a new instance of <see cref="ForbidHttpResult"/> with the
-    /// specified authentication scheme.
-    /// </summary>
-    /// <param name="authenticationScheme">The authentication scheme to challenge.</param>
-    internal ForbidHttpResult(string authenticationScheme)
-        : this(new[] { authenticationScheme })
-    {
-    }
-
     /// <summary>
     /// Initializes a new instance of <see cref="ForbidHttpResult"/> with the
     /// specified authentication schemes.
@@ -90,6 +80,8 @@ public sealed partial class ForbidHttpResult : IResult
     /// <inheritdoc />
     public async Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.ForbidResult");
diff --git a/src/Http/Http.Results/src/JsonHttpResultOfT.cs b/src/Http/Http.Results/src/JsonHttpResultOfT.cs
index dec845ac206a9a89156f3fafaf13b37c5de2da81..58496fbb8c1f3040c416ab8694a7c1f2eb020c69 100644
--- a/src/Http/Http.Results/src/JsonHttpResultOfT.cs
+++ b/src/Http/Http.Results/src/JsonHttpResultOfT.cs
@@ -34,18 +34,6 @@ public sealed partial class JsonHttpResult<TValue> : IResult
     {
     }
 
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Json"/> class with the values.
-    /// </summary>
-    /// <param name="value">The value to format in the entity body.</param>
-    /// <param name="contentType">The value for the <c>Content-Type</c> header</param>
-    /// <param name="jsonSerializerOptions">The serializer settings.</param>
-    internal JsonHttpResult(TValue? value, string? contentType, JsonSerializerOptions? jsonSerializerOptions)
-        : this(value, statusCode: null, contentType: contentType, jsonSerializerOptions: jsonSerializerOptions)
-    {
-
-    }
-
     /// <summary>
     /// Initializes a new instance of the <see cref="Json"/> class with the values.
     /// </summary>
@@ -91,6 +79,8 @@ public sealed partial class JsonHttpResult<TValue> : IResult
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.JsonResult");
diff --git a/src/Http/Http.Results/src/NoContent.cs b/src/Http/Http.Results/src/NoContent.cs
index 68920021f36cadc1c04fcc427e1bd53d61609585..a7553f706ed1fb42b8c8cee94eb4069baee569d8 100644
--- a/src/Http/Http.Results/src/NoContent.cs
+++ b/src/Http/Http.Results/src/NoContent.cs
@@ -28,6 +28,8 @@ public class NoContent : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.NoContentResult");
@@ -42,6 +44,8 @@ public class NoContent : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(StatusCodes.Status204NoContent));
     }
 }
diff --git a/src/Http/Http.Results/src/NotFound.cs b/src/Http/Http.Results/src/NotFound.cs
index 9b0dbe7848d168fe4804082d34e246177444114c..7118acac2804f0bba09a554bb1d9f91a06105fa2 100644
--- a/src/Http/Http.Results/src/NotFound.cs
+++ b/src/Http/Http.Results/src/NotFound.cs
@@ -28,6 +28,8 @@ public sealed class NotFound : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.NotFoundObjectResult");
@@ -41,6 +43,8 @@ public sealed class NotFound : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(StatusCodes.Status404NotFound));
     }
 }
diff --git a/src/Http/Http.Results/src/NotFoundOfT.cs b/src/Http/Http.Results/src/NotFoundOfT.cs
index 8e1bacf533eecd72f7f51811c1ff17beea048071..8da3d95b1dc53bb31014686445e9bb444f7f38ac 100644
--- a/src/Http/Http.Results/src/NotFoundOfT.cs
+++ b/src/Http/Http.Results/src/NotFoundOfT.cs
@@ -37,6 +37,8 @@ public sealed class NotFound<TValue> : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.NotFoundObjectResult");
@@ -53,6 +55,8 @@ public sealed class NotFound<TValue> : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(typeof(TValue), StatusCodes.Status404NotFound, "application/json"));
     }
 }
diff --git a/src/Http/Http.Results/src/Ok.cs b/src/Http/Http.Results/src/Ok.cs
index 8d2197d0e45845f460a2ee1d981af83303e10e03..8bd80f9ba6ba32e9feb1ee48154138d111710919 100644
--- a/src/Http/Http.Results/src/Ok.cs
+++ b/src/Http/Http.Results/src/Ok.cs
@@ -28,6 +28,8 @@ public sealed class Ok : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.OkObjectResult");
@@ -41,6 +43,8 @@ public sealed class Ok : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(StatusCodes.Status200OK));
     }
 }
diff --git a/src/Http/Http.Results/src/OkOfT.cs b/src/Http/Http.Results/src/OkOfT.cs
index ccbef8a73b79aaa2e247df6d23be638bfb87e681..494f6d9a3e75722138a6c1eaea1f4a5b80721cd9 100644
--- a/src/Http/Http.Results/src/OkOfT.cs
+++ b/src/Http/Http.Results/src/OkOfT.cs
@@ -37,6 +37,8 @@ public sealed class Ok<TValue> : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.OkObjectResult");
@@ -53,6 +55,8 @@ public sealed class Ok<TValue> : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(typeof(TValue), StatusCodes.Status200OK, "application/json"));
     }
 }
diff --git a/src/Http/Http.Results/src/PhysicalFileHttpResult.cs b/src/Http/Http.Results/src/PhysicalFileHttpResult.cs
index 4e69b71a88f61a32d350aeb33f7ae16a3b4b60a6..415124218aba53a138772f790ed14be749eca2f0 100644
--- a/src/Http/Http.Results/src/PhysicalFileHttpResult.cs
+++ b/src/Http/Http.Results/src/PhysicalFileHttpResult.cs
@@ -107,6 +107,8 @@ public sealed partial class PhysicalFileHttpResult : IResult
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         var fileInfo = GetFileInfoWrapper(FileName);
         if (!fileInfo.Exists)
         {
diff --git a/src/Http/Http.Results/src/ProblemHttpResult.cs b/src/Http/Http.Results/src/ProblemHttpResult.cs
index 45b8017565bd6f95c51cdf80835dc72e16f7ff21..bd7e72ff87aa9bd15e751e558d0f704f50e64199 100644
--- a/src/Http/Http.Results/src/ProblemHttpResult.cs
+++ b/src/Http/Http.Results/src/ProblemHttpResult.cs
@@ -42,6 +42,8 @@ public sealed class ProblemHttpResult : IResult
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger(typeof(ProblemHttpResult));
 
diff --git a/src/Http/Http.Results/src/PublicAPI.Unshipped.txt b/src/Http/Http.Results/src/PublicAPI.Unshipped.txt
index e87a32cfd7d1ccbbd52e2c7dee6305f2883a9a7d..4178ba1a4abeddcfa8cac68229a82161dc1ff494 100644
--- a/src/Http/Http.Results/src/PublicAPI.Unshipped.txt
+++ b/src/Http/Http.Results/src/PublicAPI.Unshipped.txt
@@ -144,21 +144,19 @@ Microsoft.AspNetCore.Http.HttpResults.RedirectToRouteHttpResult.Permanent.get ->
 Microsoft.AspNetCore.Http.HttpResults.RedirectToRouteHttpResult.PreserveMethod.get -> bool
 Microsoft.AspNetCore.Http.HttpResults.RedirectToRouteHttpResult.RouteName.get -> string?
 Microsoft.AspNetCore.Http.HttpResults.RedirectToRouteHttpResult.RouteValues.get -> Microsoft.AspNetCore.Routing.RouteValueDictionary?
-Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>
-Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.ExecuteAsync(Microsoft.AspNetCore.Http.HttpContext! httpContext) -> System.Threading.Tasks.Task!
-Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.Result.get -> Microsoft.AspNetCore.Http.IResult!
-Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>
-Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.ExecuteAsync(Microsoft.AspNetCore.Http.HttpContext! httpContext) -> System.Threading.Tasks.Task!
-Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.Result.get -> Microsoft.AspNetCore.Http.IResult!
-Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>
-Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>.ExecuteAsync(Microsoft.AspNetCore.Http.HttpContext! httpContext) -> System.Threading.Tasks.Task!
-Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>.Result.get -> Microsoft.AspNetCore.Http.IResult!
-Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>
-Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>.ExecuteAsync(Microsoft.AspNetCore.Http.HttpContext! httpContext) -> System.Threading.Tasks.Task!
-Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>.Result.get -> Microsoft.AspNetCore.Http.IResult!
-Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2>
-Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2>.ExecuteAsync(Microsoft.AspNetCore.Http.HttpContext! httpContext) -> System.Threading.Tasks.Task!
-Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2>.Result.get -> Microsoft.AspNetCore.Http.IResult!
+~Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>
+~Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.ExecuteAsync(Microsoft.AspNetCore.Http.HttpContext httpContext) -> System.Threading.Tasks.Task
+~Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.Result.get -> Microsoft.AspNetCore.Http.IResult
+~Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>
+~Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.ExecuteAsync(Microsoft.AspNetCore.Http.HttpContext httpContext) -> System.Threading.Tasks.Task
+~Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.Result.get -> Microsoft.AspNetCore.Http.IResult
+~Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>
+~Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>.ExecuteAsync(Microsoft.AspNetCore.Http.HttpContext httpContext) -> System.Threading.Tasks.Task
+~Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>.Result.get -> Microsoft.AspNetCore.Http.IResult
+~Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>
+~Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>.ExecuteAsync(Microsoft.AspNetCore.Http.HttpContext httpContext) -> System.Threading.Tasks.Task
+~Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>.Result.get -> Microsoft.AspNetCore.Http.IResult
+~Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2>
 Microsoft.AspNetCore.Http.HttpResults.SignInHttpResult
 Microsoft.AspNetCore.Http.HttpResults.SignInHttpResult.AuthenticationScheme.get -> string?
 Microsoft.AspNetCore.Http.HttpResults.SignInHttpResult.ExecuteAsync(Microsoft.AspNetCore.Http.HttpContext! httpContext) -> System.Threading.Tasks.Task!
@@ -197,26 +195,6 @@ Microsoft.AspNetCore.Http.HttpResults.VirtualFileHttpResult.FileName.get -> stri
 Microsoft.AspNetCore.Http.HttpResults.VirtualFileHttpResult.LastModified.get -> System.DateTimeOffset?
 Microsoft.AspNetCore.Http.TypedResults
 static Microsoft.AspNetCore.Http.HttpResults.EmptyHttpResult.Instance.get -> Microsoft.AspNetCore.Http.HttpResults.EmptyHttpResult!
-static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!(TResult1 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!
-static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!(TResult2 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!
-static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!(TResult3 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!
-static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!(TResult4 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!
-static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!(TResult5 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!
-static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!(TResult6 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>!
-static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>!(TResult1 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>!
-static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>!(TResult2 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>!
-static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>!(TResult3 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>!
-static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>!(TResult4 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>!
-static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>!(TResult5 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>!
-static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>!(TResult1 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>!
-static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>!(TResult2 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>!
-static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>!(TResult3 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>!
-static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>!(TResult4 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>!
-static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>!(TResult1 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>!
-static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>!(TResult2 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>!
-static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>!(TResult3 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>!
-static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2>!(TResult1 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2>!
-static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2>!(TResult2 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2>!
 static Microsoft.AspNetCore.Http.Results.Bytes(System.ReadOnlyMemory<byte> contents, string? contentType = null, string? fileDownloadName = null, bool enableRangeProcessing = false, System.DateTimeOffset? lastModified = null, Microsoft.Net.Http.Headers.EntityTagHeaderValue? entityTag = null) -> Microsoft.AspNetCore.Http.IResult!
 static Microsoft.AspNetCore.Http.Results.Empty.get -> Microsoft.AspNetCore.Http.IResult!
 static Microsoft.AspNetCore.Http.Results.Stream(System.Func<System.IO.Stream!, System.Threading.Tasks.Task!>! streamWriterCallback, string? contentType = null, string? fileDownloadName = null, System.DateTimeOffset? lastModified = null, Microsoft.Net.Http.Headers.EntityTagHeaderValue? entityTag = null) -> Microsoft.AspNetCore.Http.IResult!
@@ -234,8 +212,8 @@ static Microsoft.AspNetCore.Http.TypedResults.Bytes(byte[]! contents, string? co
 static Microsoft.AspNetCore.Http.TypedResults.Challenge(Microsoft.AspNetCore.Authentication.AuthenticationProperties? properties = null, System.Collections.Generic.IList<string!>? authenticationSchemes = null) -> Microsoft.AspNetCore.Http.HttpResults.ChallengeHttpResult!
 static Microsoft.AspNetCore.Http.TypedResults.Conflict() -> Microsoft.AspNetCore.Http.HttpResults.Conflict!
 static Microsoft.AspNetCore.Http.TypedResults.Conflict<TValue>(TValue? error) -> Microsoft.AspNetCore.Http.HttpResults.Conflict<TValue>!
-static Microsoft.AspNetCore.Http.TypedResults.Content(string! content, Microsoft.Net.Http.Headers.MediaTypeHeaderValue! contentType) -> Microsoft.AspNetCore.Http.HttpResults.ContentHttpResult!
-static Microsoft.AspNetCore.Http.TypedResults.Content(string! content, string? contentType = null, System.Text.Encoding? contentEncoding = null) -> Microsoft.AspNetCore.Http.HttpResults.ContentHttpResult!
+static Microsoft.AspNetCore.Http.TypedResults.Content(string? content, Microsoft.Net.Http.Headers.MediaTypeHeaderValue! contentType) -> Microsoft.AspNetCore.Http.HttpResults.ContentHttpResult!
+static Microsoft.AspNetCore.Http.TypedResults.Content(string? content, string? contentType = null, System.Text.Encoding? contentEncoding = null) -> Microsoft.AspNetCore.Http.HttpResults.ContentHttpResult!
 static Microsoft.AspNetCore.Http.TypedResults.Created(System.Uri! uri) -> Microsoft.AspNetCore.Http.HttpResults.Created!
 static Microsoft.AspNetCore.Http.TypedResults.Created(string! uri) -> Microsoft.AspNetCore.Http.HttpResults.Created!
 static Microsoft.AspNetCore.Http.TypedResults.Created<TValue>(System.Uri! uri, TValue? value) -> Microsoft.AspNetCore.Http.HttpResults.Created<TValue>!
@@ -264,9 +242,31 @@ static Microsoft.AspNetCore.Http.TypedResults.StatusCode(int statusCode) -> Micr
 static Microsoft.AspNetCore.Http.TypedResults.Stream(System.Func<System.IO.Stream!, System.Threading.Tasks.Task!>! streamWriterCallback, string? contentType = null, string? fileDownloadName = null, System.DateTimeOffset? lastModified = null, Microsoft.Net.Http.Headers.EntityTagHeaderValue? entityTag = null) -> Microsoft.AspNetCore.Http.HttpResults.PushStreamHttpResult!
 static Microsoft.AspNetCore.Http.TypedResults.Stream(System.IO.Pipelines.PipeReader! pipeReader, string? contentType = null, string? fileDownloadName = null, System.DateTimeOffset? lastModified = null, Microsoft.Net.Http.Headers.EntityTagHeaderValue? entityTag = null, bool enableRangeProcessing = false) -> Microsoft.AspNetCore.Http.HttpResults.FileStreamHttpResult!
 static Microsoft.AspNetCore.Http.TypedResults.Stream(System.IO.Stream! stream, string? contentType = null, string? fileDownloadName = null, System.DateTimeOffset? lastModified = null, Microsoft.Net.Http.Headers.EntityTagHeaderValue? entityTag = null, bool enableRangeProcessing = false) -> Microsoft.AspNetCore.Http.HttpResults.FileStreamHttpResult!
-static Microsoft.AspNetCore.Http.TypedResults.Text(string! content, string? contentType = null, System.Text.Encoding? contentEncoding = null) -> Microsoft.AspNetCore.Http.HttpResults.ContentHttpResult!
+static Microsoft.AspNetCore.Http.TypedResults.Text(string? content, string? contentType = null, System.Text.Encoding? contentEncoding = null) -> Microsoft.AspNetCore.Http.HttpResults.ContentHttpResult!
 static Microsoft.AspNetCore.Http.TypedResults.Unauthorized() -> Microsoft.AspNetCore.Http.HttpResults.UnauthorizedHttpResult!
 static Microsoft.AspNetCore.Http.TypedResults.UnprocessableEntity() -> Microsoft.AspNetCore.Http.HttpResults.UnprocessableEntity!
 static Microsoft.AspNetCore.Http.TypedResults.UnprocessableEntity<TValue>(TValue? error) -> Microsoft.AspNetCore.Http.HttpResults.UnprocessableEntity<TValue>!
 static Microsoft.AspNetCore.Http.TypedResults.ValidationProblem(System.Collections.Generic.IDictionary<string!, string![]!>! errors, string? detail = null, string? instance = null, string? title = null, string? type = null, System.Collections.Generic.IDictionary<string!, object?>? extensions = null) -> Microsoft.AspNetCore.Http.HttpResults.ValidationProblem!
 static Microsoft.AspNetCore.Http.TypedResults.VirtualFile(string! path, string? contentType = null, string? fileDownloadName = null, System.DateTimeOffset? lastModified = null, Microsoft.Net.Http.Headers.EntityTagHeaderValue? entityTag = null, bool enableRangeProcessing = false) -> Microsoft.AspNetCore.Http.HttpResults.VirtualFileHttpResult!
+~Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2>.ExecuteAsync(Microsoft.AspNetCore.Http.HttpContext httpContext) -> System.Threading.Tasks.Task
+~Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2>.Result.get -> Microsoft.AspNetCore.Http.IResult
+~static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>(TResult1 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>
+~static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>(TResult2 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>
+~static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>(TResult3 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>
+~static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>(TResult4 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>
+~static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>(TResult5 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>
+~static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>(TResult6 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6>
+~static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>(TResult1 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>
+~static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>(TResult2 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>
+~static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>(TResult3 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>
+~static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>(TResult4 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>
+~static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>(TResult5 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4, TResult5>
+~static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>(TResult1 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>
+~static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>(TResult2 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>
+~static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>(TResult3 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>
+~static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>(TResult4 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3, TResult4>
+~static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>(TResult1 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>
+~static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>(TResult2 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>
+~static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>(TResult3 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2, TResult3>
+~static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2>(TResult1 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2>
+~static Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2>.implicit operator Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2>(TResult2 result) -> Microsoft.AspNetCore.Http.HttpResults.Results<TResult1, TResult2>
diff --git a/src/Http/Http.Results/src/PushStreamHttpResult.cs b/src/Http/Http.Results/src/PushStreamHttpResult.cs
index e7d3e852788b41d60d770a60d8fe17b048d47443..b6e8d5eaa87ab5d226590d239161c3fec6e69ddd 100644
--- a/src/Http/Http.Results/src/PushStreamHttpResult.cs
+++ b/src/Http/Http.Results/src/PushStreamHttpResult.cs
@@ -100,6 +100,8 @@ public sealed class PushStreamHttpResult : IResult
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.PushStreamResult");
diff --git a/src/Http/Http.Results/src/RedirectHttpResult.cs b/src/Http/Http.Results/src/RedirectHttpResult.cs
index e466cef62dcd0281b38e8bffe7c33a07a4e11d59..d1ca73d1dde75bcde9928b18a29fdf360a711056 100644
--- a/src/Http/Http.Results/src/RedirectHttpResult.cs
+++ b/src/Http/Http.Results/src/RedirectHttpResult.cs
@@ -58,16 +58,6 @@ public sealed partial class RedirectHttpResult : IResult
     /// and will throw an exception when the supplied URL is not considered local.</param>
     internal RedirectHttpResult(string url, bool acceptLocalUrlOnly, bool permanent, bool preserveMethod)
     {
-        if (url == null)
-        {
-            throw new ArgumentNullException(nameof(url));
-        }
-
-        if (string.IsNullOrEmpty(url))
-        {
-            throw new ArgumentException("Argument cannot be null or empty", nameof(url));
-        }
-
         Url = url;
         Permanent = permanent;
         PreserveMethod = preserveMethod;
@@ -97,6 +87,8 @@ public sealed partial class RedirectHttpResult : IResult
     /// <inheritdoc />
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.RedirectResult");
diff --git a/src/Http/Http.Results/src/RedirectToRouteHttpResult.cs b/src/Http/Http.Results/src/RedirectToRouteHttpResult.cs
index a846f56dd3c47399522b48e2d4e41db90da65dd3..0daa608bc58df71c0a7c9ab0e47bc739b7e4ae35 100644
--- a/src/Http/Http.Results/src/RedirectToRouteHttpResult.cs
+++ b/src/Http/Http.Results/src/RedirectToRouteHttpResult.cs
@@ -53,40 +53,6 @@ public sealed partial class RedirectToRouteHttpResult : IResult
     {
     }
 
-    /// <summary>
-    /// Initializes a new instance of the <see cref="RedirectToRouteHttpResult"/> with the values
-    /// provided.
-    /// </summary>
-    /// <param name="routeName">The name of the route.</param>
-    /// <param name="routeValues">The parameters for the route.</param>
-    /// <param name="permanent">If set to true, makes the redirect permanent (301).
-    /// Otherwise a temporary redirect is used (302).</param>
-    /// <param name="preserveMethod">If set to true, make the temporary redirect (307)
-    /// or permanent redirect (308) preserve the initial request method.</param>
-    internal RedirectToRouteHttpResult(
-        string? routeName,
-        object? routeValues,
-        bool permanent,
-        bool preserveMethod)
-        : this(routeName, routeValues, permanent, preserveMethod, fragment: null)
-    {
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="RedirectToRouteHttpResult"/> with the values
-    /// provided.
-    /// </summary>
-    /// <param name="routeName">The name of the route.</param>
-    /// <param name="routeValues">The parameters for the route.</param>
-    /// <param name="fragment">The fragment to add to the URL.</param>
-    internal RedirectToRouteHttpResult(
-        string? routeName,
-        object? routeValues,
-        string? fragment)
-        : this(routeName, routeValues, permanent: false, fragment: fragment)
-    {
-    }
-
     /// <summary>
     /// Initializes a new instance of the <see cref="RedirectToRouteHttpResult"/> with the values
     /// provided.
@@ -158,6 +124,8 @@ public sealed partial class RedirectToRouteHttpResult : IResult
     /// <inheritdoc />
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         var linkGenerator = httpContext.RequestServices.GetRequiredService<LinkGenerator>();
 
         var destinationUrl = linkGenerator.GetUriByRouteValues(
diff --git a/src/Http/Http.Results/src/ResultsOfT.cs b/src/Http/Http.Results/src/ResultsOfT.Generated.cs
similarity index 96%
rename from src/Http/Http.Results/src/ResultsOfT.cs
rename to src/Http/Http.Results/src/ResultsOfT.Generated.cs
index 33559b6c6e98e37a5071a81a1d17bcaa35464097..921ca0bde1f93149408d529df7cd06e7c15457e8 100644
--- a/src/Http/Http.Results/src/ResultsOfT.cs
+++ b/src/Http/Http.Results/src/ResultsOfT.Generated.cs
@@ -14,7 +14,7 @@ namespace Microsoft.AspNetCore.Http.HttpResults;
 /// <remarks>
 /// An instance of this type cannot be created explicitly. Use the implicit cast operators to create an instance
 /// from an instance of one of the declared type arguments, e.g.
-/// <code>Results&lt;OkObjectHttpResult, ProblemHttpResult&gt; result = Results.Ok();</code>
+/// <code>Results&lt;Ok, BadRequest&gt; result = TypedResults.Ok();</code>
 /// </remarks>
 /// <typeparam name="TResult1">The first result type.</typeparam>
 /// <typeparam name="TResult2">The second result type.</typeparam>
@@ -61,6 +61,8 @@ public sealed class Results<TResult1, TResult2> : IResult, IEndpointMetadataProv
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         ResultsOfTHelper.PopulateMetadataIfTargetIsIEndpointMetadataProvider<TResult1>(context);
         ResultsOfTHelper.PopulateMetadataIfTargetIsIEndpointMetadataProvider<TResult2>(context);
     }
@@ -73,7 +75,7 @@ public sealed class Results<TResult1, TResult2> : IResult, IEndpointMetadataProv
 /// <remarks>
 /// An instance of this type cannot be created explicitly. Use the implicit cast operators to create an instance
 /// from an instance of one of the declared type arguments, e.g.
-/// <code>Results&lt;OkObjectHttpResult, ProblemHttpResult&gt; result = Results.Ok();</code>
+/// <code>Results&lt;Ok, BadRequest&gt; result = TypedResults.Ok();</code>
 /// </remarks>
 /// <typeparam name="TResult1">The first result type.</typeparam>
 /// <typeparam name="TResult2">The second result type.</typeparam>
@@ -128,6 +130,8 @@ public sealed class Results<TResult1, TResult2, TResult3> : IResult, IEndpointMe
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         ResultsOfTHelper.PopulateMetadataIfTargetIsIEndpointMetadataProvider<TResult1>(context);
         ResultsOfTHelper.PopulateMetadataIfTargetIsIEndpointMetadataProvider<TResult2>(context);
         ResultsOfTHelper.PopulateMetadataIfTargetIsIEndpointMetadataProvider<TResult3>(context);
@@ -141,7 +145,7 @@ public sealed class Results<TResult1, TResult2, TResult3> : IResult, IEndpointMe
 /// <remarks>
 /// An instance of this type cannot be created explicitly. Use the implicit cast operators to create an instance
 /// from an instance of one of the declared type arguments, e.g.
-/// <code>Results&lt;OkObjectHttpResult, ProblemHttpResult&gt; result = Results.Ok();</code>
+/// <code>Results&lt;Ok, BadRequest&gt; result = TypedResults.Ok();</code>
 /// </remarks>
 /// <typeparam name="TResult1">The first result type.</typeparam>
 /// <typeparam name="TResult2">The second result type.</typeparam>
@@ -204,6 +208,8 @@ public sealed class Results<TResult1, TResult2, TResult3, TResult4> : IResult, I
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         ResultsOfTHelper.PopulateMetadataIfTargetIsIEndpointMetadataProvider<TResult1>(context);
         ResultsOfTHelper.PopulateMetadataIfTargetIsIEndpointMetadataProvider<TResult2>(context);
         ResultsOfTHelper.PopulateMetadataIfTargetIsIEndpointMetadataProvider<TResult3>(context);
@@ -218,7 +224,7 @@ public sealed class Results<TResult1, TResult2, TResult3, TResult4> : IResult, I
 /// <remarks>
 /// An instance of this type cannot be created explicitly. Use the implicit cast operators to create an instance
 /// from an instance of one of the declared type arguments, e.g.
-/// <code>Results&lt;OkObjectHttpResult, ProblemHttpResult&gt; result = Results.Ok();</code>
+/// <code>Results&lt;Ok, BadRequest&gt; result = TypedResults.Ok();</code>
 /// </remarks>
 /// <typeparam name="TResult1">The first result type.</typeparam>
 /// <typeparam name="TResult2">The second result type.</typeparam>
@@ -289,6 +295,8 @@ public sealed class Results<TResult1, TResult2, TResult3, TResult4, TResult5> :
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         ResultsOfTHelper.PopulateMetadataIfTargetIsIEndpointMetadataProvider<TResult1>(context);
         ResultsOfTHelper.PopulateMetadataIfTargetIsIEndpointMetadataProvider<TResult2>(context);
         ResultsOfTHelper.PopulateMetadataIfTargetIsIEndpointMetadataProvider<TResult3>(context);
@@ -304,7 +312,7 @@ public sealed class Results<TResult1, TResult2, TResult3, TResult4, TResult5> :
 /// <remarks>
 /// An instance of this type cannot be created explicitly. Use the implicit cast operators to create an instance
 /// from an instance of one of the declared type arguments, e.g.
-/// <code>Results&lt;OkObjectHttpResult, ProblemHttpResult&gt; result = Results.Ok();</code>
+/// <code>Results&lt;Ok, BadRequest&gt; result = TypedResults.Ok();</code>
 /// </remarks>
 /// <typeparam name="TResult1">The first result type.</typeparam>
 /// <typeparam name="TResult2">The second result type.</typeparam>
@@ -383,6 +391,8 @@ public sealed class Results<TResult1, TResult2, TResult3, TResult4, TResult5, TR
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         ResultsOfTHelper.PopulateMetadataIfTargetIsIEndpointMetadataProvider<TResult1>(context);
         ResultsOfTHelper.PopulateMetadataIfTargetIsIEndpointMetadataProvider<TResult2>(context);
         ResultsOfTHelper.PopulateMetadataIfTargetIsIEndpointMetadataProvider<TResult3>(context);
diff --git a/src/Http/Http.Results/src/SignInHttpResult.cs b/src/Http/Http.Results/src/SignInHttpResult.cs
index 8ce3b72767321b1d8f23c2fd3eb0a301f9ee1606..72e5dd44ad4bb3fe8a97343728a24fccedb7cd3c 100644
--- a/src/Http/Http.Results/src/SignInHttpResult.cs
+++ b/src/Http/Http.Results/src/SignInHttpResult.cs
@@ -32,7 +32,7 @@ public sealed partial class SignInHttpResult : IResult
     /// <param name="properties"><see cref="AuthenticationProperties"/> used to perform the sign-in operation.</param>
     internal SignInHttpResult(ClaimsPrincipal principal, string? authenticationScheme, AuthenticationProperties? properties)
     {
-        Principal = principal ?? throw new ArgumentNullException(nameof(principal));
+        Principal = principal;
         AuthenticationScheme = authenticationScheme;
         Properties = properties;
     }
@@ -55,6 +55,8 @@ public sealed partial class SignInHttpResult : IResult
     /// <inheritdoc />
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.SignInResult");
diff --git a/src/Http/Http.Results/src/SignOutHttpResult.cs b/src/Http/Http.Results/src/SignOutHttpResult.cs
index 515fb89e4183ff7de75ddef5345f741118214811..74044c003a7fb3b3168f8f853e9a1868133ab67f 100644
--- a/src/Http/Http.Results/src/SignOutHttpResult.cs
+++ b/src/Http/Http.Results/src/SignOutHttpResult.cs
@@ -21,26 +21,6 @@ public sealed partial class SignOutHttpResult : IResult
     {
     }
 
-    /// <summary>
-    /// Initializes a new instance of <see cref="SignOutHttpResult"/> with the default sign out scheme.
-    /// specified authentication scheme and <paramref name="properties"/>.
-    /// </summary>
-    /// <param name="properties"><see cref="AuthenticationProperties"/> used to perform the sign-out operation.</param>
-    internal SignOutHttpResult(AuthenticationProperties properties)
-        : this(Array.Empty<string>(), properties)
-    {
-    }
-
-    /// <summary>
-    /// Initializes a new instance of <see cref="SignOutHttpResult"/> with the
-    /// specified authentication scheme.
-    /// </summary>
-    /// <param name="authenticationScheme">The authentication scheme to use when signing out the user.</param>
-    internal SignOutHttpResult(string authenticationScheme)
-        : this(new[] { authenticationScheme })
-    {
-    }
-
     /// <summary>
     /// Initializes a new instance of <see cref="SignOutHttpResult"/> with the
     /// specified authentication schemes.
@@ -92,6 +72,8 @@ public sealed partial class SignOutHttpResult : IResult
     /// <inheritdoc />
     public async Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.SignOutResult");
diff --git a/src/Http/Http.Results/src/StatusCodeHttpResult.cs b/src/Http/Http.Results/src/StatusCodeHttpResult.cs
index ad951df8beb7cca755d377a40310025231ab32fb..662e0fd692355513895613e5589aeb90caa14276 100644
--- a/src/Http/Http.Results/src/StatusCodeHttpResult.cs
+++ b/src/Http/Http.Results/src/StatusCodeHttpResult.cs
@@ -1,11 +1,11 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-namespace Microsoft.AspNetCore.Http.HttpResults;
-
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
+namespace Microsoft.AspNetCore.Http.HttpResults;
+
 /// <summary>
 /// Represents an <see cref="IResult"/> that when executed will
 /// produce an HTTP response with the given response status code.
@@ -34,6 +34,8 @@ public sealed partial class StatusCodeHttpResult : IResult
     /// <returns>A task that represents the asynchronous execute operation.</returns>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.StatusCodeResult");
diff --git a/src/Http/Http.Results/src/TypedResults.cs b/src/Http/Http.Results/src/TypedResults.cs
index 938400a4169bec190bee4703acc6c2281ad876ce..8b21ea1cdfb8512fe41f75cb02b44a781d7ce541 100644
--- a/src/Http/Http.Results/src/TypedResults.cs
+++ b/src/Http/Http.Results/src/TypedResults.cs
@@ -64,7 +64,11 @@ public static class TypedResults
         ClaimsPrincipal principal,
         AuthenticationProperties? properties = null,
         string? authenticationScheme = null)
-        => new(principal, authenticationScheme, properties);
+    {
+        ArgumentNullException.ThrowIfNull(principal);
+
+        return new(principal, authenticationScheme, properties);
+    }
 
     /// <summary>
     /// Creates a <see cref="SignOutHttpResult"/> that on execution invokes <see cref="AuthenticationHttpContextExtensions.SignOutAsync(HttpContext, string?, AuthenticationProperties?)" />.
@@ -89,7 +93,7 @@ public static class TypedResults
     /// <param name="contentType">The content type (MIME type).</param>
     /// <param name="contentEncoding">The content encoding.</param>
     /// <returns>The created <see cref="ContentHttpResult"/> object for the response.</returns>
-    public static ContentHttpResult Content(string content, string? contentType = null, Encoding? contentEncoding = null)
+    public static ContentHttpResult Content(string? content, string? contentType = null, Encoding? contentEncoding = null)
         => Text(content, contentType, contentEncoding);
 
     /// <summary>
@@ -106,7 +110,7 @@ public static class TypedResults
     /// <param name="contentType">The content type (MIME type).</param>
     /// <param name="contentEncoding">The content encoding.</param>
     /// <returns>The created <see cref="ContentHttpResult"/> object for the response.</returns>
-    public static ContentHttpResult Text(string content, string? contentType = null, Encoding? contentEncoding = null)
+    public static ContentHttpResult Text(string? content, string? contentType = null, Encoding? contentEncoding = null)
     {
         MediaTypeHeaderValue? mediaTypeHeaderValue = null;
         if (contentType is not null)
@@ -124,7 +128,7 @@ public static class TypedResults
     /// <param name="content">The content to write to the response.</param>
     /// <param name="contentType">The content type (MIME type).</param>
     /// <returns>The created <see cref="ContentHttpResult"/> object for the response.</returns>
-    public static ContentHttpResult Content(string content, MediaTypeHeaderValue contentType)
+    public static ContentHttpResult Content(string? content, MediaTypeHeaderValue contentType)
         => new(content, contentType.ToString());
 
     /// <summary>
@@ -170,13 +174,17 @@ public static class TypedResults
         bool enableRangeProcessing = false,
         DateTimeOffset? lastModified = null,
         EntityTagHeaderValue? entityTag = null)
-        => new(fileContents, contentType)
+    {
+        ArgumentNullException.ThrowIfNull(fileContents);
+
+        return new(fileContents, contentType)
         {
             FileDownloadName = fileDownloadName,
             EnableRangeProcessing = enableRangeProcessing,
             LastModified = lastModified,
             EntityTag = entityTag,
         };
+    }
 
     /// <summary>
     /// Writes the byte-array content to the response.
@@ -203,13 +211,17 @@ public static class TypedResults
         bool enableRangeProcessing = false,
         DateTimeOffset? lastModified = null,
         EntityTagHeaderValue? entityTag = null)
-        => new(contents, contentType)
+    {
+        ArgumentNullException.ThrowIfNull(contents);
+
+        return new(contents, contentType)
         {
             FileDownloadName = fileDownloadName,
             EnableRangeProcessing = enableRangeProcessing,
             LastModified = lastModified,
             EntityTag = entityTag,
         };
+    }
 
     /// <summary>
     /// Writes the byte-array content to the response.
@@ -274,6 +286,8 @@ public static class TypedResults
         EntityTagHeaderValue? entityTag = null,
         bool enableRangeProcessing = false)
     {
+        ArgumentNullException.ThrowIfNull(fileStream);
+
         return new(fileStream, contentType)
         {
             LastModified = lastModified,
@@ -315,6 +329,8 @@ public static class TypedResults
         EntityTagHeaderValue? entityTag = null,
         bool enableRangeProcessing = false)
     {
+        ArgumentNullException.ThrowIfNull(stream);
+
         return new(stream, contentType)
         {
             LastModified = lastModified,
@@ -353,6 +369,8 @@ public static class TypedResults
         EntityTagHeaderValue? entityTag = null,
         bool enableRangeProcessing = false)
     {
+        ArgumentNullException.ThrowIfNull(pipeReader);
+
         return new(pipeReader.AsStream(), contentType)
         {
             LastModified = lastModified,
@@ -386,6 +404,8 @@ public static class TypedResults
         DateTimeOffset? lastModified = null,
         EntityTagHeaderValue? entityTag = null)
     {
+        ArgumentNullException.ThrowIfNull(streamWriterCallback);
+
         return new(streamWriterCallback, contentType)
         {
             LastModified = lastModified,
@@ -418,6 +438,11 @@ public static class TypedResults
         EntityTagHeaderValue? entityTag = null,
         bool enableRangeProcessing = false)
     {
+        if (string.IsNullOrEmpty(path))
+        {
+            throw new ArgumentException("Argument cannot be null or empty", nameof(path));
+        }
+
         return new(path, contentType)
         {
             FileDownloadName = fileDownloadName,
@@ -451,6 +476,11 @@ public static class TypedResults
         EntityTagHeaderValue? entityTag = null,
         bool enableRangeProcessing = false)
     {
+        if (string.IsNullOrEmpty(path))
+        {
+            throw new ArgumentException("Argument cannot be null or empty", nameof(path));
+        }
+
         return new(path, contentType)
         {
             FileDownloadName = fileDownloadName,
@@ -474,7 +504,14 @@ public static class TypedResults
     /// <param name="preserveMethod">If set to true, make the temporary redirect (307) or permanent redirect (308) preserve the initial request method.</param>
     /// <returns>The created <see cref="RedirectHttpResult"/> for the response.</returns>
     public static RedirectHttpResult Redirect(string url, bool permanent = false, bool preserveMethod = false)
-        => new(url, permanent, preserveMethod);
+    {
+        if (string.IsNullOrEmpty(url))
+        {
+            throw new ArgumentException("Argument cannot be null or empty", nameof(url));
+        }
+
+        return new(url, permanent, preserveMethod);
+    }
 
     /// <summary>
     /// Redirects to the specified <paramref name="localUrl"/>.
@@ -490,7 +527,14 @@ public static class TypedResults
     /// <param name="preserveMethod">If set to true, make the temporary redirect (307) or permanent redirect (308) preserve the initial request method.</param>
     /// <returns>The created <see cref="RedirectHttpResult"/> for the response.</returns>
     public static RedirectHttpResult LocalRedirect(string localUrl, bool permanent = false, bool preserveMethod = false)
-        => new(localUrl, acceptLocalUrlOnly: true, permanent, preserveMethod);
+    {
+        if (string.IsNullOrEmpty(localUrl))
+        {
+            throw new ArgumentException("Argument cannot be null or empty", nameof(localUrl));
+        }
+
+        return new(localUrl, acceptLocalUrlOnly: true, permanent, preserveMethod);
+    }
 
     /// <summary>
     /// Redirects to the specified route.
@@ -650,6 +694,8 @@ public static class TypedResults
     /// <returns>The created <see cref="ProblemHttpResult"/> for the response.</returns>
     public static ProblemHttpResult Problem(ProblemDetails problemDetails)
     {
+        ArgumentNullException.ThrowIfNull(problemDetails);
+
         return new(problemDetails);
     }
 
@@ -671,6 +717,8 @@ public static class TypedResults
         string? type = null,
         IDictionary<string, object?>? extensions = null)
     {
+        ArgumentNullException.ThrowIfNull(errors);
+
         var problemDetails = new HttpValidationProblemDetails(errors)
         {
             Detail = detail,
@@ -698,9 +746,9 @@ public static class TypedResults
     /// <returns>The created <see cref="HttpResults.Created"/> for the response.</returns>
     public static Created Created(string uri)
     {
-        if (uri == null)
+        if (string.IsNullOrEmpty(uri))
         {
-            throw new ArgumentNullException(nameof(uri));
+            throw new ArgumentException("Argument cannot be null or empty", nameof(uri));
         }
 
         return new(uri);
@@ -715,9 +763,9 @@ public static class TypedResults
     /// <returns>The created <see cref="HttpResults.Created{TValue}"/> for the response.</returns>
     public static Created<TValue> Created<TValue>(string uri, TValue? value)
     {
-        if (uri == null)
+        if (string.IsNullOrEmpty(uri))
         {
-            throw new ArgumentNullException(nameof(uri));
+            throw new ArgumentException("Argument cannot be null or empty", nameof(uri));
         }
 
         return new(uri, value);
@@ -730,10 +778,7 @@ public static class TypedResults
     /// <returns>The created <see cref="HttpResults.Created"/> for the response.</returns>
     public static Created Created(Uri uri)
     {
-        if (uri == null)
-        {
-            throw new ArgumentNullException(nameof(uri));
-        }
+        ArgumentNullException.ThrowIfNull(uri);
 
         return new(uri);
     }
@@ -747,10 +792,7 @@ public static class TypedResults
     /// <returns>The created <see cref="HttpResults.Created{TValue}"/> for the response.</returns>
     public static Created<TValue> Created<TValue>(Uri uri, TValue? value)
     {
-        if (uri == null)
-        {
-            throw new ArgumentNullException(nameof(uri));
-        }
+        ArgumentNullException.ThrowIfNull(uri);
 
         return new(uri, value);
     }
@@ -804,10 +846,7 @@ public static class TypedResults
     /// <returns>The created <see cref="HttpResults.Accepted"/> for the response.</returns>
     public static Accepted Accepted(Uri uri)
     {
-        if (uri == null)
-        {
-            throw new ArgumentNullException(nameof(uri));
-        }
+        ArgumentNullException.ThrowIfNull(uri);
 
         return new(uri);
     }
@@ -821,10 +860,7 @@ public static class TypedResults
     /// <returns>The created <see cref="HttpResults.Accepted{TValue}"/> for the response.</returns>
     public static Accepted<TValue> Accepted<TValue>(Uri uri, TValue? value)
     {
-        if (uri == null)
-        {
-            throw new ArgumentNullException(nameof(uri));
-        }
+        ArgumentNullException.ThrowIfNull(uri);
 
         return new(uri, value);
     }
diff --git a/src/Http/Http.Results/src/UnauthorizedHttpResult.cs b/src/Http/Http.Results/src/UnauthorizedHttpResult.cs
index e6dfaec3d86f7354265cd4d30fcd8a4ed95de288..5662c3fde02924cb49d5a12210b7c4fa8c94c39e 100644
--- a/src/Http/Http.Results/src/UnauthorizedHttpResult.cs
+++ b/src/Http/Http.Results/src/UnauthorizedHttpResult.cs
@@ -27,6 +27,8 @@ public sealed class UnauthorizedHttpResult : IResult
     /// <inheritdoc />
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.UnauthorizedResult");
diff --git a/src/Http/Http.Results/src/UnprocessableEntity.cs b/src/Http/Http.Results/src/UnprocessableEntity.cs
index eaa851ae1c07d0ab08ab02303d3d80de3d4e2dbe..1b5bb29a5fcd125fd5ae93b4bf400d832d136bc3 100644
--- a/src/Http/Http.Results/src/UnprocessableEntity.cs
+++ b/src/Http/Http.Results/src/UnprocessableEntity.cs
@@ -29,6 +29,8 @@ public sealed class UnprocessableEntity : IResult, IEndpointMetadataProvider
     /// <inheritdoc />
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.UnprocessableEntityObjectResult");
@@ -42,6 +44,8 @@ public sealed class UnprocessableEntity : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(StatusCodes.Status422UnprocessableEntity));
     }
 }
diff --git a/src/Http/Http.Results/src/UnprocessableEntityOfT.cs b/src/Http/Http.Results/src/UnprocessableEntityOfT.cs
index 3232114b569f8f86a1114621c060782b2b96b726..7653bc1c0d416112e2f88c01919fc99e070c15c7 100644
--- a/src/Http/Http.Results/src/UnprocessableEntityOfT.cs
+++ b/src/Http/Http.Results/src/UnprocessableEntityOfT.cs
@@ -38,6 +38,8 @@ public sealed class UnprocessableEntity<TValue> : IResult, IEndpointMetadataProv
     /// <inheritdoc />
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         // Creating the logger with a string to preserve the category after the refactoring.
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.UnprocessableEntityObjectResult");
@@ -54,6 +56,8 @@ public sealed class UnprocessableEntity<TValue> : IResult, IEndpointMetadataProv
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(typeof(TValue), StatusCodes.Status422UnprocessableEntity, "application/json"));
     }
 }
diff --git a/src/Http/Http.Results/src/ValidationProblem.cs b/src/Http/Http.Results/src/ValidationProblem.cs
index 9812ec9ce0dcb57849e20678c0f57f8e3a857dca..4c5206c4b8814dbffad30662ba5aab5afde0d4f0 100644
--- a/src/Http/Http.Results/src/ValidationProblem.cs
+++ b/src/Http/Http.Results/src/ValidationProblem.cs
@@ -43,6 +43,8 @@ public sealed class ValidationProblem : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         var loggerFactory = httpContext.RequestServices.GetRequiredService<ILoggerFactory>();
         var logger = loggerFactory.CreateLogger(typeof(ValidationProblem));
 
@@ -59,6 +61,8 @@ public sealed class ValidationProblem : IResult, IEndpointMetadataProvider
     /// <inheritdoc/>
     static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
     {
+        ArgumentNullException.ThrowIfNull(context);
+
         context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(typeof(HttpValidationProblemDetails), StatusCodes.Status400BadRequest, "application/problem+json"));
     }
 }
diff --git a/src/Http/Http.Results/src/VirtualFileHttpResult.cs b/src/Http/Http.Results/src/VirtualFileHttpResult.cs
index 6739676d9700498b30358c11c7508c32f1e664e2..56bec2e6e2f25ffa76750c73b5704687e6c2d596 100644
--- a/src/Http/Http.Results/src/VirtualFileHttpResult.cs
+++ b/src/Http/Http.Results/src/VirtualFileHttpResult.cs
@@ -62,7 +62,7 @@ public sealed class VirtualFileHttpResult : IResult
         DateTimeOffset? lastModified = null,
         EntityTagHeaderValue? entityTag = null)
     {
-        FileName = fileName ?? throw new ArgumentNullException(nameof(fileName));
+        FileName = fileName;
         ContentType = contentType ?? "application/octet-stream";
         FileDownloadName = fileDownloadName;
         EnableRangeProcessing = enableRangeProcessing;
@@ -101,6 +101,8 @@ public sealed class VirtualFileHttpResult : IResult
     /// <inheritdoc/>
     public Task ExecuteAsync(HttpContext httpContext)
     {
+        ArgumentNullException.ThrowIfNull(httpContext);
+
         var hostingEnvironment = httpContext.RequestServices.GetRequiredService<IWebHostEnvironment>();
 
         var fileInfo = GetFileInformation(hostingEnvironment.WebRootFileProvider);
diff --git a/src/Http/Http.Results/test/AcceptedAtRouteOfTResultTests.cs b/src/Http/Http.Results/test/AcceptedAtRouteOfTResultTests.cs
index 45fb26fd95f1cd2d26649b223f56bf6e4d563f2d..bd03a6e3f2fd527fa65b6086c5fc2ac2ff13fb19 100644
--- a/src/Http/Http.Results/test/AcceptedAtRouteOfTResultTests.cs
+++ b/src/Http/Http.Results/test/AcceptedAtRouteOfTResultTests.cs
@@ -134,6 +134,24 @@ public class AcceptedAtRouteOfTResultTests
         Assert.Single(producesResponseTypeMetadata.ContentTypes, "application/json");
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new AcceptedAtRoute<object>(null, null);
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
+    [Fact]
+    public void PopulateMetadata_ThrowsArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<AcceptedAtRoute<object>>(null));
+    }
+
     private static void PopulateMetadata<TResult>(EndpointMetadataContext context)
         where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(context);
 
diff --git a/src/Http/Http.Results/test/AcceptedAtRouteResultTests.cs b/src/Http/Http.Results/test/AcceptedAtRouteResultTests.cs
index 4c43df6dfb70ddf543eb23f08ed402955d2ee8c2..c8d663b5254afdac9c4e1e4eb3b33884e8f97243 100644
--- a/src/Http/Http.Results/test/AcceptedAtRouteResultTests.cs
+++ b/src/Http/Http.Results/test/AcceptedAtRouteResultTests.cs
@@ -85,6 +85,24 @@ public class AcceptedAtRouteResultTests
         Assert.Equal(StatusCodes.Status202Accepted, producesResponseTypeMetadata.StatusCode);
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new AcceptedAtRoute(null);
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
+    [Fact]
+    public void PopulateMetadata_ThrowsArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<AcceptedAtRoute>(null));
+    }
+
     private static void PopulateMetadata<TResult>(EndpointMetadataContext context)
         where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(context);
 
diff --git a/src/Http/Http.Results/test/AcceptedOfTResultTests.cs b/src/Http/Http.Results/test/AcceptedOfTResultTests.cs
index 3bc477cffad14a1c67e26e42e6f6220e1645c570..4a9193ed1eefe5ac6f54789e2b93f44269df6baa 100644
--- a/src/Http/Http.Results/test/AcceptedOfTResultTests.cs
+++ b/src/Http/Http.Results/test/AcceptedOfTResultTests.cs
@@ -74,6 +74,24 @@ public class AcceptedOfTResultTests
         Assert.Single(producesResponseTypeMetadata.ContentTypes, "application/json");
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new Accepted<object>("location", null);
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
+    [Fact]
+    public void PopulateMetadata_ThrowsArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<Accepted<object>>(null));
+    }
+
     private static void PopulateMetadata<TResult>(EndpointMetadataContext context)
         where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(context);
 
diff --git a/src/Http/Http.Results/test/AcceptedResultTests.cs b/src/Http/Http.Results/test/AcceptedResultTests.cs
index a8fad797f1eadefedcbb06efe765fd67a9ab020e..4c762562a61ecc387790a719d0c549363b75aca7 100644
--- a/src/Http/Http.Results/test/AcceptedResultTests.cs
+++ b/src/Http/Http.Results/test/AcceptedResultTests.cs
@@ -11,7 +11,7 @@ namespace Microsoft.AspNetCore.Http.HttpResults;
 public class AcceptedResultTests
 {
     [Fact]
-    public async Task ExecuteResultAsync_SetsStatusCodeAndLocationHeader()
+    public async Task ExecuteAsync_SetsStatusCodeAndLocationHeader()
     {
         // Arrange
         var expectedUrl = "testAction";
@@ -41,6 +41,24 @@ public class AcceptedResultTests
         Assert.Contains(context.EndpointMetadata, m => m is ProducesResponseTypeMetadata { StatusCode: StatusCodes.Status202Accepted });
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new Accepted("location");
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
+    [Fact]
+    public void PopulateMetadata_ThrowsArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<Accepted>(null));
+    }
+
     private static void PopulateMetadata<TResult>(EndpointMetadataContext context)
         where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(context);
 
diff --git a/src/Http/Http.Results/test/BadRequestOfTResultTests.cs b/src/Http/Http.Results/test/BadRequestOfTResultTests.cs
index 8d223c3b468184e65c3576f716554eb0bce77d60..f5ad69cfdcbdfb2e5c451e25ffd2625097e06b45 100644
--- a/src/Http/Http.Results/test/BadRequestOfTResultTests.cs
+++ b/src/Http/Http.Results/test/BadRequestOfTResultTests.cs
@@ -116,6 +116,24 @@ public class BadRequestOfTResultTests
         Assert.Single(producesResponseTypeMetadata.ContentTypes, "application/json");
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new BadRequest<object>(null);
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
+    [Fact]
+    public void PopulateMetadata_ThrowsArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<BadRequest<object>>(null));
+    }
+
     private static void PopulateMetadata<TResult>(EndpointMetadataContext context)
         where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(context);
 
diff --git a/src/Http/Http.Results/test/BadRequestResultTests.cs b/src/Http/Http.Results/test/BadRequestResultTests.cs
index 30286b384bc9a9b14c155d7c2c7835204746dd2f..587e503b38951d0662344f10416a79274acb0bff 100644
--- a/src/Http/Http.Results/test/BadRequestResultTests.cs
+++ b/src/Http/Http.Results/test/BadRequestResultTests.cs
@@ -55,6 +55,24 @@ public class BadRequestResultTests
         Assert.Equal(StatusCodes.Status400BadRequest, producesResponseTypeMetadata.StatusCode);
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new BadRequest();
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
+    [Fact]
+    public void PopulateMetadata_ThrowsArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<BadRequest>(null));
+    }
+
     private static void PopulateMetadata<TResult>(EndpointMetadataContext context)
         where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(context);
 
diff --git a/src/Http/Http.Results/test/ChallengeResultTests.cs b/src/Http/Http.Results/test/ChallengeResultTests.cs
index a5d02031d54d44ee597b409617ea6f75bf523287..28ae90c013435ad9f920c588a58c18afe2664673 100644
--- a/src/Http/Http.Results/test/ChallengeResultTests.cs
+++ b/src/Http/Http.Results/test/ChallengeResultTests.cs
@@ -41,6 +41,17 @@ public class ChallengeResultTests
         auth.Verify(c => c.ChallengeAsync(httpContext, null, null), Times.Exactly(1));
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new ChallengeHttpResult();
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
     private static DefaultHttpContext GetHttpContext(Mock<IAuthenticationService> auth)
     {
         var httpContext = new DefaultHttpContext();
diff --git a/src/Http/Http.Results/test/ConflictOfTResultTests.cs b/src/Http/Http.Results/test/ConflictOfTResultTests.cs
index 9ecf5b06dcb0df54e5f5bd6862051d045f256909..8d54e526fe84b7ec8d3a6a9b84aa858102012581 100644
--- a/src/Http/Http.Results/test/ConflictOfTResultTests.cs
+++ b/src/Http/Http.Results/test/ConflictOfTResultTests.cs
@@ -95,6 +95,24 @@ public class ConflictOfTResultTests
         Assert.Single(producesResponseTypeMetadata.ContentTypes, "application/json");
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new Conflict<object>(null);
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
+    [Fact]
+    public void PopulateMetadata_ThrowsArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<Conflict<object>>(null));
+    }
+
     private static void PopulateMetadata<TResult>(EndpointMetadataContext context)
         where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(context);
 
diff --git a/src/Http/Http.Results/test/ConflictResultTests.cs b/src/Http/Http.Results/test/ConflictResultTests.cs
index 45337e675be0c4cfb1bc098895d953db53cb925b..e709d7a9f8720ca7c0b61043ed5e7eb4f9a51175 100644
--- a/src/Http/Http.Results/test/ConflictResultTests.cs
+++ b/src/Http/Http.Results/test/ConflictResultTests.cs
@@ -56,6 +56,24 @@ public class ConflictResultTests
         Assert.Equal(StatusCodes.Status409Conflict, producesResponseTypeMetadata.StatusCode);
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new Conflict();
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
+    [Fact]
+    public void PopulateMetadata_ThrowsArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<Conflict>(null));
+    }
+
     private static void PopulateMetadata<TResult>(EndpointMetadataContext context)
         where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(context);
 
diff --git a/src/Http/Http.Results/test/ContentResultTests.cs b/src/Http/Http.Results/test/ContentResultTests.cs
index 7b316c41098127a8bc3d7b17c901a4d610e3e46f..7f22daa0785774e7b77c2cdb9c0098b4ed34a204 100644
--- a/src/Http/Http.Results/test/ContentResultTests.cs
+++ b/src/Http/Http.Results/test/ContentResultTests.cs
@@ -123,6 +123,17 @@ public class ContentResultTests
         Assert.Equal(expectedContentData.Length, httpContext.Response.ContentLength);
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new ContentHttpResult("content", null);
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
     private static IServiceCollection CreateServices()
     {
         var services = new ServiceCollection();
diff --git a/src/Http/Http.Results/test/CreatedAtRouteOfTResultTests.cs b/src/Http/Http.Results/test/CreatedAtRouteOfTResultTests.cs
index afa6c0cfb4d6d20823f76f5a7c9c6e479797278c..9579f00e042310c3362bae6b8a6dc7e97aca1da0 100644
--- a/src/Http/Http.Results/test/CreatedAtRouteOfTResultTests.cs
+++ b/src/Http/Http.Results/test/CreatedAtRouteOfTResultTests.cs
@@ -101,6 +101,24 @@ public partial class CreatedAtRouteOfTResultTests
         Assert.Single(producesResponseTypeMetadata.ContentTypes, "application/json");
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new CreatedAtRoute<object>(null, null);
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
+    [Fact]
+    public void PopulateMetadata_ThrowsArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<CreatedAtRoute<object>>(null));
+    }
+
     private static void PopulateMetadata<TResult>(EndpointMetadataContext context)
         where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(context);
 
diff --git a/src/Http/Http.Results/test/CreatedAtRouteResultTests.cs b/src/Http/Http.Results/test/CreatedAtRouteResultTests.cs
index bd8f0c2a0fb9b036eb8e89d4fd3afb51dfea7a34..04c55274d619b1d701d187c5d42212094a2d870f 100644
--- a/src/Http/Http.Results/test/CreatedAtRouteResultTests.cs
+++ b/src/Http/Http.Results/test/CreatedAtRouteResultTests.cs
@@ -81,6 +81,24 @@ public partial class CreatedAtRouteResultTests
         Assert.Equal(StatusCodes.Status201Created, producesResponseTypeMetadata.StatusCode);
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new CreatedAtRoute(null);
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
+    [Fact]
+    public void PopulateMetadata_ThrowsArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<CreatedAtRoute>(null));
+    }
+
     private static void PopulateMetadata<TResult>(EndpointMetadataContext context)
         where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(context);
 
diff --git a/src/Http/Http.Results/test/CreatedOfTResultTests.cs b/src/Http/Http.Results/test/CreatedOfTResultTests.cs
index f0ac3d838ffc49b7f4dfb5a05e16dd8ef598ae00..272022a88ef216468b3242d3a2003ebf9251c9e4 100644
--- a/src/Http/Http.Results/test/CreatedOfTResultTests.cs
+++ b/src/Http/Http.Results/test/CreatedOfTResultTests.cs
@@ -109,6 +109,24 @@ public class CreatedOfTResultTests
         Assert.Single(producesResponseTypeMetadata.ContentTypes, "application/json");
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new Created<object>("location", null);
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
+    [Fact]
+    public void PopulateMetadata_ThrowsArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<Created<object>>(null));
+    }
+
     private static void PopulateMetadata<TResult>(EndpointMetadataContext context)
         where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(context);
 
diff --git a/src/Http/Http.Results/test/CreatedResultTests.cs b/src/Http/Http.Results/test/CreatedResultTests.cs
index 0591cd7db003c5e0cad5cb169255899088f902af..e4ca455e146b509635dee7c907ccbc43047f5500 100644
--- a/src/Http/Http.Results/test/CreatedResultTests.cs
+++ b/src/Http/Http.Results/test/CreatedResultTests.cs
@@ -73,6 +73,24 @@ public class CreatedResultTests
         Assert.Equal(StatusCodes.Status201Created, producesResponseTypeMetadata.StatusCode);
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new Created("location");
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
+    [Fact]
+    public void PopulateMetadata_ThrowsArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<Created>(null));
+    }
+
     private static void PopulateMetadata<TResult>(EndpointMetadataContext context)
         where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(context);
 
diff --git a/src/Http/Http.Results/test/EmptyResultTests.cs b/src/Http/Http.Results/test/EmptyResultTests.cs
index cde7fde64971bfdd7263d7f1b1a275b635d955ac..f974a0211a18d3e669ac239ec6e3d8cb8d8d1ef0 100644
--- a/src/Http/Http.Results/test/EmptyResultTests.cs
+++ b/src/Http/Http.Results/test/EmptyResultTests.cs
@@ -23,6 +23,17 @@ public class EmptyResultTests
         Assert.Equal(0, memoryStream.Length);
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = EmptyHttpResult.Instance;
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
     private static HttpContext GetHttpContext()
     {
         var httpContext = new DefaultHttpContext();
diff --git a/src/Http/Http.Results/test/ForbidResultTests.cs b/src/Http/Http.Results/test/ForbidResultTests.cs
index ee58a6539e68b3f7669faa61405efbb1dcf02b38..a28e20304528c03bea97f7a369e1a94a0943c964 100644
--- a/src/Http/Http.Results/test/ForbidResultTests.cs
+++ b/src/Http/Http.Results/test/ForbidResultTests.cs
@@ -108,6 +108,17 @@ public class ForbidResultTests
         auth.Verify();
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new ForbidHttpResult();
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
     private static DefaultHttpContext GetHttpContext(IAuthenticationService auth)
     {
         var httpContext = new DefaultHttpContext();
diff --git a/src/Http/Http.Results/test/HttpFileStreamResultTests.cs b/src/Http/Http.Results/test/HttpFileStreamResultTests.cs
index 40cbc188ee54505ba00696205e22a20be5019ff1..f3c32f6e48b5f3e44287f617ad6cf297162094e5 100644
--- a/src/Http/Http.Results/test/HttpFileStreamResultTests.cs
+++ b/src/Http/Http.Results/test/HttpFileStreamResultTests.cs
@@ -78,4 +78,14 @@ public class HttpFileStreamResultTests : FileStreamResultTestBase
         Assert.Equal(expectedMediaType, result.ContentType);
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new FileStreamHttpResult(new MemoryStream(), null);
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
 }
diff --git a/src/Http/Http.Results/test/JsonResultTests.cs b/src/Http/Http.Results/test/JsonResultTests.cs
index d0804b3ab4d35b0a78edd4382189957aceaefda9..fbc3f6ece6bfd17c0f49e9c13d2877b15378d53a 100644
--- a/src/Http/Http.Results/test/JsonResultTests.cs
+++ b/src/Http/Http.Results/test/JsonResultTests.cs
@@ -206,6 +206,17 @@ public class JsonResultTests
         Assert.Equal(StatusCodes.Status413RequestEntityTooLarge, httpContext.Response.StatusCode);
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new JsonHttpResult<object>(null, null);
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
     private static IServiceProvider CreateServices()
     {
         var services = new ServiceCollection();
diff --git a/src/Http/Http.Results/test/Microsoft.AspNetCore.Http.Results.Tests.csproj b/src/Http/Http.Results/test/Microsoft.AspNetCore.Http.Results.Tests.csproj
index e89f39527936f00e1cbf671e7b169493f14b2193..c9d39f858d43d60dc4c030fdd5674de680829a5d 100644
--- a/src/Http/Http.Results/test/Microsoft.AspNetCore.Http.Results.Tests.csproj
+++ b/src/Http/Http.Results/test/Microsoft.AspNetCore.Http.Results.Tests.csproj
@@ -15,7 +15,7 @@
     <Compile Include="$(SharedSourceRoot)ResultsTests\*.cs" LinkBase="Shared" />
     <Content Include="$(HttpResultsSourceRoot)\ResultsCache.StatusCodes.tt" LinkBase="Shared\GeneratedContent" CopyToOutputDirectory="PreserveNewest" />
     <Content Include="$(HttpResultsSourceRoot)\ResultsCache.StatusCodes.cs" LinkBase="Shared\GeneratedContent" CopyToOutputDirectory="PreserveNewest" />
-    <Content Include="$(HttpResultsSourceRoot)\ResultsOfT.cs" LinkBase="Shared\GeneratedContent" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="$(HttpResultsSourceRoot)\ResultsOfT.Generated.cs" LinkBase="Shared\GeneratedContent" CopyToOutputDirectory="PreserveNewest" />
     <Compile Update="ResultsOfTTests.Generated.cs" Link="Shared\GeneratedContent\%(RecursiveDir)%(Filename)%(Extension)" CopyToOutputDirectory="PreserveNewest" />
   </ItemGroup>
 
diff --git a/src/Http/Http.Results/test/NoContentResultTests.cs b/src/Http/Http.Results/test/NoContentResultTests.cs
index de0c82a63277716f88f6f7e885d3b5a3ab85d9f9..17435be5099165cbbc58a417290d5f79d3cf6776 100644
--- a/src/Http/Http.Results/test/NoContentResultTests.cs
+++ b/src/Http/Http.Results/test/NoContentResultTests.cs
@@ -52,6 +52,24 @@ public class NoContentResultTests
         Assert.Equal(StatusCodes.Status204NoContent, producesResponseTypeMetadata.StatusCode);
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new NoContent();
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
+    [Fact]
+    public void PopulateMetadata_ThrowsArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<NoContent>(null));
+    }
+
     private static void PopulateMetadata<TResult>(EndpointMetadataContext context)
         where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(context);
 
diff --git a/src/Http/Http.Results/test/NotFoundOfTResultTests.cs b/src/Http/Http.Results/test/NotFoundOfTResultTests.cs
index 9a15ae0d76c7b0e53cc40654077d6c30a614aed5..959c09340c561295829bef9ee783dbdf2dfe06db 100644
--- a/src/Http/Http.Results/test/NotFoundOfTResultTests.cs
+++ b/src/Http/Http.Results/test/NotFoundOfTResultTests.cs
@@ -77,6 +77,24 @@ public class NotFoundOfTResultTests
         Assert.Single(producesResponseTypeMetadata.ContentTypes, "application/json");
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new NotFound<object>(null);
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
+    [Fact]
+    public void PopulateMetadata_ThrowsArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<NotFound<object>>(null));
+    }
+
     private static void PopulateMetadata<TResult>(EndpointMetadataContext context)
         where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(context);
 
diff --git a/src/Http/Http.Results/test/NotFoundResultTests.cs b/src/Http/Http.Results/test/NotFoundResultTests.cs
index 20d69a54e4880fe91e2e0a894a87143d535067bb..0e7a2cb70c92908dc5b6cc0350a6288356236f49 100644
--- a/src/Http/Http.Results/test/NotFoundResultTests.cs
+++ b/src/Http/Http.Results/test/NotFoundResultTests.cs
@@ -51,6 +51,24 @@ public class NotFoundResultTests
         Assert.Equal(StatusCodes.Status404NotFound, producesResponseTypeMetadata.StatusCode);
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new NotFound();
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
+    [Fact]
+    public void PopulateMetadata_ThrowsArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<NotFound>(null));
+    }
+
     private static void PopulateMetadata<TResult>(EndpointMetadataContext context)
         where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(context);
 
diff --git a/src/Http/Http.Results/test/OkOfTResultTests.cs b/src/Http/Http.Results/test/OkOfTResultTests.cs
index 11e1af79a23e1777663810e8c3feb576b07867e5..bd4d11e1ebed6dde57696fb0e6df2be029691bc2 100644
--- a/src/Http/Http.Results/test/OkOfTResultTests.cs
+++ b/src/Http/Http.Results/test/OkOfTResultTests.cs
@@ -94,6 +94,24 @@ public class OkOfTResultTests
         Assert.Single(producesResponseTypeMetadata.ContentTypes, "application/json");
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new Ok<object>(null);
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
+    [Fact]
+    public void PopulateMetadata_ThrowsArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<Ok<object>>(null));
+    }
+
     private static void PopulateMetadata<TResult>(EndpointMetadataContext context)
         where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(context);
 
diff --git a/src/Http/Http.Results/test/OkResultTests.cs b/src/Http/Http.Results/test/OkResultTests.cs
index c199a2b08634c53651b874045445158eb7399ebc..da480961e636cbd75a49f8234c5ea61eff39018c 100644
--- a/src/Http/Http.Results/test/OkResultTests.cs
+++ b/src/Http/Http.Results/test/OkResultTests.cs
@@ -55,6 +55,24 @@ public class OkResultTests
         Assert.Equal(StatusCodes.Status200OK, producesResponseTypeMetadata.StatusCode);
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new Ok();
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
+    [Fact]
+    public void PopulateMetadata_ThrowsArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<Ok>(null));
+    }
+
     private static void PopulateMetadata<TResult>(EndpointMetadataContext context)
         where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(context);
 
diff --git a/src/Http/Http.Results/test/ProblemResultTests.cs b/src/Http/Http.Results/test/ProblemResultTests.cs
index 35bf6ea7ba27f3ff75c47d41307f64718c7164e6..4e6c38a5670dd744dba8e5cde3cf2460005d7f05 100644
--- a/src/Http/Http.Results/test/ProblemResultTests.cs
+++ b/src/Http/Http.Results/test/ProblemResultTests.cs
@@ -91,6 +91,17 @@ public class ProblemResultTests
         Assert.Equal(StatusCodes.Status413RequestEntityTooLarge, httpContext.Response.StatusCode);
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new ProblemHttpResult(new());
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
     private static IServiceProvider CreateServices()
     {
         var services = new ServiceCollection();
diff --git a/src/Http/Http.Results/test/PushStreamResultTests.cs b/src/Http/Http.Results/test/PushStreamResultTests.cs
index 669720f87f44a918ca356ffecc0ed525585c6781..43541f080944fe4eb8dc81e6c99c8c6dc1451061 100644
--- a/src/Http/Http.Results/test/PushStreamResultTests.cs
+++ b/src/Http/Http.Results/test/PushStreamResultTests.cs
@@ -66,4 +66,15 @@ public class PushStreamResultTests
         Assert.Equal(entityTag, result.EntityTag);
         Assert.Equal(expectedMediaType, result.ContentType);
     }
+
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new PushStreamHttpResult(s => Task.CompletedTask, "content-type");
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
 }
diff --git a/src/Http/Http.Results/test/RedirectResultTests.cs b/src/Http/Http.Results/test/RedirectResultTests.cs
index 8690e68a5be4d77335e2729ec1429fcfb457ccff..6a41ab6acf6eded869bfa8ea647302f751e059d5 100644
--- a/src/Http/Http.Results/test/RedirectResultTests.cs
+++ b/src/Http/Http.Results/test/RedirectResultTests.cs
@@ -22,6 +22,17 @@ public class RedirectResultTests : RedirectResultTestBase
         Assert.Same(url, result.Url);
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new RedirectHttpResult("url");
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
     protected override Task ExecuteAsync(HttpContext httpContext, string contentPath)
     {
         var redirectResult = new RedirectHttpResult(contentPath, false, false);
diff --git a/src/Http/Http.Results/test/RedirectToRouteResultTests.cs b/src/Http/Http.Results/test/RedirectToRouteResultTests.cs
index d7f27a5561dade2114fd7923e2cb7328b764b162..6df007652eb97c0ccbb22e86d11d8fd0df55b6e3 100644
--- a/src/Http/Http.Results/test/RedirectToRouteResultTests.cs
+++ b/src/Http/Http.Results/test/RedirectToRouteResultTests.cs
@@ -84,6 +84,17 @@ public class RedirectToRouteResultTests
         Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]);
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new RedirectToRouteHttpResult(null);
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
     private static HttpContext GetHttpContext(string path)
     {
         var services = CreateServices(path);
diff --git a/src/Http/Http.Results/test/ResultsOfTTests.Generated.cs b/src/Http/Http.Results/test/ResultsOfTTests.Generated.cs
index a17541fa7c2bea9f69d9deb956e6524de6f0af6d..2588a2e2751897638825f0ebbb233f66444119e6 100644
--- a/src/Http/Http.Results/test/ResultsOfTTests.Generated.cs
+++ b/src/Http/Http.Results/test/ResultsOfTTests.Generated.cs
@@ -218,6 +218,13 @@ public partial class ResultsOfTTests
         Assert.Contains(context.EndpointMetadata, m => m is ResultTypeProvidedMetadata { SourceTypeName: nameof(ProvidesMetadataResult2) });
     }
 
+    [Fact]
+    public void ResultsOfTResult1TResult2_PopulateMetadata_Throws_ArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<Results<ProvidesMetadataResult1, ProvidesMetadataResult2>>(null));
+    }
+
     [Theory]
     [InlineData(1, typeof(ChecksumResult1))]
     [InlineData(2, typeof(ChecksumResult2))]
@@ -491,6 +498,13 @@ public partial class ResultsOfTTests
         Assert.Contains(context.EndpointMetadata, m => m is ResultTypeProvidedMetadata { SourceTypeName: nameof(ProvidesMetadataResult3) });
     }
 
+    [Fact]
+    public void ResultsOfTResult1TResult2TResult3_PopulateMetadata_Throws_ArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<Results<ProvidesMetadataResult1, ProvidesMetadataResult2, ProvidesMetadataResult3>>(null));
+    }
+
     [Theory]
     [InlineData(1, typeof(ChecksumResult1))]
     [InlineData(2, typeof(ChecksumResult2))]
@@ -841,6 +855,13 @@ public partial class ResultsOfTTests
         Assert.Contains(context.EndpointMetadata, m => m is ResultTypeProvidedMetadata { SourceTypeName: nameof(ProvidesMetadataResult4) });
     }
 
+    [Fact]
+    public void ResultsOfTResult1TResult2TResult3TResult4_PopulateMetadata_Throws_ArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<Results<ProvidesMetadataResult1, ProvidesMetadataResult2, ProvidesMetadataResult3, ProvidesMetadataResult4>>(null));
+    }
+
     [Theory]
     [InlineData(1, typeof(ChecksumResult1))]
     [InlineData(2, typeof(ChecksumResult2))]
@@ -1276,6 +1297,13 @@ public partial class ResultsOfTTests
         Assert.Contains(context.EndpointMetadata, m => m is ResultTypeProvidedMetadata { SourceTypeName: nameof(ProvidesMetadataResult5) });
     }
 
+    [Fact]
+    public void ResultsOfTResult1TResult2TResult3TResult4TResult5_PopulateMetadata_Throws_ArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<Results<ProvidesMetadataResult1, ProvidesMetadataResult2, ProvidesMetadataResult3, ProvidesMetadataResult4, ProvidesMetadataResult5>>(null));
+    }
+
     [Theory]
     [InlineData(1, typeof(ChecksumResult1))]
     [InlineData(2, typeof(ChecksumResult2))]
@@ -1804,6 +1832,13 @@ public partial class ResultsOfTTests
         Assert.Contains(context.EndpointMetadata, m => m is ResultTypeProvidedMetadata { SourceTypeName: nameof(ProvidesMetadataResult6) });
     }
 
+    [Fact]
+    public void ResultsOfTResult1TResult2TResult3TResult4TResult5TResult6_PopulateMetadata_Throws_ArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<Results<ProvidesMetadataResult1, ProvidesMetadataResult2, ProvidesMetadataResult3, ProvidesMetadataResult4, ProvidesMetadataResult5, ProvidesMetadataResult6>>(null));
+    }
+
     abstract class ChecksumResult : IResult
     {
         public ChecksumResult(int checksum = 0)
diff --git a/src/Http/Http.Results/test/ResultsOfTTests.cs b/src/Http/Http.Results/test/ResultsOfTTests.cs
index 4cb810d91b5cf8ddde1d4233c795b631d8b6be70..1fcca5437cea032d18da37fcc4e34d0ed9a084b7 100644
--- a/src/Http/Http.Results/test/ResultsOfTTests.cs
+++ b/src/Http/Http.Results/test/ResultsOfTTests.cs
@@ -22,7 +22,7 @@ public partial class ResultsOfTTests
     public void GeneratedCodeIsUpToDate()
     {
         // This assumes the output is in the repo artifacts directory
-        var resultsOfTGeneratedPath = Path.Combine(AppContext.BaseDirectory, "Shared", "GeneratedContent", "ResultsOfT.cs");
+        var resultsOfTGeneratedPath = Path.Combine(AppContext.BaseDirectory, "Shared", "GeneratedContent", "ResultsOfT.Generated.cs");
         var testsGeneratedPath = Path.Combine(AppContext.BaseDirectory, "Shared", "GeneratedContent", "ResultsOfTTests.Generated.cs");
 
         var testResultsOfTGeneratedPath = Path.GetTempFileName();
@@ -38,7 +38,7 @@ public partial class ResultsOfTTests
             var testResultsOfTGenerated = File.ReadAllText(testResultsOfTGeneratedPath);
             var testTestsGenerated = File.ReadAllText(testTestsGeneratedPath);
 
-            AssertFileContentEqual(currentResultsOfTGenerated, testResultsOfTGenerated, "ResultsOfT.cs");
+            AssertFileContentEqual(currentResultsOfTGenerated, testResultsOfTGenerated, "ResultsOfT.Generated.cs");
             AssertFileContentEqual(currentTestsGenerated, testTestsGenerated, "ResultsOfTTests.Generated.cs");
         }
         finally
diff --git a/src/Http/Http.Results/test/ResultsTests.cs b/src/Http/Http.Results/test/ResultsTests.cs
index 213163608c064932260ff6d3b655ecf89d304f4c..711bd5ef2c0e6af06dddbc4dded4b1c2d86af371 100644
--- a/src/Http/Http.Results/test/ResultsTests.cs
+++ b/src/Http/Http.Results/test/ResultsTests.cs
@@ -209,6 +209,42 @@ public class ResultsTests
         new object[] { 2, default(string), default(string), default(bool), default(DateTimeOffset?), default(EntityTagHeaderValue) }
     };
 
+    [Fact]
+    public void Bytes_WithNullContents_ThrowsArgNullException()
+    {
+        Assert.Throws<ArgumentNullException>("contents", () => Results.Bytes(null));
+    }
+
+    [Fact]
+    public void File_WithNullContents_ThrowsArgNullException()
+    {
+        Assert.Throws<ArgumentNullException>("fileContents", () => Results.File(default(byte[])));
+    }
+
+    [Fact]
+    public void File_WithNullStream_ThrowsArgNullException()
+    {
+        Assert.Throws<ArgumentNullException>("fileStream", () => Results.File(default(Stream)));
+    }
+
+    [Fact]
+    public void Stream_WithNullStream_ThrowsArgNullException()
+    {
+        Assert.Throws<ArgumentNullException>("stream", () => Results.Stream(default(Stream)));
+    }
+
+    [Fact]
+    public void Stream_WithNullPipeReader_ThrowsArgNullException()
+    {
+        Assert.Throws<ArgumentNullException>("pipeReader", () => Results.Stream(default(PipeReader)));
+    }
+
+    [Fact]
+    public void Stream_WithNullCallback_ThrowsArgNullException()
+    {
+        Assert.Throws<ArgumentNullException>("streamWriterCallback", () => TypedResults.Stream(default(Func<Stream, Task>)));
+    }
+
     [Theory]
     [MemberData(nameof(ChallengeForbidSignInOut_ResultHasCorrectValues_Data))]
     public void Challenge_ResultHasCorrectValues(AuthenticationProperties properties, IList<string> authenticationSchemes)
@@ -393,9 +429,15 @@ public class ResultsTests
     }
 
     [Fact]
-    public void Created_WithNullStringUri_ThrowsArgNullException()
+    public void Created_WithNullStringUri_ThrowsArgException()
     {
-        Assert.Throws<ArgumentNullException>("uri", () => Results.Created(default(string), null));
+        Assert.Throws<ArgumentException>("uri", () => Results.Created(default(string), null));
+    }
+
+    [Fact]
+    public void Created_WithEmptyStringUri_ThrowsArgException()
+    {
+        Assert.Throws<ArgumentException>("uri", () => Results.Created(string.Empty, null));
     }
 
     [Fact]
@@ -404,6 +446,24 @@ public class ResultsTests
         Assert.Throws<ArgumentNullException>("uri", () => Results.Created(default(Uri), null));
     }
 
+    [Fact]
+    public void Created_WithNullStringUriAndValue_ThrowsArgException()
+    {
+        Assert.Throws<ArgumentException>("uri", () => Results.Created(default(string), new { }));
+    }
+
+    [Fact]
+    public void Created_WithEmptyStringUriAndValue_ThrowsArgException()
+    {
+        Assert.Throws<ArgumentException>("uri", () => Results.Created(string.Empty, new { }));
+    }
+
+    [Fact]
+    public void Created_WithNullUriAndValue_ThrowsArgNullException()
+    {
+        Assert.Throws<ArgumentNullException>("uri", () => Results.Created(default(Uri), new { }));
+    }
+
     [Fact]
     public void CreatedAtRoute_WithRouteNameAndRouteValuesAndValue_ResultHasCorrectValues()
     {
@@ -508,6 +568,18 @@ public class ResultsTests
         Assert.Null(result.StatusCode);
     }
 
+    [Fact]
+    public void LocalRedirect_WithNullStringUrl_ThrowsArgException()
+    {
+        Assert.Throws<ArgumentException>("localUrl", () => Results.LocalRedirect(default(string)));
+    }
+
+    [Fact]
+    public void LocalRedirect_WithEmptyStringUrl_ThrowsArgException()
+    {
+        Assert.Throws<ArgumentException>("localUrl", () => Results.LocalRedirect(string.Empty));
+    }
+
     [Fact]
     public void LocalRedirect_WithUrl_ResultHasCorrectValues()
     {
@@ -635,6 +707,12 @@ public class ResultsTests
         Assert.Equal(StatusCodes.Status200OK, result.StatusCode);
     }
 
+    [Fact]
+    public void Problem_WithNullProblem_ThrowsArgNullException()
+    {
+        Assert.Throws<ArgumentNullException>("problemDetails", () => Results.Problem(default(ProblemDetails)));
+    }
+
     [Fact]
     public void Problem_WithArgs_ResultHasCorrectValues()
     {
@@ -707,6 +785,12 @@ public class ResultsTests
         Assert.Equal(StatusCodes.Status400BadRequest, result.StatusCode);
     }
 
+    [Fact]
+    public void ValidationProblem_WithNullErrors_ThrowsArgNullException()
+    {
+        Assert.Throws<ArgumentNullException>("errors", () => Results.ValidationProblem(default(IDictionary<string, string[]>)));
+    }
+
     [Fact]
     public void ValidationProblem_WithValidationProblemArg_ResultHasCorrectValues()
     {
@@ -738,6 +822,18 @@ public class ResultsTests
         Assert.Equal(extensions, result.ProblemDetails.Extensions);
     }
 
+    [Fact]
+    public void Redirect_WithNullStringUrl_ThrowsArgException()
+    {
+        Assert.Throws<ArgumentException>("url", () => Results.Redirect(default(string)));
+    }
+
+    [Fact]
+    public void Redirect_WithEmptyStringUrl_ThrowsArgException()
+    {
+        Assert.Throws<ArgumentException>("url", () => Results.Redirect(string.Empty));
+    }
+
     [Fact]
     public void Redirect_WithDefaults_ResultHasCorrectValues()
     {
diff --git a/src/Http/Http.Results/test/SignInResultTests.cs b/src/Http/Http.Results/test/SignInResultTests.cs
index 3d4c4136740acf4a61078417107595770ee7c2cb..9fe069c41b2148a7cc9fed2c3a8e4eff45e25a6a 100644
--- a/src/Http/Http.Results/test/SignInResultTests.cs
+++ b/src/Http/Http.Results/test/SignInResultTests.cs
@@ -74,6 +74,17 @@ public class SignInResultTests
         auth.Verify();
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new SignInHttpResult(new());
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
     private static DefaultHttpContext GetHttpContext(IAuthenticationService auth)
     {
         var httpContext = new DefaultHttpContext();
diff --git a/src/Http/Http.Results/test/SignOutResultTests.cs b/src/Http/Http.Results/test/SignOutResultTests.cs
index 386b29e928b6ee24ccb9eb1cb0176093674440dc..1549013182125bfcb56fe2058d44687be63caa6f 100644
--- a/src/Http/Http.Results/test/SignOutResultTests.cs
+++ b/src/Http/Http.Results/test/SignOutResultTests.cs
@@ -73,6 +73,17 @@ public class SignOutResultTests
         auth.Verify();
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new SignOutHttpResult();
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
     private static DefaultHttpContext GetHttpContext(IAuthenticationService auth)
     {
         var httpContext = new DefaultHttpContext();
diff --git a/src/Http/Http.Results/test/StatusCodeResultTests.cs b/src/Http/Http.Results/test/StatusCodeResultTests.cs
index 4e28357b5b1929f991ce77179058a6ad8382d876..8fc4b54a3870692816071e5aad040674d00b4104 100644
--- a/src/Http/Http.Results/test/StatusCodeResultTests.cs
+++ b/src/Http/Http.Results/test/StatusCodeResultTests.cs
@@ -24,6 +24,17 @@ public class StatusCodeResultTests
         Assert.Equal(StatusCodes.Status404NotFound, httpContext.Response.StatusCode);
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new StatusCodeHttpResult(200);
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
     private static IServiceCollection CreateServices()
     {
         var services = new ServiceCollection();
diff --git a/src/Http/Http.Results/test/TypedResultsTests.cs b/src/Http/Http.Results/test/TypedResultsTests.cs
index c927bd9423455a7d82b20ca3668d201e3953ff7f..37e024e8b4f4f3eaaac45fe2e8c4da9002da62a3 100644
--- a/src/Http/Http.Results/test/TypedResultsTests.cs
+++ b/src/Http/Http.Results/test/TypedResultsTests.cs
@@ -97,6 +97,12 @@ public class TypedResultsTests
         Assert.Throws<ArgumentNullException>("uri", () => TypedResults.Accepted(default(Uri)));
     }
 
+    [Fact]
+    public void Accepted_WithNullUriAndValue_ThrowsArgumentNullException()
+    {
+        Assert.Throws<ArgumentNullException>("uri", () => TypedResults.Accepted(default(Uri), default(object)));
+    }
+
     [Fact]
     public void AcceptedAtRoute_WithRouteNameAndRouteValuesAndValue_ResultHasCorrectValues()
     {
@@ -198,6 +204,112 @@ public class TypedResultsTests
         new object[] { 1, default(string), default(string), default(bool), default(DateTimeOffset?), default(EntityTagHeaderValue) }
     };
 
+    [Theory]
+    [MemberData(nameof(PhysicalOrVirtualFile_ResultHasCorrectValues_Data))]
+    public void PhysicalFile_ResultHasCorrectValues(string contentType, string fileDownloadName, bool enableRangeProcessing, DateTimeOffset lastModified, EntityTagHeaderValue entityTag)
+    {
+        // Arrange
+        var path = "path";
+
+        // Act
+        var result = TypedResults.PhysicalFile(path, contentType, fileDownloadName, lastModified, entityTag, enableRangeProcessing);
+
+        // Assert
+        Assert.Equal(path, result.FileName);
+        Assert.Equal(contentType ?? "application/octet-stream", result.ContentType);
+        Assert.Equal(fileDownloadName, result.FileDownloadName);
+        Assert.Equal(enableRangeProcessing, result.EnableRangeProcessing);
+        Assert.Equal(lastModified, result.LastModified);
+        Assert.Equal(entityTag, result.EntityTag);
+    }
+
+    [Theory]
+    [MemberData(nameof(PhysicalOrVirtualFile_ResultHasCorrectValues_Data))]
+    public void VirtualFile_ResultHasCorrectValues(string contentType, string fileDownloadName, bool enableRangeProcessing, DateTimeOffset lastModified, EntityTagHeaderValue entityTag)
+    {
+        // Arrange
+        var path = "path";
+
+        // Act
+        var result = TypedResults.VirtualFile(path, contentType, fileDownloadName, lastModified, entityTag, enableRangeProcessing);
+
+        // Assert
+        Assert.Equal(path, result.FileName);
+        Assert.Equal(contentType ?? "application/octet-stream", result.ContentType);
+        Assert.Equal(fileDownloadName, result.FileDownloadName);
+        Assert.Equal(enableRangeProcessing, result.EnableRangeProcessing);
+        Assert.Equal(lastModified, result.LastModified);
+        Assert.Equal(entityTag, result.EntityTag);
+    }
+
+    public static IEnumerable<object[]> PhysicalOrVirtualFile_ResultHasCorrectValues_Data => new List<object[]>
+    {
+        new object[] { "text/plain", "testfile", true, new DateTimeOffset(2022, 1, 1, 0, 0, 1, TimeSpan.FromHours(-8)), EntityTagHeaderValue.Any },
+        new object[] { default(string), default(string), default(bool), default(DateTimeOffset?), default(EntityTagHeaderValue) },
+        new object[] { "text/plain", "testfile", true, new DateTimeOffset(2022, 1, 1, 0, 0, 1, TimeSpan.FromHours(-8)), EntityTagHeaderValue.Any },
+        new object[] { default(string), default(string), default(bool), default(DateTimeOffset?), default(EntityTagHeaderValue) }
+    };
+
+    [Fact]
+    public void Bytes_WithNullContents_ThrowsArgNullException()
+    {
+        Assert.Throws<ArgumentNullException>("contents", () => TypedResults.Bytes(null));
+    }
+
+    [Fact]
+    public void File_WithNullContents_ThrowsArgNullException()
+    {
+        Assert.Throws<ArgumentNullException>("fileContents", () => TypedResults.File(default(byte[])));
+    }
+
+    [Fact]
+    public void File_WithNullStream_ThrowsArgNullException()
+    {
+        Assert.Throws<ArgumentNullException>("fileStream", () => TypedResults.File(default(Stream)));
+    }
+
+    [Fact]
+    public void Stream_WithNullStream_ThrowsArgNullException()
+    {
+        Assert.Throws<ArgumentNullException>("stream", () => TypedResults.Stream(default(Stream)));
+    }
+
+    [Fact]
+    public void Stream_WithNullPipeReader_ThrowsArgNullException()
+    {
+        Assert.Throws<ArgumentNullException>("pipeReader", () => TypedResults.Stream(default(PipeReader)));
+    }
+
+    [Fact]
+    public void Stream_WithNullCallback_ThrowsArgNullException()
+    {
+        Assert.Throws<ArgumentNullException>("streamWriterCallback", () => TypedResults.Stream(default(Func<Stream, Task>)));
+    }
+
+    [Fact]
+    public void PhysicalFile_WithNullPath_ThrowsArgException()
+    {
+        Assert.Throws<ArgumentException>("path", () => TypedResults.PhysicalFile(default(string)));
+    }
+
+    [Fact]
+    public void PhysicalFile_WithEmptyPath_ThrowsArgException()
+    {
+        Assert.Throws<ArgumentException>("path", () => TypedResults.PhysicalFile(string.Empty));
+    }
+
+    [Fact]
+    public void VirtualFile_WithNullPath_ThrowsArgException()
+    {
+        Assert.Throws<ArgumentException>("path", () => TypedResults.VirtualFile(default(string)));
+    }
+
+    [Fact]
+    public void VirtualFile_WithEmptyPath_ThrowsArgException()
+    {
+        Assert.Throws<ArgumentException>("path", () => TypedResults.VirtualFile(string.Empty));
+    }
+
     [Theory]
     [MemberData(nameof(Stream_ResultHasCorrectValues_Data))]
     public void Stream_ResultHasCorrectValues(int overload, string contentType, string fileDownloadName, bool enableRangeProcessing, DateTimeOffset lastModified, EntityTagHeaderValue entityTag)
@@ -432,9 +544,15 @@ public class TypedResultsTests
     }
 
     [Fact]
-    public void Created_WithNullStringUri_ThrowsArgNullException()
+    public void Created_WithNullStringUri_ThrowsArgException()
     {
-        Assert.Throws<ArgumentNullException>("uri", () => TypedResults.Created(default(string)));
+        Assert.Throws<ArgumentException>("uri", () => TypedResults.Created(default(string)));
+    }
+
+    [Fact]
+    public void Created_WithEmptyStringUri_ThrowsArgException()
+    {
+        Assert.Throws<ArgumentException>("uri", () => TypedResults.Created(string.Empty));
     }
 
     [Fact]
@@ -443,6 +561,24 @@ public class TypedResultsTests
         Assert.Throws<ArgumentNullException>("uri", () => TypedResults.Created(default(Uri)));
     }
 
+    [Fact]
+    public void CreatedOfT_WithNullStringUri_ThrowsArgException()
+    {
+        Assert.Throws<ArgumentException>("uri", () => TypedResults.Created(default(string), default(object)));
+    }
+
+    [Fact]
+    public void CreatedOfT_WithEmptyStringUri_ThrowsArgException()
+    {
+        Assert.Throws<ArgumentException>("uri", () => TypedResults.Created(string.Empty, default(object)));
+    }
+
+    [Fact]
+    public void CreatedOfT_WithNullUri_ThrowsArgNullException()
+    {
+        Assert.Throws<ArgumentNullException>("uri", () => TypedResults.Created(default(Uri), default(object)));
+    }
+
     [Fact]
     public void CreatedAtRoute_WithRouteNameAndRouteValuesAndValue_ResultHasCorrectValues()
     {
@@ -550,6 +686,18 @@ public class TypedResultsTests
         Assert.Null(result.StatusCode);
     }
 
+    [Fact]
+    public void LocalRedirect_WithNullStringUrl_ThrowsArgException()
+    {
+        Assert.Throws<ArgumentException>("localUrl", () => TypedResults.LocalRedirect(default(string)));
+    }
+
+    [Fact]
+    public void LocalRedirect_WithEmptyStringUrl_ThrowsArgException()
+    {
+        Assert.Throws<ArgumentException>("localUrl", () => TypedResults.LocalRedirect(string.Empty));
+    }
+
     [Fact]
     public void LocalRedirect_WithUrl_ResultHasCorrectValues()
     {
@@ -677,6 +825,12 @@ public class TypedResultsTests
         Assert.Equal(StatusCodes.Status200OK, result.StatusCode);
     }
 
+    [Fact]
+    public void Problem_WithNullProblem_ThrowsArgNullException()
+    {
+        Assert.Throws<ArgumentNullException>("problemDetails", () => TypedResults.Problem(default(ProblemDetails)));
+    }
+
     [Fact]
     public void Problem_WithArgs_ResultHasCorrectValues()
     {
@@ -749,6 +903,12 @@ public class TypedResultsTests
         Assert.Equal(StatusCodes.Status400BadRequest, result.StatusCode);
     }
 
+    [Fact]
+    public void ValidationProblem_WithNullErrors_ThrowsArgNullException()
+    {
+        Assert.Throws<ArgumentNullException>("errors", () => TypedResults.ValidationProblem(default(IDictionary<string, string[]>)));
+    }
+
     [Fact]
     public void ValidationProblem_WithValidationProblemArg_ResultHasCorrectValues()
     {
@@ -775,6 +935,18 @@ public class TypedResultsTests
         Assert.Equal(extensions, result.ProblemDetails.Extensions);
     }
 
+    [Fact]
+    public void Redirect_WithNullStringUrl_ThrowsArgException()
+    {
+        Assert.Throws<ArgumentException>("url", () => TypedResults.Redirect(default(string)));
+    }
+
+    [Fact]
+    public void Redirect_WithEmptyStringUrl_ThrowsArgException()
+    {
+        Assert.Throws<ArgumentException>("url", () => TypedResults.Redirect(string.Empty));
+    }
+
     [Fact]
     public void Redirect_WithDefaults_ResultHasCorrectValues()
     {
diff --git a/src/Http/Http.Results/test/UnauthorizedResultTests.cs b/src/Http/Http.Results/test/UnauthorizedResultTests.cs
index 9f25870fea87e7561517e710fbe343a808a7886a..34b830fbca18c3f60d54cb34eb0107c5bb49e77f 100644
--- a/src/Http/Http.Results/test/UnauthorizedResultTests.cs
+++ b/src/Http/Http.Results/test/UnauthorizedResultTests.cs
@@ -34,6 +34,17 @@ public class UnauthorizedResultTests
         Assert.Equal(StatusCodes.Status401Unauthorized, httpContext.Response.StatusCode);
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new UnauthorizedHttpResult();
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
     private static IServiceCollection CreateServices()
     {
         var services = new ServiceCollection();
diff --git a/src/Http/Http.Results/test/UnprocessableEntityOfTResultTests.cs b/src/Http/Http.Results/test/UnprocessableEntityOfTResultTests.cs
index d5d3938d85a2fb2995aeac18a120d3e5498c0bac..9a2349a21fd1eed0755f8853cf486a8d315fa711 100644
--- a/src/Http/Http.Results/test/UnprocessableEntityOfTResultTests.cs
+++ b/src/Http/Http.Results/test/UnprocessableEntityOfTResultTests.cs
@@ -94,6 +94,24 @@ public class UnprocessableEntityOfTResultTests
         Assert.Single(producesResponseTypeMetadata.ContentTypes, "application/json");
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new UnprocessableEntity<object>(null);
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
+    [Fact]
+    public void PopulateMetadata_ThrowsArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<UnprocessableEntity<object>>(null));
+    }
+
     private static void PopulateMetadata<TResult>(EndpointMetadataContext context)
         where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(context);
 
diff --git a/src/Http/Http.Results/test/UnprocessableEntityResultTests.cs b/src/Http/Http.Results/test/UnprocessableEntityResultTests.cs
index 049d3bfab56fa07048404f62aa5c54c4983ba6f1..1f1592fdaa5bf64341e5e3526f547378247731b8 100644
--- a/src/Http/Http.Results/test/UnprocessableEntityResultTests.cs
+++ b/src/Http/Http.Results/test/UnprocessableEntityResultTests.cs
@@ -55,6 +55,24 @@ public class UnprocessableEntityResultTests
         Assert.Equal(StatusCodes.Status422UnprocessableEntity, producesResponseTypeMetadata.StatusCode);
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new UnprocessableEntity();
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
+    [Fact]
+    public void PopulateMetadata_ThrowsArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<UnprocessableEntity>(null));
+    }
+
     private static void PopulateMetadata<TResult>(EndpointMetadataContext context)
         where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(context);
 
diff --git a/src/Http/Http.Results/test/ValidationProblemResultTests.cs b/src/Http/Http.Results/test/ValidationProblemResultTests.cs
index e6b9455d43ef35eed451c04722b70e0c9b9cf77f..40c01b4419b794e118035de5393d39ffc8fa2273 100644
--- a/src/Http/Http.Results/test/ValidationProblemResultTests.cs
+++ b/src/Http/Http.Results/test/ValidationProblemResultTests.cs
@@ -74,6 +74,24 @@ public class ValidationProblemResultTests
         Assert.Single(producesResponseTypeMetadata.ContentTypes, "application/problem+json");
     }
 
+    [Fact]
+    public void ExecuteAsync_ThrowsArgumentNullException_WhenHttpContextIsNull()
+    {
+        // Arrange
+        var result = new ValidationProblem(new());
+        HttpContext httpContext = null;
+
+        // Act & Assert
+        Assert.ThrowsAsync<ArgumentNullException>("httpContext", () => result.ExecuteAsync(httpContext));
+    }
+
+    [Fact]
+    public void PopulateMetadata_ThrowsArgumentNullException_WhenContextIsNull()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<ValidationProblem>(null));
+    }
+
     private static void PopulateMetadata<TResult>(EndpointMetadataContext context)
         where TResult : IEndpointMetadataProvider => TResult.PopulateMetadata(context);
 
diff --git a/src/Http/Http.Results/tools/ResultsOfTGenerator/Program.cs b/src/Http/Http.Results/tools/ResultsOfTGenerator/Program.cs
index 033e1f00e4de0c027511335070afd0ca0d2c1307..1479e7d3fff5a7195995ed2d70215037fbb07383 100644
--- a/src/Http/Http.Results/tools/ResultsOfTGenerator/Program.cs
+++ b/src/Http/Http.Results/tools/ResultsOfTGenerator/Program.cs
@@ -14,7 +14,7 @@ public class Program
     {
         // By default we assume we're being run in the context of the <repo>/src/Http/Http.Results/src
         var pwd = Directory.GetCurrentDirectory();
-        var classTargetFilePath = Path.Combine(pwd, "ResultsOfT.cs");
+        var classTargetFilePath = Path.Combine(pwd, "ResultsOfT.Generated.cs");
         var testsTargetFilePath = Path.Combine(pwd, "..", "test", "ResultsOfTTests.Generated.cs");
 
         if (args.Length > 0)
@@ -80,7 +80,7 @@ public class Program
             writer.WriteLine("/// <remarks>");
             writer.WriteLine("/// An instance of this type cannot be created explicitly. Use the implicit cast operators to create an instance");
             writer.WriteLine("/// from an instance of one of the declared type arguments, e.g.");
-            writer.WriteLine("/// <code>Results&lt;OkObjectHttpResult, ProblemHttpResult&gt; result = Results.Ok();</code>");
+            writer.WriteLine("/// <code>Results&lt;Ok, BadRequest&gt; result = TypedResults.Ok();</code>");
             writer.WriteLine("/// </remarks>");
 
             // Type params docs
@@ -179,6 +179,8 @@ public class Program
             writer.WriteIndentedLine("/// <inheritdoc/>");
             writer.WriteIndentedLine("static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)");
             writer.WriteIndentedLine("{");
+            writer.WriteIndentedLine(2, "ArgumentNullException.ThrowIfNull(context);");
+            writer.WriteLine();
             for (int j = 1; j <= i; j++)
             {
                 writer.WriteIndentedLine(2, $"ResultsOfTHelper.PopulateMetadataIfTargetIsIEndpointMetadataProvider<TResult{j}>(context);");
@@ -257,9 +259,10 @@ public class Program
             GenerateTest_ExecuteResult_ExecutesAssignedResult(writer, i);
             GenerateTest_Throws_ArgumentNullException_WhenHttpContextIsNull(writer, i);
             GenerateTest_Throws_InvalidOperationException_WhenResultIsNull(writer, i);
-            Generate_AcceptsIResult_AsAnyTypeArg(writer, i);
-            Generate_AcceptsNestedResultsOfT_AsAnyTypeArg(writer, i);
-            Generate_PopulateMetadata_PopulatesMetadataFromTypeArgsThatImplementIEndpointMetadataProvider(writer, i);
+            GenerateTest_AcceptsIResult_AsAnyTypeArg(writer, i);
+            GenerateTest_AcceptsNestedResultsOfT_AsAnyTypeArg(writer, i);
+            GenerateTest_PopulateMetadata_PopulatesMetadataFromTypeArgsThatImplementIEndpointMetadataProvider(writer, i);
+            GenerateTest_PopulateMetadata_Throws_ArgumentNullException_WhenContextIsNull(writer, i);
         }
 
         Generate_ChecksumResultClass(writer);
@@ -587,15 +590,15 @@ public class Program
         writer.WriteLine();
     }
 
-    static void Generate_AcceptsIResult_AsAnyTypeArg(StreamWriter writer, int typeArgCount)
+    static void GenerateTest_AcceptsIResult_AsAnyTypeArg(StreamWriter writer, int typeArgCount)
     {
         for (int i = 1; i <= typeArgCount; i++)
         {
-            Generate_AcceptsIResult_AsNthTypeArg(writer, typeArgCount, i);
+            GenerateTest_AcceptsIResult_AsNthTypeArg(writer, typeArgCount, i);
         }
     }
 
-    static void Generate_AcceptsIResult_AsNthTypeArg(StreamWriter writer, int typeArgCount, int typeArgNumber)
+    static void GenerateTest_AcceptsIResult_AsNthTypeArg(StreamWriter writer, int typeArgCount, int typeArgNumber)
     {
         //[Theory]
         //[InlineData(1, typeof(ChecksumResult1))]
@@ -695,15 +698,15 @@ public class Program
         writer.WriteLine();
     }
 
-    static void Generate_AcceptsNestedResultsOfT_AsAnyTypeArg(StreamWriter writer, int typeArgCount)
+    static void GenerateTest_AcceptsNestedResultsOfT_AsAnyTypeArg(StreamWriter writer, int typeArgCount)
     {
         for (int i = 1; i <= typeArgCount; i++)
         {
-            Generate_AcceptsNestedResultsOfT_AsNthTypeArg(writer, typeArgCount, i);
+            GenerateTest_AcceptsNestedResultsOfT_AsNthTypeArg(writer, typeArgCount, i);
         }
     }
 
-    static void Generate_AcceptsNestedResultsOfT_AsNthTypeArg(StreamWriter writer, int typeArgCount, int typeArgNumber)
+    static void GenerateTest_AcceptsNestedResultsOfT_AsNthTypeArg(StreamWriter writer, int typeArgCount, int typeArgNumber)
     {
         //[Theory]
         //[InlineData(1, typeof(Results<ChecksumResult1, ChecksumResult2>))]
@@ -803,7 +806,7 @@ public class Program
         writer.WriteLine();
     }
 
-    static void Generate_PopulateMetadata_PopulatesMetadataFromTypeArgsThatImplementIEndpointMetadataProvider(StreamWriter writer, int typeArgNumber)
+    static void GenerateTest_PopulateMetadata_PopulatesMetadataFromTypeArgsThatImplementIEndpointMetadataProvider(StreamWriter writer, int typeArgNumber)
     {
         //[Fact]
         //public void ResultsOfTResult1TResult2_PopulateMetadata_PopulatesMetadataFromTypeArgsThatImplementIEndpointMetadataProvider()
@@ -877,6 +880,46 @@ public class Program
         writer.WriteLine();
     }
 
+    static void GenerateTest_PopulateMetadata_Throws_ArgumentNullException_WhenContextIsNull(StreamWriter writer, int typeArgNumber)
+    {
+        //[Fact]
+        //public void ResultsOfTResult1TResult2_PopulateMetadata_Throws_ArgumentNullException_WhenContextIsNull()
+        //{
+        //    // Act & Assert
+        //    Assert.Throws<ArgumentNullException>("context", () => PopulateMetadata<Results<ProvidesMetadataResult1, ProvidesMetadataResult2>>(null));
+        //}
+
+        // Attributes
+        writer.WriteIndentedLine("[Fact]");
+
+        // Start method
+        writer.WriteIndent(1, "public void ResultsOf");
+        for (int j = 1; j <= typeArgNumber; j++)
+        {
+            writer.Write($"TResult{j}");
+        }
+        writer.WriteLine("_PopulateMetadata_Throws_ArgumentNullException_WhenContextIsNull()");
+        writer.WriteIndentedLine("{");
+
+        // Act & Assert
+        writer.WriteIndentedLine(2, "// Act & Assert");
+        writer.WriteIndent(2, "Assert.Throws<ArgumentNullException>(\"context\", () => PopulateMetadata<Results<");
+        for (int j = 1; j <= typeArgNumber; j++)
+        {
+            writer.Write($"ProvidesMetadataResult{j}");
+
+            if (j != typeArgNumber)
+            {
+                writer.Write(", ");
+            }
+        }
+        writer.WriteLine(">>(null));");
+
+        // Close method
+        writer.WriteIndentedLine(1, "}");
+        writer.WriteLine();
+    }
+
     static void Generate_ChecksumResultClass(StreamWriter writer, int typeArgNumber = -1)
     {
         if (typeArgNumber <= 0)