Programmation avec liaison tardive et anticipée à l’aide du SDK pour .NET

Lorsque vous utilisez le Kit de développement logiciel (SDK) pour les assemblys .NET, vous avez deux styles de programmation que vous pouvez utiliser : à liaison tardive et à liaison anticipée.

La différence clé entre la liaison anticipée et tardive implique la conversion de type. Bien que la liaison anticipée permette de vérifier tous les types au moment de la compilation pour éviter tout cast implicite, la liaison tardive ne vérifie les types que lorsque l'objet est créé ou qu'une action est effectuée sur celui-ci. La Entity classe exige que les types soient explicitement spécifiés pour empêcher les casts implicites.

La liaison tardive vous permet d’utiliser des tables personnalisées (entités) ou des colonnes (attributs) qui n’étaient pas disponibles lorsque votre code a été compilé.

Liaison tardive

La programmation à liaison tardive utilise la classe Entity, où vous devez faire référence à des lignes et des colonnes de table (entités et attributs) à l’aide de leurs propriétés LogicalName.

• EntityMetadata.LogicalName
• AttributeMetadata.LogicalName

Les relations n’ont pas de LogicalName propriété. La RelationshipMetadataBasepropriété .SchemaName est donc utilisée.

L’avantage principal de la programmation à liaison tardive est que vous n’avez pas besoin de générer les classes ou d’inclure ce fichier généré dans vos projets. Le fichier généré peut être volumineux.

Les principaux inconvénients sont les suivants :

• Vous n’obtenez pas la validation au moment de la compilation sur les noms d’entités, d’attributs et de relations.
• Vous devez connaître les noms des attributs et des relations dans les métadonnées.

Example

L’exemple suivant crée un compte à l’aide du style avec liaison tardive.

//Use Entity class specifying the entity logical name
var account = new Entity("account");

// set attribute values
    // string primary name
    account["name"] = "Contoso";            
    // Boolean (Two option)
    account["creditonhold"] = false;
    // DateTime
    account["lastonholdtime"] = new DateTime(2017, 1, 1);
    // Double
    account["address1_latitude"] = 47.642311;
    account["address1_longitude"] = -122.136841;
    // Int
    account["numberofemployees"] = 500;
    // Money
    account["revenue"] = new Money(new decimal(5000000.00));
    // Picklist (Option set)
    account["accountcategorycode"] = new OptionSetValue(1); //Preferred customer
                
//Create the account
Guid accountid = svc.Create(account);

Liaison anticipée

La programmation à liaison anticipée nécessite que vous génériez d’abord un ensemble de classes à partir des définitions de table et de colonne (métadonnées d’entité et d’attribut) pour un environnement particulier en utilisant l’outil de génération de code Power Platform CLI pac modelbuilder build command. Plus d'information : Générer des classes pour la programmation à liaison précoce à l'aide du Kit de développement logiciel (SDK) pour .NET

Après avoir généré des classes avec liaison anticipée avec l’outil de génération de code, vous bénéficierez d’une meilleure expérience lors de l’écriture du code parce que les classes et les propriétés utilisent les valeurs de propriété SchemaName respectives :

• EntityMetadata.SchemaName
• AttributeMetadata.SchemaName
• RelationshipMetadataBase.SchemaName

Instanciez simplement la classe et laissez Visual Studio IntelliSense fournir les noms des propriétés et des relations.

Les classes générées pour la programmation avec liaison anticipée peuvent également inclure des définitions pour toute action personnalisée définie pour l’environnement. Cela vous fournit une paire de classes de requête et de réponse à utiliser avec ces actions personnalisées. Plus d’informations : Actions personnalisées

Les classes sont générées à l’aide de définitions de table à partir d’une instance d’environnement spécifique, et chaque instance peut avoir des tables et des colonnes différentes où elles peuvent changer au fil du temps. Vous devrez peut-être écrire du code pour traiter des tables qui ne sont pas présentes au moment de la génération de classes fortement typées.

Example

L’exemple suivant crée un compte à l’aide du style de liaison anticipée.

var account = new Account();
// set attribute values
    // string primary name
    account.Name = "Contoso";
    // Boolean (Two option)
    account.CreditOnHold = false;
    // DateTime
    account.LastOnHoldTime = new DateTime(2017, 1, 1);
    // Double
    account.Address1_Latitude = 47.642311;
    account.Address1_Longitude = -122.136841;
    // Int
    account.NumberOfEmployees = 500;
    // Money
    account.Revenue = new Money(new decimal(5000000.00));
    // Picklist (Option set)
    account.AccountCategoryCode = new OptionSetValue(1); //Preferred customer

//Create the account
Guid accountid = svc.Create(account);

Choisir le style

Le style de programmation que vous choisissez d’utiliser est à vous. Le tableau suivant présente les avantages et les inconvénients pour chacun d’eux.

Combiner la liaison anticipée et la liaison tardive

Étant donné que toutes les classes générées héritent de la classe utilisée avec la Entity programmation à liaison tardive, vous pouvez utiliser des entités, des attributs et des relations non définies dans les classes.

Examples

L’exemple suivant montre un moyen de combiner des méthodes de liaison précoce et tardive en utilisant OrganizationServiceContext.

// Create an context object  
AWCServiceContext context = new AWCServiceContext(_serviceProxy);  
  
// Instantiate an account object using the Entity class.  
Entity testaccount = new Entity("account");  
  
// Set several attributes. For account, only the name is required.   
testaccount["name"] = "Fourth Coffee";  
testaccount["emailaddress1"] = "marshd@contoso.com";  
  
// Save the entity using the context object.  
context.AddToAccountSet(testaccount);  
context.SaveChanges();  
  

Si un attribut personnalisé n’a pas été inclus dans les classes générées, vous pouvez toujours l’utiliser.

var account = new Account();
// set attribute values
    // string primary name
    account.Name = "Contoso";
    // A custom boolean attribute not included in the generated classes.
    account["sample_customboolean"] = false;


//Create the account
Guid accountid = svc.Create(account);

Affecter une instance avec liaison anticipée à une instance avec liaison tardive

L’exemple suivant montre comment affecter une instance liée anticipée à une instance liée tardive.

Entity incident = ((Entity)context.InputParameters[ParameterName.Target]).ToEntity<Incident>();  
Task relatedEntity = new Task() { Id = this.TaskId };  
  
incident.RelatedEntities[new Relationship("Incident_Tasks")] =   
new EntityCollection(new Entity[] { relatedEntity.ToEntity<Entity>() });  

Voir aussi

Opérations d’entité à l’aide du Kit de développement logiciel (SDK) pour .NET
Créer des lignes de table à l’aide du SDK pour .NET
Récupérer une ligne de table à l’aide du Kit de développement logiciel (SDK) pour .NET
Interroger des données à l’aide du Kit de développement logiciel (SDK) pour .NET
Mettre à jour et supprimer des lignes de table à l’aide du Kit de développement logiciel (SDK) pour .NET
Associer et dissocier des lignes de table à l’aide du Kit de développement logiciel (SDK) pour .NET
Interface IOrganizationService
Utilisation de OrganizationServiceContext