Asp.net mvc 迁移到WebApi 2.2 RC并获得响应状态406（不可接受）

我迁移到WebAPI 2.2 RC（Microsoft.AspNet.WebAPI-Version 5.2.0-RC），从中我只得到406（不可接受）作为我所有查询的状态响应，例如：

http://localhost:7923/api/Quotes(1)

OData服务配置

public static class WebApiConfig
{
    public static void Register(HttpConfiguration config)
    {
        config.MapHttpAttributeRoutes();
        config.EnableSystemDiagnosticsTracing();
        config.MapODataServiceRoute("api", "api", CreateEdmModel());
    }

    private static IEdmModel CreateEdmModel()
    {
        var odataModelBuilder = new ODataConventionModelBuilder();

        odataModelBuilder.EntitySet<Tag>("Tags");
        odataModelBuilder.EntitySet<Author>("Authors");
        EntitySetConfiguration<Quote> quoteEntitySetConfiguration = odataModelBuilder.EntitySet<Quote>("Quotes");

        FunctionConfiguration getQuotesRandomFunction = quoteEntitySetConfiguration.EntityType.Collection.Function("Random");
        getQuotesRandomFunction.Parameter<int>("count");
        getQuotesRandomFunction.ReturnsCollectionFromEntitySet<Quote>("Quotes");

        return odataModelBuilder.GetEdmModel();
    }
}

公共静态类WebApiConfig
{
公共静态无效寄存器（HttpConfiguration配置）
{
config.maphttpAttribute路由（）；
config.EnableSystemDiagnosticsTracing（）；
MapODataServiceRoute（“api”，“api”，createdModel（））；
}
私有静态IEdmModel CreateDMModel（）
{
var odataModelBuilder=新ODataConventionModelBuilder（）；
odataModelBuilder.EntitySet（“标记”）；
odataModelBuilder.EntitySet（“作者”）；
EntitySetConfiguration quoteEntitySetConfiguration=odataModelBuilder.EntitySet（“报价”）；
FunctionConfiguration getQuotesRandomFunction=QuotentitySetConfiguration.EntityType.Collection.Function（“随机”）；
getQuotesRandomFunction.Parameter（“count”）；
getQuotesRandomFunction.ReturnsCollectionFromEntitySet（“Quotes”）；
返回odataModelBuilder.GetEdmModel（）；
}
}

报价控制器

public class QuotesController : ODataController
{
    private WhatAQuoteDb db = new WhatAQuoteDb();

    [ODataRoute("Default.Random(count={count})")]
    [EnableQuery]
    public IHttpActionResult GetQuotesRandom(int count)
    {
        return Ok(db.Quotes.OrderBy(quote => Guid.NewGuid()).Take(count));
    }

    // GET: odata/Quotes
    [EnableQuery]
    public IQueryable<Quote> GetQuotes()
    {
        return db.Quotes;
    }

    // GET: odata/Quotes(5)
    [EnableQuery]
    public SingleResult<Quote> GetQuote([FromODataUri] int key)
    {
        return SingleResult.Create(db.Quotes.Where(quote => quote.Id == key));
    }

    // PUT: odata/Quotes(5)
    public async Task<IHttpActionResult> Put([FromODataUri] int key, Quote quote)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }

        if (key != quote.Id)
        {
            return BadRequest();
        }

        db.Entry(quote).State = EntityState.Modified;

        try
        {
            await db.SaveChangesAsync();
        }
        catch (DbUpdateConcurrencyException)
        {
            if (!QuoteExists(key))
            {
                return NotFound();
            }
            else
            {
                throw;
            }
        }

        return Updated(quote);
    }

    // POST: odata/Quotes
    public async Task<IHttpActionResult> Post(Quote quote)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }

        db.Quotes.Add(quote);
        await db.SaveChangesAsync();

        return Created(quote);
    }

    // PATCH: odata/Quotes(5)
    [AcceptVerbs("PATCH", "MERGE")]
    public async Task<IHttpActionResult> Patch([FromODataUri] int key, Delta<Quote> patch)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }

        Quote quote = await db.Quotes.FindAsync(key);
        if (quote == null)
        {
            return NotFound();
        }

        patch.Patch(quote);

        try
        {
            await db.SaveChangesAsync();
        }
        catch (DbUpdateConcurrencyException)
        {
            if (!QuoteExists(key))
            {
                return NotFound();
            }
            else
            {
                throw;
            }
        }

        return Updated(quote);
    }

    // DELETE: odata/Quotes(5)
    public async Task<IHttpActionResult> Delete([FromODataUri] int key)
    {
        Quote quote = await db.Quotes.FindAsync(key);
        if (quote == null)
        {
            return NotFound();
        }

        db.Quotes.Remove(quote);
        await db.SaveChangesAsync();

        return StatusCode(HttpStatusCode.NoContent);
    }

    // GET: odata/Quotes(5)/Author
    [EnableQuery]
    public SingleResult<Author> GetAuthor([FromODataUri] int key)
    {
        return SingleResult.Create(db.Quotes.Where(m => m.Id == key).Select(m => m.Author));
    }

    // GET: odata/Quotes(5)/Tags
    [EnableQuery]
    public IQueryable<Tag> GetTags([FromODataUri] int key)
    {
        return db.Quotes.Where(m => m.Id == key).SelectMany(m => m.Tags);
    }

    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            db.Dispose();
        }
        base.Dispose(disposing);
    }

    private bool QuoteExists(int key)
    {
        return db.Quotes.Count(e => e.Id == key) > 0;
    }
}

