Binden von Daten an Steuerelemente (WCF Data Services)Binding Data to Controls (WCF Data Services)

Mit WCF Data ServicesWCF Data Services können Sie Steuerelemente wie ComboBox und ListView an eine Instanz der DataServiceCollection<T>-Klasse binden.With WCF Data ServicesWCF Data Services, you can bind controls such as the ComboBox and ListView controls to an instance of the DataServiceCollection<T> class. Diese Auflistung, die von der ObservableCollection<T>-Klasse erbt, enthält die Daten aus einem Open Data Protocol (OData)Open Data Protocol (OData)-Feed.This collection, which inherits from the ObservableCollection<T> class, contains the data from an Open Data Protocol (OData)Open Data Protocol (OData) feed. Die Klasse stellt eine dynamische Datensammlung dar, die Benachrichtigungen bereitstellt, wenn Elemente hinzugefügt oder entfernt werden.This class represents a dynamic data collection that provides notifications when items get added or removed. Wenn Sie eine Instanz von DataServiceCollection<T> für die Datenbindung verwenden, behandeln die WCF Data ServicesWCF Data Services Client Bibliotheken diese Ereignisse, um sicherzustellen DataServiceContext , dass vom verfolgte Objekte mit den Daten im gebundenen Benutzeroberflächen Element synchronisiert bleiben.When you use an instance of DataServiceCollection<T> for data binding, the WCF Data ServicesWCF Data Services client libraries handle these events to ensure that objects tracked by the DataServiceContext remain synchronized with the data in the bound UI element.

Die DataServiceCollection<T>-Klasse implementiert (indirekt) die INotifyCollectionChanged-Schnittstelle, um den Kontext zu warnen, wenn Objekte der Sammlung hinzugefügt oder daraus entfernt werden.The DataServiceCollection<T> class (indirectly) implements the INotifyCollectionChanged interface to alert the context when objects are added to or removed from the collection. Mit einer DataServiceCollection<T>-Instanz verwendete Datendiensttypobjekte müssen auch die INotifyPropertyChanged-Schnittstelle implementieren, um die DataServiceCollection<T>-Instanz zu warnen, wenn sich Eigenschaften von Objekten in der Bindungssammlung geändert haben.Data service type objects used with a DataServiceCollection<T> must also implement the INotifyPropertyChanged interface to alert the DataServiceCollection<T> when properties of objects in the binding collection have changed.

Hinweis

Wenn Sie das Dialogfeld Dienstverweis hinzufügen oder das Tool DataSvcUtil. exe mit der /dataservicecollection Option zum Generieren der Client Datendienst Klassen verwenden, implementieren die generierten Daten Klassen INotifyPropertyChanged die-Schnittstelle.When you use the Add Service Reference dialog or the DataSvcUtil.exe tool with the /dataservicecollection option to generate the client data service classes, the generated data classes implement the INotifyPropertyChanged interface. Weitere Informationen finden Sie unter Vorgehensweise: Manuelles Generieren von Client DatenDienst Klassen.For more information, see How to: Manually Generate Client Data Service Classes.

Erstellen der BindungsauflistungCreating the Binding Collection

Erstellen Sie eine neue Instanz der DataServiceCollection<T>-Klasse, indem Sie eine der Klassenkonstruktormethoden mit einer angegebenen DataServiceContext-Instanz und optional eine DataServiceQuery<TElement> oder LINQ-Abfrage aufrufen, die bei Ausführung eine IEnumerable<T>-Instanz zurückgibt.Create a new instance of the DataServiceCollection<T> class by calling one of the class constructor methods with a supplied DataServiceContext instance and optionally a DataServiceQuery<TElement> or LINQ query that, when it is executed, returns an IEnumerable<T> instance. Dadurch IEnumerable<T> wird die Quelle von Objekten für die Bindungs Auflistung bereitstellt, die von einem ODataOData -Feed materialisiert werden.This IEnumerable<T> provides the source of objects for the binding collection, which are materialized from an ODataOData feed. Weitere Informationen finden Sie unter Objektmaterialisierung.For more information, see Object Materialization. Standardmäßig werden an in die Auflistung eingefügten gebundenen Objekten und Elementen vorgenommene Änderungen automatisch vom DataServiceContext nachverfolgt.By default, changes made to bound objects and items inserted into the collection are automatically tracked by the DataServiceContext. Wenn Sie diese Änderungen manuell nachverfolgen müssen, müssen Sie eine der Konstruktormethoden aufrufen, die trackingMode einen-Parameter annimmt, und Noneden Wert angeben.If you need to manually track these changes, call one of the constructor methods that takes a trackingMode parameter and specify a value of None.

