使用 Web API 2.2 的 OData v4 中的包含

作者：谭金福

传统上，仅当实体封装在实体集中时，才能访问该实体。 但 OData v4 提供了两个附加选项：单一实例和包含，WebAPI 2.2 都支持这两个选项。

本主题演示如何在 WebApi 2.2 中的 OData 终结点中定义包含。 有关包含的详细信息，请参阅 包含随 OData v4 一起提供。 若要在 Web API 中创建 OData V4 终结点，请参阅使用 ASP.NET Web API 2.2 创建 OData v4 终结点。

首先，我们将使用此数据模型在 OData 服务中创建包含域模型：

一个帐户包含许多 PaymentInstruments (PI) ，但我们未为 PI 定义实体集。 相反，只能通过帐户访问这些 API。

定义数据模型

1. 定义 CLR 类型。

   public class Account     
   {         
       public int AccountID { get; set; }         
       public string Name { get; set; }         
       [Contained]         
       public IList<PaymentInstrument> PayinPIs { get; set; }     
   }     
   
   public class PaymentInstrument     
   {         
       public int PaymentInstrumentID { get; set; }        
       public string FriendlyName { get; set; }     
   }
   

   特性 Contained 用于包含导航属性。

2. 基于 CLR 类型生成 EDM 模型。

   public static IEdmModel GetModel()         
   {             
       ODataConventionModelBuilder builder = new ODataConventionModelBuilder();             
       builder.EntitySet<Account>("Accounts");             
       var paymentInstrumentType = builder.EntityType<PaymentInstrument>();             
       var functionConfiguration = 
           paymentInstrumentType.Collection.Function("GetCount");             
       functionConfiguration.Parameter<string>("NameContains");             
       functionConfiguration.Returns<int>();             
       builder.Namespace = typeof(Account).Namespace;             
       return builder.GetEdmModel();         
   }
   

   ODataConventionModelBuilder如果将 属性添加到相应的导航属性，Contained则 将处理 EDM 模型的生成。 如果该属性是集合类型，则还将创建一个 GetCount(string NameContains) 函数。

   生成的元数据如下所示：

   <EntityType Name="Account">   
     <Key>     
       <PropertyRef Name="AccountID" />   
     </Key>   
     <Property Name="AccountID" Type="Edm.Int32" Nullable="false" />   
     <Property Name="Name" Type="Edm.String" />   
     <NavigationProperty 
       Name="PayinPIs" 
       Type="Collection(ODataContrainmentSample.PaymentInstrument)" 
       ContainsTarget="true" /> 
   </EntityType>
   

   属性 ContainsTarget 指示导航属性是包含。

定义包含实体集控制器

包含的实体没有自己的控制器;操作在包含实体集控制器中定义。 在此示例中，有一个 AccountsController，但没有 PaymentInstrumentsController。

public class AccountsController : ODataController     
{         
    private static IList<Account> _accounts = null;         
    public AccountsController()         
    {             
        if (_accounts == null)             
        {                 
            _accounts = InitAccounts();             
        }         
    }         
    // PUT ~/Accounts(100)/PayinPIs         
    [EnableQuery] 
    public IHttpActionResult GetPayinPIs(int key)         
    {             
        var payinPIs = _accounts.Single(a => a.AccountID == key).PayinPIs;             
        return Ok(payinPIs);         
    }         
    [EnableQuery]         
    [ODataRoute("Accounts({accountId})/PayinPIs({paymentInstrumentId})")]         
    public IHttpActionResult GetSinglePayinPI(int accountId, int paymentInstrumentId)         
    {             
        var payinPIs = _accounts.Single(a => a.AccountID == accountId).PayinPIs;             
        var payinPI = payinPIs.Single(pi => pi.PaymentInstrumentID == paymentInstrumentId);             
        return Ok(payinPI);         
    }         
    // PUT ~/Accounts(100)/PayinPIs(101)         
    [ODataRoute("Accounts({accountId})/PayinPIs({paymentInstrumentId})")]         
    public IHttpActionResult PutToPayinPI(int accountId, int paymentInstrumentId, [FromBody]PaymentInstrument paymentInstrument)         
    {             
        var account = _accounts.Single(a => a.AccountID == accountId);             
        var originalPi = account.PayinPIs.Single(p => p.PaymentInstrumentID == paymentInstrumentId);             
        originalPi.FriendlyName = paymentInstrument.FriendlyName;             
        return Ok(paymentInstrument);         
    }         
    // DELETE ~/Accounts(100)/PayinPIs(101)         
    [ODataRoute("Accounts({accountId})/PayinPIs({paymentInstrumentId})")]         
    public IHttpActionResult DeletePayinPIFromAccount(int accountId, int paymentInstrumentId)         
    {             
        var account = _accounts.Single(a => a.AccountID == accountId);             
        var originalPi = account.PayinPIs.Single(p => p.PaymentInstrumentID == paymentInstrumentId);             
        if (account.PayinPIs.Remove(originalPi))             
        {                 
            return StatusCode(HttpStatusCode.NoContent);             
        }             
        else             
        {                 
            return StatusCode(HttpStatusCode.InternalServerError);             
        }         
    }         
    // GET ~/Accounts(100)/PayinPIs/Namespace.GetCount() 
    [ODataRoute("Accounts({accountId})/PayinPIs/ODataContrainmentSample.GetCount(NameContains={name})")]         
    public IHttpActionResult GetPayinPIsCountWhoseNameContainsGivenValue(int accountId, [FromODataUri]string name)         
    {             
        var account = _accounts.Single(a => a.AccountID == accountId);             
        var count = account.PayinPIs.Where(pi => pi.FriendlyName.Contains(name)).Count();             
        return Ok(count);         
    }         
    private static IList<Account> InitAccounts()         
    {             
        var accounts = new List<Account>() 
        { 
            new Account()                 
            {                    
                AccountID = 100,                    
                Name="Name100",                    
                PayinPIs = new List<PaymentInstrument>()                     
                {                         
                    new PaymentInstrument()                         
                    {                             
                        PaymentInstrumentID = 101,                             
                        FriendlyName = "101 first PI",                         
                    },                         
                    new PaymentInstrument()                         
                    {                             
                        PaymentInstrumentID = 102,                             
                        FriendlyName = "102 second PI",                         
                    },                     
                },                 
            },             
        };            
        return accounts;         
    }     
}

如果 OData 路径为 4 个或更多段，则只有属性路由有效，例如 [ODataRoute("Accounts({accountId})/PayinPIs({paymentInstrumentId})")] 在上述控制器中。 否则，属性和传统路由都有效：例如， GetPayInPIs(int key) 匹配 GET ~/Accounts(1)/PayinPIs。

感谢胡利奥对本文的原创内容。