Convert from Httpresponsemessage to Iactionresult in .Net Core

Convert from HttpResponseMessage to IActionResult in .NET Core

You can return using hardset status codes like Ok(); or BadRequest();

Or return using a dynamic one using

StatusCode(<Your status code number>,<Optional return object>);

This is using Microsoft.AspNetCore.Mvc

Below is this.StatusCode spelled out a little more:

/* "this" comes from your class being a subclass of Microsoft.AspNetCore.Mvc.ControllerBase */
StatusCodeResult scr = this.StatusCode(200);
/* OR */
Object myObject = new Object();
ObjectResult ores = this.StatusCode(200, myObject);
return scr; /* or return ores;*/

Correct way to return HttpResponseMessage as IActionResult in .Net Core 2.2

public class HttpResponseMessageResult : IActionResult
{
    private readonly HttpResponseMessage _responseMessage;

    public HttpResponseMessageResult(HttpResponseMessage responseMessage)
    {
        _responseMessage = responseMessage; // could add throw if null
    }

    public async Task ExecuteResultAsync(ActionContext context)
    {
        var response = context.HttpContext.Response;


        if (_responseMessage == null)
        {
            var message = "Response message cannot be null";

            throw new InvalidOperationException(message);
        }

        using (_responseMessage)
        {
            response.StatusCode = (int)_responseMessage.StatusCode;

            var responseFeature = context.HttpContext.Features.Get<IHttpResponseFeature>();
            if (responseFeature != null)
            {
                responseFeature.ReasonPhrase = _responseMessage.ReasonPhrase;
            }

            var responseHeaders = _responseMessage.Headers;

            // Ignore the Transfer-Encoding header if it is just "chunked".
            // We let the host decide about whether the response should be chunked or not.
            if (responseHeaders.TransferEncodingChunked == true &&
                responseHeaders.TransferEncoding.Count == 1)
            {
                responseHeaders.TransferEncoding.Clear();
            }

            foreach (var header in responseHeaders)
            {
                response.Headers.Append(header.Key, header.Value.ToArray());
            }

            if (_responseMessage.Content != null)
            {
                var contentHeaders = _responseMessage.Content.Headers;

                // Copy the response content headers only after ensuring they are complete.
                // We ask for Content-Length first because HttpContent lazily computes this
                // and only afterwards writes the value into the content headers.
                var unused = contentHeaders.ContentLength;

                foreach (var header in contentHeaders)
                {
                    response.Headers.Append(header.Key, header.Value.ToArray());
                }

                await _responseMessage.Content.CopyToAsync(response.Body);
            }
        }
    }

Is there any in-built function/method to return, IActionResult/ActionResult instead of HttpResponseMessage in .Net Core 3.1

Since you aren’t doing anything fancy there, you can translate your return object directly into corresponding action results here. In your case, you want a JsonResult and a FileResult with a custom response header:

[HttpGet]
[Route("GetTemplate")]
public async Task<HttpResponseMessage> GetTemplate(string id)
{
    var userAgent = this.Request.Headers.UserAgent;
    bool IsWindows = !userAgent.ToString().ToLower().Contains("apple");

    var template = await _templateService.GetTemplateContent(id);
    if (IsWindows)
    {
        return Json(template);
    }
    else
    {
        Response.Headers.Add("x-filename", template.Name);
        return File(template.ContentBytes, "application/octet-stream", template.Name);
    }
}

There are a lot similar utility methods on the Controller and ControllerBase type that help you create a variety of different response messages. For most use cases, there should be a built-in way to produce the response.

How Can convert System.Net.Http.HttpResponseMessage to System.Web.Mvc.ActionResult

I suggest you to use IHttpActionResult as action result which are introduced in Web API 2.
You can convert HttpResponseMessage to IHttpActionResult using the method ResponseMessage
from ApiController. so , your controller should inherit the ApiController.

My solution :

 public class TrainController : ApiController
{
    public IHttpActionResult SomeAction()
    {
        HttpResponseMessage responseMsg =
            new 
            HttpResponseMessage(HttpStatusCode.RedirectMethod);

        /*responseMsg = your implementation*/

        IHttpActionResult response = this.ResponseMessage(responseMsg);
        return response;
    }
}

Easiest way to convert HttpResponseMessage to HttpActionResult outside of a controller

the MSDN page will help you: https://docs.microsoft.com/en-us/aspnet/web-api/overview/error-handling/web-api-global-error-handling

you need a global error handler. here is core code, you will find details in MSDN page.

class OopsExceptionHandler : ExceptionHandler
{
    public override void HandleCore(ExceptionHandlerContext context)
    {
        context.Result = new TextPlainErrorResult
        {
            Request = context.ExceptionContext.Request,
            Content = "Oops! Sorry! Something went wrong." +
                      "Please contact support@contoso.com so we can try to fix it."
        };
    }

    private class TextPlainErrorResult : IHttpActionResult
    {
        public HttpRequestMessage Request { get; set; }

        public string Content { get; set; }

        public Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            HttpResponseMessage response = 
                             new HttpResponseMessage(HttpStatusCode.InternalServerError);
            response.Content = new StringContent(Content);
            response.RequestMessage = Request;
            return Task.FromResult(response);
        }
    }
}

BTW, you should mention MVC version:

1. IHttpActionResult is replaced with IActionResult in ASP.NET Core 2:
2. ExceptionHandlerContext is in System.Web.Http, no longer exist too.
   here is details: https://docs.microsoft.com/en-us/aspnet/core/migration/webapi?view=aspnetcore-2.1#migrate-models-and-controllers

.Net Core returning an int in HttpResponseMessage

.net-core no longer returns HttpResponseMessage.

Controller has helper methods that allow you to return specific IActionResult results/responses..

like

public IActionResult MyControllerAction() {
    //...

    return Ok(100);
}

which will return a HTTP 200 response with 100 in the body of the response

Asp.net Core 3.1 Web Api return custom error message from IActionResult

To do this, you can create a Custom Error class that implements the IActionResult interface as follows:

 public class CustomError : IActionResult
{
    private readonly HttpStatusCode _status;
    private readonly string _errorMessage;

    public CustomError(HttpStatusCode status, string errorMessage)
    {
        _status = status;
        _errorMessage = errorMessage;
    }
    public async Task ExecuteResultAsync(ActionContext context)
    {
        var objectResult = new ObjectResult(new
        {
            errorMessage = _errorMessage
        })
        {
            StatusCode = (int)_status,

        };

      context.HttpContext.Features.Get<IHttpResponseFeature>().ReasonPhrase = _errorMessage;
      
      await objectResult.ExecuteResultAsync(context);

    }
}

And use the following form :

[HttpGet]
public IActionResult GetEmployee()
{
   return new CustomError(HttpStatusCode.NotFound, "The employee was not found");
}

---

Related Topics