Exemplarische Vorgehensweise: Zuordnen von Vererbung - 'Tabelle pro Typ' (Entity Data Model-Tools)

Artikel
04/19/2011

In diesem Thema wird dargestellt, wie die "Tabelle pro Typ"-Vererbung durch Änderung eines konzeptionellen Modells implementiert wird. Bei der "Tabelle pro Typ"-Vererbung wird eine separate Tabelle in der Datenbank verwendet, um die Daten für nicht geerbte Eigenschaften und Schlüsseleigenschaften für jeden Typ in der Vererbungshierarchie zu verwalten.

In dieser exemplarischen Vorgehensweise implementieren Sie die "Tabelle pro Typ"-Vererbung, indem Sie das in der Anwendung "CourseManager" (weitere Informationen finden Sie im Abschnitt "Erforderliche Komponenten" weiter unten in diesem Thema) verwendete konzeptionelle Modell ändern.

In der Anwendung "CourseManager" sind die Entitätstypen Course, OnlineCourse und OnsiteCourse Tabellen mit denselben Namen zugeordnet. Da der OnlineCourse-Entitätstyp und der OnsiteCourse-Entitätstyp Informationen enthalten, die für beide Kurstypen eindeutig sind, und sie einen gemeinsamen Schlüssel verwenden, können sie so geändert werden, dass sie vom Course-Entitätstyp erben. Die folgenden Schritte fassen die Implementierung der "Tabelle pro Typ"-Vererbung in diesem Fall zusammen (in den Verfahren weiter unten in diesem Thema erfahren Sie weitere Einzelheiten):

Löschen Sie die Zuordnung zwischen dem OnlineCourse-Entitätstyp und dem Course-Entitätstyp. Löschen Sie die Zuordnung zwischen dem OnsiteCourse-Entitätstyp und dem Course-Entitätstyp. Diese Zuordnungen werden ersetzt, indem die Vererbungshierarchie implementiert wird.
Löschen Sie die CourseID-Schlüsseleigenschaft aus dem OnlineCourse-Entitätstyp und dem OnsiteCourse-Entitätstyp. Diese Eigenschaft wird vom Course-Entitätstyp geerbt.
Legen Sie den Course-Entitätstyp als Basistyp für den OnlineCourse-Entitätstyp und den OnsiteCourse-Entitätstyp fest.
Legen Sie den Course-Entitätstyp als abstrakten Typ fest.
Ordnen Sie die geerbten CourseID-Eigenschaften des OnlineCourse-Entitätstyps und des OnsiteCourse-Entitätstyps den entsprechenden Spalten zu.

Erforderliche Komponenten

Um diese exemplarische Vorgehensweise durchzuführen, müssen Sie zunächst die Anwendung "CourseManager" erstellen. Weitere Informationen und Anweisungen finden Sie im Entity Framework-Schnellstart. Sie implementieren die "Tabelle pro Typ"-Vererbung, indem Sie das in der Anwendung CourseManager verwendete konzeptionelle Model ändern. Anschließend erweitern Sie die Funktionalität der Anwendung, um die Onlinekurse und die vor Ort stattfindenden Kurse für eine ausgewählte Abteilung getrennt anzuzeigen.

Hinweis:
Da viele der exemplarischen Vorgehensweisen in dieser Dokumentation die Anwendung CourseManager als Ausgangspunkt verwenden, wird empfohlen, für diese exemplarische Vorgehensweise eine Kopie der Anwendung "CourseManager" zu verwenden, statt den ursprünglichen Code von "CourseManager" zu bearbeiten.

In dieser exemplarischen Vorgehensweise wird davon ausgegangen, dass Sie über grundlegende Kenntnisse in Visual Studio, .NET Framework und entweder Visual C#- oder Visual Basic-Programmierung verfügen.

Implementieren der "Tabelle pro Typ"-Vererbung

In diesem Verfahren ändern Sie das SchoolModel, indem Sie die "Tabelle pro Hierarchie"-Vererbung implementieren. Eine Videopräsentation des folgenden Verfahrens finden Sie unter How.

