Partager via

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

  • Article

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 peuvent être accomplies uniquement en ajoutant le code à une application.Par exemple, pour valider un champ en appliquant des conditions personnalisées, vous devez écrire le 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 :

Pour obtenir des conseils d'ordre général sur l'écriture de code dans Visual Studio LightSwitch, consultez Écriture de code dans LightSwitch.

Tâches courantes

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.

  • Lecture de données

  • Mise à jour des données

  • Suppression de données

  • Ajout de données

  • Enregistrement des données

  • Validation des données

  • Définition d'autorisations sur les données

  • Utilisation d'ensembles de modifications

  • Extension de requêtes

Lecture de données

Vous pouvez lire des éléments de données individuels ou des collections d'éléments de données de toute source de données de votre application.

L'exemple suivant extrait le client qui est actuellement sélectionné dans un écran.

Private Sub RetrieveCustomer_Execute()
    Dim cust As Customer = Me.Customers.SelectedItem
    If cust.ContactName = "Bob" Then
        'Perform some task on the customer entity.
    End If
End Sub

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.

Private Sub RetrieveCustomers_Execute()
    For Each cust As Customer In Me.DataWorkspace.NorthwindData.Customers
        If cust.ContactName = "Bob" Then
            'Perform some task on the customer entity.
        End If
    Next

End Sub

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.110).gifDéplacement au sein de relations de 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.

Private Sub RetrieveSalesOrders_Execute()
    Dim cust As Customer = Me.Customers.SelectedItem
    For Each myOrder As Order In cust.Orders
        If myOrder.OrderDate = Today Then
            'Perform some task on the order entity.
        End If
    Next
End Sub

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.

Private Sub RetrieveCustomer_Execute()
    Dim order As Order
    order = Me.DataWorkspace.NorthwindData.Orders_Single _
        (Orders.SelectedItem.OrderID)
    Dim cust As Customer
    cust = order.Customer
    'Perform some task on the order entity.
End Sub

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.110).gifLecture des données en exécutant une requête

Vous pouvez extraire des requêtes 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.

Mise à jour des données

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

Private Sub Orders_Inserting(entity As Order)
    For Each detail In entity.Order_Details
        detail.Product.UnitsInStock =
            detail.Product.UnitsInStock - detail.Quantity
    Next
End Sub

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

[!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.Pour plus d'informations, consultez How to: Save Data.

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

Private Sub DeleteCustomer_Execute()
    Dim cust As Customer
    cust = Me.Customers.SelectedItem
    If Customers.CanDelete Then
        cust.Delete()
    End If

End Sub

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

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

Ajout de données

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 contacts dans la liste SharePoint n'ont pas encore été importés dans la source de données NorthwindData.

Private Sub ImportCustomers_Execute()
    For Each spCust As SharePointCustomer In _
        Me.DataWorkspace.SharePointData.NewCustomersInSharePoint
        Dim newCust As Customer = New Customer()
        With newCust

            .ContactName = spCust.FirstName & " " & spCust.LastName
            .Address = spCust.Address
            .City = spCust.City
            .PostalCode = spCust.PostalCode
            .Region = spCust.Region

            'Set the CopiedToDatabase field of the item in SharePoint.
            spCust.CopiedToDatabase = "Yes"
        End With

    Next
    Me.DataWorkspace.SharePointData.SaveChanges()



End Sub

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


}

Enregistrement des données

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 :

  • Validez les modifications que vous apportez aux données qui se trouvent dans d'autres sources de données.

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

Ff851990.collapse_all(fr-fr,VS.110).gifValidation des modifications que vous apportez aux données qui se trouvent dans d'autres sources de données

Les fichiers dans lesquels vous écrivez le code personnalisé ont une source de données primaire.Si vous ajoutez du code personnalisé qui modifie des 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 dans 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.

Private Sub Orders_Inserting(entity As Order1)
    For Each detail In entity.Order_Details
        detail.Product.UnitsInStock = detail.Product.UnitsInStock - detail.Quantity
    Next
    Me.DataWorkspace.ProductDataSource.SaveChanges()

End Sub

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.110).gifSubstitution d'un é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.

Private Sub CustomersListDetail_Saving(ByRef handled As Boolean)
    Try
        Me.DataWorkspace.SharePointData.SaveChanges()

    Catch ex As DataServiceOperationException

        If ex.ErrorInfo = "DTSException" Then
            Me.ShowMessageBox(ex.Message)
        Else
            Throw ex

        End If

    End Try

    handled = True


End Sub

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;


}

Validation des données

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 conformes à vos règles de validation.Pour plus d'informations, consultez Comment : Valider les données.

Définition d'autorisations sur les données

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 l'utilisateur a l'autorisation de mettre à 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 d'une autorisation et création d'autorisations.

Private Sub Customers_CanUpdate(ByRef result As Boolean)
    result = Me.Application.User.HasPermission(Permissions.RoleUpdate)
End Sub

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 soient lues ou modifiées.

Utilisation d'ensembles de modifications

Vous pouvez identifier et ignorer des modifications en attente avant qu'elles soient validées dans une source de données.L'exemple suivant affiche 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 des modifications apportées à la ligne de données sélectionnée actuellement dans un écran de client.

Private Sub UndoAllCustomerUpdates_Execute()
    For Each Cust As Customer In _
        Me.DataWorkspace.NorthwindData.Details. _
        GetChanges().OfType(Of Customer)()

        Cust.Details.DiscardChanges()

    Next
End Sub

Private Sub UndoAllUpdates_Execute()
    Me.DataWorkspace.NorthwindData.Details.DiscardChanges()
End Sub

Private Sub UnduCustomerEdit_Execute()
    Customers.SelectedItem.Details.DiscardChanges()
End Sub

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();
}

Extension de requêtes modélisées

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

Voir aussi

Concepts

Écriture de code dans LightSwitch