Im folgenden Beispiel wird gezeigt, wie eine Instanz von DataServiceCollection<T> basierend auf einem angegebenen DataServiceContext und einer DataServiceQuery<TElement> erstellt wird, die alle Kunden mit verknüpften Bestellungen zurückgibt:The following example shows how to create an instance of DataServiceCollection<T> based on a supplied DataServiceContext and a DataServiceQuery<TElement> that returns all customers with related orders:

// Create a new collection that contains all customers and related orders.
DataServiceCollection<Customer> trackedCustomers = 
    new DataServiceCollection<Customer>(context.Customers.Expand("Orders"));
' Create a new collection that contains all customers and related orders.
Dim trackedCustomers As DataServiceCollection(Of Customer) = _
        New DataServiceCollection(Of Customer)(context.Customers.Expand("Orders"))

Binden von Daten an Windows Presentation Foundation-ElementeBinding Data to Windows Presentation Foundation Elements

Da die DataServiceCollection<T>-Klasse von der ObservableCollection<T>-Klasse erbt, können Sie Objekte in einer WPF (Windows Presentation Foundation)-Anwendung an ein Element oder Steuerelement binden, ähnlich wie beim Verwenden der ObservableCollection<T>-Klasse für die Bindung.Because the DataServiceCollection<T> class inherits from the ObservableCollection<T> class, you can bind objects to an element, or control, in a Windows Presentation Foundation (WPF) application as you would when using the ObservableCollection<T> class for binding. Weitere Informationen finden Sie unter Datenbindung (Windows Presentation Foundation).For more information, see Data Binding (Windows Presentation Foundation). Eine Möglichkeit zum Binden von Datendienstdaten an WPF-Steuerelemente ist das Festlegen der DataContext-Eigenschaft des Elements auf die Instanz der DataServiceCollection<T>-Klasse, die das Abfrageergebnis enthält.One way to bind data service data to WPF controls is to set the DataContext property of the element to the instance of the DataServiceCollection<T> class that contains the query result. In diesem Fall verwenden Sie die ItemsSource-Eigenschaft, um die Objektquelle für das Steuerelement festzulegen.In this case, you use the ItemsSource property to set the object source for the control. Verwenden Sie die DisplayMemberPath-Eigenschaft, um anzugeben, welche Eigenschaft des gebundenen Objekts angezeigt werden soll.Use the DisplayMemberPath property to specify which property of the bound object to display. Wenn Sie ein Element an ein verknüpftes Objekt binden, das von einer Navigationseigenschaft zurückgegeben wird, schließen Sie den Pfad in die für die ItemsSource-Eigenschaft definierte Bindung ein.If you are binding an element to a related object that is returned by a navigation property, include the path in the binding defined for the ItemsSource property. Der Pfad ist relativ zum Stammobjekt, das von der DataContext-Eigenschaft des übergeordneten Steuerelements festgelegt ist.This path is relative to the root object set by the DataContext property of the parent control. Im folgenden Beispiel wird die DataContext-Eigenschaft eines StackPanel-Elements festgelegt, um das übergeordnete Steuerelement an eine DataServiceCollection<T> von Customer-Objekten zu binden:The following example sets the DataContext property of a StackPanel element to bind the parent control to an DataServiceCollection<T> of customer objects:

// Create a LINQ query that returns customers with related orders.
var customerQuery = from cust in context.Customers.Expand("Orders")
                    where cust.Country == customerCountry
                    select cust;

