带有NOLOCK的实体框架

如何NOLOCK在实体框架上使用该功能？XML是做到这一点的唯一方法吗？

否，但是您可以启动事务并将隔离级别设置为uncommited。这本质上与NOLOCK相同，但是它不是针对每个表执行此操作，而是针对事务范围内的所有操作执行此操作。

如果这听起来像您想要的，那么您可以按照以下方法进行操作...

//declare the transaction options
var transactionOptions = new System.Transactions.TransactionOptions();
//set it to read uncommited
transactionOptions.IsolationLevel = System.Transactions.IsolationLevel.ReadUncommitted;
//create the transaction scope, passing our options in
using (var transactionScope = new System.Transactions.TransactionScope(
    System.Transactions.TransactionScopeOption.Required, 
    transactionOptions)
)

//declare our context
using (var context = new MyEntityConnection())
{
    //any reads we do here will also read uncomitted data
    //...
    //...
    //don't forget to complete the transaction scope
    transactionScope.Complete();
}

扩展方法可以使此操作更容易

public static List<T> ToListReadUncommitted<T>(this IQueryable<T> query)
{
    using (var scope = new TransactionScope(
        TransactionScopeOption.Required, 
        new TransactionOptions() { 
            IsolationLevel = System.Transactions.IsolationLevel.ReadUncommitted }))
    {
        List<T> toReturn = query.ToList();
        scope.Complete();
        return toReturn;
    }
}

public static int CountReadUncommitted<T>(this IQueryable<T> query)
{
    using (var scope = new TransactionScope(
        TransactionScopeOption.Required, 
        new TransactionOptions() { 
            IsolationLevel = System.Transactions.IsolationLevel.ReadUncommitted }))
    {
        int toReturn = query.Count();
        scope.Complete();
        return toReturn;
    }
}

如果您需要大量的东西，最好的方法是，在每次创建对象上下文之后，通过运行以下简单命令，简单地在连接上设置默认的事务隔离级别：

this.context.ExecuteStoreCommand("SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;");

http://msdn.microsoft.com/zh-CN/library/aa259216(v=sql.80).aspx

使用这种技术，我们能够创建一个简单的EF提供程序，该提供程序为我们创建上下文，并为所有上下文每次实际运行此命令，因此默认情况下我们始终处于“未提交读”状态。

尽管我绝对同意使用“读取未提交的事务隔离级别”是最佳选择，但是一段时间后，您不得不根据经理或客户的请求而强制使用NOLOCK提示，并且没有理由反对接受此请求。

使用Entity Framework 6，您可以像这样实现自己的DbCommandInterceptor：

public class NoLockInterceptor : DbCommandInterceptor
{
    private static readonly Regex _tableAliasRegex = 
        new Regex(@"(?<tableAlias>AS \[Extent\d+\](?! WITH \(NOLOCK\)))", 
            RegexOptions.Multiline | RegexOptions.IgnoreCase);

    [ThreadStatic]
    public static bool SuppressNoLock;

    public override void ScalarExecuting(DbCommand command, 
        DbCommandInterceptionContext<object> interceptionContext)
    {
        if (!SuppressNoLock)
        {
            command.CommandText = 
                _tableAliasRegex.Replace(command.CommandText, "${tableAlias} WITH (NOLOCK)");
        }
    }

    public override void ReaderExecuting(DbCommand command, DbCommandInterceptionContext<DbDataReader> interceptionContext)
    {
        if (!SuppressNoLock)
        {
            command.CommandText = 
                _tableAliasRegex.Replace(command.CommandText, "${tableAlias} WITH (NOLOCK)");
        }
    }
}

使用此类，您可以在应用程序启动时应用它：

DbInterception.Add(new NoLockInterceptor());

并有条件地关闭NOLOCK在当前线程的查询中添加提示的操作：

NoLockInterceptor.SuppressNoLock = true;

加强琼斯医生的公认答案，并使用PostSharp ;

第一个“ ReadUncommitedTransactionScopeAttribute ”

[Serializable]
public class ReadUncommitedTransactionScopeAttribute : MethodInterceptionAspect
{
    public override void OnInvoke(MethodInterceptionArgs args)
    {
        //declare the transaction options
        var transactionOptions = new TransactionOptions();
        //set it to read uncommited
        transactionOptions.IsolationLevel = IsolationLevel.ReadUncommitted;
        //create the transaction scope, passing our options in
        using (var transactionScope = new TransactionScope(TransactionScopeOption.Required, transactionOptions))
        {
            //declare our context
            using (var scope = new TransactionScope())
            {
                args.Proceed();
                scope.Complete();
            }
        }
    }
}

那只要你需要

    [ReadUncommitedTransactionScope()]
    public static SomeEntities[] GetSomeEntities()
    {
        using (var context = new MyEntityConnection())
        {
            //any reads we do here will also read uncomitted data
            //...
            //...

        }
    }

能够使用拦截器添加“ NOLOCK”也很好，但是在连接到像Oracle这样的其他数据库系统时将不起作用。

为了解决这个问题，我在数据库上创建了一个视图，并将NOLOCK应用于该视图的查询。然后，我将视图视为EF中的表格。

随着EF6的引入，Microsoft建议使用BeginTransaction（）方法。

您可以在EF6 +和EF Core中使用BeginTransaction代替TransactionScope

using (var ctx = new ContractDbContext())
using (var transaction = ctx.Database.BeginTransaction(System.Data.IsolationLevel.ReadUncommitted))
{
    //any reads we do here will also read uncommitted data
}

不，不是真的-实体框架基本上是您实际数据库之上的一个相当严格的层。您的查询以ESQL-实体SQL编写，它首先针对您的实体模型，并且由于EF支持多个数据库后端，因此您无法真正将“本机” SQL直接发送到后端。

NOLOCK查询提示是SQL Server特有的，不能在任何其他受支持的数据库上运行（除非它们也实现了相同的提示-我对此表示强烈怀疑）。

马克

一种选择是使用存储过程（类似于Ryan提出的视图解决方案），然后从EF执行存储过程。这样，存储过程执行脏读取，而EF仅通过管道传递结果。