Lier des objets en tant que sources de données dans des applications .NET Framework à l’aide de Visual Studio

Visual Studio fournit des outils au moment du design pour l’utilisation d’objets personnalisés comme source de données dans votre application. Lorsque vous souhaitez stocker des données à partir d’une base de données dans un objet que vous liez aux contrôles d’interface utilisateur, l’approche recommandée consiste à utiliser Entity Framework pour générer la classe ou les classes. Entity Framework génère automatiquement tout le code standard de suivi des modifications, ce qui signifie que toutes les modifications apportées aux objets locaux sont automatiquement enregistrées dans la base de données lorsque vous appelez AcceptChanges sur l'objet DbSet. Pour plus d’informations, consultez la documentation Entity Framework.

Exigences relatives à l’objet

La seule exigence pour que les objets personnalisés fonctionnent avec les outils de conception de données dans Visual Studio est que l’objet a besoin d’au moins une propriété publique.

En règle générale, les objets personnalisés ne nécessitent pas d’interfaces, de constructeurs ou d’attributs spécifiques pour agir comme source de données pour une application. Toutefois, si vous souhaitez faire glisser l’objet de la fenêtre Sources de données vers une aire de conception pour créer un contrôle lié aux données, et si l’objet implémente l'interface ITypedList ou IListSource, l’objet doit avoir un constructeur par défaut. Sinon, Visual Studio ne peut pas instancier l’objet source de données et affiche une erreur lorsque vous faites glisser l’élément vers l’aire de conception.

Exemples d’utilisation d’objets personnalisés comme sources de données

Bien qu’il existe de nombreuses façons d’implémenter votre logique d’application lors de l’utilisation d’objets comme source de données, pour les bases de données SQL, il existe quelques opérations standard qui peuvent être simplifiées à l’aide des objets TableAdapter générés par Visual Studio. Cette page explique comment implémenter ces processus standard à l’aide de TableAdapters. Il n’est pas destiné à servir de guide pour la création de vos objets personnalisés. Par exemple, vous allez généralement effectuer les opérations standard suivantes, quelle que soit l’implémentation spécifique de vos objets ou 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 d’objets à une collection et suppression d’objets.

• Affichage des données d’objet aux utilisateurs d’un formulaire.

• Modification/édition des données dans un objet.

• Enregistrement des données des objets dans la base de données.

Charger des données dans des objets

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

• La TableAdapter.Fill méthode remplit une table de données existante avec les données retournées.

• La TableAdapter.GetData méthode retourne une nouvelle table de données remplie avec des données.

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

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

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

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

Créer 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 automatiquement fournies par le composant 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 des fonctionnalités pour administrer votre collection, ainsi que la possibilité 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 de le BindingSource utilise une 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 le BindingSource. Pour plus d’informations, consultez la List propriété de la BindingSource classe.

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

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

''' <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

Ajouter des objets à une collection

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

Le code suivant montre comment ajouter des objets à la collection typée dans un BindingSource:

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

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

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

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

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

Supprimer des 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.

Le code suivant montre comment localiser et supprimer des objets de la collection typée dans une BindingSource avec la méthodeRemoveAt :

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

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

Afficher les données d’objet aux utilisateurs

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

Modifier les données dans les objets

Pour modifier des données dans des objets personnalisés liés aux contrôles Windows Forms, modifiez simplement les données dans le contrôle lié (ou directement dans les propriétés de l’objet). L’architecture de liaison de données met à jour les données de l’objet.

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

Enregistrer les données des objets dans la base de données

Enregistrez les données dans la base de données en passant les valeurs de votre objet aux méthodes DBDirect de TableAdapter.

Visual Studio crée des méthodes DBDirect qui peuvent être exécutées directement sur la base de données. Ces méthodes ne nécessitent pas d’objets DataSet ou DataTable.

Pour enregistrer des données à partir d’une collection d’objets, parcourez la collection d’objets (par exemple, à l’aide d’une boucle for-next). Envoyez les valeurs de chaque objet à la base de données à l’aide des méthodes DBDirect de TableAdapter.

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

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

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

Contenu connexe

• lier des contrôles aux données dans Visual Studio