WPF DataGrid Ajouter, mettre à jour et supprimer en utilisant MVVM

Ici sur CodeProject est un article sur WPF DataGrid + pattern MVVM:

http://www.codeproject.com/KB/WPF/MVVM_DataGrid.aspx

Modifier:Collé de la partie, qui s'adapte à votre question.
Article complet: http://www.codeproject.com/Articles/30905/WPF-DataGrid-Practical-Examples

Cet exemple montre comment utiliser un contrôle DataGrid à effectuer des opérations CRUD via la liaison où l'intégration de base de données est découplée par l'intermédiaire d'une Couche d'Accès aux Données (DAL).

L'Architecture

Cet exemple est une simple application CRUD qui permet à l'utilisateur de modifier des éléments dans la table Clients de la base de données Northwind. L'exemple a une Couche d'Accès aux Données, ce qui les expose à Trouver/Supprimer/mettre à Jour les méthodes qui fonctionnent sur de simples objets de données, et une Couche de Présentation qui s'adapte à ces objets de telle sorte qu'ils peuvent être liés de manière efficace par le Framework WPF. Parce que nous sommes uniquement CRUD fonctions, je n'ai pas ajouté une Couche de Logique Métier (BLL); si vous êtes un puriste, vous pouvez ajouter un passe-BLL; cependant, je pense qu'il serait ajouter un peu de cet exemple.

La clé de classes au sein de cette architecture sont présentés ci-dessous:

La Couche d'Accès aux Données expose une interface pour gérer le cycle de vie du Client d'Objets de Données. La classe qui implémente cette interface utilise un DataSet typé comme une base de données de la couche d'intégration; cependant, ce qui est caché des clients de la DAL. La présence de cette couche signifie que nous ne sommes pas directement couplé à la base de données de schéma ou de la générées schéma de dataset, c'est à dire, nous pouvons changer notre schéma, mais encore de fournir l'interface ci-dessous pour nos clients:

public interface ICustomerDataAccessLayer
{
    ///Return all the persistent customers
    List<CustomerDataObject> GetCustomers();

    ///Updates or adds the given customer
    void UpdateCustomer(CustomerDataObject customer);

    ///Delete the given customer
    void DeleteCustomer(CustomerDataObject customer);
}
public class CustomerDataObject
{
    public string ID { get; set; }

    public string CompanyName { get; set; }

    public string ContactName { get; set; }
}

Comme vous pouvez le voir, il n'y a pas d'INTERFACE utilisateur cadre spécifique des interfaces ou des classes (comme ObservableCollection) exposés par le DAL. Le problème ici est de savoir comment lier les clients retournés par ICustomerDataAccess.GetCustomers à notre grille de données et de s'assurer que les modifications sont synchronisées avec la base de données.

On pourrait lier le contrôle DataGrid directement à notre service client de la collection, Liste, cependant, nous devons nous assurer que les UpdateCustomer et DeleteCustomer méthodes sur notre DAL interface sont invoquées au point approprié dans le temps. Une approche que l'on peut prendre est de gérer les événements /commandes exposés par la grille de données afin de déterminer l'action qu'il vient d'effectuer ou entend exercer sur le relié à la clientèle de la collection. Cependant, en agissant de la sorte, nous serions dans l'écriture du code de l'intégration qui est spécifique à la grille de données. Que faire si nous voulions changer l'INTERFACE utilisateur pour présenter une liste et un certain nombre de zones de texte (affichage des détails)? Il nous faudrait ré-écrire cette logique. Aussi, aucun de la grille de données des événements tout à fait correspondre à ce que nous voulons. Il y a de "mettre Fin aux" événements", mais pas "Terminé" événements; par conséquent, les données visibles pour les gestionnaires d'événement n'est pas dans son état validé. Une meilleure approche serait si nous pouvions adapter notre collection d'objets de Client de telle manière qu'ils pourraient être liés à des WPF contrôle d'INTERFACE utilisateur, d'ajouter/modifier/supprimer les opérations synchronisées avec la base de données par l'intermédiaire de notre DAL.
La Manipulation De Supprimer Les Opérations De

La classe ObservableCollection est un bon candidat pour notre liaison de données doit. Il expose un événement CollectionChanged qui est déclenché lorsque des éléments sont ajoutés ou supprimés à partir de la collection. Si on copie les données de nos clients dans une ObservableCollection et lier cela à la grille, nous pouvons gérer l'événement CollectionChanged et d'effectuer l'opération requise sur le DAL. L'extrait de code suivant montre comment le CustomerObjectDataProvider (qui est définie comme une ObjectDataProvider dans le code XAML) construit une ObservableCollection de CustomerUIObjects. Ces objets de l'INTERFACE utilisateur tout simplement envelopper leurs données objet homologues afin d'exposer les mêmes propriétés.

public CustomerObjectDataProvider()
{
    dataAccessLayer = new CustomerDataAccessLayer();
}

public CustomerUIObjects GetCustomers()
{
    //populate our list of customers from the data access layer
    CustomerUIObjects customers = new CustomerUIObjects();

    List<CustomerDataObject> customerDataObjects = dataAccessLayer.GetCustomers();
    foreach (CustomerDataObject customerDataObject in customerDataObjects)
    {
        //create a business object from each data object
        customers.Add(new CustomerUIObject(customerDataObject));
    }

    customers.CollectionChanged += new
      NotifyCollectionChangedEventHandler(CustomersCollectionChanged);

    return customers;
}

void CustomersCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
    if (e.Action == NotifyCollectionChangedAction.Remove)
    {
        foreach (object item in e.OldItems)
        {
            CustomerUIObject customerObject = item as CustomerUIObject;

            //use the data access layer to delete the wrapped data object
            dataAccessLayer.DeleteCustomer(customerObject.GetDataObject());
        }
    }
}

Lorsqu'un utilisateur supprime une ligne avec le contrôle DataGrid, l'événement CollectionChanged est tiré sur la collection liée. Dans le gestionnaire d'événements, nous invoquons le DAL DeleteCustomer méthode avec le enveloppés de données de l'objet passé en paramètre.

De la manipulation de supprimer des opérations est relativement simple, mais que diriez-insertions ou mises à jour? Vous pourriez penser que la même approche peut être utilisée, la NotifyCollectionChangedEventArgs.L'Action de la propriété inclut les opérations d'Ajout; cependant, cet événement n'est pas déclenché lorsque les éléments de la collection sont mis à jour. En outre, lorsqu'un utilisateur ajoute un nouvel élément à la grille de données, l'objet est d'abord ajouté à la collection liée à une non-initialisé à l'état, de sorte que nous ne pouvons jamais voir l'objet avec ses valeurs de propriété par défaut. Ce dont nous avons vraiment besoin de faire est de déterminer lorsque l'utilisateur termine la modification d'un élément dans la grille.
Gérer Les Mises À Jour /Inserts

Pour déterminer si un utilisateur a terminé l'édition d'un objet lié, nous avons besoin d'explorer un peu plus profondément dans le mécanisme de liaison de lui-même. Le contrôle DataGrid est capable d'effectuer une livraison atomique de la ligne qui est actuellement en cours d'édition; ceci est rendu possible que si les éléments liés mettre en œuvre l'interface IEditableObject qui expose BeginEdit, EndEdit et méthodes CancelEdit. Généralement, un objet qui implémente cette interface serait de retour à son état au moment de l'BeginEdit méthode a été appelée comme une réponse à la CancelEdit méthode invoquée. Cependant, dans ce cas, nous ne sommes pas vraiment inquiet d'être en mesure d'annuler les modifications; tout ce que nous vraiment besoin de savoir, c'est quand l'utilisateur a fini de modifier une ligne. C'est inculpé lorsque le contrôle DataGrid appelle EndEdit sur notre objet lié.

Afin de prévenir le CustomerDataObjectProvider que EndEdit a été appelée sur l'un des objets de la collection liée, la CustomerUIObject implémente IEditableObject comme suit:

public delegate void ItemEndEditEventHandler(IEditableObject sender);

public event ItemEndEditEventHandler ItemEndEdit;

#region IEditableObject Members

public void BeginEdit() {}

public void CancelEdit() {}

public void EndEdit()
{
    if (ItemEndEdit != null)
    {
        ItemEndEdit(this);
    }
}

#endregion

Lorsque des éléments sont ajoutés à la CustomerUIObjects collection, cet événement est pris en charge pour tous les éléments de la collection, avec le gestionnaire de simplement transmettre l'événement:

public class CustomerUIObjects : ObservableCollection<CustomerDataObject>
{
    protected override void InsertItem(int index, CustomerUIObject item)
    {
        base.InsertItem(index, item);

        //handle any EndEdit events relating to this item
        item.ItemEndEdit += new ItemEndEditEventHandler(ItemEndEditHandler);
    }

    void ItemEndEditHandler(IEditableObject sender)
    {
        //simply forward any EndEdit events
        if (ItemEndEdit != null)
        {
            ItemEndEdit(sender);
        }
    }

    public event ItemEndEditEventHandler ItemEndEdit;
}

La CustomerObjectDataProvider pouvez maintenant gérer cet événement afin de recevoir la notification de CommitEdit être appelé sur un des objets liés. Il peut alors invoquer le DAL méthodes pour synchroniser la base de données de l'état:

public CustomerUIObjects GetCustomers()
{
    //populate our list of customers from the data access layer
    CustomerUIObjects customers = new CustomerUIObjects();

    List<CustomerDataObject> customerDataObjects = dataAccessLayer.GetCustomers();
    foreach (CustomerDataObject customerDataObject in customerDataObjects)
    {
        //create a business object from each data object
        customers.Add(new CustomerUIObject(customerDataObject));
    }

    customers.ItemEndEdit += new ItemEndEditEventHandler(CustomersItemEndEdit);
    customers.CollectionChanged += new
      NotifyCollectionChangedEventHandler(CustomersCollectionChanged);

    return customers;
}

void CustomersItemEndEdit(IEditableObject sender)
{
    CustomerUIObject customerObject = sender as CustomerUIObject;

    //use the data access layer to update the wrapped data object
    dataAccessLayer.UpdateCustomer(customerObject.GetDataObject());
}

Le code ci-dessus de la poignée d'insertion et de mise à jour.

En conclusion, cette méthode s'adapte les éléments de données et la collecte fournis par le DAL dans les éléments de l'UI et les collections qui sont plus appropriées pour la liaison de données dans le Framework WPF. La base de données de synchronisation logique est effectuée par la gestion de l'événement de cette collection liée; par conséquent, il n'y a pas de WPF DataGrid code spécifique.