本文将介绍c#–WebApi控制器没有找到控制器的动作的详细情况，特别是关于breedweb控制台文件未找到的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及

本文将介绍c# – WebApi控制器没有找到控制器的动作的详细情况，特别是关于breed web控制台文件未找到的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关于.Net Core WebApi控制器接收原始请求正文内容、.net – 单元测试api控制器的示例代码、angularjs – 带有null参数的$http.get没有访问Web API控制器、ASP.NET Core WebAPI控制器返回类型的最佳选项的知识。

• c# – WebApi控制器没有找到控制器的动作（breed web控制台文件未找到）
• .Net Core WebApi控制器接收原始请求正文内容
• .net – 单元测试api控制器的示例代码
• angularjs – 带有null参数的$http.get没有访问Web API控制器
• ASP.NET Core WebAPI控制器返回类型的最佳选项

c# – WebApi控制器没有找到控制器的动作（breed web控制台文件未找到）

namespace ControlTower.Controllers
{
    public class AirlinesController : ApiController
    {
        private static IEnumerable<Airline> MapAirlines()
        {
            return (Jetstream.AirlineObject.GetAirlines()).Select(x => x);
        }

        [HttpGet]
        public IEnumerable<Airline> GetAirlines()
        {
            return MapAirlines().AsEnumerable();
        }

        [HttpGet]
        public Airline GetAirlineByCode(string code)
        {
            return Jetstream.AirlineObject.GetAirline(code);
        }
    }
}

namespace ControlTower.Controllers
{
    public class ReviewsController : ApiController
    {
        private static IEnumerable<Review> MapReviews(int airline)
        {
            return (Jetstream.ReviewObject.GetReviews(airline)).Select(x => x);
        }

        [HttpGet]
        public IEnumerable<Review> GetReviews(int airline)
        {
            return MapReviews(airline).AsEnumerable();
        }

        [HttpGet]
        public Review GetReviewById(int review)
        {
            return Jetstream.ReviewObject.GetReview(review);
        }
    }
}

config.Routes.MapHttpRoute(
                name: "DefaultApi",routeTemplate: "api/{controller}/get/{code}",defaults: new { code = RouteParameter.Optional }
            );

.Net Core WebApi控制器接收原始请求正文内容

主要目标

在Asp.net Core控制器中，通过自定义格式化程序来映射自定义处理控制器中的“未知”内容。

简单案例

为了演示这个问题，我们用VS2017创建一个默认的Asp.net Core Web Api项目。

    
    [Route("api/[controller]")]
    [ApiController]
    public class ValuesController : ControllerBase{
        [HttpGet]
        public ActionResult<string> Get() {
            return "ok";
        }

        [HttpPost]
        [Route("PostX")]
        public ActionResult<string> Post([FromBody] string value)
        {
            return value;
        }
    }

Json请求

我们从最常见的json输入请求开始。

User-Agent: Fiddler
Host: localhost:5000
Content-Type: application/json
Content-Length: 16 

请求body：

{"123456"}

通过后台调试和fiddler抓包，我们可以看到请求输入和返回。

后台调试，查看请求输入结果

fiddler查看请求header

fiddler查看返回结果

注意！！

• 别忘了[FromBody],有时候会忘的。
• 后台action接收类型为string的时候，请求body只能是字符串，不能传json对象。我演示这个例子时，被这点坑了。如果接收对象是一个类的时候，才可以传json对象。

没有JSON

虽然传输json数据是最常用的，但有时候我们需要支持普通的文本或者二进制信息。我们将Content-Type改为
text/plain

User-Agent: Fiddler
Host: localhost:5000
Content-Type:text/plain
Content-Length: 16 

请求body：

{"123456"}

悲剧的事情来，报404！

不支持text/plain

事情到此就变得稍微复杂了一些，因为asp.netcore只处理它认识的类型，如json和formdata。默认情况下，原始数据不能直接映射到控制器参数。这是个小坑，不知你踩到过没有？仔细想想，这是有道理的。MVC具有特定内容类型的映射，如果您传递的数据不符合这些内容类型，则无法转换数据，因此它假定没有匹配的端点可以处理请求。
那么怎么支持原始的请求映射呢？

支持原始正文请求

不幸的是，ASP.NET Core不允许您仅通过方法参数以任何有意义的方式捕获“原始”数据。无论如何，您需要对其进行一些自定义处理Request.Body以获取原始数据，然后对其进行反序列化。

您可以捕获原始数据Request.Body并从中直接读取原始缓冲区。

最简单，最不易侵入，但不那么明显的方法是使用一个方法接受没有参数的 POST或PUT数据，然后从Request.Body以下位置读取原始数据：

