Ausführen datenbezogener Aufgaben mithilfe von Code

Mit den Designern und Toolfenstern in Visual Studio LightSwitch können Sie zahlreiche datenbezogene Entwurfsaufgaben ausführen.Bestimmte Aufgaben können jedoch nur ausgeführt werden, indem einer Anwendung Code hinzugefügt wird.Um beispielsweise durch das Anwenden benutzerdefinierter Bedingungen ein Feld zu überprüfen, müssen Sie Code schreiben.In diesem Dokument wird gezeigt, wie datenbezogene Aufgaben mit dem Laufzeitobjekt-Datenmodell ausgeführt werden können.Weitere Informationen dazu, wo Sie in einer Anwendung Code schreiben und einfügen können, finden Sie in den folgenden Themen:

• Gewusst wie: Behandlung von Datenereignissen

• Gewusst wie: Behandeln von Silverlight-Bildschirmereignissen

• Gewusst wie: Behandlung von Abfrageereignissen

Allgemeine Hinweise zum Schreiben von Code in Visual Studio LightSwitch finden Sie unter Schreiben von Code in LightSwitch.

Allgemeine Aufgaben

In der folgenden Liste werden gängige Aufgaben für Daten angezeigt, die Sie mit dem Laufzeitobjekt-Datenmodell ausführen können.Die Aufgaben werden weiter unten in diesem Dokument beschrieben.

• Lesen von Daten

• Aktualisieren von Daten

• Löschen von Daten

• Hinzufügen von Daten

• Speichern von Daten

• Überprüfen von Daten

• Festlegen von Berechtigungen für Daten

• Arbeiten mit Changesets

• Erweitern von Abfragen

Lesen von Daten

Sie können einzelne Datenelemente oder Auflistungen von Datenelementen aus einer beliebigen Datenquelle in der Anwendung auslesen.

Im folgenden Beispiel wird der Kunde abgerufen, der gerade in einem Bildschirm ausgewählt ist.

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

Im folgenden Beispiel wird eine Auflistung von Kunden durchlaufen.

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

Navigieren in Datenbeziehungen

Sie können Daten aus verwandten Entitäten lesen.Beispielsweise kann eine Customer-Entität über eine 1:n-Beziehung zu einer Orders-Entität verfügen.Mit der Orders-Eigenschaft der Customer-Entität können Sie alle Aufträge eines Kunden durchlaufen.

Im folgenden Beispiel wird die Auflistung von Bestellungen durchlaufen, die sich auf einen Kunden beziehen.

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

Im folgenden Beispiel wird der Kunde abgerufen, der eine bestimmte Bestellung aufgegeben hat.

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.

}

Lesen von Daten durch Ausführen einer Abfrage

Sie können Abfragen aus dem Modell der Anwendung abrufen und im Code ausführen.Ein Beispiel hierzu finden Sie unter Gewusst wie: Abrufen von Daten aus einer Abfrage mithilfe von Code.

Aktualisieren von Daten

Sie können Daten für jede Entität mithilfe von Code aktualisieren.Das folgende Beispiel enthält Code, der ausgeführt wird, wenn ein Benutzer in der Order-Entität eines Bildschirms eine Bestellung erstellt und auf die Schaltfläche Speichern klickt.Im Code wird ein Feld in der Products-Entität mit einem Feld in der Order Details-Entität aktualisiert.

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

Hinweis
Wenn mit dem Code Daten aus einer anderen Datenquelle geändert werden, müssen Sie einen Commit für diese Änderungen durchführen, indem Sie die SaveChanges-Methode der Datenquelle aufrufen.Weitere Informationen finden Sie unter How to: Save Data.

Löschen von Daten

Sie können Daten löschen, indem Sie die Delete-Methode einer beliebigen Entität aufrufen.Im folgenden Beispiel wird ein Kunde aus der NorthwindData-Datenquelle gelöscht.

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

Hinzufügen von Daten

Im folgenden Beispiel wird der NorthwindData-Datenquelle ein neuer Kunde hinzugefügt.In diesem Beispiel werden die Felder aufgefüllt, in denen der neue Kunde mit Informationen von einem Kontakt beschrieben wird, der kürzlich einer SharePoint-Liste hinzugefügt wurde.Im Beispiel wird die Abfrage NewCustomersInSharePoint aufgerufen, um zu ermitteln, welche Kontakte in der SharePoint-Liste noch nicht in die NorthwindData-Datenquelle importiert wurden.

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


}

Speichern von Daten

In der Regel werden ausstehende Änderungen an eine Datenquelle übergeben, wenn der Benutzer in einem Bildschirm auf die Schaltfläche Speichern klickt.Sie können jedoch auch einen Commit für ausstehende Änderungen durchführen, indem Sie Code hinzufügen, mit dem die SaveChanges-Methode einer Datenquelle aufgerufen wird.Sie müssen diesen Code hinzufügen, um die folgenden Aufgaben auszuführen:

