[ASP.NET MVC Mavericks Road] 06 – Verwenden von Entity Framework

[ASP.NET
MVC The Road to Mavericks] 06 – Verwendung des Entity Framework

Es ist in Ordnung, zu Hause untätig zu sein, schreiben wir weiter an meiner [ASP.NET MVC The Road to Mavericks]-Reihe . Im vorherigen Blogbeitrag dieser Serie haben wir bei der Anzeige der Buchinformationsliste die Daten im Programmcode manuell erstellt. In diesem Artikel wird gezeigt, wie Sie das Entity
Framework in ASP.NET MVC verwenden, um Daten aus der Datenbank abzurufen. Obwohl der Titel dieses Artikels relativ einfach klingt, glaube ich, dass Sie bei sorgfältiger Lektüre auf jeden Fall etwas gewinnen werden.

Verzeichnis dieses Artikels:

ORM und EF

Wenn wir eine Anwendung entwickeln möchten, müssen wir überlegen, wie Daten angezeigt werden und wie man sie speichert. Bei der Betrachtung dieses Problems sollten wir uns vor allem auf die Leistung des Programms, die einfache Entwicklung sowie die Wartbarkeit und Skalierbarkeit des Codes konzentrieren.

Persistenz bezeichnet einen Mechanismus, der verschiedene Bearbeitungsstatusinformationen in einer Anwendung dauerhaft speichern kann. Wenn kein Persistenzmechanismus vorhanden ist, kann der Status nur im Speicher gespeichert werden und geht beim Herunterfahren der Maschine verloren.

Wenn wir in Anwendungen Daten dauerhaft speichern möchten, wählen wir eine relationale Datenbank (Relation DataBase); wenn wir Daten vorübergehend speichern möchten, verwenden wir im Speicher gespeicherte Objekte. Derzeit verwenden die meisten Entwickler die relationale Datenbanktechnologie als Persistenzmechanismus. Obwohl einige Leute jetzt versuchen, die Objektdatenbanktechnologie (Object DataBase) zu verwenden, wird die relationale Datenbanktechnologie noch viele Jahre lang der wichtigste Persistenzmechanismus sein.

Warum erscheint die Objektdatenbank? Die SQL-Sprache ist eine nicht-prozedurale, mengenorientierte, interpretierte Sprache, während viele Hochsprachen prozedurale, objektorientierte, kompilierte Sprachen sind. Dies führt zu einer Diskrepanz zwischen den beiden Sprachen, was zu einer unbefriedigenden Effizienz führt. Diese Nichtübereinstimmung wird als „Impedanzfehlanpassung“ bezeichnet, und die Objektdatenbank wurde entwickelt, um die „Impedanzfehlanpassung“ zu beheben.

Wir wissen, dass in der relationalen Datenbanktechnologie Tabellen zum Speichern und Organisieren von Daten in einer Zeilen- und Spaltenstruktur verwendet werden. Vor .NET 2.0, als es in C# keine Generika gab, verwendeten die Leute grundsätzlich in DataSets gefüllte DataTables, um aus relationalen Datenbanken abgefragte Daten abzubilden und zu speichern, wie im folgenden Code gezeigt:

using (SqlConnection conn = new SqlConnection(connString)) {
    using (SqlDataAdapter da = new SqlDataAdapter("Select * from order", conn)) {
        DataTable dt = new DataTable();
        da.Fill(dt);
        ...
    }
}

Obwohl diese Methode Objekte zulässt -orientierte Sprachen, die mit relationalen Datenbanken übereinstimmen, weisen einige offensichtliche Mängel auf, wie z. B. Nichttypsicherheit, Schwierigkeiten bei der Manipulation und geringe Leistung. Ab .NET 2.0 begannen Menschen, Sammlungen von Entitätsmodellobjekten zu verwenden, um Daten in relationalen Datenbanken mithilfe generischer Technologie abzugleichen. Diese Methode behebt die Mängel der DataTable-Methode und verfügt über eine starke Typisierung, automatische Vervollständigung in VS und Kompilierungszeit Überprüfung und andere Funktionen machen es bei .Net-Entwicklern beliebt.