读取字符串缓冲区

        [HttpPost]
        [Route("PostText")]
        public async Task<string> PostText()
        {
            using (StreamReader reader = new StreamReader(Request.Body, Encoding.UTF8))
            {
                return await reader.ReadToEndAsync();
            }
        }

这适用于一下Http和文本

User-Agent: Fiddler
Host: localhost:5000
Content-Type: text/plain
Content-Length: 6

要读取二进制数据，你可以使用以下内容：

读取byte缓冲区

        [HttpPost]
        [Route("PostBinary")]
        public async Task<byte[]> PostBinary()
        {
            using (var ms = new MemoryStream(2048))
            {
                await Request.Body.CopyToAsync(ms);
                return ms.ToArray();  // returns base64 encoded string JSON result
            }
        }

查看执行结果

接收文本内容

接收二进制数据

HttpRequest静态扩展

如果你为了方便，写了很多HttpRequest的扩展，接收参数时，可以看起来更简洁一些。

public static class HttpRequestExtension
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="httpRequest"></param>
        /// <param name="encoding"></param>
        /// <returns></returns>
        public static async Task<string> GetRawBodyStringFormater(this HttpRequest httpRequest, Encoding encoding)
        {
            if (encoding == null)
            {
                encoding = Encoding.UTF8;
            }

            using (StreamReader reader = new StreamReader(httpRequest.Body, encoding))
            {
                return await reader.ReadToEndAsync();
            }
        }
        /// <summary>
        /// 二进制
        /// </summary>
        /// <param name="httpRequest"></param>
        /// <param name="encoding"></param>
        /// <returns></returns>
        public static async Task<byte[]> GetRawBodyBinaryFormater(this HttpRequest httpRequest, Encoding encoding)
        {
            if (encoding == null)
            {
                encoding = Encoding.UTF8;
            }

            using (StreamReader reader = new StreamReader(httpRequest.Body, encoding))
            {
                using (var ms = new MemoryStream(2048))
                {
                    await httpRequest.Body.CopyToAsync(ms);
                    return ms.ToArray();  // returns base64 encoded string JSON result
                }
            }
        }
    }

        [HttpPost]
        [Route("PostTextX")]
        public async Task<string> PostTextX()
        {
            return await Request.GetRawBodyStringAsyn();
        }
        /// <summary>
        /// 接收
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [Route("PostBinaryX")]
        public async Task<byte[]> PostBinaryX()
        {
            return await Request.GetRawBodyBinaryAsyn();
        }

自动转换文本和二进制值

上面虽然解决了原始参数转换问题，但不够友好。如果你打算像原生MVC那样自动映射参数的话，你需要做一些自定义格式化适配。

创建一个Asp.net MVC InputFormatter

ASP.NET Core使用一种干净且更通用的方式来处理内容的自定义格式InputFormatter。输入格式化程序挂钩到请求处理管道，让您查看特定类型的内容以确定是否要处理它。然后，您可以阅读请求正文并对入站内容执行自己的反序列化。
InputFormatter有几个要求

• 您需要使用[FromBody]去获取
• 您必须能够查看请求并确定是否以及如何处理内容。

在这个例子中，对于“原始内容”，我想查看具有以下类型的请求：

• text/plain(文本)
• appliaction/octet-stream(byte[])
  没有内容类型(string）

要创建格式化程序，你可以实现IInputFormatter或者从InputFormatter继承。

    public class RawRequestBodyFormatter : IInputFormatter
    {
        public RawRequestBodyFormatter()
        {

        }

        public bool CanRead(InputFormatterContext context)
        {
            if (context == null) throw new ArgumentNullException("argument is Null");
            var contentType = context.HttpContext.Request.ContentType;
            if (string.IsNullOrEmpty(contentType) || contentType == "text/plain" || contentType == "application/octet-stream")
                return true;
            return false;
        }

        public async Task<InputFormatterResult> ReadAsync(InputFormatterContext context)
        {
            var request = context.HttpContext.Request;
            var contentType = context.HttpContext.Request.ContentType;
            if (string.IsNullOrEmpty(contentType) || contentType.ToLower() == "text/plain")
            {
                using (StreamReader reader = new StreamReader(request.Body, Encoding.UTF8))
                {
                    var content = await reader.ReadToEndAsync();
                    return await InputFormatterResult.SuccessAsync(content);
                }
            }
            if (contentType == "application/octet-stream")
            {
                using (StreamReader reader = new StreamReader(request.Body, Encoding.UTF8))
                {
                    using (var ms = new MemoryStream(2048))
                    {
                        await request.Body.CopyToAsync(ms);
                        var content = ms.ToArray();

                        return await InputFormatterResult.SuccessAsync(content);
                    }
                }
            }
            return await InputFormatterResult.FailureAsync();
        }
    }

格式化程序用于CanRead()检查对内容类型的请求以支持，然后将ReadRequestBodyAsync()内容读取和反序列化为应在控制器方法的参数中返回的结果类型。

InputFormatter必须在ConfigureServices()启动代码中注册MVC ：

 public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc(o=>o.InputFormatters.Insert(0,new RawRequestBodyFormatter())).SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
        }