// Create a new collection for binding based on the LINQ query.
trackedCustomers = new DataServiceCollection<Customer>(customerQuery, 
    TrackingMode.AutoChangeTracking,"Customers", 
    OnPropertyChanged, OnCollectionChanged);

// Bind the root StackPanel element to the collection;
// related object binding paths are defined in the XAML.
this.LayoutRoot.DataContext = trackedCustomers;
// Create a LINQ query that returns customers with related orders.
var customerQuery = from cust in context.Customers.Expand("Orders")
                    where cust.Country == customerCountry
                    select cust;

// Create a new collection for binding based on the LINQ query.
trackedCustomers = new DataServiceCollection<Customer>(customerQuery);

// Bind the root StackPanel element to the collection;
// related object binding paths are defined in the XAML.
LayoutRoot.DataContext = trackedCustomers;
' Create a LINQ query that returns customers with related orders.
Dim customerQuery = From cust In context.Customers.Expand("Orders") _
                        Where cust.Country = customerCountry _
                        Select cust

' Create a new collection for binding based on the LINQ query.
trackedCustomers = New DataServiceCollection(Of Customer)(customerQuery, _
        TrackingMode.AutoChangeTracking, "Customers", _
        AddressOf OnMyPropertyChanged, AddressOf OnMyCollectionChanged)

' Bind the root StackPanel element to the collection
' related object binding paths are defined in the XAML.
Me.LayoutRoot.DataContext = trackedCustomers
' Create a LINQ query that returns customers with related orders.
Dim customerQuery = From cust In context.Customers.Expand("Orders") _
                        Where cust.Country = customerCountry _
                        Select cust

    ' Create a new collection for binding based on the LINQ query.
trackedCustomers = New DataServiceCollection(Of Customer)(customerQuery)

    ' Bind the root StackPanel element to the collection
    ' related object binding paths are defined in the XAML.
Me.LayoutRoot.DataContext = trackedCustomers
' Create a LINQ query that returns customers with related orders.
Dim customerQuery = From cust In context.Customers.Expand("Orders") _
                        Where cust.Country = customerCountry _
                        Select cust

' Create a new collection for binding based on the LINQ query.
trackedCustomers = New DataServiceCollection(Of Customers)(customerQuery, _
        TrackingMode.AutoChangeTracking, "Customers", _
        AddressOf OnMyPropertyChanged, AddressOf OnMyCollectionChanged)

    ' Bind the root StackPanel element to the collection
    ' related object binding paths are defined in the XAML.
    Me.LayoutRoot.DataContext = trackedCustomers
    Me.LayoutRoot.UpdateLayout()

Das folgende Beispiel veranschaulicht die XAML-Bindungsdefinition des untergeordneten DataGrid-Elements und der ComboBox-Steuerelemente:The following example shows the XAML binding definition of the child DataGrid and ComboBox controls:

<StackPanel Orientation="Vertical" Height="Auto" Name="LayoutRoot" Width="Auto">
    <Label Content="Customer ID" Margin="20,0,0,0" />
    <ComboBox Name="customerIDComboBox" DisplayMemberPath="CustomerID" ItemsSource="{Binding}" 
              IsSynchronizedWithCurrentItem="True" SelectedIndex="0" Height="23" Width="120" 
              HorizontalAlignment="Left" Margin="20,0,0,0" VerticalAlignment="Center" />
    <ListView ItemsSource="{Binding Path=Orders}" Name="ordersDataGrid" Margin="34,46,34,50">
        <ListView.View>
            <GridView AllowsColumnReorder="False" ColumnHeaderToolTip="Line Items">
                <GridViewColumn DisplayMemberBinding="{Binding Path=OrderID, Mode=OneWay}" 
                    Header="Order ID" Width="50"/>
                <GridViewColumn DisplayMemberBinding="{Binding Path=OrderDate, Mode=TwoWay}" 
                    Header="Order Date" Width="50"/>
                <GridViewColumn DisplayMemberBinding="{Binding Path=Freight, Mode=TwoWay}" 
                    Header="Freight Cost" Width="50"/>
            </GridView>
        </ListView.View>
    </ListView>
    <Button Name="saveChangesButton" Content="Save Changes" Click="saveChangesButton_Click" 
            Width="80" Height="30" Margin="450,0,0,0"/>
