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

  • Article

Remarque

Les jeux de données et les classes associées sont des technologies .NET Framework héritées qui datent du début des années 2000. Elles permettent aux applications d’utiliser des données en mémoire pendant que les applications sont déconnectées de la base de données. Elles sont particulièrement utiles aux applications qui permettent aux utilisateurs de modifier des données, et de rendre ces changements persistants dans la base de données. Même si les jeux de données sont une technologie très efficace, nous vous recommandons d’utiliser Entity Framework Core pour les nouvelles applications .NET. Entity Framework offre un moyen plus naturel d’utiliser des données tabulaires en tant que modèles objet. De plus, il présente une interface de programmation plus simple.

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 provenant d'une base de données dans un objet que vous liez aux contrôles de l'interface utilisateur, l'approche recommandée est d'utiliser Entity Framework pour générer la ou les classes. Entity Framework génère automatiquement tout le code de suivi des modifications réutilisables, ce qui signifie que toutes les modifications apportées aux objets locaux sont automatiquement conservées dans la base de données lorsque vous appelez AcceptChanges sur l’objet DbSet. Pour plus d’informations, consultez la documentation d’Entity Framework.

Conseil

Les approches de liaison d’objet dans cet article ne doivent être prises en compte que si votre application est déjà basée sur des groupes de données. Vous pouvez également utiliser ces approches si vous êtes déjà familiarisé avec les groupes de données, et si les données que vous allez traiter sont tabulaires et pas trop complexes ou trop volumineuses. Pour obtenir un exemple encore plus simple, impliquant le chargement de données directement dans des objets à l’aide d’un DataReader et la mise à jour manuelle de l’interface utilisateur sans liaison de données, consultez l’article Créer une application de données simple à l’aide de ADO.NET.

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’objet ITypedList ou l’interface 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 :

  • Charger des 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 pour les utilisateurs dans un formulaire.

  • Changer/modifier les données d'un objet.

  • Enregistrer des données à partir d’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 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 des données.

Le moyen le plus simple de charger vos objets personnalisés avec des données consiste à appeler la méthode TableAdapter.GetData, à 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 table de données GetData remplie pour toute requête ajoutée à un TableAdapter.

Notes

Visual Studio nomme les requêtes TableAdapter Fill et GetData, par défaut, vous pouvez les remplacer par n’importe quel nom de méthode valide.

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

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.

Notes

Si votre collection nécessite des fonctionnalités non fournies par l’implémentation de base du BindingList<T>, vous devez créer une collection personnalisée afin de pouvoir ajouter à la classe si nécessaire.

Le code suivant montre comment créer la classe d’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.
}

Ajouter des objets à une collection

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

Notes

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

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

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

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

Notes

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

Order currentOrder = 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.

Notes

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

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

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 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, HasChanges et GetChanges.

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

Enregistrez les données dans la base de données en transmettant 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.

Méthode DBDirect du TableAdapter Description
TableAdapter.Insert Ajoute de nouveaux enregistrements à une base de données, ce qui vous permet de transmettre des valeurs de colonne individuelles en tant que paramètres de méthode.
TableAdapter.Update Met à jour les enregistrements existants dans une base de données. La méthode Update prend les valeurs des colonnes originales et nouvelles comme paramètres de méthode. Les valeurs d’origine sont utilisées pour localiser l’enregistrement d’origine et les nouvelles valeurs sont utilisées pour mettre à jour cet enregistrement.

La méthode TableAdapter.Update est également utilisée pour rapprocher les modifications d’un jeu de données vers la base de données, en prenant un DataSet, DataTable, DataRow ou tableau de DataRow comme paramètres de méthode.
TableAdapter.Delete Supprime les enregistrements existants de la base de données en fonction des valeurs de colonne d’origine transmises en tant que paramètres de méthode.

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 méthode TableAdapter.Insert 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);
}

Contenu connexe