接受原始输入

        [HttpPost]
        [Route("PostTextPlus")]
        public string PostTextPlus([FromBody] string value)
        {
            return value;
        }

然后你就可以发送post请求，像这样：

User-Agent: Fiddler
Host: localhost:5000
Content-Length: 6

或者

User-Agent: Fiddler
Host: localhost:5000
Content-Type:text/plain
Content-Length: 6

请注意，您可以使用内容类型调用相同的控制器方法application/json并传递JSON字符串，这也将起作用。在RawRequestBodyFormatter 简单地增加它支持的附加内容类型的支持。

二进制数据

        [HttpPost]
        [Route("PostBinaryPlus")]
        public byte[] PostBinaryPlus([FromBody] byte[] value)
        {
            return value;
        }

请求内容如下：

User-Agent: Fiddler
Host: localhost:5000
Content-Length: 6
Content-Type: application/octet-stream

源代码

示例代码已上传到 CsharpFanDemo

参考链接

本文包含翻译和自己实践。主要思路和代码来源于以下链接：
Accepting Raw Request Body Content in ASP.NET Core API Controllers

.net – 单元测试api控制器的示例代码

public class FooController : ApiController
{
    private IRepository<Foo> _fooRepository;

    public FooController(IRepository<Foo> fooRepository)
    {
        _fooRepository = fooRepository;
    }

    public HttpResponseMessage Post(Foo value)
    {
        HttpResponseMessage response;

        Foo returnValue = _fooRepository.Save(value);
        response = Request.CreateResponse<Foo>(HttpStatusCode.Created,returnValue,this.Configuration);
        response.Headers.Location = "http://server.com/foos/1";

        return response;
    }
}

Foo dto = new Foo() { 
            Id = -1,Name = "Hiya" 
        };

        IRepository<Foo> fooRepository = MockRepository.GenerateMock<IRepository<Foo>>();
        fooRepository.Stub(x => x.Save(dto)).Return(new Foo() { Id = 1,Name = "Hiya" });

        FooController controller = new FooController(fooRepository);

        controller.Request = new HttpRequestMessage(HttpMethod.Post,"http://server.com/foos");
        //The line below was needed in WebApi RC as null config caused an issue after upgrade from Beta
        controller.Configuration = new System.Web.Http.HttpConfiguration(new System.Web.Http.HttpRouteCollection());

        var result = controller.Post(dto);

        Assert.AreEqual(HttpStatusCode.Created,result.StatusCode,"Expecting a 201 Message");

        var resultFoo = result.Content.ReadAsAsync<Foo>().Result;
        Assert.IsNotNull(resultFoo,"Response was empty!");
        Assert.AreEqual(1,resultFoo.Id,"Foo id should be set");

angularjs – 带有null参数的$http.get没有访问Web API控制器

