Exporter (0) Imprimer
Développer tout
Développer Réduire
Cet article a fait l'objet d'une traduction manuelle. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

Réalisation de tâches liées aux données à l'aide du code

Vous pouvez utiliser les concepteurs et les fenêtres Outil dans Visual Studio LightSwitch pour effectuer de nombreuses tâches de conception liées aux données. Toutefois, certaines tâches ne peuvent être accomplies qu'en ajoutant du code à une application. Par exemple, pour valider un champ en appliquant des conditions personnalisées, vous devez écrire du code. Ce document indique comment accomplir des tâches liées aux données à l'aide du modèle objet d'exécution de données. Pour plus d'informations sur les emplacements où vous pouvez écrire du code dans une application, consultez les rubriques suivantes :

La liste suivante décrit quelques tâches liées aux données communes, que vous accomplissez à l'aide du modèle objet d'exécution des données. Les tâches sont décrites ultérieurement dans ce document.

Vous pouvez lire des éléments de données individuels ou des collections d'éléments de données à partir de toutes les sources de données de votre application.

L'exemple suivant récupère le client actuellement sélectionné dans un écran.


partial void RetrieveCustomer_Execute()
{
    Customer cust = this.Customers.SelectedItem;
    if (cust.ContactName == "Bob")
    {
        //Perform some task on the customer entity.
    }
}


L'exemple suivant itère au sein d'une collection de clients.


partial void RetrieveCustomers_Execute()
{
    foreach (Customer cust in this.DataWorkspace.NorthwindData.Customers)
    {
        if (cust.ContactName == "Bob")
        {
            //Perform some task on the customer entity.
        }
    }
}


Ff851990.collapse_all(fr-fr,VS.120).gifNavigation au sein des relations entre les données

Vous pouvez lire des données d'entités associées. Par exemple, une entité Customer peut avoir une relation un-à-plusieurs avec une entité Orders. Vous pouvez itérer au sein de toutes les commandes passées par un client à l'aide de la propriété Orders de l'entité Customer.

L'exemple suivant itère au sein d'une collection de commandes associées à un client.


partial void RetrieveSalesOrders_Execute()
{
    Customer cust = this.Customers.SelectedItem;

    foreach (Order order in cust.Orders)
    {
        if (order.OrderDate == DateTime.Today)
        {
            //perform some task on the order entity.
        }
    }
}


L'exemple suivant obtient le client qui a passé une commande spécifique.


partial void RetrieveCustomer_Execute()
{
    Order order = this.DataWorkspace.NorthwindData.Orders_Single
        (Orders.SelectedItem.OrderID);

    Customer cust = order.Customer;
    //Perform some task on the customer entity.

}


Ff851990.collapse_all(fr-fr,VS.120).gifLecture des données en exécutant une requête

Vous pouvez récupérer des requêtes à partir du modèle, puis les exécuter dans votre code. Pour examiner un exemple, consultez Comment : Récupérer les données d'une requête à l'aide du code.

Vous pouvez mettre à jour des données d'entité à l'aide de code. L'exemple suivant affiche le code qui s'exécute lorsqu'un utilisateur crée une commande dans l'entité Order d'un écran, puis clique sur le bouton Enregistrer. Le code met à jour un champ dans l'entité Products en utilisant un champ dans l'entité Order Details.


partial void Orders_Inserting(Order entity)
{
    foreach (Order_Detail detail in entity.Order_Details)
    {
        detail.Product.UnitsInStock = 
            (short?)(detail.Product.UnitsInStock - detail.Quantity);
    }
}


Remarque Remarque

Si votre code modifie des données d'autres sources de données, vous devez valider ces modifications en appelant la méthode SaveChanges de cette source de données.

Vous pouvez supprimer des données en appelant la méthode Delete d'une entité. L'exemple suivant supprime un client de la source de données NorthwindData.


partial void DeleteCustomer_Execute()
{
    Customer cust =
        this.Customers.SelectedItem;

    if (Customers.CanDelete)
    {
        cust.Delete();
    }
}


L'exemple suivant ajoute un nouveau client à la source de données NorthwindData. Cet exemple remplit les champs qui décrivent le nouveau client en utilisant les informations d'un contact ajouté récemment à une liste SharePoint. L'exemple appelle une requête nommée NewCustomersInSharePoint pour déterminer quels sont les contacts de la liste SharePoint qui n'ont pas encore été importés dans la source de données NorthwindData.


partial void ImportCustomers_Execute()
{
    foreach (SharePointCustomer spCust in
this.DataWorkspace.SharePointData.NewCustomersInSharePoint())
    {
        Customer newCust = new Customer();

        newCust.ContactName = spCust.FirstName + " " + spCust.LastName;
        newCust.Address = spCust.Address;
        newCust.City = spCust.City;
        newCust.PostalCode = spCust.PostalCode;
        newCust.Region = spCust.Region;

        //Set the CopiedToDatabase field of the item in SharePoint.
        spCust.CopiedToDatabase = "Yes";
    }
    this.DataWorkspace.SharePointData.SaveChanges();


}


En général, les modifications en attente sont validées dans une source de données lorsque l'utilisateur clique sur le bouton Enregistrer dans un écran. Toutefois, vous pouvez également valider des modifications en attente en ajoutant le code qui appelle la méthode SaveChanges d'une source de données. Vous devez ajouter ce code si vous voulez effectuer l'une de ces tâches :

  • Valider les modifications apportées aux données situées dans d'autres sources de données.

  • Substituer l'événement Save d'un écran.