Um Entwicklern die manuelle Durchführung dieser „Matching“-Arbeit zu ersparen, wurden viele ORM-Tools (wie Entity Framework, NHibernate usw.) entwickelt. Das ORM-Tool (Object Relation Mapping) besteht, wie der Name schon sagt, darin, das „Missverhältnis“ zwischen „Beziehung“ und „Objektorientierung“ zu beheben. Dadurch können Entwickler mehr Zeit aufwenden, ohne sich zu viele Gedanken über die Persistenzschicht zu machen im Geschäft.

Entity Framework (EF) ist eine von Microsoft entwickelte ORM-Lösung auf Basis von ADO.NET, die hauptsächlich auf dem Entity Data Model (EDM) basiert. EF verwendet die Methode der Abstraktion von Datenstrukturen, um jedes Datenbankobjekt in ein Klassenobjekt (Entity) in der Anwendung umzuwandeln, während die Datenfelder in Eigenschaften (Property) und die Beziehungen in Assoziationseigenschaften (Association) umgewandelt werden Das E/R
-Modell der Datenbank wird vollständig in ein Objektmodell umgewandelt, sodass Entwickler bekannte objektorientierte Programmiersprachen zum Aufrufen und Zugriff verwenden können. EF 4.0 und höher unterstützt drei Generierungsmodi: Database First, Model First und Code First. Der Code First-Modus wird von mehr Leuten verwendet.

Ich werde nicht viel über Konzepte und theoretische Dinge sprechen. Ich habe auch nach Online-Ressourcen mit Fragen gesucht und diese auf der Grundlage meines eigenen Verständnisses zusammengefasst. Es gibt viele Dinge, die ich beschreiben möchte aber ich kann nicht wissen, wie man Sprache organisiert.

Der Zweck dieses Artikels besteht hauptsächlich darin, den Lesern ein Wahrnehmungsverständnis von EF zu vermitteln und dann die Anwendung von EF in ASP.NET MVC zu verstehen. Ich werde EF beim nächsten Mal nicht separat vorstellen . .

Verwendung von Entity Framework

Im Anschluss an den vorherigen Blog-Beitrag [ASP.NET
MVC Mavericks Road] 05 – Mit Ninject müssen wir nun die handgefertigten Daten im Code ändern Aus Datenbank lesen. Dazu bereiten wir zunächst die Datenbank vor. In diesem Beispiel wird MS SQL Server verwendet, das Gleiche gilt jedoch auch für andere Datenbanken. Erstellen Sie zunächst eine Datenbank mit dem Namen BookShop und führen Sie dann das folgende Skript aus, um eine Books-Tabelle zu erstellen:

CREATE TABLE Books 
( 
    [ID] INT NOT NULL PRIMARY KEY IDENTITY, 
    [Title] NVARCHAR(100) NOT NULL,
    [Isbn] VARCHAR(20) NOT NULL, 
    [Summary] NVARCHAR(1000) NOT NULL,
    [Author] NVARCHAR(50) NOT NULL,
    [Thumbnail] VARBINARY(MAX),  
    [Price] DECIMAL(16, 2) NOT NULL,
    [Published] DATE NOT NULL,
)

然后随便在表中加几条用于测试的数据：

接下来我们就要让应用程序连接数据库了。由于上一篇博文是我在公司用休息的时间写的，公司的电脑装的是VS2010，家里的笔记本装的是VS2012，所以得重新把上篇博文的示例移到VS2012上，对于本示例，VS2010和VS2012都是一样的。上一篇示例项目的目录结构如下：

本文的示例将在上篇的这个示例基础上继续。

用NuGet在BookShop.Domain工程中安装Entity Framework包，方法请参考本系列的上一篇文章。

在BookShop.Domain工程的Concrete文件夹中添加一个名为EFDbContext的类，代码如下：

public class EFDbContext : DbContext { 
    public DbSet<Book> Books { get; set; } 
}

使用EF Code First第一步就是创建一个继承自System.Data.Entity.DbContext的类，这个类将为数据库中的每个表定义一个属性，属性的名称代表数据库中的表名。DbSet作为返回类型，它是用于生成CRUD(Create、Read、Update和Delete)操作的装置，映射数据库表的行。

我们需要在BookShop.WebUI工程中的web.config配置文件中添加数据库的连接字符串，来告诉EF怎样连接数据库。根据自己机器上的数据库配置连接字符串如下：

<connectionStrings>
  <add name="EFDbContext" connectionString="Data Source=.\SQLEXPRESS;Initial Catalog=BookShop;User ID=sa;Password=sa" providerName="System.Data.SqlClient" />
</connectionStrings>

