Esecuzione delle attività relative ai dati tramite codice

  • Articolo

È possibile utilizzare le finestre di progettazione e le finestre degli strumenti in Visual Studio LightSwitch per completare molte attività di progettazione correlate ai dati.Tuttavia, determinate attività possono essere completate solo aggiungendo codice ad un'applicazione.Ad esempio, per convalidare un campo applicando condizioni personalizzate, è necessario scrivere codice.In questo documento viene illustrato come completare le attività correlate ai dati tramite il modello ad oggetti di runtime dei dati.Per ulteriori informazioni su dove sia possibile scrivere codice in un'applicazione, vedere gli argomenti seguenti:

Per le linee guida generali su come scrivere il codice in Visual Studio LightSwitch, vedere Scrittura di codice in LightSwitch.

Attività comuni

Nell'elenco seguente vengono illustrate le attività comuni correlate ai dati che possono essere completate tramite il modello a oggetti di runtime dei dati.Le attività vengono descritte più avanti in questo documento.

  • Lettura dei dati

  • Aggiornamento di dati

  • Eliminazione di dati

  • Aggiunta di dati

  • Salvataggio di dati

  • Convalida dei dati

  • Impostazione delle autorizzazioni sui dati

  • Utilizzo dei set di modifiche

  • Estensione di query

Lettura dei dati

È possibile leggere raccolte di elementi di dati o di elementi di dati singoli da qualsiasi origine dati nell'applicazione.

Nell'esempio seguente viene recuperato il cliente attualmente selezionato in una schermata.

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

Nell'esempio seguente si scorre una raccolta di clienti.

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(it-it,VS.110).gifEsplorazione delle relazioni tra i dati

È possibile leggere dati da entità correlate.Ad esempio, un'entità Customer potrebbe disporre di una relazione uno-a-molti con un'entità Orders.È possibile scorrere tutti gli ordini inseriti da un cliente tramite la proprietà Orders dell'entità Customers.

Nell'esempio seguente si scorre la raccolta di ordini correlata a un cliente.

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

Nell'esempio seguente si ottiene il cliente che ha inserito un ordine specifico.

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(it-it,VS.110).gifLettura dei dati eseguendo una query

È possibile recuperare query dal modello ed eseguirle nel codice.Per un esempio, vedere Procedura: recuperare dati da una query tramite codice.

Aggiornamento di dati

È possibile aggiornare dati per qualsiasi entità tramite codice.Nell'esempio seguente viene mostrato il codice che viene eseguito quando un utente crea un ordine nell'entità Order in una schermata e quindi fa clic sul pulsante Salva.Tramite il codice viene aggiornato un campo nell'entità Products utilizzando un campo nell'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);
    }
}

[!NOTA]

Se tramite il codice vengono modificati i dati da altre origini dati, è necessario eseguire il commit di tali modifiche chiamando il metodo SaveChanges di quell'origine dati.Per ulteriori informazioni, vedere How to: Save Data.

Eliminazione di dati

È possibile eliminare dati chiamando il metodo Delete di una qualsiasi entità.Nell'esempio riportato di seguito viene eliminato un cliente dall'origine dati 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();
    }
}

Aggiunta di dati

Nell'esempio seguente viene aggiunto un nuovo cliente all'origine dati NorthwindData.In questo esempio vengono popolati i campi in cui viene descritto il nuovo cliente utilizzando le informazioni da un contatto aggiunto recentemente a un elenco SharePoint.Nell'esempio viene chiamata una query denominata NewCustomersInSharePoint per determinare quali contatti nell'elenco SharePoint non sono stati ancora importati nell'origine dati 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();


}

Salvataggio di dati

In genere, viene eseguito il commit delle modifiche in sospeso su un'origine dati quando l'utente fa clic sul pulsante Salva in una schermata.Tuttavia, è possibile eseguire il commit anche delle modifiche in sospeso aggiungendo codice tramite cui viene chiamato il metodo SaveChanges di un'origine dati.È necessario aggiungere questo codice se si desidera completare entrambe queste attività:

  • Commit delle modifiche apportate ai dati che si trovano in altre origini dati.

  • Eseguire l'override dell'evento Save di una schermata.