So implementieren Sie die "Tabelle pro Typ"-Vererbung

Öffnen Sie in Visual Studio die CourseManager-Projektmappe.
Doppelklicken Sie im Projektmappen-Explorer auf die Datei School.edmx.

Die Datei School.edmx wird im EDM-Designer (Entity Designer) geöffnet.
Klicken Sie mit der rechten Maustaste auf den OnlineCourse-Entitätstyp, und wählen Sie Eigenschaften aus.
Legen Sie im Fenster Eigenschaften die Basistyp-Eigenschaft auf Course fest.
Wiederholen Sie die Schritte 3 und 4 für den OnsiteCourse-Entitätstyp.
Klicken Sie mit der rechten Maustaste auf die Zuordnung (die Linie) zwischen dem OnlineCourse-Entitätstyp und dem Course-Entitätstyp. Wählen Sie Löschen aus.
Klicken Sie mit der rechten Maustaste auf die Zuordnung zwischen dem OnsiteCourse-Entitätstyp und dem Course-Entitätstyp. Wählen Sie Löschen aus.
Klicken Sie mit der rechten Maustaste auf die CourseID-Eigenschaft des OnlineCourse-Entitätstyps, und wählen Sie dann Löschen aus.
Klicken Sie mit der rechten Maustaste auf die CourseID-Eigenschaft des OnsiteCourse-Entitätstyps, und wählen Sie dann Löschen aus.
Wählen Sie den Course-Entitätstyp aus. Legen Sie im Fenster Eigenschaften dessen Abstrakt-Eigenschaft auf true fest.

Ein Meldungsfeld mit dem Hinweis, dass alle vorhandenen Funktionsmappings für einen Entitätstyp entfernt werden, wenn dieser als abstrakt definiert wird, wird angezeigt. Klicken Sie auf OK.

Hinweis:

Da der Course-Entitätstyp nun in einen abstrakten Typ geändert wurde, funktioniert die Aktualisierungsfunktion der ursprünglichen "CourseManager"-Anwendung nicht mehr.
Klicken Sie mit der rechten Maustaste auf den OnlineCourse-Entitätstyp, und wählen Sie Tabellenmapping aus.

Das Fenster Mappingdetails wird angezeigt.
Klicken Sie auf das Feld Wert/Eigenschaft, das der Spalte CourseID entspricht.

Das Feld Wert/Eigenschaft wird zu einer Dropdownliste mit Eigenschaften, die für das Mapping zur entsprechenden Spalte zur Verfügung stehen.
Wählen Sie in der Dropdownliste den Eintrag CourseID aus.
Wiederholen Sie die Schritte 11 bis 13 für den OnsiteCourse-Entitätstyp.

Hinweis:
Da der Course-Entitätstyp nun in einen abstrakten Typ geändert wurde, funktioniert die Aktualisierungsfunktion der ursprünglichen "CourseManager"-Anwendung nicht mehr.

Die "Tabelle pro Typ"-Vererbung ist damit implementiert.

Erstellen der Benutzeroberfläche

Als Nächstes fügen Sie dem CourseViewer-Formular eine Schaltfläche hinzu, mit der das CourseDiscrimForm-Formular geladen und angezeigt wird. Dann fügen Sie zwei DataGridView-Steuerelemente hinzu, um OnsiteCourses und OnlineCourses anzuzeigen. Schließlich binden Sie das DataGridView-Steuerelement an BindingSource-Steuerelemente. Weitere Informationen über das Binden von Objekten an Steuerelemente finden Sie unter Binding Objects to Controls (Entity Framework).

So erstellen Sie die Benutzeroberfläche

Klicken Sie mit der rechten Maustaste im Projektmappen-Explorer auf das Projekt CourseManager, zeigen Sie auf Hinzufügen, und wählen Sie anschließend Neues Element aus.

