Entity Framework 查漏补缺 （二）

数据加载

 如下这样的一个lamda查询语句，不会立马去查询数据库，只有当需要用时去调用（如取某行，取某个字段、聚合），才会去操作数据库，ef中本身的查询方法返回的都是iqueryable接口。

链接：ienumerable和iqueryable接口说明

其中聚合函数会影响数据加载，诸如：tolist()，sum(),count(),first()能使数据立即查询加载。

iqueryable中的load方法

 一般情况，我们都是使用tolist或first来完成预先加载数据操作。但在ef中还可以使用load() 方法来显式加载，将获取的数据放到ef context中，缓存起来备用。和tolist()很像，只是它不创建列表只是把数据缓存到ef context中而已，开销较少。

using (var context = new testdb())
{
    context.place.where(t=>t.placeid==9).load();
}

vs中的方法说明：

延迟加载

用之前的place类和people为例

place对象如下：

public class place
{
    [key]
    public int placeid { get; set;}

    public string provice { get; set; }

    public string city { get; set; }
    //导航属性
    public virtual list<people> population { get; set; }

}

下面查询，不会主动去查询出导航属性（population ）关联的数据

using (var context = new testdb())
{
    var obj = context.place.where(t => t.placeid == 9).firstordefault();
}

可以看到population为null

只有用到population对象时，ef才会发起到数据库的查询；

当然导航数据必须标记virtual，配置延迟加载

//导航属性
public virtual place place { get; set; }

要注意的事：在延迟加载条件下，经常以为导航数据也加载了，从而在循环中去遍历导航属性，造成多次访问数据库。

立即加载

除了前面所说的，使用聚合函数（sum等）外来立即预加载数据，还可以使用include方法

在上面的查询中，想要查询place以及关联的population数据如下:

using (var context = new testdb())
{
    var obj = context.place.where(t => t.placeid == 9).include(p=>p.population).firstordefault();
}

事务

 在ef中，savechanges()默认是开启了事务的，在调用savechanges()之前，所有的操作都在同一个事务中，同一次数据库连接。若使用同一dbcontext对象，ef的默认事务处理机制基本满足使用。

除此之外，以下两种情况怎么使用事务：

1. 数据分阶段保存，多次调用savechanges()
2. 使用多个dbcontext对象（尽量避免）

第一种情况：显式事务

using (var context = new testdb())
{
    using (var tran=context.database.begintransaction())
    {
        try
        {
            context.place.add(new place { city = "beijing", placeid = 11 });
            context.savechanges();
            context.people.add(new people { name = "xiaoli" });
            context.savechanges();
            tran.commit();
        }
        catch (exception)
        {
            tran.rollback();
        }
    }
}

注意的是，不调用commit()提交，没有异常事务也不会默认提交。

第二种情况：transactionscope分布式事务

• 引入system.transactions.dll
• windows需要开启msdtc
• transactionscope也于适用于第一种情况。这里只讨论连接多个dbcontext的事务使用
• 需要调用complete()，否则事务不会提交
• 在事务内，报错会自动回滚

using (var tran = new transactionscope())
{
    try
    {
        using (var context = new testdb())
        {
            context.place.add(new place { city = "5555"});
            context.savechanges();
        }
        using (var context2 = new testdb2())
        {
            context2.student.add(new student { name="li"});
            context2.savechanges();
        }
        throw new exception();
        tran.complete();
    }
    catch (exception)
    {
                    
    }
}

注意：上面代码在同一个事务内使用了多个dbcontext，会造次多次连接关闭数据库

题外话

如是多个dbcontext连着是同一个数据库的话，可以将一个己打开的数据库连接对象传给它，并且需要指定ef在dbcontext对象销毁时不关闭数据库连接。避免造成多次连接关闭数据库

dbcontext对象改造，增加重载构造函数;；传入两个参数

• 数据库连接dbconnection
• contextownsconnection=false（dbcontext对象销毁时不关闭数据库连接）：

public class testdb2 : dbcontext
{
    public testdb2():base("name=test")
    {
    }
    public testdb2(dbconnection conn, bool contextownsconnection) : base(conn, contextownsconnection)
    {
    }
    public dbset<student> student { get; set; }
}

