Add TypedResults static factory class for creating typed IResult objects (#41161)

- Use the `HttpResult` suffix on `IResult` types except for where the short name has recognized value, e.g. those types that implement `IEndpointMetadataProvider` and will be used in conjunction with `Results<T1, TN>`, e.g. `Results<Ok<Todo>, NotFound>`
- Add `TypedResults.xxx` factory class
- Added `HttpResults.ValidationProblem` type that represents 400 responses with validation errors (equiv to `BadRequest<HttpValidationProblemDetails>`
- Moved `Results<TResult1, TResultN>` types into the `Microsoft.AspNetCore.Http.HttpResults` namespace to match where the other results types are
- Changed `Results.xxx` methods to call through to `TypedResults.xxx` methods
- Explicitly implemented `IEndpointMetadataProvider` on following `IResult` types:
  - `Accepted`
  - `Accepted<TValue>`
  - `AcceptedAtRoute`
  - `AcceptedAtRoute<TValue>` 
  - `BadRequest`
  - `BadRequest<TValue>`
  - `Conflict`
  - `Conflict<TValue>`
  - `Created`
  - `Created<TValue>`
  - `CreatedAtRoute`
  - `CreatedAtRoute<TValue>`
  - `NoContent`
  - `NotFound`
  - `NotFound<TValue>`
  - `Ok`
  - `Ok<TValue>`
  - `UnprocessableEntity`
  - `UnprocessableEntity<TValue>`
- Order `using` statements before `namespace` declarations
- Added tests for `Microsoft.AspNetCore.Http.Results` and `Microsoft.AspNetCore.Http.TypedResults`

Fixes #41009

Co-authored-by: Bruno Lins de Oliveira <brolivei@microsoft.com>

Author: DamianEdwards

src/Http/Http.Results/src/Accepted.cs

@@ -0,0 +1,82 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.AspNetCore.Http.Metadata;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.AspNetCore.Http.HttpResults;
+
+/// <summary>
+/// An <see cref="IResult"/> that on execution will write an object to the response
+/// with status code Accepted (202) and Location header.
+/// Targets a registered route.
+/// </summary>
+public sealed class Accepted : IResult, IEndpointMetadataProvider
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Accepted"/> class with the values
+    /// provided.
+    /// </summary>
+    /// <param name="location">The location at which the status of requested content can be monitored.</param>
+    internal Accepted(string? location)
+    {
+        Location = location;
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Accepted"/> class with the values
+    /// provided.
+    /// </summary>
+    /// <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;
+        }
+        else
+        {
+            Location = locationUri.GetComponents(UriComponents.SerializationInfoString, UriFormat.UriEscaped);
+        }
+    }
+
+    /// <summary>
+    /// Gets the HTTP status code: <see cref="StatusCodes.Status202Accepted"/>
+    /// </summary>
+    public int StatusCode => StatusCodes.Status202Accepted;
+
+    /// <summary>
+    /// Gets the location at which the status of the requested content can be monitored.
+    /// </summary>
+    public string? Location { get; }
+
+    /// <inheritdoc/>
+    public Task ExecuteAsync(HttpContext 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");
+
+        if (!string.IsNullOrEmpty(Location))
+        {
+            httpContext.Response.Headers.Location = Location;
+        }
+
+        HttpResultsHelper.Log.WritingResultAsStatusCode(logger, StatusCode);
+        httpContext.Response.StatusCode = StatusCode;
+
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc/>
+    static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
+    {
+        context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(StatusCodes.Status202Accepted));
+    }
+}

src/Http/Http.Results/src/AcceptedAtRoute.cs

