De basisklasse van een TableAdapter wijzigen in een getypte gegevensset

Code om een getypte dataset te maken en te genereren

Met een getypte DataSet u een Gegevenstabel maken met tekstgegevens voor elke kolom op basis van SQL, of een TableAdapter die de gegevensinteractie met DB vereenvoudigt op basis van een getypte Gegevenstabel.

Aangezien het doel niet is om hier een getypte DataSet te maken, maken we snel een DataSet met de database en tabel klaar voor nu. U ook doen wat u wilt lay-out van de tafel.

De eerste stap is het toevoegen van een DataSet als nieuw item aan uw project. De naam is allesbehalve hier.

Open de DataSet en voeg een TableAdapter van de ontwerper toe.

Volg de wizard om een DataTable en Een TableAdapter te maken.

Ik denk dat het volgende formulier een voorbeeld kan zijn van het ophalen en gebruiken van records uit de database met behulp van de DataTable en TableAdapter die u hebt gemaakt. (Dit is slechts een voorbeeld.)

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.金額));
    }
  }
}

Een project dat deze DataSet gebruikt, heeft doorgaans minder dan één tabel en u maakt veel gegevenssets die het aantal tabellen of meerdere tabellen combineren. Ik denk dat het een gemeenschappelijke verdichting van de verwerking te komen wanneer het gebeurt. U bijvoorbeeld de interne SQL wijzigen om de voorwaarden voor het ophalen van records te wijzigen.

De klasse TableAdapter die is gemaakt met de DataSet, wordt echter automatisch gegenereerd door de code. Omdat deze klasse TableAdapter de klasse Component erft, zijn er ook geen methoden of eigenschappen die in echte gangbare bepalingen kunnen worden gebruikt. U een basisklasse niet doorgeven aan een methode om een tabeladaptergerelateerde bewerking aan te roepen.

Daarnaast wordt sql intern gebruikt, sqldataadapter die wordt gebruikt om toegang te krijgen tot de database, etc. worden gedeclareerd in beschermd, dus je ze niet van buitenaf aanraken.

Als u echter declareert voor methoden en eigenschappen die in beschermd zijn gedeclareerd, u deze aanraken door een klasse te maken die de klasse TableAdapter erft, en deze klasse TableAdapter heeft een gedeeltelijke modifier, zodat u een andere methode of eigenschap declareren om het proces uit te breiden. U ook een nieuwe eigenschap maken om de interne eigenschap te krijgen, zoals in de volgende code:

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

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

U deze TableAdapter gebruiken om te zien dat u toegang hebt tot de uitgebreide eigenschappen.

Toegang tot interne eigenschappen betekent echter niet dat het proces gebruikelijk is en dat u nog steeds code moet schrijven voor elke DataSet die u maakt.

De basisklasse van een TabelAdapter wijzigen

Zoals eerder vermeld, erft de klasse TableAdapter de klasse Component, waardoor het moeilijk is om verwerking te delen. Als u het deel van de code wijzigt dat een klasse overneemt, wordt de code automatisch gegenereerd, zodat het bijwerken van de DataSet de code opnieuw retourneert. Als u, u een gedeeltelijke klasse die interface erft in een apart bestand, maar het heeft niet veel zin, omdat je zo veel TableAdapters schrijven als je hebt gemaakt.

In feite is er een mechanisme om de erfklasse van deze TableAdapter te wijzigen. Ik wil de procedure uitleggen.

Maak eerst de klasse die u wilt erven. TableAdapter heeft oorspronkelijk de klasse Component overgenomen, dus u moet de klasse Component overnemen, zelfs als u deze maakt. Ik schrijf de code die ik hier wil delen, maar ik schrijf gewoon een les. Koppel de naamruimte aan wat u hebt gemaakt.

using System.ComponentModel;

namespace DataSetBaseAdapter
{
  public class BaseAdapter : Component
  {
  }
}

Open vervolgens de ontwerper DataSet en selecteer de TabelAdapter die u hebt gemaakt.

Klik met de rechtermuisknop om de eigenschap te openen. Er is een eigenschap genaamd BaseClass, die in eerste instantie zou moeten worden "System.ComponentModel.Component". Herschrijf dit naar de klasse die je net hebt gemaakt. Ik schrijf alles, inclusief de naamruimte.

Als u deze opslaat, ziet u dat de basisklasse van de TableAdapter is gewijzigd. Door dit in te stellen op elke TableAdapter, u algemene verwerking naar de basisklasse schrijven.

Als u bijvoorbeeld toegang wilt tot een interne SQL of SQLDataAdapter, schrijft u: Adapters en CommandCollections die automatisch worden gemaakt, zijn alleen eigenschappen die zijn gemaakt door de klasse inheritor, zodat ze niet rechtstreeks van de overerver kunnen worden aangeraakt. De volgende code maakt gebruik van reflectie om toegang af te dwingen.

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

U zien dat u de TableAdapter daadwerkelijk gebruiken om toegang te krijgen tot de eigenschappen van de overgenomen klasse.