Code First für eine vorhandene Datenbank

  • Artikel

Dieses schrittweise Anleitung bietet eine Einführung in die Code First-Entwicklung für eine neue Datenbank. Mit Code First können Sie Ihr Modell mithilfe von C# oder VB.Net-Klassen definieren. Eine zusätzliche Konfiguration kann optional mithilfe von Attributen für Ihre Klassen und Eigenschaften oder mithilfe einer Fluent-API ausgeführt werden.

Voraussetzungen

Sie müssen Visual Studio 2012 oder Visual Studio 2013 installiert haben, um diese Anleitung abzuschließen.

Außerdem muss Version 6.1 (oder höher) der Entity Framework-Tools für Visual Studio installiert sein. Informationen zum Installieren der neuesten Version der Entity Framework-Tools finden Sie unter Abrufen von Entity Framework.

1. Erstellen einer vorhandenen Datenbank

Wenn Sie auf eine bestehende Datenbank zugreifen, ist diese in der Regel bereits erstellt, aber für dieses Beispiel müssen wir eine Datenbank erstellen, auf die wir zugreifen können.

Lassen Sie uns nun die Datenbank generieren.

  • Öffnen Sie Visual Studio.

  • Ansicht > Server-Explorer

  • Klicken Sie mit der rechten Maustaste auf Datenverbindungen > Verbindung hinzufügen….

  • Wenn Sie im Server-Explorer noch keine Verbindung mit einer Datenbank hergestellt haben, müssen Sie Microsoft SQL Server als Datenquelle auswählen.

    Select Data Source

  • Stellen Sie eine Verbindung mit Ihrer LocalDB-Instanz her, und geben Sie als Datenbanknamen Blogging ein.

    LocalDB Connection

  • Wählen Sie OK aus. Sie werden daraufhin gefragt, ob Sie eine neue Datenbank erstellen möchten. Wählen Sie Ja aus.

    Create Database Dialog

  • Die neue Datenbank wird nun im Server-Explorer angezeigt. Klicken Sie mit der rechten Maustaste darauf, und wählen Sie Neue Abfrage aus.

  • Kopieren Sie die folgende SQL-Datei in die neue Abfrage, klicken Sie dann mit der rechten Maustaste auf die Abfrage, und wählen Sie Ausführen aus.

CREATE TABLE [dbo].[Blogs] (
    [BlogId] INT IDENTITY (1, 1) NOT NULL,
    [Name] NVARCHAR (200) NULL,
    [Url]  NVARCHAR (200) NULL,
    CONSTRAINT [PK_dbo.Blogs] PRIMARY KEY CLUSTERED ([BlogId] ASC)
);

CREATE TABLE [dbo].[Posts] (
    [PostId] INT IDENTITY (1, 1) NOT NULL,
    [Title] NVARCHAR (200) NULL,
    [Content] NTEXT NULL,
    [BlogId] INT NOT NULL,
    CONSTRAINT [PK_dbo.Posts] PRIMARY KEY CLUSTERED ([PostId] ASC),
    CONSTRAINT [FK_dbo.Posts_dbo.Blogs_BlogId] FOREIGN KEY ([BlogId]) REFERENCES [dbo].[Blogs] ([BlogId]) ON DELETE CASCADE
);

INSERT INTO [dbo].[Blogs] ([Name],[Url])
VALUES ('The Visual Studio Blog', 'http://blogs.msdn.com/visualstudio/')

INSERT INTO [dbo].[Blogs] ([Name],[Url])
VALUES ('.NET Framework Blog', 'http://blogs.msdn.com/dotnet/')

2. Erstellen der Anwendung

Um die Dinge einfach zu halten, erstellen wir eine einfache Konsolenanwendung, die Code First für den Datenzugriff verwendet.

  • Öffnen Sie Visual Studio.
  • Datei -> Neu -> Projekt
  • Wählen Sie im linken Menü Windows und Konsolenanwendung aus.
  • Geben Sie CodeFirstExistingDatabaseSample als Namen ein.
  • Klicken Sie auf OK.

 

3. Zurückentwickeln (Reverse Engineering) des Modells

Wir verwenden die Entity Framework-Tools für Visual Studio, um uns beim Generieren von anfänglichen Code unterstützen zu lassen, der der Datenbank zugeordnet wird. Diese Tools generieren lediglich Code, den Sie auf Wunsch auch manuell eingeben könnten.

  • Projekt -> Neues Element hinzufügen…

  • Wählen Sie Daten im linken Menü und dannADO.NET Entity Data Model aus.

  • Geben Sie als Name BloggingContext ein, und klicken Sie auf OK.

  • Dadurch wird der Entity Data Model-Assistent gestartet.

  • Wählen Sie Code First aus Datenbank aus, und klicken Sie auf Weiter.

    Wizard One CFE

  • Wählen Sie die Verbindung mit der Datenbank aus, die Sie im ersten Abschnitt erstellt haben, und klicken Sie auf Weiter.

    Wizard Two CFE

  • Klicken Sie auf das Kontrollkästchen neben Tabellen, um alle Tabellen zu importieren, und klicken Sie auf Fertig stellen.

    Wizard Three CFE

Nachdem der Reverse Engineering-Prozess abgeschlossen ist, wurden dem Projekt eine Reihe von Elementen hinzugefügt. Sehen wir uns genauer an, was hinzugefügt wurde.

