Share via


Créer un Singleton dans OData v4 à l’aide de l’API web 2.2

par Zoe Luo

Traditionnellement, une entité n’était accessible que si elle était encapsulée à l’intérieur d’un ensemble d’entités. Mais OData v4 fournit deux options supplémentaires, Singleton et Containment, que WebAPI 2.2 prend en charge.

Cet article explique comment définir un singleton dans un point de terminaison OData dans l’API Web 2.2. Pour plus d’informations sur ce qu’est un singleton et sur la façon dont vous pouvez tirer parti de son utilisation, consultez Utilisation d’un singleton pour définir votre entité spéciale. Pour créer un point de terminaison OData V4 dans l’API web, consultez Créer un point de terminaison OData v4 à l’aide de API Web ASP.NET 2.2.

Nous allons créer un singleton dans votre projet d’API web à l’aide du modèle de données suivant :

Modèle de données

Un singleton nommé Umbrella sera défini en fonction du type Company, et un jeu d’entités nommé Employees sera défini en fonction du type Employee.

Définir le modèle de données

  1. Définissez les types CLR.

    /// <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. Générez le modèle EDM en fonction des types CLR.

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

    Ici, builder.Singleton<Company>("Umbrella") indique au générateur de modèle de créer un singleton nommé Umbrella dans le modèle EDM.

    Les métadonnées générées se présenteront comme suit :

    <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>
    

    À partir des métadonnées, nous pouvons voir que la propriété Company de navigation dans le Employees jeu d’entités est liée au singleton Umbrella. La liaison est effectuée automatiquement par ODataConventionModelBuilder, car a uniquement Umbrella le Company type . En cas d’ambiguïté dans le modèle, vous pouvez utiliser HasSingletonBinding pour lier explicitement une propriété de navigation à un singleton ; HasSingletonBinding a le même effet que l’utilisation de l’attribut dans la Singleton définition de type CLR :

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

Définir le contrôleur singleton

Comme le contrôleur EntitySet, le contrôleur singleton hérite de ODataController, et le nom du contrôleur singleton doit être [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>()
        };
    } 
}

Pour gérer différents types de requêtes, les actions doivent être prédéfinies dans le contrôleur. Le routage d’attributs est activé par défaut dans WebApi 2.2. Par exemple, pour définir une action permettant de gérer l’interrogation Revenue à partir du Company routage d’attributs, utilisez les éléments suivants :

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

Si vous n’êtes pas prêt à définir des attributs pour chaque action, définissez simplement vos actions en suivant les conventions de routage OData. Étant donné qu’une clé n’est pas requise pour interroger un singleton, les actions définies dans le contrôleur singleton sont légèrement différentes des actions définies dans le contrôleur entityset.

Pour référence, les signatures de méthode pour chaque définition d’action dans le contrôleur singleton sont répertoriées ci-dessous.

// 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()

Fondamentalement, c’est tout ce que vous avez à faire côté service. L’exemple de projet contient tout le code de la solution et du client OData qui montre comment utiliser le singleton. Le client est créé en suivant les étapes décrites dans Créer une application cliente OData v4.

.

Merci à Leo Hu pour le contenu original de cet article.