Ff851990.collapse_all(it-it,VS.110).gifCommit delle modifiche apportate ai dati che si trovano in altre origini dati

I file nei quali si scrive codice personalizzato dispongono di un'origine dati primaria.Se si aggiunge codice personalizzato tramite cui vengono modificati i dati da un'altra origine dati nella soluzione di LightSwitch, è necessario eseguire il commit di tali modifiche chiamando il metodo SaveChanges di quell'origine dati.

Nell'esempio seguente viene mostrato il codice che viene eseguito quando un utente crea un ordine in un'entità Order in una schermata e quindi fa clic sul pulsante Salva.Tramite il codice viene aggiornato un campo nell'entità Products utilizzando un campo nell'entità Order Details.Poiché l'entità Products si trova in un'altra origine dati, tramite questo codice viene chiamato il metodo SaveChanges di tale origine dati per eseguire il commit delle modifiche.

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(it-it,VS.110).gifOverride dell'evento Save di una schermata

È possibile modificare il comportamento del pulsante Salva in una schermata eseguendo l'override dell'evento Save.Dal momento che si sta sostituendo il comportamento del pulsante Salva, tramite il codice è necessario chiamare il metodo SaveChanges quando si desidera eseguire il commit delle modifiche in sospeso.

Nell'esempio seguente viene eseguito l'override dell'evento Save di una schermata del cliente per rilevare e gestire un'eccezione specifica che potrebbe essere generata in caso di errore dell'operazione di salvataggio.

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;


}

Convalida dei dati

È possibile applicare regole di convalida personalizzate ai campi di un'entità.È possibile aggiungere messaggi di errore personalizzati visualizzati quando gli utenti modificano il valore delle proprietà con modalità non conformi alle regole di convalida.Per ulteriori informazioni, vedere Procedura: convalidare i dati.

Impostazione delle autorizzazioni sui dati

Per impostazione predefinita, tutti gli utenti possono visualizzare, inserire, eliminare o aggiornare i dati che vengono visualizzati in una schermata.Tuttavia, è possibile limitare queste autorizzazioni aggiungendo codice a uno dei metodi seguenti:

  • CanRead

  • CanInsert

  • CanDelete

  • CanUpdate

Se si limita un'operazione tramite questi metodi, in LightSwitch tale operazione non sarà resa disponibile a utenti che non dispongono di autorizzazioni senza restrizioni.Per ulteriori informazioni, vedere Procedura: gestire gli eventi di dati.

Nell'esempio seguente un utente, se dispone dell'autorizzazione di aggiornamento, può aggiornare le informazioni sul cliente.Per questo esempio di codice viene richiesto un gruppo di autorizzazioni denominato RoleUpdate.Per ulteriori informazioni su come aggiungere un gruppo di autorizzazioni all'applicazione, vedere Abilitazione dell'autorizzazione e creazione di autorizzazioni.

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

Per impostazione predefinita, in LightSwitch questi metodi vengono chiamati quando un utente tenta di visualizzare, inserire, eliminare o aggiornare informazioni.È possibile chiamare anche questi metodi nel codice personalizzato prima che vengano letti o modificati i dati.

Utilizzo dei set di modifiche

È possibile identificare e rimuovere modifiche in sospeso prima che venga eseguito il commit di tali modifiche su un'origine dati.Nell'esempio seguente vengono mostrati tre metodi di supporto che consentono di identificare e rimuovere le modifiche in sospeso.Tramite il metodo UndoAllCustomerUpdates vengono rimosse tutte le modifiche apportate a tutti i clienti.Tramite il metodo UndoAllUpdates vengono rimosse tutte le modifiche apportate all'origine dati.Tramite il metodo UndoCustomerEdit vengono rimosse le modifiche apportate alla riga di dati attualmente selezionata in una schermata del cliente.

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

Estensione di query create in base a un modello

Se si desidera modificare una query oltre le funzionalità della progettazione query, è possibile estendere la query aggiungendo codice al metodo PreProcessQuery della query.Per ulteriori informazioni, vedere Procedura: estendere una query tramite codice.

Vedere anche

Concetti

Scrittura di codice in LightSwitch