接下来，我们把BookShop.Domain工程下Concrete文件中的BookRepository类文件改造一下，把代码中手工造的数据改成从数据库读取，以测试应用程序是否可以正常连接数据库。修改后的BookRepository类如下：

public class BookRepository : IBookRepository {
    private EFDbContext context = new EFDbContext();

    public IQueryable<Book> Books {
        get { return context.Books; }
    }
}

在我们的这个仓储类中，我们改使用EF，通过创建一个EFDbContext类的实例来获取数据库中的数据。如你所见，我们不需要自己写ADO.NET代码去连接和读取数据库，非常简洁明了，我们就是这样使用Entity Framework的。我们来看一下运行效果吧：

到这我们已经成功使用EF连接上了数据库，并从数据库中读取出来了数据。我们还可以通过Linq进行非常灵活的查询，就像写SQL一样。比如要查询价格在100元以下的前10条记录，并且按价格从低到高显示，那么我们可以在BookShop.WebUI工程下的BookController中的List方法中这样写：

public ViewResult List() {
    return View(repository.Books
        .OrderBy(b => b.Price)
        .Where(b => b.Price < 100)
        .Take(10));
}

或许你很快就会对EF获取数据库的方式产生这样的疑问：EF从数据库中读取整个Books表的数据到内存，然后返回给调用者(上面代码中的repository.Books)用Linq语句过滤用户想要的前10条数据，如果Books表中有几百万条数据，那内存岂不是完蛋了，EF不会这么傻吧？EF会不会根据Linq查询语句智能地生成SQL文本再到数据库中去查询数据呢？这里就要讲讲IQueryable和IEnumerable了。

IQueryable 和 IEnumerable

其实，对于上面的即有过虑又有排序的条件查询Linq语句，EF是读取数据库中整个Books表中的数据到内存，还是根据Linq查询语句智能的生成SQL再执行查询，完全编码者来决定的。我们打开BookShop.Domain工程的BookRepository类文件，请注意该类中Books属性的返回类型：

...
public IQueryable<Book> Books {
    get { return context.Books; }
}

我们对使用IQueryable作为返回类型提了个疑问：为什么用IQueryable而不用IEnumerable作为返回类型？答案是：使用IQueryable，EF会根据调用者的Linq表达式先生成相应的SQL查询语句，然后到数据库中执行查询，查询出来的数据即是用户想要的数据；而使用IEnumerable，Linq表达式的过滤、排序等操作都是在内存中发生的，即EF会先从数据库中把整个表的数据查询出来放在内存中，然后由调用者使用Linq语句进行过滤、排序等操作。是不是这样呢？我们来监视一下两种情况EF生成的SQL语句就知道了。

我们先来看看使用IQueryable的情况。重新运行一下程序，然后使用SQL Server Management Studio的活动和监视器查看一下我们的BookShop应用程序所执行的SQL语句，结果如下：

结果证明使用IQueryable，EF是先根据Linq表达式生成相应的SQL语句再执行查询的。

我们再稍稍修改一下代码来看看用IEnumerable的情况。把BookRepository类修改如下：

public class BookRepository : IBookRepository {
    private EFDbContext context = new EFDbContext();

    public IEnumerable<Book> Books {
        get { return context.Books; }
    }
}

当然BookRepository类所实现的IBookRepository接口（在BookShop.Domain工程的Abstract文件夹中）也要改一下：

public interface IBookRepository {    IEnumerable<Book> Books { get; }
}

再重新运行一下应用程序，用活动和监视器查看最后执行的SQL语句如下图：

我们看到改用IEnumerable后，EF生成的SQL没有任何过滤、排序等的操作，它一次把表中的所有数据都Select出来，和上面写的Linq表达式一点都没关系。

IQueryable虽然可以很智能地根据Linq表达式生成相应的SQL语句，但毕竟有一个分析Linq表达式的过程，相对来说性能比IEnumerable要差。那么我们什么时候用IEnumerable，什么时候用IQueryable呢？我想，对于少量的数据（比如从数据库中读取应用程序相关的系统信息）和不需要对数据进行过滤操作的情况，用IEnumerable比较适合；对于数据量较大需要对数据进行过滤（比如分页查询）的情况，则用IQueryable比较合适。

 以上就是[ASP.NET MVC 小牛之路]06 - 使用 Entity Framework的内容，更多相关内容请关注PHP中文网（www.php.cn）！