Erstellen eines Singletons in OData v4 mithilfe der Web-API 2.2

von Zoe Luo

Traditionell konnte nur auf eine Entität zugegriffen werden, wenn sie innerhalb einer Entitätsgruppe gekapselt wurde. OData v4 bietet jedoch zwei zusätzliche Optionen, Singleton und Containment, die von WebAPI 2.2 unterstützt werden.

In diesem Artikel erfahren Sie, wie Sie einen Singleton in einem OData-Endpunkt in Der Web-API 2.2 definieren. Informationen dazu, was ein Singleton ist und wie Sie von seiner Verwendung profitieren können, finden Sie unter Verwenden eines Singletons zum Definieren Ihrer speziellen Entität. Informationen zum Erstellen eines OData V4-Endpunkts in der Web-API finden Sie unter Erstellen eines OData v4-Endpunkts mit ASP.NET-Web-API 2.2.

Wir erstellen ein Singleton in Ihrem Web-API-Projekt mit dem folgenden Datenmodell:

Ein Singleton mit dem Namen Umbrella wird basierend auf dem Typ Companydefiniert, und ein Entitätssatz mit dem Namen Employees wird basierend auf dem Typ Employeedefiniert.

Definieren des Datenmodells

1. Definieren Sie die CLR-Typen.

   /// <summary> 
   /// Present the EntityType "Employee" 
   /// </summary> 
   public class Employee 
   {     
       public int ID { get; set; }     
       public string Name { get; set; }  
      
       [Singleton]     
       public Company Company { get; set; } 
   } 
   /// <summary> 
   /// Present company category, which is an enum type 
   /// </summary> 
   public enum CompanyCategory 
   { 
       IT = 0,     
       Communication = 1,     
       Electronics = 2,     
       Others = 3 
   } 
   /// <summary> 
   /// Present the EntityType "Company" 
   /// </summary> 
   public class Company 
   {
        public int ID { get; set; }
        public string Name { get; set; }
        public Int64 Revenue { get; set; }
        public CompanyCategory Category { get; set; }
        public List<Employee> Employees { get; set; } 
   }
   

2. Generieren Sie das EDM-Modell basierend auf den CLR-Typen.

   public static IEdmModel GetEdmModel() 
   { 
       ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
       builder.EntitySet<Employee>("Employees"); builder.Singleton<Company>("Umbrella");
       builder.Namespace = typeof(Company).Namespace;
       return builder.GetEdmModel(); 
   }
   

   Hier weist der Modell-Generator an, builder.Singleton<Company>("Umbrella") ein Singleton namens Umbrella im EDM-Modell zu erstellen.

   Die generierten Metadaten sehen wie folgt aus:

   <EntityContainer Name="Container"> 
     <EntitySet Name="Employees" EntityType="ODataSingletonSample.Employee"> 
       <NavigationPropertyBinding Path="Company" Target="Umbrella"/> 
     </EntitySet> 
     <Singleton Name="Umbrella" Type="ODataSingletonSample.Company"> 
       <NavigationPropertyBinding Path="Employees" Target="Employees"/> 
     </Singleton> 
   </EntityContainer>
   

   Aus den Metadaten können wir sehen, dass die Navigationseigenschaft Company im Employees Entitätssatz an den Singleton Umbrellagebunden ist. Die Bindung erfolgt automatisch von ODataConventionModelBuilder, da nur Umbrella der Company Typ vorhanden ist. Wenn das Modell mehrdeutig ist, können HasSingletonBinding Sie verwenden, um eine Navigationseigenschaft explizit an ein Singleton zu binden. HasSingletonBinding Hat die gleiche Auswirkung wie die Verwendung des Singleton Attributs in der CLR-Typdefinition:

   EntitySetConfiguration<Employee> employeesConfiguration = 
       builder.EntitySet<Employee>("Employees"); 
   employeesConfiguration.HasSingletonBinding(c => c.Company, "Umbrella");
   

Definieren des Singleton-Controllers

Wie der EntitySet-Controller erbt der Singleton-Controller von ODataController, und der Name des Singleton-Controllers sollte sein [singletonName]Controller.

public class UmbrellaController : ODataController 
{
    public static Company Umbrella;
    static UmbrellaController()
    {
        InitData();
    }
    private static void InitData()
    {
        Umbrella = new Company()
        {
            ID = 1,
            Name = "Umbrella",
            Revenue = 1000,
            Category = CompanyCategory.Communication,
            Employees = new List<Employee>()
        };
    } 
}

Um verschiedene Arten von Anforderungen behandeln zu können, müssen Aktionen im Controller vorab definiert werden. Attributrouting ist in WebApi 2.2 standardmäßig aktiviert. Verwenden Sie beispielsweise Folgendes, um eine Aktion zum Verarbeiten von Abfragen Revenue mithilfe des Company Attributroutings zu definieren:

[ODataRoute("Umbrella/Revenue")] 
public IHttpActionResult GetCompanyRevenue() 
{
     return Ok(Umbrella.Revenue); 
}

Wenn Sie nicht bereit sind, Attribute für jede Aktion zu definieren, definieren Sie einfach Ihre Aktionen gemäß den OData-Routingkonventionen. Da zum Abfragen eines Singletons kein Schlüssel erforderlich ist, unterscheiden sich die im Singleton-Controller definierten Aktionen geringfügig von aktionen, die im Entityset-Controller definiert sind.

Als Referenz sind die Methodensignaturen für jede Aktionsdefinition im Singleton-Controller unten aufgeführt.

// Get Singleton 
// ~/singleton 
public IHttpActionResult Get() 
public IHttpActionResult GetUmbrella() 

// Get Singleton 
// ~/singleton/cast 
public IHttpActionResult GetFromSubCompany() 
public IHttpActionResult GetUmbrellaFromSubCompany() 

// Get Singleton Property 
// ~/singleton/property  
public IHttpActionResult GetName() 
public IHttpActionResult GetNameFromCompany() 

// Get Singleton Navigation Property 
// ~/singleton/navigation  
public IHttpActionResult GetEmployees() 
public IHttpActionResult GetEmployeesFromCompany() 

// Update singleton by PUT 
// PUT ~/singleton 
public IHttpActionResult Put(Company newCompany) 
public IHttpActionResult PutUmbrella(Company newCompany) 

// Update singleton by Patch 
// PATCH ~/singleton 
public IHttpActionResult Patch(Delta<Company> item) 
public IHttpActionResult PatchUmbrella(Delta<Company> item) 

// Add navigation link to singleton 
// POST ~/singleton/navigation/$ref 
public IHttpActionResult CreateRef(string navigationProperty, [FromBody] Uri link) 

// Delete navigation link from singleton 
// DELETE ~/singleton/navigation/$ref?$id=~/relatedKey 
public IHttpActionResult DeleteRef(string relatedKey, string navigationProperty) 

// Add a new entity to singleton navigation property 
// POST ~/singleton/navigation 
public IHttpActionResult PostToEmployees([FromBody] Employee employee) 

// Call function bounded to singleton 
// GET ~/singleton/function() 
public IHttpActionResult GetEmployeesCount()

Im Grunde ist dies alles, was Sie auf der Dienstseite tun müssen. Das Beispielprojekt enthält den gesamten Code für die Projektmappe und den OData-Client, der zeigt, wie der Singleton verwendet wird. Der Client wird erstellt, indem Sie die Schritte unter Erstellen einer OData v4-Client-App ausführen.

.

Vielen Dank an Leo Hu für den ursprünglichen Inhalt dieses Artikels.