Liaison d'objets dans Visual Studio

Article
08/21/2008

Mise à jour : novembre 2007

Visual Studio fournit des outils de conception pour l'utilisation d'objets personnalisés (par opposition aux groupes de données et services Web) comme source de données dans votre application.

La seule condition indispensable au bon fonctionnement des objets personnalisés avec les outils de conception de données dans Visual Studio est que l'objet possède au moins une propriété publique. Aucun constructeur ou attribut spécifique n'est requis pour que les objets personnalisés fonctionnent avec des outils tels que la fenêtre Sources de données.

Alors qu'il existe d'innombrables façons d'implémenter votre logique d'application lors de l'utilisation d'objets en tant que source de données, il existe un certain nombre d'opérations standard qui peuvent être simplifiées grâce aux nouveaux objets TableAdapter générés par Visual Studio. Cette page explique comment implémenter ces processus standard à l'aide de TableAdapters ; elle n'est pas conçue comme un guide pour créer vos objets personnalisés. Par exemple, vous exécutez généralement les opérations standard suivantes indépendamment de l'implémentation spécifique de vos objets ou de la logique de l'application :

Chargement de données dans des objets (généralement à partir d'une base de données)
Création d'une collection typée d'objets
Ajout et suppression d'objets dans une collection
Affichage des données d'objet pour les utilisateurs sur un formulaire
Modification/édition des données dans un objet
Réenregistrement des données provenant d'objets dans la base de données

Remarque :
Pour mieux comprendre et fournir le contexte pour les exemples de cette page, nous vous suggérons d'effectuer la procédure suivante : Procédure pas à pas : connexion aux données dans des objets. Cette procédure pas à pas crée les objets présentés sur cette page d'aide.

Chargement de données dans des objets

Pour cet exemple, vous chargez des données dans vos objets à l'aide de TableAdapters. Par défaut, les TableAdapters sont créés avec deux types de méthodes qui extraient les données d'une base de données et remplissent des tables de données.

La méthode TableAdapter.Fill remplit une table de données existante avec les données retournées.
La méthode TableAdapter.GetData retourne une nouvelle table de données remplie avec les données.

La façon la plus facile de charger vos objets personnalisés avec les données consiste à appeler la méthode TableAdapter.GetData, parcourir la collection de lignes dans la table de données retournée et remplir chaque objet avec les valeurs dans chaque ligne. Vous pouvez créer une méthode GetData qui retourne une table de données remplie pour toute requête ajoutée à un TableAdapter.

Remarque :
Visual Studio nomme les requêtes TableAdapter Fill et GetData par défaut, mais ces noms peuvent être modifiés en noms de méthodes valides.

L'exemple suivant indique comment parcourir les lignes d'une table de données et remplir un objet avec les données :

Pour obtenir un exemple de code complet, consultez Procédure pas à pas : connexion aux données dans des objets.

Private Sub LoadCustomers()
    Dim customerData As NorthwindDataSet.CustomersDataTable = _
        CustomersTableAdapter1.GetTop5Customers()

    Dim customerRow As NorthwindDataSet.CustomersRow

    For Each customerRow In customerData
        Dim currentCustomer As New Customer()
        With currentCustomer

            .CustomerID = customerRow.CustomerID
            .CompanyName = customerRow.CompanyName

            If Not customerRow.IsAddressNull Then
                .Address = customerRow.Address
            End If

            If Not customerRow.IsCityNull Then
                .City = customerRow.City
            End If

            If Not customerRow.IsContactNameNull Then
                .ContactName = customerRow.ContactName
            End If

            If Not customerRow.IsContactTitleNull Then
                .ContactTitle = customerRow.ContactTitle
            End If

            If Not customerRow.IsCountryNull Then
                .Country = customerRow.Country
            End If

            If Not customerRow.IsFaxNull Then
                .Fax = customerRow.Fax
            End If

            If Not customerRow.IsPhoneNull Then
                .Phone = customerRow.Phone
            End If

            If Not customerRow.IsPostalCodeNull Then
                .PostalCode = customerRow.PostalCode
            End If

            If Not customerRow.Is_RegionNull Then
                .Region = customerRow._Region
            End If

        End With

        LoadOrders(currentCustomer)
        CustomerBindingSource.Add(currentCustomer)
    Next
End Sub

private void LoadCustomers()
{
    NorthwindDataSet.CustomersDataTable customerData = 
        customersTableAdapter1.GetTop5Customers();

    foreach (NorthwindDataSet.CustomersRow customerRow in customerData)
    {
        Customer currentCustomer = new Customer();
        currentCustomer.CustomerID = customerRow.CustomerID;
        currentCustomer.CompanyName = customerRow.CompanyName;

        if (customerRow.IsAddressNull() == false)
        {
            currentCustomer.Address = customerRow.Address;
        }

        if (customerRow.IsCityNull() == false)
        {
            currentCustomer.City = customerRow.City;
        }

        if (customerRow.IsContactNameNull() == false)
        {
            currentCustomer.ContactName = customerRow.ContactName;
        }

        if (customerRow.IsContactTitleNull() == false)
        {
            currentCustomer.ContactTitle = customerRow.ContactTitle;
        }

        if (customerRow.IsCountryNull() == false)
        {
            currentCustomer.Country = customerRow.Country;
        }

        if (customerRow.IsFaxNull() == false)
        {
            currentCustomer.Fax = customerRow.Fax;
        }

        if (customerRow.IsPhoneNull() == false)
        {
            currentCustomer.Phone = customerRow.Phone;
        }

        if (customerRow.IsPostalCodeNull() == false)
        {
            currentCustomer.PostalCode = customerRow.PostalCode;
        }

        if (customerRow.IsRegionNull() == false)
        {
            currentCustomer.Region = customerRow.Region;
        }

        LoadOrders(currentCustomer);
        customerBindingSource.Add(currentCustomer);
    }
}

Création d'une collection typée d'objets

Vous pouvez créer des classes de collection pour vos objets ou utiliser les collections typées qui sont fournies automatiquement par lecomposant BindingSource.

Lorsque vous créez une classe de collection personnalisée pour les objets, nous vous suggérons d'hériter de BindingList<T>. Cette classe générique fournit les fonctionnalités destinées à l'administration de votre collection et vous permet de déclencher des événements qui envoient des notifications à l'infrastructure de liaison de données dans Windows Forms.

La collection générée automatiquement dans BindingSource utilise BindingList<T> pour sa collection typée. Si votre application ne nécessite pas de fonctionnalités supplémentaires, vous pouvez conserver votre collection dans BindingSource. Pour plus d'informations, reportez-vous à la propriété List de la classe BindingSource.

Remarque :
Si votre collection requiert des fonctionnalités non fournies par l'implémentation de base de BindingList<T>, vous devez créer une collection personnalisée pour pouvoir ajouter à la classe selon les besoins.

Le code suivant indique comment créer la classe pour une collection fortement typée d'objets Order :

''' <summary>
''' A collection of Orders
''' </summary>
Public Class Orders
    Inherits System.ComponentModel.BindingList(Of Order)

    ' Add any additional functionality required by your collection.

End Class

/// <summary>
/// A collection of Orders
/// </summary>
public class Orders: System.ComponentModel.BindingList<Order>
{
    // Add any additional functionality required by your collection.
}

Ajout de plusieurs objets à une collection.

Vous ajoutez des objets à une collection en appelant la méthode Add de votre classe de collection personnalisée ou de BindingSource.

Pour obtenir un exemple d'ajout de collection à l'aide de BindingSource, consultez la méthode LoadCustomers dans Procédure pas à pas : connexion aux données dans des objets.

Pour obtenir un exemple d'ajout d'objets à une collection personnalisée, consultez la méthode LoadOrders dans Procédure pas à pas : connexion aux données dans des objets.

Remarque :
La méthode Add est fournie automatiquement pour votre collection personnalisée lorsque vous héritez de BindingList<T>.

Le code suivant indique comment ajouter des objets à la collection typée à BindingSource :

Dim currentCustomer As New Customer()
CustomerBindingSource.Add(currentCustomer)

Customer currentCustomer = new Customer();
customerBindingSource.Add(currentCustomer);

Le code suivant indique comment ajouter des objets à une collection typée qui hérite de BindingList<T> :

Remarque :
Dans cet exemple, la collection Orders est une propriété de l'objet Customer.

Dim currentOrder As New Order()
currentCustomer.Orders.Add(currentOrder)

Order currentOrder = new Order();
currentCustomer.Orders.Add(currentOrder);

Suppression d'objets d'une collection

Vous supprimez des objets d'une collection en appelant la méthode Remove ou RemoveAt de votre classe de collection personnalisée ou de BindingSource.

Remarque :
Les méthodes Remove et RemoveAt sont fournies automatiquement pour votre collection personnalisée lorsque vous héritez de BindingList<T>.

Le code suivant indique comment localiser et supprimer des objets de la collection typée dans un BindingSource avec la méthode RemoveAt :

Dim customerIndex As Integer = CustomerBindingSource.Find("CustomerID", "ALFKI")
CustomerBindingSource.RemoveAt(customerIndex)

int customerIndex = customerBindingSource.Find("CustomerID", "ALFKI");
customerBindingSource.RemoveAt(customerIndex);

Affichage de données d'objet pour les utilisateurs

Pour afficher les données contenues dans des objets pour les utilisateurs, créez une source de données d'objet à l'aide de l'Assistant Configuration de source de données, puis faites glisser l'objet entier ou les propriétés individuelles sur votre formulaire à partir de la fenêtre Sources de données.

Pour plus d'informations sur la création d'une source de données d'objet, consultez Comment : établir une connexion à des données dans un objet.

Pour plus d'informations sur l'affichage de données provenant d'objets sur Windows Forms, consultez Affichage des données sur des formulaires dans les applications Windows.

Modification des données contenues dans des objets

Pour modifier les données contenues dans des objets personnalisés qui sont liés par des données aux contrôles Windows Forms, il vous suffit de modifier les données dans le contrôle associé (ou directement dans les propriétés de l'objet). L'architecture de liaison de données met à jour les données dans l'objet.

Si votre application nécessite le suivi de modifications et la restauration de modifications proposées à leurs valeurs d'origine, vous devez implémenter ces fonctionnalités dans votre modèle objet. Pour obtenir des exemples de la façon dont les tables de données suivent les modifications proposées, consultez DataRowState, HasChanges et GetChanges.

Réenregistrement dans la base de données de données contenues dans les objets

Vous réenregistrez des données dans la base de données en passant les valeurs provenant de votre objet dans les méthodes DBDirect du TableAdapter.

Visual Studio crée des méthodes DBDirect qui peuvent être exécutées directement par rapport à la base de données. Ces méthodes ne requièrent pas d'objets DataSet ou DataTable.

Méthode DBDirect de TableAdapter	Description
TableAdapter.Insert	Ajoute de nouveaux enregistrements à une base de données, ce qui vous permet de passer des valeurs de colonne individuelles comme paramètres de méthode.
TableAdapter.Update	Met à jour des enregistrements existants dans une base de données. La méthode Update prend des valeurs de colonne nouvelles et d'origine comme paramètres de méthode. Les valeurs d'origine servent à localiser l'enregistrement d'origine et les nouvelles valeurs à mettre à jour cet enregistrement. La méthode TableAdapter.Update permet également de rapprocher les modifications apportées à un groupe de données dans la base de données en prenant une DataSet, DataTable, DataRow ou un tableau de DataRow comme paramètres de méthode.
TableAdapter.Delete	Supprimer des enregistrements existants de la base de données en fonction des valeurs de colonne transmises en tant que paramètres de méthode.

TableAdapter.Insert

Ajoute de nouveaux enregistrements à une base de données, ce qui vous permet de passer des valeurs de colonne individuelles comme paramètres de méthode.

TableAdapter.Update

Met à jour des enregistrements existants dans une base de données. La méthode Update prend des valeurs de colonne nouvelles et d'origine comme paramètres de méthode. Les valeurs d'origine servent à localiser l'enregistrement d'origine et les nouvelles valeurs à mettre à jour cet enregistrement.

La méthode TableAdapter.Update permet également de rapprocher les modifications apportées à un groupe de données dans la base de données en prenant une DataSet, DataTable, DataRow ou un tableau de DataRow comme paramètres de méthode.

TableAdapter.Delete

Supprimer des enregistrements existants de la base de données en fonction des valeurs de colonne transmises en tant que paramètres de méthode.

Pour enregistrer des données provenant d'une collection d'objets, parcourez la collection d'objets (par exemple, à l'aide d'une boucle for-next) et envoyez les valeurs pour chaque objet à la base de données à l'aide des méthodes DBDirect du TableAdapter.

L'exemple suivant indique comment utiliser la méthode TableAdapter.Insert DBDirect pour ajouter un nouveau client directement dans la base de données :

Private Sub AddNewCustomer(ByVal currentCustomer As Customer)

    CustomersTableAdapter.Insert( _
        currentCustomer.CustomerID, _
        currentCustomer.CompanyName, _
        currentCustomer.ContactName, _
        currentCustomer.ContactTitle, _
        currentCustomer.Address, _
        currentCustomer.City, _
        currentCustomer.Region, _
        currentCustomer.PostalCode, _
        currentCustomer.Country, _
        currentCustomer.Phone, _
        currentCustomer.Fax)
End Sub

private void AddNewCustomers(Customer currentCustomer)
{
    customersTableAdapter.Insert( 
        currentCustomer.CustomerID, 
        currentCustomer.CompanyName, 
        currentCustomer.ContactName, 
        currentCustomer.ContactTitle, 
        currentCustomer.Address, 
        currentCustomer.City, 
        currentCustomer.Region, 
        currentCustomer.PostalCode, 
        currentCustomer.Country, 
        currentCustomer.Phone, 
        currentCustomer.Fax);
}