</StackPanel>

Weitere Informationen finden Sie unter Vorgehensweise: Binden Sie Daten an Windows Presentation FoundationElemente.For more information, see How to: Bind Data to Windows Presentation Foundation Elements.

Wenn eine Entität an einer 1:n- oder m:n-Beziehung beteiligt ist, gibt die Navigationseigenschaft für die Beziehung eine Auflistung von verknüpften Objekten zurück.When an entity participates in a one-to-many or many-to-many relationship, the navigation property for the relationship returns a collection of related objects. Wenn Sie das Dialogfeld Dienstverweis hinzufügen oder das Tool DataSvcUtil. exe zum Generieren der Client Datendienst Klassen verwenden, gibt die Navigations Eigenschaft eine Instanz von DataServiceCollection<T>zurück.When you use the Add Service Reference dialog box or the DataSvcUtil.exe tool to generate the client data service classes, the navigation property returns an instance of DataServiceCollection<T>. Dies ermöglicht es Ihnen, verknüpfte Objekte an ein Steuerelement zu binden, und unterstützt allgemeine WPF-Bindungsszenarien, z. B. das Master-Detail-Bindungsmuster für verknüpfte Entitäten.This enables you to bind related objects to a control, and support common WPF binding scenarios, such as the master-detail binding pattern for related entities. Im vorherigen XAML-Beispiel bindet der XAML-Code die Master-DataServiceCollection<T> an das Stammdatenelement.In the previous XAML example, the XAML code binds the master DataServiceCollection<T> to the root data element. Die Bestellung DataGrid wird dann an die aus dem ausgewählten Customers-Objekt zurückgegebene Orders-DataServiceCollection<T> gebunden, die wiederum an das Stammdatenelement des Window gebunden wird.The order DataGrid is then bound to the Orders DataServiceCollection<T> returned from the selected Customers object, which is in turn bound to the root data element of the Window.

Binden von Daten an Windows Forms-SteuerelementeBinding Data to Windows Forms Controls

Legen Sie die DataSource-Eigenschaft des Steuerelements auf die Instanz der DataServiceCollection<T>-Klasse fest, die das Abfrageergebnis enthält, um Objekte an ein Windows Form-Steuerelement zu binden.To bind objects to a Windows Form control, set the DataSource property of the control to the instance of the DataServiceCollection<T> class that contains the query result.

Hinweis

Die Datenbindung wird nur für Steuerelemente unterstützt, die Änderungsereignisse durch das Implementieren der INotifyCollectionChanged- und der INotifyPropertyChanged-Schnittstelle überwachen.Data binding is only supported for controls that listen for change events by implementing the INotifyCollectionChanged and INotifyPropertyChanged interfaces. Wenn ein Steuerelement diese Art von Änderungsbenachrichtigung nicht unterstützt, spiegeln sich Änderungen, die an der zugrunde liegenden DataServiceCollection<T> vorgenommen werden, nicht im gebundenen Steuerelement wider.When a control does not support this kind of change notification, changes that are made to the underlying DataServiceCollection<T> are not reflected in the bound control.

Im folgenden Beispiel wird eine DataServiceCollection<T> an ein ComboBox-Steuerelement gebunden:The following example binds an DataServiceCollection<T> to a ComboBox control:

// Create a new collection for binding based on the LINQ query.
trackedCustomers = new DataServiceCollection<Customer>(customerQuery);

//Bind the Customers combobox to the collection.
customersComboBox.DisplayMember = "CustomerID";
customersComboBox.DataSource = trackedCustomers;
' Create a new collection for binding based on the LINQ query.
trackedCustomers = New DataServiceCollection(Of Customer)(customerQuery)

'Bind the Customers combobox to the collection.
customersComboBox.DisplayMember = "CustomerID"
customersComboBox.DataSource = trackedCustomers

