Implémentation d'un DataAdapter

Si vous implémentez l'ensemble complet des interfaces des fournisseurs de données .NET Framework, l'implémentation du DataAdapter ne nécessitera qu'un codage minimum, car la classe System.Data.Common.DbDataAdapter fournit l'essentiel de l'implémentation.

Pour utiliser DbDataAdapter

1. Fournissez les implémentations de IDbConnection, IDbCommand, IDataReader, etc. La classe DbDataAdapter met à niveau ces composants dans son implémentation.

2. Créez une classe qui hérite de DbDataAdapter et de IDbDataAdapter. Exemple :

   Public Class TemplateDataAdapter
     Inherits DbDataAdapter
     Implements IDbDataAdapter
   End Class
   [C#]
   public class TemplateDataAdapter : DbDataAdapter, IDbDataAdapter
   {
   }
   

3. Implémentez l'interface IDbDataAdapter et fournissez les implémentations des propriétés et méthodes qui permettent le « typage fort ». Cela permet aux utilisateurs de votre fournisseur de données .NET Framework de faire directement référence aux objets que vous fournissez, au lieu de le faire via des interfaces telles que IDbCommand.

   L'exemple suivant illustre une propriété SelectCommand qui retourne un TemplateCommand fortement typé. La propriété TemplateDataAdapter.SelectCommand retourne un IDbCommand lorsque le TemplateDataAdapter est casté en IDbDataAdapter.

   Private m_selectCommand As TemplateCommand
   
   Property IDbDataAdapterSelectCommand As IDbCommand Implements IDbDataAdapter.SelectCommand
     Get
       Return m_selectCommand
     End Get
     Set
       m_selectCommand = CType(value, TemplateCommand)
     End Set
   End Property
   
   Public Property SelectCommand As TemplateCommand
     Get
       Return m_selectCommand
     End Get
     Set
       m_selectCommand = value
     End Set
   End Property
   [C#]
   private TemplateCommand m_selectCommand;
   
   public TemplateCommand SelectCommand 
   {
     get { return m_selectCommand; }
     set { m_selectCommand = value; }
   }
   
   IDbCommand IDbDataAdapter.SelectCommand 
   {
     get { return m_selectCommand; }
     set { m_selectCommand = (TemplateCommand)value; }
   }
   

4. Implémentez des versions propres au fournisseur de RowUpdatedEventArgs et RowUpdatingEventArgs, ainsi que les types de gestionnaires d'événements associés (ce code est souvent utilisé). Les types d'événements surchargés existent également pour permettre un typage fort, autorisant ainsi l'exposition d'une manière fortement typée de l'objet lui-même, mais aussi des propriétés appropriées (la propriété Command, par exemple). Exemple :

   Public Class TemplateRowUpdatingEventArgs
     Inherits RowUpdatingEventArgs
   
     Public Sub New(row As DataRow, command As IDbCommand, statementType As StatementType, tableMapping As DataTableMapping)
                    MyBase.New(row, command, statementType, tableMapping)
     End Sub
   
     ' Hide the inherited implementation of the command property.
     Public Shadows Property Command As TemplateCommand
       Get
         Return CType(MyBase.Command, TemplateCommand)
       End Get
       Set
         MyBase.Command = value
       End Set
     End Property
   End Class
   
   Public Class TemplateRowUpdatedEventArgs
     Inherits RowUpdatedEventArgs
   
     Public Sub New(row As DataRow, command As IDbCommand, statementType As StatementType, tableMapping As DataTableMapping)
       MyBase.New(row, command, statementType, tableMapping) 
     End Sub
   
     ' Hide the inherited implementation of the command property.
     Public Shadows ReadOnly Property Command As TemplateCommand 
       Get
         Return CType(MyBase.Command, TemplateCommand)
       End Get
     End Property
   End Class
   [C#]
   public class TemplateRowUpdatingEventArgs : RowUpdatingEventArgs
   {
     public TemplateRowUpdatingEventArgs(DataRow row, IDbCommand command, StatementType statementType, DataTableMapping tableMapping) 
       : base(row, command, statementType, tableMapping) 
     {
     }
   
     // Hide the inherited implementation of the command property.
     new public TemplateCommand Command
     {
       get  { return (TemplateCommand)base.Command; }
       set  { base.Command = value; }
     }
   }
   
   public class TemplateRowUpdatedEventArgs : RowUpdatedEventArgs
   {
     public TemplateRowUpdatedEventArgs(DataRow row, IDbCommand command, StatementType statementType, DataTableMapping tableMapping)
       : base(row, command, statementType, tableMapping) 
     {
     }
   
     // Hide the inherited implementation of the command property.
     new public TemplateCommand Command
     {
       get  { return (TemplateCommand)base.Command; }
     }
   }
   

5. Implémentez les méthodes abstraites du DbDataAdapter. Exemple :

   Protected Overrides Function CreateRowUpdatedEvent(dataRow As DataRow, command As IDbCommand, statementType As StatementType, tableMapping As DataTableMapping) As RowUpdatedEventArgs
     Return New TemplateRowUpdatedEventArgs(dataRow, command, statementType, tableMapping)
   End Function
   
   Protected Overrides Function CreateRowUpdatingEvent(dataRow As DataRow, command As IDbCommand, statementType As StatementType, tableMapping As DataTableMapping) As RowUpdatingEventArgs
     Return New TemplateRowUpdatingEventArgs(dataRow, command, statementType, tableMapping)
   End Function
   
   Protected Overrides Sub OnRowUpdating(value As RowUpdatingEventArgs)
     Dim handler As TemplateRowUpdatingEventHandler  = CType(Events(EventRowUpdating), TemplateRowUpdatingEventHandler)
     If Not handler Is Nothing And value.GetType() Is Type.GetType("TemplateRowUpdatingEventArgs") Then 
       handler(Me, CType(value, TemplateRowUpdatingEventArgs))
     End If
   End Sub
   
   Protected Overrides Sub OnRowUpdated(value As RowUpdatedEventArgs)
     Dim handler As TemplateRowUpdatedEventHandler  = CType(Events(EventRowUpdated), TemplateRowUpdatedEventHandler)
     If Not handler Is Nothing And value.GetType() Is Type.GetType("TemplateRowUpdatedEventArgs") Then 
       handler(Me, CType(value, TemplateRowUpdatedEventArgs))
     End If
   End Sub
   [C#]
   override protected RowUpdatedEventArgs CreateRowUpdatedEvent(DataRow dataRow, IDbCommand command, StatementType statementType, DataTableMapping tableMapping)
   {
     return new TemplateRowUpdatedEventArgs(dataRow, command, statementType, tableMapping);
   }
   
   override protected RowUpdatingEventArgs CreateRowUpdatingEvent(DataRow dataRow, IDbCommand command, StatementType statementType, DataTableMapping tableMapping)
   {
     return new TemplateRowUpdatingEventArgs(dataRow, command, statementType, tableMapping);
   }
   
   override protected void OnRowUpdating(RowUpdatingEventArgs value)
   {
     TemplateRowUpdatingEventHandler handler = (TemplateRowUpdatingEventHandler) Events[EventRowUpdating];
     if ((null != handler) && (value is TemplateRowUpdatingEventArgs)) 
     {
       handler(this, (TemplateRowUpdatingEventArgs) value);
     }
   }
   
   override protected void OnRowUpdated(RowUpdatedEventArgs value)
   {
     TemplateRowUpdatedEventHandler handler = (TemplateRowUpdatedEventHandler) Events[EventRowUpdated];
     if ((null != handler) && (value is TemplateRowUpdatedEventArgs)) 
     {
       handler(this, (TemplateRowUpdatedEventArgs) value);
     }
   }
   

6. Terminez l'implémentation des événements sur la classe dérivée DbDataAdapter, comme dans l'exemple suivant. Notez que les événements font partie de la classe TemplateDataAdapter, alors que les délégués appartiennent à l'espace de noms.

   Public Event RowUpdating As TemplateRowUpdatingEventHandler 
   Public Event RowUpdated As TemplateRowUpdatedEventHandler 
   
   Public Delegate Sub TemplateRowUpdatingEventHandler(sender As Object, e As TemplateRowUpdatingEventArgs)
   Public Delegate Sub TemplateRowUpdatedEventHandler(sender As Object, e As TemplateRowUpdatedEventArgs)
   [C#]
   public event TemplateRowUpdatingEventHandler RowUpdating
   {
     add { Events.AddHandler(EventRowUpdating, value); }
     remove { Events.RemoveHandler(EventRowUpdating, value); }
   }
   
   public event TemplateRowUpdatedEventHandler RowUpdated
   {
     add { Events.AddHandler(EventRowUpdated, value); }
     remove { Events.RemoveHandler(EventRowUpdated, value); }
   }
   
   public delegate void TemplateRowUpdatingEventHandler(object sender, TemplateRowUpdatingEventArgs e);
   public delegate void TemplateRowUpdatedEventHandler(object sender, TemplateRowUpdatedEventArgs e);
   

Les rubriques suivantes contiennent des exemples de code pour l'implémentation d'un objet DataAdapter.

Pour un exemple d'implémentation Visual Basic :

• TemplateDataAdapter.vb

Pour un exemple d'implémentation C# :

• TemplateDataAdapter.cs

Voir aussi

Implémentation d'un fournisseur de données .NET Framework | Exemple de fournisseur de données .NET Framework