事务代码如下：

using (transactionscope scope = new transactionscope())
{
    string connstr = ……;
    using (var conn = sqlconnection(connstr))
    {
        try
        {
            conn.open();
            using (var context1 = new mydbcontext(conn, contextownsconnection: false))
            {
                ……
                context1.savechanges();
            }
            using (var context2 = new mydbcontext(conn, contextownsconnection: false))
            {
                ……
                context2.savechanges();
            }
　　　　　　　scope.complete();
         }
        catch (exception e)
        {

        }
        finally
        {
            conn.close();
        }
    }
}

dbcontent线程内唯一

 

链接：

 

并发

在实际场景中，并发是很常见的事，同条记录同时被不同的两个用户修改

在ef中有两种常见的并发冲突检测

方法一：concurrencycheck特性

可以指定对象的一个或多个属性用于并发检测，在对应属性加上concurrencycheck特性

这里我们指定student 对象的属性name

public class student
{
    [key]
    public int id { get; set; }
    [concurrencycheck]
    public string name { get; set; }
    public int age { get; set; }
}

用个两个线程同时去更新student对象，模拟用户并发操作

static void main(string[] args)
{
    task t1 = task.run(() => {
        using (var context = new testdb2())
        {
            var obj = context.student.first();
            obj.name = "liming";
            context.savechanges();
        }
    });
    task t2 = task.run(() => {
        using (var context = new testdb2())
        {
            var obj = context.student.first();
            obj.age = 26;
            context.savechanges();
        }
    });
    task.waitall(t1,t2);

}

并发冲突报错：

 

查看了sql server profiler，发现加了[concurrencycheck]的属性名和值将出现在where子句中

exec sp_executesql n'update [dbo].[students]
set [age] = @0
where (([id] = @1) and ([name] = @2))
',n'@0 int,@1 int,@2 nvarchar(max) ',@0=26,@1=1,@2=n'wang'

 很显然：

t2再修改age，根据并发检测属性name的值已被改变，有其他用户在修改同一条数据，并发冲突。

为每个实体类都单独地设定检测属性实在太麻烦，应该由数据库来设定特殊字段值并维护更新会更好，下面就是另一种方法

 方法二：timestamp

创建一个基类base，指定一个特殊属性值，sql server中相应的字段类型为timestamp，自己项目中的实体类都可以继承它，

public class base
{
    [timestamp]
    public byte[] rowversion { get; set; }
}

student先基础base类，每次更新student数据，rowversion 字段就会由数据库生成一个新的值，根据这个特殊字段来检测并发冲突；实体类不再去考虑设置那个属性值和更新。

 

并发处理

同时更新并发，ef会抛出：dbupdateconcurrencyexception

两个更新线程如上：t1和t2

处理一

task t1 = task.run(() => {
    using (var context = new testdb())
    {
        try
        {
            var obj = context.student.first();
            obj.name = "liming2";
            context.savechanges();
        }
        catch (dbupdateconcurrencyexception ex)
        {
            //从数据库重新加载数据并覆盖当前保存失败的对象
            ex.entries.single().reload();
            context.savechanges();
        }
    }
});

也就是说，t1并发冲突更新失败，会重新从数据库拉取对象覆盖当前失败的对象，t1原本的更新被作废，于此同时的其他用户并发操作，如t2的更新将会被保存下来

处理二

task t1 = task.run(() => {
    using (var context = new testdb())
    {
        try
        {
            var obj = context.student.first();
            obj.name = "liming2";
            context.savechanges();
        }
        catch (dbupdateconcurrencyexception ex)
        {
            var entry = ex.entries.single();
            entry.originalvalues.setvalues(entry.getdatabasevalues());
            context.savechanges();
        }
    }
});

从数据库重新获取值来替换保存失败的对象的属性原始值，再次提交更改，数据库就不会因为当前更新操作获取的原始值与数据库里现有值不同而产生异常（如检测属性的值已成一样），t1的更新操作就能顺利提交，其他并发操作如t2被覆盖