Wenn Sie das Dialogfeld " Dienstverweis hinzufügen " zum Generieren der Client Datendienst Klassen verwenden, wird auch eine Projektdaten Quelle erstellt, die auf DataServiceContextdem generierten basiert.When you use the Add Service Reference dialog to generate the client data service classes, a project data source is also created that is based on the generated DataServiceContext. Mit dieser Datenquelle können Sie Benutzeroberflächen Elemente oder Steuerelemente erstellen, die Daten aus dem Datendienst anzeigen, indem Sie einfach Elemente aus dem Datenquellen Fenster auf den Designer ziehen.With this data source, you can create UI elements or controls that display data from the data service simply by dragging items from the Data Sources window onto the designer. Diese Elemente werden zu an die Datenquelle gebundenen Elementen auf der Benutzeroberfläche der Anwendung.These items become elements in the application UI that are bound to the data source. Weitere Informationen finden Sie unter Vorgehensweise: Binden von Daten mit einer ProjektdatenQuelle.For more information, see How to: Bind Data Using a Project Data Source.

Binden von ausgelagerten DatenBinding Paged Data

Ein Datendienst kann so konfiguriert werden, dass die Menge an abgefragten Daten beschränkt wird, die in einer einzelnen Antwortnachricht zurückgegeben werden.A data service can be configured to limit the amount of queried data that is returned in a single response message. Weitere Informationen finden Sie unter Konfigurieren des Daten Dienstanbieter.For more information, see Configuring the Data Service. Wenn der Datendienst Paging von Antwortdaten durchführt, enthält jede Antwort einen Link, der zum Zurückgeben der nächsten Ergebnisseite verwendet wird.When the data service is paging response data, each response contains a link that is used to return the next page of results. Weitere Informationen finden Sie unter Laden von verzögertem Inhalt.For more information, see Loading Deferred Content. In diesem Fall müssen Sie Seiten durch Aufrufen der Load-Methode für die DataServiceCollection<T> explizit laden, indem Sie den aus der NextLinkUri-Eigenschaft abgerufenen URI wie im folgenden Beispiel weiterleiten:In this case, you must explicitly load pages by calling the Load method on the DataServiceCollection<T> by passing the URI obtained from the NextLinkUri property, as in the following example:

// Create a new collection for binding based on the LINQ query.
trackedCustomers = new DataServiceCollection<Customer>(customerQuery);

// Load all pages of the response at once.
while (trackedCustomers.Continuation != null)
{
    trackedCustomers.Load(
        context.Execute<Customer>(trackedCustomers.Continuation.NextLinkUri));
}
    ' Create a new collection for binding based on the LINQ query.
trackedCustomers = New DataServiceCollection(Of Customer)(customerQuery)

    ' Load all pages of the response at once.
While trackedCustomers.Continuation IsNot Nothing
    trackedCustomers.Load( _
            context.Execute(Of Customer)(trackedCustomers.Continuation.NextLinkUri))
End While

Verknüpfte Objekte werden auf ähnliche Weise geladen.Related objects are loaded in a similar manner. Weitere Informationen finden Sie unter Vorgehensweise: Binden Sie Daten an Windows Presentation FoundationElemente.For more information, see How to: Bind Data to Windows Presentation Foundation Elements.

Anpassen von DatenbindungsverhaltenCustomizing Data Binding Behaviors

Die DataServiceCollection<T>-Klasse ermöglicht Ihnen das Abfangen der Ereignisse, die ausgelöst werden, wenn Änderungen an der Auflistung wie das Hinzufügen oder Entfernen eines Objekts und wenn Änderungen an den Eigenschaften des Objekts in einer Auflistung vorgenommen werden.The DataServiceCollection<T> class enables you to intercept the events raised when changes are made to the collection, such as an object being added or removed, and when changes are made to the properties of object in a collection. Sie können die Datenbindungsereignisse ändern, um das Standardverhalten zu überschreiben, was die folgenden Einschränkungen einschließt:You can modify the data binding events to override the default behavior, which includes the following constraints:

  • Innerhalb der Delegaten wird keine Validierung ausgeführt.No validation is performed within the delegates.

  • Beim Hinzufügen einer Entität werden automatisch verknüpfte Entitäten hinzugefügt.Adding an entity automatically adds related entities.

  • Beim Löschen einer Entität werden die verknüpften Entitäten nicht gelöscht.Deleting an entity does not delete the related entities.

