Freigeben über

Code-First-Ansatz für eine vorhandene Datenbank

Diese Schritt-für-Schritt-Anleitung bietet eine Einführung in die Code-First-Entwicklung für eine vorhandene Datenbank. Mit Code First können Sie Ihr Modell mithilfe von C# oder VB.Net Klassen definieren. Optional können zusätzliche Konfigurationen 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 exemplarische Vorgehensweise abzuschließen.

Außerdem benötigen Sie Version 6.1 (oder höher) der Entity Framework Tools für Visual Studio installiert. Informationen zum Installieren der neuesten Version der Entity Framework-Tools finden Sie unter "Entity Framework abrufen".

1. Erstellen einer vorhandenen Datenbank

In der Regel, wenn Sie auf eine vorhandene Datenbank abzielen, wird sie bereits erstellt, aber für diese exemplarische Vorgehensweise müssen wir eine Datenbank erstellen, auf die zugegriffen werden kann.

Lassen Sie uns fortfahren und 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.

    Datenquelle auswählen

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

    LocalDB-Verbindung

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

    Dialogfeld

  • 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 verwendet, um den Datenzugriff auszuführen:

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

 

3. Modell rückentwickeln

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

  • Projekt –> Neues Element hinzufügen...

  • Wählen Sie Daten aus dem linken Menü und dann ADO.NET Entity Data Model

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

  • Dadurch wird der Entitätsdatenmodell-Assistent gestartet.

  • Wählen Sie Code First aus der Datenbank 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".

    Assistent Zwei 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 an, was hinzugefügt wurde.

Konfigurationsdatei

Dem Projekt wurde eine App.config Datei hinzugefügt, diese Datei enthält die Verbindungszeichenfolge mit der vorhandenen 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 feststellen. Dies sind die STANDARD-EF-Einstellungen, die Code First anweisen, wo Datenbanken erstellt werden sollen. Da wir einer vorhandenen Datenbank zuordnen, werden diese Einstellungen in unserer Anwendung ignoriert.

Abgeleiteter Kontext

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

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 Syntax "name=" verwenden, wenn Sie eine Verbindungszeichenfolge in der Konfigurationsdatei verwenden. Dadurch wird sichergestellt, dass, wenn die Verbindungszeichenfolge nicht vorhanden ist, das Entity Framework ausgelöst wird, anstatt eine neue Datenbank nach Konvention zu erstellen.

Modellklassen

Schließlich wurde dem Projekt auch eine Blog - und Post-Klasse hinzugefügt. Dies sind die Domänenklassen, aus denen unser Modell besteht. Auf die Klassen angewendete Datenanmerkungen werden angezeigt, um die Konfiguration 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 eine maximale Länge von 200 in der Datenbank haben (der Code First-Standard ist die maximale Länge, die vom Datenbankanbieter unterstützt wird - nvarchar(max) in SQL Server).

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

Nachdem wir nun über ein Modell verfügen, ist es an der Zeit, es für den Zugriff auf einige Daten zu verwenden. 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 Assistent "Code First to Database" wurde entwickelt, um eine Ausgangspunkt-Klasse von Klassen zu generieren, die Sie anschließend anpassen und verändern können. Wenn sich Ihr Datenbankschema ändert, können Sie entweder die Klassen manuell bearbeiten oder einen anderen Reverse Engineering ausführen, um die Klassen zu überschreiben.

Verwenden von Code First Migrationen für eine vorhandene Datenbank

Wenn Sie Code First-Migrationen mit einer vorhandenen Datenbank verwenden möchten, lesen Sie Code First Migrationen zu einer vorhandenen Datenbank.

Zusammenfassung

In diesem Leitfaden haben wir uns die Code First-Entwicklung mithilfe einer vorhandenen Datenbank angesehen. Wir haben die Entity Framework Tools für Visual Studio verwendet, um durch Reverse Engineering eine Reihe von Klassen zu generieren, die der Datenbank zugeordnet wurden und genutzt werden können, um Daten zu speichern und abzurufen.

  • Last updated on