Modificare la classe base di un oggetto TableAdapter in un DataSet tipizzato

Codice per creare e generare un DataSet tipizzato

Un DataSet tipizzato consente di creare un DataTable con informazioni sul tipo per ogni colonna in base a SQL o un TableAdapter che semplifica l'interazione dei dati con DB in base a un oggetto DataTable tipizzato.

Poiché lo scopo non è quello di creare un DataSet tipizzato qui, creiamo rapidamente un DataSet con il database e la tabella pronti per il momento. Puoi anche fare quello che vuoi per stendere la tabella.

Il primo passaggio consiste nell'aggiungere un DataSet come nuovo elemento al progetto. Il nome è tutt'altro che è lasciato qui.

Aprire il DataSet e aggiungere un TableAdapter dalla finestra di progettazione.

Seguire la procedura guidata per creare un oggetto DataTable e un oggetto TableAdapter.

Penso che il seguente modulo potrebbe essere un esempio di recupero e utilizzo di record dal database utilizzando il DataTable e TableAdapter che è stato creato. (Questo è solo un esempio.)

public Form1()
{
  InitializeComponent();

  using (var adapter = new 金額集計TestTableAdapter())
  {
    var table = adapter.GetData();

    foreach (var row in table)
    {
      Trace.WriteLine(string.Format("{0}:{1}", row.年月, row.金額));
    }
  }
}

In genere, un progetto che utilizza questo DataSet dispone di meno di una tabella e si creano molti DataSet che combinano il numero di tabelle o più tabelle. Penso che sia una comandamento del processo a venire quando si verifica. Ad esempio, è possibile modificare dinamicamente il codice SQL utilizzato internamente per modificare le condizioni per il recupero dei record.

Tuttavia, il TableAdapter classe creata dal DataSet viene effettivamente generata automaticamente dal codice. Inoltre, poiché questa classe TableAdapter eredita la classe Component, non esistono metodi o proprietà che possono essere utilizzati in comune. Non è possibile passare una classe base a un metodo per chiamare un'operazione correlata al tableadapter.

Inoltre, sql utilizzato internamente, sqldataadapter utilizzato per accedere al database e così via sono dichiarati in protected, pertanto non è possibile toccarli dall'esterno.

Tuttavia, come si dichiara per i metodi e le proprietà dichiarate in protected, è possibile toccarli creando una classe che eredita il TableAdapter classe e questa TableAdapter classe dispone di un modificatore parziale, in modo da poter dichiarare un altro metodo o proprietà per estendere il processo. È inoltre possibile creare una nuova proprietà per ottenere la proprietà interna, come nel codice seguente:You can also create a new property to get the internal property, as in the following code:

using System.Data.SqlClient;
namespace DataSetBaseAdapter {
    public partial class DataSet1 {
    }
}

namespace DataSetBaseAdapter.DataSet1TableAdapters
{
  public partial class 金額集計TestTableAdapter
  {
    public SqlDataAdapter InnerAdapter
    {
      get { return Adapter; }
    }
  }
}

È effettivamente possibile utilizzare questo TableAdapter per verificare che si abbia accesso alle proprietà estese.

Tuttavia, l'accesso alle proprietà interne non significa che il processo è comune ed è comunque necessario scrivere codice per ogni DataSet creato.

Modificare la classe base di un oggetto TableAdapterChange the base class of a TableAdapter

Come accennato in precedenza, la classe TableAdapter eredita la classe Component, rendendo difficile la condivisione dell'elaborazione. Se si modifica la parte di codice che eredita una classe, il codice viene generato automaticamente, pertanto l'aggiornamento del DataSet restituisce nuovamente il codice. Se è possibile, è possibile scrivere una classe parziale che eredita l'interfaccia in un file separato, ma non ha molto senso perché è necessario scrivere tutti i TableAdapter che è stato creato.

In fatti, esiste un meccanismo per modificare la classe che eredita di questo TableAdapter. Vorrei spiegare la procedura.

Creare innanzitutto la classe che si desidera ereditare. TableAdapter originariamente ereditato il Component classe, pertanto è necessario ereditare il Component classe anche se viene creata. Scriverò il codice che voglio condividere qui, ma mi limiterò a scrivere una classe. Associare lo spazio dei nomi a quello creato.

using System.ComponentModel;

namespace DataSetBaseAdapter
{
  public class BaseAdapter : Component
  {
  }
}

Aprire quindi la finestra di progettazione DataSet e selezionare il TableAdapter creato.

Fare clic con il pulsante destro del mouse per aprire la proprietà. Esiste una proprietà denominata BaseClass, che dovrebbe essere inizialmente "System.ComponentModel.Component". Riscrivilo alla classe che hai appena creato. Scriverò tutto, incluso lo spazio dei nomi.

Se lo si salva, si noterà che la classe di base del TableAdapter è stata modificata. Impostando questa opzione su ogni TableAdapter, è possibile scrivere l'elaborazione comune nella classe base.

Ad esempio, se si desidera accedere a un SQL interno o SQLDataAdapter, scrivere:For example, if you want to access an internal SQL or SQLDataAdapter, write: Gli adattatori e gli adattatori CommandCollections creati automaticamente sono solo proprietà create dalla classe inheritor, pertanto non possono essere toccate direttamente dall'erecheggiatore. Il codice seguente usa la reflection per forzare l'accesso.

using System.ComponentModel;
using System.Data.SqlClient;
using System.Reflection;

namespace DataSetBaseAdapter
{
  public class BaseAdapter : Component
  {
    public SqlDataAdapter InnerAdapter
    {
      get
      {
        return (SqlDataAdapter)GetType().GetProperty("Adapter",
          BindingFlags.NonPublic | BindingFlags.Instance).GetValue(this, null);
      }
    }

    public SqlCommand[] InnerCommandCollection
    {
      get
      {
        return (SqlCommand[])GetType().GetProperty("CommandCollection",
          BindingFlags.NonPublic | BindingFlags.Instance).GetValue(this, null);
      }
    }
  }
}

Si può vedere che è effettivamente possibile utilizzare il TableAdapter per accedere alle proprietà della classe ereditata.