公共类QuotesController:ODataController
{
私有WhatAQuoteDb=新WhatAQuoteDb（）；
[ODataRoute（“Default.Random（count={count}）”）]
[启用查询]
公共IHttpActionResult GetQuotesRandom（整数计数）
{
返回Ok（db.Quotes.OrderBy（quote=>Guid.NewGuid（））.Take（count））；
}
//获取：odata/Quotes
[启用查询]
公共IQueryable GetQuotes（）
{
返回db.Quotes；
}
//获取：odata/Quotes（5）
[启用查询]
公共SingleResult GetQuote（[FromODataUri]int键）
{
返回SingleResult.Create（db.Quotes.Where（quote=>quote.Id==key））；
}
//PUT:odata/Quotes（5）
公共异步任务Put（[FromODataUri]int键，引号）
{
如果（！ModelState.IsValid）
{
返回请求（ModelState）；
}
if（key！=quote.Id）
{
返回请求（）；
}
db.Entry（quote.State=EntityState.Modified；
尝试
{
等待db.saveChangesSync（）；
}
catch（DbUpdateConcurrencyException）
{
如果（！QuoteExists（键））
{
返回NotFound（）；
}
其他的
{
投掷；
}
}
更新申报表（报价）；
}
//帖子：odata/Quotes
公共异步任务发布（Quote）
{
如果（！ModelState.IsValid）
{
返回请求（ModelState）；
}
db.Quotes.Add（quote）；
等待db.saveChangesSync（）；
已创建的退货（报价）；
}
//补丁：odata/Quotes（5）
[接受动词（“补丁”、“合并”）]
公共异步任务修补程序（[FromODataUri]int-key，增量修补程序）
{
如果（！ModelState.IsValid）
{
返回请求（ModelState）；
}
Quote Quote=WAIT db.Quotes.FINDASSYNC（键）；
if（引号==null）
{
返回NotFound（）；
}
补丁。补丁（引用）；
尝试
{
等待db.saveChangesSync（）；
}
catch（DbUpdateConcurrencyException）
{
如果（！QuoteExists（键））
{
返回NotFound（）；
}
其他的
{
投掷；
}
}
更新申报表（报价）；
}
//删除：odata/Quotes（5）
公共异步任务删除（[FromODataUri]int-key）
{
Quote Quote=WAIT db.Quotes.FINDASSYNC（键）；
if（引号==null）
{
返回NotFound（）；
}
db.Quotes.Remove（quote）；
等待db.saveChangesSync（）；
返回状态码（HttpStatusCode.NoContent）；
}
//获取：odata/Quotes（5）/作者
[启用查询]
公共SingleResult GetAuthor（[FromODataUri]int键）
{
返回SingleResult.Create（db.Quotes.Where（m=>m.Id==key）。选择（m=>m.Author））；
}
//获取：odata/Quotes（5）/Tags
[启用查询]
公共IQueryable GetTags（[FromODataUri]int键）
{
返回db.Quotes.Where（m=>m.Id==key），选择many（m=>m.Tags）；
}
受保护的覆盖无效处置（布尔处置）
{
如果（处置）
{
db.Dispose（）；
}
基地。处置（处置）；
}
私有布尔QuoteExists（整型密钥）
{
返回db.Quotes.Count（e=>e.Id==key）>0；
}
}

我检查了您的解决方案，发现您使用了服务引用

但是，添加服务引用不支持OData V4，并且生成的代码中的版本是V3

您可以尝试使用OData T4代码生成器生成客户端代码

查看以下博客：

---

更新：

我再次检查了您的解决方案，发现问题：

您使用的ODataController是V3

如果需要V4版本，则需要更改控制器cs文件中的using命名空间

从

到

此外，还有一个问题，当我启动项目时，下面的模板是无效的

[ODataRoute("Default.Random(count={count})")]

我认为您定义的随机函数是一个函数导入，您应该这样定义：

FunctionConfiguration getQuotesRandomFunction = odataModelBuilder.Function("Random");

函数导入不应添加命名空间，模板应为：

[ODataRoute("Random(count={count})")]

---

如果您有其他问题，请告诉我。

您知道如何获取RTM夜间比特吗？请参见-。更具体地说，我们（WebAPI团队）将快速查看，并很快回复您。谢谢你提出这个问题。我们无法根据这篇文章中的代码重新设置问题。我们尝试了RC和夜间构建，但效果很好。你能给我们提供更多的细节或者一个复制项目吗？我使用了官方的NuGet软件包。我可以为你提供整个解决方案，你需要的一切都可以开始。或者我怎样才能找到其他人

FunctionConfiguration getQuotesRandomFunction = odataModelBuilder.Function("Random");

[ODataRoute("Random(count={count})")]