@@ -0,0 +1,89 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.AspNetCore.Http.Metadata;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.AspNetCore.Http.HttpResults;
+
+/// <summary>
+/// An <see cref="IResult"/> that on execution will write an object to the response
+/// with status code Accepted (202) and Location header.
+/// Targets a registered route.
+/// </summary>
+public sealed class AcceptedAtRoute : IResult, IEndpointMetadataProvider
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AcceptedAtRoute"/> class with the values
+    /// provided.
+    /// </summary>
+    /// <param name="routeValues">The route data to use for generating the URL.</param>
+    internal AcceptedAtRoute(object? routeValues)
+        : this(routeName: null, routeValues: routeValues)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AcceptedAtRoute"/> class with the values
+    /// provided.
+    /// </summary>
+    /// <param name="routeName">The name of the route to use for generating the URL.</param>
+    /// <param name="routeValues">The route data to use for generating the URL.</param>
+    internal AcceptedAtRoute(
+        string? routeName,
+        object? routeValues)
+    {
+        RouteName = routeName;
+        RouteValues = new RouteValueDictionary(routeValues);
+    }
+
+    /// <summary>
+    /// Gets the name of the route to use for generating the URL.
+    /// </summary>
+    public string? RouteName { get; }
+
+    /// <summary>
+    /// Gets the route data to use for generating the URL.
+    /// </summary>
+    public RouteValueDictionary RouteValues { get; }
+
+    /// <summary>
+    /// Gets the HTTP status code: <see cref="StatusCodes.Status202Accepted"/>
+    /// </summary>
+    public int StatusCode => StatusCodes.Status202Accepted;
+
+    /// <inheritdoc/>
+    public Task ExecuteAsync(HttpContext httpContext)
+    {
+        var linkGenerator = httpContext.RequestServices.GetRequiredService<LinkGenerator>();
+        var url = linkGenerator.GetUriByAddress(
+            httpContext,
+            RouteName,
+            RouteValues,
+            fragment: FragmentString.Empty);
+
+        if (string.IsNullOrEmpty(url))
+        {
+            throw new InvalidOperationException("No route matches the supplied values.");
+        }
+
+        // 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.AcceptedAtRouteResult");
+
+        httpContext.Response.Headers.Location = url;
+
+        HttpResultsHelper.Log.WritingResultAsStatusCode(logger, StatusCode);
+        httpContext.Response.StatusCode = StatusCode;
+
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc/>
+    static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
+    {
+        context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(StatusCodes.Status202Accepted));
+    }
+}

…Results/src/AcceptedAtRouteHttpResult.cs …p/Http.Results/src/AcceptedAtRouteOfT.cssrc/Http/Http.Results/src/AcceptedAtRouteHttpResult.cs renamed to src/Http/Http.Results/src/AcceptedAtRouteOfT.cs src/Http/Http.Results/src/AcceptedAtRouteHttpResult.cs renamed to src/Http/Http.Results/src/AcceptedAtRouteOfT.cs

@@ -1,42 +1,43 @@
 // 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;
-
-using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http.Metadata;
 using Microsoft.AspNetCore.Routing;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
+namespace Microsoft.AspNetCore.Http.HttpResults;
+
 /// <summary>
 /// An <see cref="IResult"/> that on execution will write an object to the response
 /// with status code Accepted (202) and Location header.
 /// Targets a registered route.
 /// </summary>