• Durchführen eines Commits für Änderungen an Daten in anderen Datenquellen

• Überschreiben des Save-Ereignisses eines Bildschirms

Durchführen eines Commits für Änderungen an Daten in anderen Datenquellen

Die Dateien, in die benutzerdefinierter Code geschrieben wird, weisen eine primäre Datenquelle auf.Wenn Sie benutzerdefinierten Code hinzufügen, in dem Daten aus einer anderen Datenquelle in der LightSwitch-Projektmappe geändert werden, müssen Sie einen Commit für diese Änderungen durchführen, indem Sie die SaveChanges-Methode dieser Datenquelle aufrufen.

Das folgende Beispiel enthält Code, der ausgeführt wird, wenn ein Benutzer in der Order-Entität eines Bildschirms eine Bestellung erstellt und auf die Schaltfläche Speichern klickt.Im Code wird ein Feld in der Products-Entität mit einem Feld in der Order Details-Entität aktualisiert.Da sich die Products-Entität in einer anderen Datenquelle befindet, wird von diesem Code die SaveChanges-Methode der Datenquelle aufgerufen, um einen Commit für die Änderungen durchzuführen.

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

}

Überschreiben des Save-Ereignisses eines Bildschirms

Sie können das Verhalten der Schaltfläche Speichern in einem Bildschirm ändern, indem Sie das Save-Ereignis überschreiben.Da Sie das Verhalten der Schaltfläche Speichern ersetzen, muss vom Code die SaveChanges-Methode aufgerufen werden, wenn Sie einen Commit für ausstehende Änderungen durchführen möchten.

Im folgenden Beispiel wird das Save-Ereignis eines Kundenbildschirms überschrieben, um eine bestimmte Ausnahme abzufangen und zu behandeln, die bei einem Fehler während des Speichervorgangs möglicherweise ausgelöst wird.

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;


}

Überprüfen von Daten

Sie können benutzerdefinierte Validierungsregeln auf die Felder einer Entität anwenden.Sie können benutzerdefinierte Fehlermeldungen hinzufügen, die angezeigt werden, wenn Benutzer den Wert der Eigenschaften entgegen den Bestimmungen der Validierungsregeln ändern.Weitere Informationen finden Sie unter Gewusst wie: Überprüfen von Daten.

Festlegen von Berechtigungen für Daten

Standardmäßig können alle Benutzer Daten, die in einem Bildschirm angezeigt werden, anzeigen, einfügen, löschen oder aktualisieren.Sie können diese Berechtigungen jedoch einschränken, indem Sie einer der folgenden Methoden Code hinzufügen:

• CanRead

• CanInsert

• CanDelete

• CanUpdate

Wenn Sie einen Vorgang mit diesen Methoden einschränken, macht LightSwitch den Vorgang nicht für Benutzer verfügbar, die nur über eingeschränkte Berechtigungen verfügen.Weitere Informationen finden Sie unter Gewusst wie: Behandlung von Datenereignissen.

Das folgende Beispiel ermöglicht es einem Benutzer, Kundeninformationen zu aktualisieren, wenn der Benutzer über die Berechtigung zur Aktualisierung verfügt.Dieses Codebeispiel erfordert eine Berechtigungsgruppe mit dem Namen RoleUpdate.Weitere Informationen zum Hinzufügen einer Berechtigungsgruppe zur Anwendung finden Sie unter Aktivieren der Autorisierung und Erstellen von Berechtigungen

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

Diese Methoden werden von LightSwitch standardmäßig aufgerufen, wenn ein Benutzer versucht, Informationen anzuzeigen, einzufügen, zu löschen oder zu aktualisieren.Sie können diese Methoden auch im benutzerdefinierten Code aufrufen, bevor Daten gelesen oder geändert werden.

Arbeiten mit Changesets

Sie können ausstehende Änderungen identifizieren und verwerfen, bevor dafür ein Commit für eine Datenquelle durchgeführt wird.Im folgenden Beispiel werden drei Benutzermethoden zum Identifizieren und Verwerfen von ausstehenden Änderungen veranschaulicht.Mit der UndoAllCustomerUpdates-Methode werden alle an allen Kunden vorgenommenen Änderungen verworfen.Mit der UndoAllUpdates-Methode werden alle an der Datenquelle vorgenommenen Änderungen verworfen.Mit der UndoCustomerEdit-Methode werden Änderungen verworfen, die an der derzeit ausgewählten Datenzeile in einem Kundenbildschirm vorgenommen wurden.

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

Erweitern von modellierten Abfragen

Wenn Sie eine Abfrage über die Funktionen des Abfrage-Designers hinaus ändern möchten, können Sie die Abfrage erweitern, indem Sie der PreProcessQuery-Methode der Abfrage Code hinzufügen.Weitere Informationen finden Sie unter Gewusst wie: Erweitern einer Abfrage mithilfe von Code.

Siehe auch

Konzepte

Schreiben von Code in LightSwitch