Wenn Sie eine neue Instanz der DataServiceCollection<T> erstellen, haben Sie die Option, die folgenden Parameter anzugeben, die Delegaten für Methoden definieren, die die beim Ändern gebundener Objekte ausgelösten Ereignisse behandeln:When you create a new instance of DataServiceCollection<T>, you have the option to specify the following parameters that define delegates to methods that handle the events raised when bound objects are changed:

Hinweis

WCF Data ServicesWCF Data Services überprüft die benutzerdefinierten Verhalten nicht, die Sie in diesen Delegaten implementieren.performs no validation of the custom behaviors that you implement in these delegates.

Im folgenden Beispiel wird die Remove-Aktion angepasst, um die DeleteLink-Methode und DeleteObject-Methode zum Entfernen von Orders_Details-Entitäten aufzurufen, die zu einer gelöschten Orders-Entität gehören.In the following example, the Remove action is customized to call the DeleteLink and DeleteObject method to remove Orders_Details entities that belong to a deleted Orders entity. Diese benutzerdefinierte Aktion wird ausgeführt, da abhängige Entitäten beim Löschen der übergeordneten Entität nicht automatisch gelöscht werden.This custom action is performed because dependent entities are not automatically deleted when the parent entity is deleted.

// Method that is called when the CollectionChanged event is handled.
private bool OnCollectionChanged(
    EntityCollectionChangedParams entityCollectionChangedinfo)
{
    if (entityCollectionChangedinfo.Action ==
        NotifyCollectionChangedAction.Remove)
    {
        // Delete the related items when an order is deleted.
        if (entityCollectionChangedinfo.TargetEntity.GetType() == typeof(Order))
        {
            // Get the context and object from the supplied parameter.
            DataServiceContext context = entityCollectionChangedinfo.Context;
            Order deletedOrder = entityCollectionChangedinfo.TargetEntity as Order;

            if (deletedOrder.Order_Details.Count == 0)
            {
                // Load the related OrderDetails.
                context.LoadProperty(deletedOrder, "Order_Details");
            }

            // Delete the order and its related items;
            foreach (Order_Detail item in deletedOrder.Order_Details)
            {
                context.DeleteObject(item);
            }

            // Delete the order and then return true since the object is already deleted.
            context.DeleteObject(deletedOrder);

            return true;
        }
        else
        {
            return false;
        }
    }
    else 
    {
        // Use the default behavior.
        return false;
    }
}
' Method that is called when the CollectionChanged event is handled.
Private Function OnMyCollectionChanged( _
    ByVal entityCollectionChangedinfo As EntityCollectionChangedParams) As Boolean
    If entityCollectionChangedinfo.Action = _
        NotifyCollectionChangedAction.Remove Then

        ' Delete the related items when an order is deleted.
        If entityCollectionChangedinfo.TargetEntity.GetType() Is GetType(Order) Then

            ' Get the context and object from the supplied parameter.
            Dim context = entityCollectionChangedinfo.Context
            Dim deletedOrder As Order = _
            CType(entityCollectionChangedinfo.TargetEntity, Order)

            If deletedOrder.Order_Details.Count = 0 Then
                ' Load the related OrderDetails.
                context.LoadProperty(deletedOrder, "Order_Details")
            End If

            ' Delete the order and its related items
            For Each item As Order_Detail In deletedOrder.Order_Details
                context.DeleteObject(item)
            Next

            ' Delete the order and then return false since the object is already deleted.
            context.DeleteObject(deletedOrder)

            Return True
        Else
            Return False
        End If
    Else
        ' Use the default behavior.
        Return False
    End If