Konfigurationsdatei

Dem Projekt wurde eine App.config-Datei hinzugefügt. Diese Datei enthält die Verbindungszeichenfolge für die vorhandene Datenbank.

<connectionStrings>
  <add  
    name="BloggingContext"  
    connectionString="data source=(localdb)\mssqllocaldb;initial catalog=Blogging;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework"  
    providerName="System.Data.SqlClient" />
</connectionStrings>

Sie werden auch einige andere Einstellungen in der Konfigurationsdatei bemerken. Dies sind die EF-Standardeinstellungen, die Code First anweisen, wo Datenbanken erstellt werden sollen. Da wir einer vorhandenen Datenbank zuordnen, werden diese Einstellungen in unserer Anwendung ignoriert.

Abgeleiteter Kontext

Eine Klasse namnes BloggingContext wurde zum Projekt hinzugefügt. Der Kontext stellt eine Sitzung mit der Datenbank dar, sodass wir Daten abfragen und speichern können. Der Kontext macht eine DbSet<TEntity>-Eigenschaft für jeden Typ in unserem Modell verfügbar. Sie werden auch feststellen, dass der Standardkonstruktor einen Basiskonstruktor mithilfe der name=-Syntax aufruft. Dadurch wird Code First angewiesen, die für diesen Kontext zu verwendende Verbindungszeichenfolge aus der Konfigurationsdatei zu laden.

public partial class BloggingContext : DbContext
    {
        public BloggingContext()
            : base("name=BloggingContext")
        {
        }

        public virtual DbSet<Blog> Blogs { get; set; }
        public virtual DbSet<Post> Posts { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
        }
    }

Sie sollten immer die name=-Syntax verwenden, wenn Sie eine Verbindungszeichenfolge in der Konfigurationsdatei verwenden. Dadurch wird sichergestellt, dass beim Fehlen der Verbindungszeichenfolge das Entity Framework ausgelöst und keine neue Datenbank nach Konvention erstellt wird.

Modellklassen

Schließlich wurden dem Projekt auch die Klassen Blog und Post hinzugefügt. Dies sind die Domänenklassen, aus denen unser Modell besteht. Auf die Klassen angewendete Datenanmerkungen werden angezeigt, um Konfigurationen anzugeben, bei der die Code First-Konventionen nicht mit der Struktur der vorhandenen Datenbank übereinstimmen. Beispielsweise wird die StringLength--Anmerkung für Blog.Name und Blog.Url angezeigt, da sie in der Datenbank eine maximale Länge von 200 haben (laut Code First-Standard ist die maximale vom Datenbankanbieter unterstützte Länge in SQL Server – nvarchar(max)).

public partial class Blog
{
    public Blog()
    {
        Posts = new HashSet<Post>();
    }

    public int BlogId { get; set; }

    [StringLength(200)]
    public string Name { get; set; }

    [StringLength(200)]
    public string Url { get; set; }

    public virtual ICollection<Post> Posts { get; set; }
}

4. Lesen und Schreiben von Daten

Mit dem Modell können Sie nun auf die Daten zugreifen. Implementieren Sie die Main-Methode in Program.cs, wie unten dargestellt. Dieser Code erstellt eine neue Instanz unseres Kontexts und fügt dann einen neuen Blog ein. Anschließend wird eine LINQ-Abfrage verwendet, um alle Blogs aus der Datenbank abzurufen, die alphabetisch nach Title sortiert sind.

class Program
{
    static void Main(string[] args)
    {
        using (var db = new BloggingContext())
        {
            // Create and save a new Blog
            Console.Write("Enter a name for a new Blog: ");
            var name = Console.ReadLine();

            var blog = new Blog { Name = name };
            db.Blogs.Add(blog);
            db.SaveChanges();

            // Display all Blogs from the database
            var query = from b in db.Blogs
                        orderby b.Name
                        select b;

            Console.WriteLine("All blogs in the database:");
            foreach (var item in query)
            {
                Console.WriteLine(item.Name);
            }

            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }
    }
}

Sie können die Anwendung jetzt ausführen und testen.

Enter a name for a new Blog: ADO.NET Blog
All blogs in the database:
.NET Framework Blog
ADO.NET Blog
The Visual Studio Blog
Press any key to exit...

 

Was geschieht, wenn sich meine Datenbank ändert?

Der „Code First to Database“-Assistent wurde entwickelt, um für Sie als Ausgangspunkt eine Reihe von Klassen zu generieren, die Sie dann optimieren und ändern können. Wenn sich Ihr Datenbankschema ändert, können Sie die Klassen entweder manuell bearbeiten oder ein weiteres Reverse Engineering ausführen, um die Klassen zu überschreiben.

Verwenden von Code First-Migrationen für eine vorhandene Datenbank

Wenn Sie Code First-Migrationen für eine vorhandene Datenbank verwenden möchten, lesen Sie Code First Migrationen für eine vorhandene Datenbank.

Zusammenfassung

In dieser schrittweisen Anleitung haben wir uns die Code First-Entwicklung mithilfe einer vorhandenen Datenbank angesehen. Wir haben die Entity Framework-Tools für Visual Studio verwendet, um Reverse Engineering für eine Reihe von Klassen durchzuführen, die der Datenbank zugeordnet sind und zum Speichern und Abrufen von Daten verwendet werden könnten.