$http.get(BasePath + '/api/documentapi/GetDocuments/',{
                                    params: {
                                        PrimaryID: ID1,AlternateID: ID2,}
                                }).then( ...

public DocumentsDto[] GetDocuments(decimal? PrimaryID,decimal? AlternateID)
    { ...

http://BaseServerPath/api/documentapi/GetDocuments/?PrimaryID=1688

http://BaseServerPath/api/documentapi/GetDocuments/?AlternateID=154

http://BaseServerPath/api/documentapi/GetDocuments/?PrimaryID=1688&AlternateID=null

public string GetFindBooks(string author="",string title="",string isbn="",string  somethingelse="",DateTime? date= null) 
{
    // ...
}

public DocumentsDto[] GetDocuments(decimal? PrimaryID = null,decimal? AlternateID = null)
{ ...

ASP.NET Core WebAPI控制器返回类型的最佳选项

前言

从.NET Core 2.1版开始，到目前为止，控制器操作可以返回三种类型的WebApi响应。这三种类型都有自己的优点和缺点，但都缺乏满足REST和高可测性的选项。 

ASP.NET Core中可用的响应类型包括最近发布的2.2版本

• 具体类型的结果
• IActionResult 
• 的ActionResult <T>

最后一个reult选项  ActionResult <T>是在.NET Core 2.1中引入的。我将使用一个简单的例子来比较使用这三个控制器动作响应类型选项的优缺点。

文章内容

返回HTTP状态

这是您在WebAPI应用程序开发过程中必须要具备的。虽然可以遵循REST,但是任何程序功能都是由业务需求驱动的。如果由于控制器操作而返回特定类型，您可能偶尔发现的一件事肯定会返回自定义HTTP状态代码。

让我们看看具有特定类型返回的简单操作，并让它们注意比较。

具体类型

[HttpGet("{id}")]
        public IEnumerable<string> GetById(int id)
        {
            if (id>0)
            {
                return new List<string>()
                {
                    "Value1","Value2","Value3"
                };
            }
            return null;
        }

我们有了上面的简单单吗，如果ID参数大于0，并返回字符串列表，反则返回null。转换成HTTP，对于任何返回的数据，我们将有 200 OK 状态吗响应，以下是我使用PostMan的测试结果图，请参考。

 如果没有数据，我们将会有一个204 No Content 响应。 对于大多数客户来说，这是非常满意的，但是假设我们需要返回另一个状态代码，例如，小于0的任何值，我们直接希望告诉客户发送的数据无效，理想情况下，我们将会返回404 BadRequest状态代码。

现在这是特定类型选项问题，由于我们的方法，我们不能立即返回400 BadRequest状态代码，如果我们决定抛出一个异常会导致500 ServerError的响应，这是错误的，因为无效数据基本上是客户端错误并且属于4xx响应代码列表。

执行此操作的方法是显示设定响应状态码并返回空值，这样就可以保留未同步的两个操作间隙，因为你必须要处理状态并返回数据。

[HttpGet("{id}")]
        public IEnumerable<string> GetById(int id)
        {
            if (id > 0)
            {
                return new List<string>()
                {
                    "Value1","Value2","Value3"
                };
            }
            else if (id < 0)
                Response.StatusCode = 400;
            return null;
        }

处理HTTP POST和HTTP PATCH / PUT请求时遇到的问题更多，而不是200 OK，除了之前的400 BadRequest之外，您可能还必须使用201 Created of 202 Accepted HTTP状态代码进行响应，这将是模型验证的情况。使用不同的状态代码并不是那么直接，并且您有多条线负责正确的响应，这与其他两种返回类型不同。

IActionResult

让我们看看我们如何通过使用IActionResult作为控制器动作的返回类型来解决这个问题

[HttpGet("{id}")]
        public IActionResult GetById(int id)
        {
            if (id > 0)
            {
                return Ok(new List<String>()
                {
                    "Value1",
                    "Value2",
                    "Value3",
                });
            }
            else if (id < 0)
            {
                return BadRequest();
            }
            return NoContent();
        }

现在我们可以自由使用我们认为适合的状态代码，以告知客户我们或我们没有任何限制地处理他的请求。使用IAction结果显然比返回特定类型实例更先进，让.NET决定什么是状态代码。

ActionResult<T>

关于状态代码，IActionResult和ActionResult <T>返回类型同样适用在从方法返回结果时直接设置状态代码方面会产生很大差异

但是，还有其他方面，ActionResult <T>比IActionResult更高级，更适合从控制器操作方法返回响应。

[HttpGet("{id}")]
        public ActionResult<IEnumerable<string>> GetById(int id)
        {
            if (id > 0)
            {
                return Ok(new List<String>()
                {
                    "Value1",
                    "Value2",
                    "Value3",
                });
            }
            else if (id < 0)
            {
                return BadRequest();
            }
            return NoContent();
        }

您已经了解了ASP.NET MVC Core WebAPI项目中控制器操作的不同响应类型的一些优缺点。很明显IActionResult和ActionResult <T>是比返回特定类型更好的选择，虽然您可能会发现在控制器操作中返回特定类型更为舒适，但您可能会使单元测试无法正确覆盖您的代码，因此将来可能会打开潜在的危险。

总结

具体类型

如果在执行动作期间没有已知的防范条件，则返回特定类型就足够了。上述操作不接受任何参数，因此不需要参数约束验证。

IActionResult类型

 当一个动作中有多个ActionResult返回类型时，IActionResult返回类型是合适的。这些类型代表各种HTTP状态代码。属于此类别的一些常见返回类型是BadRequestResult（400），NotFoundResult（404）和OkObjectResult（200）。

ActionResult <T>类型

 大多数操作都有特定的返回类型。在操作执行期间可能发生意外情况，在这种情况下不返回特定类型。例如，操作的输入参数可能无法通过模型验证。在这种情况下，通常返回适当的ActionResult类型而不是特定类型。

我们今天的关于c# – WebApi控制器没有找到控制器的动作和breed web控制台文件未找到的分享已经告一段落，感谢您的关注，如果您想了解更多关于.Net Core WebApi控制器接收原始请求正文内容、.net – 单元测试api控制器的示例代码、angularjs – 带有null参数的$http.get没有访问Web API控制器、ASP.NET Core WebAPI控制器返回类型的最佳选项的相关信息，请在本站查询。