Ff851990.collapse_all(fr-fr,VS.120).gifValidation des modifications apportées aux données situées dans d'autres sources de données

Les fichiers dans lesquels vous écrivez du code personnalisé ont une source de données principale. Si vous ajoutez du code personnalisé qui modifie les données d'une autre source de données dans votre solution LightSwitch, vous devez valider ces modifications en appelant la méthode SaveChanges de cette source de données.

L'exemple suivant affiche le code qui s'exécute lorsqu'un utilisateur crée une commande dans une entité Order au sein d'un écran, puis clique sur le bouton Enregistrer. Le code met à jour un champ dans l'entité Products en utilisant un champ dans l'entité Order Details. Étant donné que l'entité Products se trouve dans une autre source de données, ce code appelle la méthode SaveChanges de cette source de données pour valider les modifications.


partial void Orders_Inserting(Order1 entity)
{
    foreach (Order_Detail1 detail in entity.Order_Details)
    {
        detail.Product.UnitsInStock = (short?)
            (detail.Product.UnitsInStock - detail.Quantity);
    }
    this.DataWorkspace.ProductDataSource.SaveChanges();

}


Ff851990.collapse_all(fr-fr,VS.120).gifSubstitution de l'événement Save d'un écran

Vous pouvez modifier le comportement du bouton Enregistrer sur un écran en substituant l'événement Save. Étant donné que vous remplacez le comportement du bouton Enregistrer, votre code doit appeler la méthode SaveChanges lorsque vous voulez valider des modifications en attente.

L'exemple suivant substitue l'événement Save d'un écran de client pour intercepter et gérer une exception spécifique qui peut être levée si l'opération d'enregistrement échoue.


partial void CustomersListDetail_Saving(ref bool handled)
{
    try
    {
        this.DataWorkspace.SharePointData.SaveChanges();
    }
    catch (DataServiceOperationException ex)
    {
        if (ex.ErrorInfo == "DTSException")
        {
            this.ShowMessageBox(ex.Message);
        }
        else
        {
            throw ex;
        }
    }
    handled = true;


}


Vous pouvez appliquer des règles de validation personnalisées aux champs d'une entité. Vous pouvez ajouter des messages d'erreur personnalisés qui s'affichent lorsque les utilisateurs modifient la valeur des propriétés de façon non conforme à vos règles de validation. Pour plus d’informations, consultez Comment : valider des données dans une application LightSwitch

Par défaut, tous les utilisateurs peuvent afficher, insérer, supprimer ou mettre à jour les données qui s'affichent dans un écran. Toutefois, vous pouvez restreindre ces autorisations en ajoutant du code à l'une des méthodes suivantes :

  • CanRead

  • CanInsert

  • CanDelete

  • CanUpdate

Si vous restreignez une opération à l'aide de ces méthodes, LightSwitch rend l'opération non disponible aux utilisateurs qui n'ont pas d'autorisations illimitées. Pour plus d'informations, consultez Comment : Gérer les événements de données.

L'exemple suivant permet à un utilisateur de mettre à jour les informations client, si cet utilisateur est autorisé à effectuer des mises à jour. Cet exemple de code requiert un groupe d'autorisations nommé RoleUpdate. Pour plus d'informations sur l'ajout d'un groupe d'autorisations à votre application, consultez Activation des autorisations et création de permissions dans LightSwitch.


partial void Customers_CanUpdate(ref bool result)
{
    result = this.Application.User.HasPermission(Permissions.RoleUpdate);
}


Par défaut, LightSwitch appelle ces méthodes lorsqu'un utilisateur tente d'afficher, d'insérer, de supprimer ou de mettre à jour des informations. Vous pouvez également appeler ces méthodes dans votre code personnalisé avant que les données ne soient lues ou modifiées.

Vous pouvez identifier et ignorer des modifications en attente avant qu'elles ne soient validées dans une source de données. L'exemple suivant montre trois méthodes utilisateur qui identifient et ignorent des modifications en attente. La méthode UndoAllCustomerUpdates ignore toutes les modifications apportées à tous les clients. La méthode UndoAllUpdates ignore toutes les modifications apportées à la source de données. La méthode UndoCustomerEdit ignore les modifications apportées à la ligne de données sélectionnée actuellement dans un écran de client.


partial void UndoAllCustomerUpdates_Execute()
{
    foreach (Customer cust in 
        this.DataWorkspace.NorthwindData.Details.
        GetChanges().OfType<Customer>())
    {
        cust.Details.DiscardChanges();
    }
}

partial void UndoAllUpdates_Execute()
{
    this.DataWorkspace.NorthwindData.Details.DiscardChanges();
}

partial void UndoCustomerEdit_Execute()
{
    Customers.SelectedItem.Details.DiscardChanges();
}


Si vous voulez modifier une requête au-delà des fonctionnalités du Concepteur de requêtes, vous pouvez étendre la requête en ajoutant du code à la méthode PreProcessQuery de la requête. Pour plus d'informations, consultez Comment : Étendre une requête à l'aide du code.

Ajouts de la communauté

AJOUTER
Afficher:
© 2015 Microsoft