Das Dialogfeld Neues Element hinzufügen wird angezeigt.
Wählen Sie Windows Form aus, und klicken Sie dann auf Hinzufügen.

Ein neues Formular wird dem Projekt hinzugefügt, das im Formular-Designer geöffnet wird.
Legen Sie im Fenster Eigenschaften den Namen des Formulars auf CourseDiscriminator fest.

Dem Projekt wird ein neues Formular hinzugefügt und im Formular-Designer geöffnet. Der Name des Formulars wird auf CourseDiscriminator und der Text auf CourseDiscriminator festgelegt.
Ziehen Sie ein ComboBox-Steuerelement von der Toolbox auf das Formular, und legen Sie im Fenster Eigenschaften dessen Namen auf departmentList fest.
Ziehen Sie ein DataGridView-Steuerelement von der Toolbox auf das Formular, und legen Sie dessen Namen auf onsiteGridView fest.
Ziehen Sie ein weiteres DataGridView-Steuerelement von der Toolbox auf das Formular, und legen Sie dessen Namen auf onlineGridView fest.
Doppelklicken Sie im Projektmappen-Explorer auf CourseViewer.cs oder CourseViewer.vb.

Die Entwurfsansicht des CourseViewer-Formulars wird angezeigt.
Ziehen Sie ein Button-Steuerelement von der Toolbox auf das Formular CourseViewer.
Legen Sie im Fenster Eigenschaften den Namen des Button auf viewDiscriminator und den Text der Schaltfläche auf Online vs. Onsite fest.
Doppelklicken Sie auf Button viewDiscriminator.

Die CodeBehind-Datei für das Formular wird geöffnet.

Fügen Sie dem viewDiscriminator_click-Ereignishandler folgenden Code hinzu:

Dim courseDiscrim As New CourseDiscriminator
courseDiscrim.Visible = True

CourseDiscriminator courseDiscrim = new CourseDiscriminator();
courseDiscrim.Visible = true;

Die Benutzeroberfläche für dieses Formular ist damit vollständig.

Abfragen des konzeptionellen Modells

In diesem Verfahren fragen Sie das konzeptionelle Modell ab und binden die Ergebnisse an Windows Forms-Steuerelemente.

So fragen Sie das konzeptionelle Modell ab

Öffnen Sie das CourseDiscriminator-Formular im Formular-Designer.
Ziehen Sie ein BindingSource-Steuerelement aus der Toolbox auf das Formular.
Legen Sie im Fenster Eigenschaften den Namen der BindingSource auf onsiteBindingSource fest.
Klicken Sie im Fenster Eigenschaften auf das Feld neben der DataSource-Eigenschaft.

Das Feld wird zu einer Dropdownliste mit verfügbaren Datenquellen.
Klicken Sie auf Projektdatenquelle hinzufügen.

Das Fenster Datenquellentyp auswählen vom Assistent zum Konfigurieren von Datenquellen wird geöffnet.
Wählen Sie im Feld Wo werden die Daten für die Anwendung abgerufen? den Eintrag Objekt aus.
Klicken Sie auf Weiter.

Das Fenster Objekt auswählen, an das Bindung hergestellt werden soll wird geöffnet. Der oberste Knoten einer Struktur verfügbarer Ressourcen wird angezeigt.
Erweitern Sie den CourseManager-Knoten, und erweitern Sie dann den untergeordneten CourseManager-Knoten.
Wählen Sie OnsiteCourse aus, und klicken Sie auf Fertig stellen.
Wiederholen Sie die Schritte 2 bis 9, nennen Sie das BindingSource-Steuerelement jedoch OnlineBindingSource, und binden Sie es an das OnlineCourse-Objekt.
Klicken Sie mit der rechten Maustaste auf das OnsiteGridView-Steuerelement, und wählen Sie Eigenschaften aus.
Klicken Sie im Fenster Eigenschaften auf das Feld neben der DataSource-Eigenschaft.

Das Feld wird zu einer Dropdownliste mit verfügbaren Datenquellen.
Wählen Sie OnsiteBindingSource aus.