End Function
' Method that is called when the CollectionChanged event is handled.
Private Function OnMyCollectionChanged( _
    ByVal entityCollectionChangedinfo As EntityCollectionChangedParams) As Boolean
    If entityCollectionChangedinfo.Action = _
        NotifyCollectionChangedAction.Remove Then

        ' Delete the related items when an order is deleted.
        If entityCollectionChangedinfo.TargetEntity.GetType() Is GetType(Orders) Then

            ' Get the context and object from the supplied parameter.
            Dim context = entityCollectionChangedinfo.Context
            Dim deletedOrder As Orders = _
            CType(entityCollectionChangedinfo.TargetEntity, Orders)

            ' Load the related OrderDetails.
            context.LoadProperty(deletedOrder, "Order_Details")

            ' Delete the order and its related items
            For Each item As Order_Details In deletedOrder.Order_Details
                'context.DeleteLink(deletedOrder, "Order_Details", item)
                context.DeleteObject(item)
            Next

            ' Delete the order and then return false since the object is already deleted.
            context.DeleteObject(deletedOrder)

            Return False
        Else
            Return True
        End If
    Else
        ' Use the default behavior.
        Return True
    End If
End Function

Weitere Informationen finden Sie unter Vorgehensweise: Anpassen des Daten BindungsVerhaltens.For more information, see How to: Customize Data Binding Behaviors.

Das Standardverhalten beim Entfernen eines Objekts aus einer DataServiceCollection<T> mit der Remove-Methode ist, dass das Objekt auch im DataServiceContext als gelöscht markiert wird.The default behavior when an object is removed from a DataServiceCollection<T> by using the Remove method is that the object is also marked as deleted in the DataServiceContext. Sie können einen Delegaten für eine Methode im entityCollectionChanged-Parameter angeben, der beim Auftreten des CollectionChanged-Ereignisses aufgerufen wird, um dieses Verhalten zu ändern.To change this behavior, you can specify a delegate to a method in the entityCollectionChanged parameter that is called when the CollectionChanged event occurs.

Datenbindung mit benutzerdefinierten ClientdatenklassenData Binding with Custom Client Data Classes

Um Objekte in eine DataServiceCollection<T> laden zu können, müssen die Objekte selbst die INotifyPropertyChanged-Schnittstelle implementieren.To be able to load objects into a DataServiceCollection<T>, the objects themselves must implement the INotifyPropertyChanged interface. Datendienst-Client Klassen, die generiert werden, wenn Sie das Dialogfeld Dienstverweis hinzufügen oder das Tool DataSvcUtil. exe verwenden, implementieren diese Schnittstelle.Data service client classes that are generated when you use the Add Service Reference dialog box or the DataSvcUtil.exe tool implement this interface. Wenn Sie eigene Clientdatenklassen bereitstellen, müssen Sie einen anderen Auflistungstyp für die Datenbindung verwenden.If you provide your own client data classes, you must use another type of collection for data binding. Wenn sich Objekte ändern, müssen Sie Ereignisse in den datengebundenen Steuerelementen behandeln, um die folgenden Methoden der DataServiceContext-Klasse aufzurufen:When objects change, you must handle events in the data bound controls to call the following methods of the DataServiceContext class:

  • AddObject - wenn der Auflistung ein neues Objekt hinzugefügt wird.AddObject - when a new object is added to the collection.

  • DeleteObject - wenn ein Objekt aus der Auflistung entfernt wird.DeleteObject - when an object is removed from the collection.

  • UpdateObject - wenn die Eigenschaft eines Objekts in der Auflistung geändert wird.UpdateObject - when a property is changed on an object in the collection.

  • AddLink - wenn einer Auflistung des verknüpften Objekts ein Objekt hinzugefügt wird.AddLink - when an object is added to a collection of related object.

  • SetLink - wenn einer Auflistung verknüpfter Objekte ein Objekt hinzugefügt wird.SetLink - when an object is added to a collection of related objects.

Weitere Informationen finden Sie unter Aktualisieren des Daten Dienstanbieter.For more information, see Updating the Data Service.

Siehe auchSee also