-public sealed class AcceptedAtRouteHttpResult : IResult
+/// <typeparam name="TValue">The type of object that will be JSON serialized to the response body.</typeparam>
+public sealed class AcceptedAtRoute<TValue> : IResult, IEndpointMetadataProvider
 {
     /// <summary>
-    /// Initializes a new instance of the <see cref="AcceptedAtRouteHttpResult"/> class with the values
+    /// Initializes a new instance of the <see cref="AcceptedAtRoute"/> class with the values
     /// provided.
     /// </summary>
     /// <param name="routeValues">The route data to use for generating the URL.</param>
     /// <param name="value">The value to format in the entity body.</param>
-    internal AcceptedAtRouteHttpResult(object? routeValues, object? value)
+    internal AcceptedAtRoute(object? routeValues, TValue? value)
         : this(routeName: null, routeValues: routeValues, value: value)
     {
     }
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="AcceptedAtRouteHttpResult"/> class with the values
+    /// Initializes a new instance of the <see cref="AcceptedAtRoute"/> class with the values
     /// provided.
     /// </summary>
     /// <param name="routeName">The name of the route to use for generating the URL.</param>
     /// <param name="routeValues">The route data to use for generating the URL.</param>
     /// <param name="value">The value to format in the entity body.</param>
-    internal AcceptedAtRouteHttpResult(
+    internal AcceptedAtRoute(
         string? routeName,
         object? routeValues,
-        object? value)
+        TValue? value)
     {
         Value = value;
         RouteName = routeName;
@@ -47,7 +48,7 @@ internal AcceptedAtRouteHttpResult(
     /// <summary>
     /// Gets the object result.
     /// </summary>
-    public object? Value { get; }
+    public TValue? Value { get; }
 
     /// <summary>
     /// Gets the name of the route to use for generating the URL.
@@ -60,7 +61,7 @@ internal AcceptedAtRouteHttpResult(
     public RouteValueDictionary RouteValues { get; }
 
     /// <summary>
-    /// Gets the HTTP status code.
+    /// Gets the HTTP status code: <see cref="StatusCodes.Status202Accepted"/>
     /// </summary>
     public int StatusCode => StatusCodes.Status202Accepted;
 
@@ -84,6 +85,16 @@ public Task ExecuteAsync(HttpContext httpContext)
         var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Http.Result.AcceptedAtRouteResult");
 
         httpContext.Response.Headers.Location = url;
-        return HttpResultsHelper.WriteResultAsJsonAsync(httpContext, logger, Value, StatusCode);
+
+        HttpResultsHelper.Log.WritingResultAsStatusCode(logger, StatusCode);
+        httpContext.Response.StatusCode = StatusCode;
+
+        return HttpResultsHelper.WriteResultAsJsonAsync(httpContext, logger, Value);
+    }
+
+    /// <inheritdoc/>
+    static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
+    {
+        context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(typeof(TValue), StatusCodes.Status202Accepted, "application/json"));
     }
 }

…p/Http.Results/src/AcceptedHttpResult.cs src/Http/Http.Results/src/AcceptedOfT.cssrc/Http/Http.Results/src/AcceptedHttpResult.cs renamed to src/Http/Http.Results/src/AcceptedOfT.cs src/Http/Http.Results/src/AcceptedHttpResult.cs renamed to src/Http/Http.Results/src/AcceptedOfT.cs

@@ -1,39 +1,39 @@
 // 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;
-
-using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http.Metadata;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
+namespace Microsoft.AspNetCore.Http.HttpResults;
+
 /// <summary>
 /// An <see cref="IResult"/> that on execution will write an object to the response
 /// with status code Accepted (202) and Location header.
 /// Targets a registered route.
 /// </summary>
-public sealed class AcceptedHttpResult : IResult
+public sealed class Accepted<TValue> : IResult, IEndpointMetadataProvider
 {
     /// <summary>
-    /// Initializes a new instance of the <see cref="AcceptedHttpResult"/> class with the values
+    /// Initializes a new instance of the <see cref="Accepted"/> class with the values
     /// provided.
     /// </summary>
     /// <param name="location">The location at which the status of requested content can be monitored.</param>
     /// <param name="value">The value to format in the entity body.</param>
-    internal AcceptedHttpResult(string? location, object? value)
+    internal Accepted(string? location, TValue? value)
     {
         Value = value;
         Location = location;
         HttpResultsHelper.ApplyProblemDetailsDefaultsIfNeeded(Value, StatusCode);
     }
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="AcceptedHttpResult"/> class with the values
+    /// Initializes a new instance of the <see cref="Accepted"/> class with the values
     /// provided.
     /// </summary>
     /// <param name="locationUri">The location at which the status of requested content can be monitored.</param>
     /// <param name="value">The value to format in the entity body.</param>
-    internal AcceptedHttpResult(Uri locationUri, object? value)
+    internal Accepted(Uri locationUri, TValue? value)
     {
         Value = value;
         HttpResultsHelper.ApplyProblemDetailsDefaultsIfNeeded(Value, StatusCode);
@@ -56,10 +56,10 @@ internal AcceptedHttpResult(Uri locationUri, object? value)
     /// <summary>
     /// Gets the object result.
     /// </summary>
-    public object? Value { get; }
+    public TValue? Value { get; }
 
     /// <summary>
-    /// Gets the HTTP status code.
+    /// Gets the HTTP status code: <see cref="StatusCodes.Status202Accepted"/>
     /// </summary>
     public int StatusCode => StatusCodes.Status202Accepted;
 
@@ -79,10 +79,19 @@ public Task ExecuteAsync(HttpContext 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");
+
+        HttpResultsHelper.Log.WritingResultAsStatusCode(logger, StatusCode);
+        httpContext.Response.StatusCode = StatusCode;
+
         return HttpResultsHelper.WriteResultAsJsonAsync(
                 httpContext,
                 logger,
-                Value,
-                StatusCode);
+                Value);
+    }
+
+    /// <inheritdoc/>
+    static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
+    {
+        context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(typeof(TValue), StatusCodes.Status202Accepted, "application/json"));
     }
 }

src/Http/Http.Results/src/BadRequest.cs

@@ -0,0 +1,47 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.AspNetCore.Http.Metadata;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.AspNetCore.Http.HttpResults;
+
+/// <summary>
+/// An <see cref="IResult"/> that on execution will write an object to the response
+/// with Bad Request (400) status code.
+/// </summary>
+public sealed class BadRequest : IResult, IEndpointMetadataProvider
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="BadRequest"/> class with the values
+    /// provided.
+    /// </summary>
+    internal BadRequest()
+    {
+    }
+
+    /// <summary>
+    /// Gets the HTTP status code: <see cref="StatusCodes.Status400BadRequest"/>
+    /// </summary>
+    public int StatusCode => StatusCodes.Status400BadRequest;
+
+    /// <inheritdoc/>
+    public Task ExecuteAsync(HttpContext 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");
+
+        HttpResultsHelper.Log.WritingResultAsStatusCode(logger, StatusCode);
+        httpContext.Response.StatusCode = StatusCode;
+
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc/>
+    static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context)
+    {
+        context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(StatusCodes.Status400BadRequest));
+    }
+}