Wiederholen Sie die Schritte 11 bis 13 für OnlineGridView, legen Sie die DataSource-Eigenschaft jedoch auf OnlineBindingSource fest.

Hinweis:
Die OfType-Methode gibt eine Enumeration zurück, aus der ein DataGridView-Steuerelement zur Laufzeit keine Spalten generieren kann.Um in diesem Beispiel die gewünschten Informationen anzuzeigen, werden die Datenquellen für die DataGridView-Steuerelemente zur Entwurfszeit durch BindingSource-Steuerelemente auf der Grundlage der Klassen festgelegt, an die gebunden werden soll.

Doppelklicken Sie auf das CourseDiscriminator-Formular.

Die CodeBehind-Datei für das CourseDiscriminator-Formular wird geöffnet.
Fügen Sie folgende using-Anweisung (C#) oder Imports-Anweisung (Visual Basic) hinzu, um auf das aus der Datenbank "School" erstellte Modell und den Namespace der Entität zu verweisen.
```
Imports System.Data.Objects
Imports System.Data.Objects.DataClasses
```
```
using System.Data.Objects;
using System.Data.Objects.DataClasses;
```

Fügen Sie eine Eigenschaft hinzu, die den Datenkontext zur CourseDiscriminator-Klasse darstellt:

' Create an ObjectContext instance based on SchoolEntity.
Private schoolContext As SchoolEntities

// Create an ObjectContext instance based on SchoolEntity.
private SchoolEntities schoolContext;

Fügen Sie dem CourseDiscriminator_Load-Ereignishandler Code zur Initialisierung des Objektkontexts hinzu, und binden Sie das departmentList-Steuerelement an eine Abfrage, die Department-Informationen zurückgibt.

' Initialize the ObjectContext.
schoolContext = New SchoolEntities()

' Define a query that returns all Department objects and 
' related Course objects, ordered by name.
Dim departmentQuery As ObjectQuery(Of Department) = _
    schoolContext.Departments.Include("Courses").OrderBy("it.Name")

' Bind the ComboBox control to the query, which is
' executed during data binding.
departmentList.DisplayMember = "Name"
departmentList.DataSource = departmentQuery. _
    Execute(MergeOption.OverwriteChanges)

// Initialize the ObjectContext.
schoolContext = new SchoolEntities();

// Define a query that returns all Department objects  
// and related Course objects, ordered by name.
ObjectQuery<Department> departmentQuery = 
    schoolContext.Departments.Include("Courses").
    OrderBy("it.Name");

// Bind the ComboBox control to the query.
this.departmentList.DisplayMember = "Name";
this.departmentList.DataSource = departmentQuery.
    Execute(MergeOption.OverwriteChanges);

Kehren Sie zur Entwurfsansicht des CourseDiscriminator-Formulars zurück, und doppelklicken Sie auf das ComboBox-Steuerelement departmentList.

Die CodeBehind-Datei wird geöffnet. Dem Code wurde damit ein departmentList_SelectedIndexChanged-Ereignishandler hinzugefügt.

Fügen Sie dem departmentList_SelectedIndexChanged-Ereignishandler folgenden Code hinzu, um die Datenquellen der BindingSource-Steuerelemente zu aktualisieren.

' Get the selected department object.
Dim department As Department = CType(Me.departmentList. _
        SelectedItem, Department)

' Update the data sources for the BindingSource controls.
onsiteBindingSource.DataSource = department.Courses _
    .OfType(Of OnsiteCourse)()
onlineBindingSource.DataSource = department.Courses _
    .OfType(Of OnlineCourse)()

// Get the selected department object.
Department department = (Department)this.departmentList
    .SelectedItem;

// Update the data sources for the BindingSource controls.
onsiteBindingSource.DataSource = department.Courses.
    OfType<OnsiteCourse>();
onlineBindingSource.DataSource = department.Courses.
    OfType<OnlineCourse>();

Die Anwendung ist damit fertig gestellt. Drücken Sie STRG+F5, um die Anwendung auszuführen. Klicken Sie auf die Schaltfläche Onsite vs. Online, um das CourseDiscriminator-Formular zu laden. In den DataGridView-Steuerelementen werden OnsiteCourses und OnlineCourses für die ausgewählte Abteilung angezeigt.

Codelisting

In diesem Abschnitt wird die endgültige Version der CodeBehind-Datei für das CourseDiscriminator-Formular aufgeführt.

Imports System.Data.Objects
Imports System.Data.Objects.DataClasses
Public Class CourseDiscriminator

    ' Create an ObjectContext instance based on SchoolEntity.
    Private schoolContext As SchoolEntities

    Private Sub CourseDiscriminator_Load(ByVal sender As System. _
        Object, ByVal e As System.EventArgs) Handles MyBase.Load
        ' Initialize the ObjectContext.
        schoolContext = New SchoolEntities()

        ' Define a query that returns all Department objects and 
        ' related Course objects, ordered by name.
        Dim departmentQuery As ObjectQuery(Of Department) = _
            schoolContext.Departments.Include("Courses").OrderBy("it.Name")

        ' Bind the ComboBox control to the query, which is
        ' executed during data binding.
        departmentList.DisplayMember = "Name"
        departmentList.DataSource = departmentQuery. _
            Execute(MergeOption.OverwriteChanges)
    End Sub

    Private Sub departmentList_SelectedIndexChanged(ByVal sender As  _
        System.Object, ByVal e As System.EventArgs) Handles _
        departmentList.SelectedIndexChanged
        ' Get the selected department object.
        Dim department As Department = CType(Me.departmentList. _
                SelectedItem, Department)

        ' Update the data sources for the BindingSource controls.
        onsiteBindingSource.DataSource = department.Courses _
            .OfType(Of OnsiteCourse)()
        onlineBindingSource.DataSource = department.Courses _
            .OfType(Of OnlineCourse)()
    End Sub
End Class

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Data.Objects;
using System.Data.Objects.DataClasses;

namespace CourseManager
{
    public partial class CourseDiscriminator : Form
    {
        // Create an ObjectContext instance based on SchoolEntity.
        private SchoolEntities schoolContext;

        public CourseDiscriminator()
        {
            InitializeComponent();
        }

        private void CourseDiscriminator_Load(object sender,
            EventArgs e)
        {
            // Initialize the ObjectContext.
            schoolContext = new SchoolEntities();

            // Define a query that returns all Department objects  
            // and related Course objects, ordered by name.
            ObjectQuery<Department> departmentQuery = 
                schoolContext.Departments.Include("Courses").
                OrderBy("it.Name");

            // Bind the ComboBox control to the query.
            this.departmentList.DisplayMember = "Name";
            this.departmentList.DataSource = departmentQuery.
                Execute(MergeOption.OverwriteChanges);
        }

        private void departmentList_SelectedIndexChanged(object sender,
            EventArgs e)
        {
            // Get the selected department object.
            Department department = (Department)this.departmentList
                .SelectedItem;

            // Update the data sources for the BindingSource controls.
            onsiteBindingSource.DataSource = department.Courses.
                OfType<OnsiteCourse>();
            onlineBindingSource.DataSource = department.Courses.
                OfType<OnlineCourse>();
        }
    }
}

Nächste Schritte

Sie haben die "Tabelle pro Typ"-Vererbung erfolgreich in einem konzeptionellen Modell implementiert. Weitere Informationen zum Definieren eines konzeptionellen Modells mit "Tabelle pro Typ"-Vererbung finden Sie unter How to: Define a Model with Table-per-Type Inheritance. Weitere Informationen zum Erstellen von Anwendungen, die Entity Framework verwenden, finden Sie unter ADO.NET Entity Framework.

Siehe auch

Weitere Ressourcen

Szenarien für die Verwendung der Entity Data Model-Tools
Aufgaben der Entity Data Model-Tools

Freigeben über