大家好，又见面了，我是你们的朋友全栈君。

TransactionScope

TransactionScope事务处理经常用到，老是用了又忘，做点记录。
TransactionScope的定义跟使用介绍。

TransactionScopeOption

TransactionScopeOption枚举型用来决定一个TransactionScope是用已有的事务，还是定义TransactionScope的新做一个事务，还是完全不用事务。默认是Required，Required表示如果已有事务，就加入该事务，否则新建一个事务。

TransactionOptions

TransactionOptions 结构体用来设置TransactionScope所用到事务的隔离级别与超时时间。
隔离级别参考这篇博文。（乐观锁）

实践

做两张表

USE [Learning]
GO
CREATE TABLE [dbo].[Foo](
	[Id] [bigint] IDENTITY(1,1) NOT NULL,
	[Value] [nvarchar](50) NULL,
 CONSTRAINT [PK_Foo] PRIMARY KEY CLUSTERED 
(
	[Id] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON, OPTIMIZE_FOR_SEQUENTIAL_KEY = OFF) ON [PRIMARY]
) ON [PRIMARY]
GO

CREATE TABLE [dbo].[Bar](
	[Id] [bigint] IDENTITY(1,1) NOT NULL,
	[Value] [nvarchar](50) NULL,
 CONSTRAINT [PK_Bar] PRIMARY KEY CLUSTERED 
(
	[Id] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON, OPTIMIZE_FOR_SEQUENTIAL_KEY = OFF) ON [PRIMARY]
) ON [PRIMARY]
GO

准备测试类
用了EntityFrameWorkCore的库，两个DbContext连同一个数据库。（本地测试的时候，连两个不同的数据库报错：EntityFrameWorkCore不支持分布式事务。。）

using Microsoft.EntityFrameworkCore;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Transactions;

namespace LocalAppTest
{ 
   
    public class FooDbContext : DbContext
    { 
   
        public FooDbContext(DbContextOptions<FooDbContext> options) : base(options) { 
    }

        public DbSet<Foo> Foo { 
    get; set; }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        { 
   

        }
    }

    [Table("Foo")]
    public class Foo
    { 
   
        [Key]
        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public long Id { 
    get; set; }

        [StringLength(50)]
        public string Value { 
    get; set; }
            
    }


    public class BarDbContext : DbContext
    { 
   
        public BarDbContext(DbContextOptions<BarDbContext> options) : base(options) { 
    }

        public DbSet<Bar> Bar { 
    get; set; }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        { 
   

        }
    }

    [Table("Bar")]
    public class Bar
    { 
   
        [Key]
        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public long Id { 
    get; set; }

        [StringLength(50)]
        public string Value { 
    get; set; }

    }
    
    public class TransactionScopeTest
    { 
   
        public DbContextOptions<FooDbContext> FooOptions;
        public DbContextOptions<BarDbContext> BarOptions;

        public TransactionScopeTest()
        { 
   
            FooOptions = (new DbContextOptionsBuilder<FooDbContext>()).UseSqlServer("server=localhost;database=Learning;integrated security=true;").Options;
            BarOptions = (new DbContextOptionsBuilder<BarDbContext>()).UseSqlServer("server=localhost;database=Learning;integrated security=true;").Options;
        }

        public void Test()
        { 
   
            using (var scope = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions { 
    IsolationLevel = IsolationLevel.ReadCommitted }))
            { 
   
                using (var fooContext = new FooDbContext(FooOptions))
                { 
   
                    var foo = new Foo { 
    Value = "Hi" };
                    fooContext.Add(foo);
                    fooContext.SaveChanges();

                    using (var barContext = new BarDbContext(BarOptions))
                    { 
   
                        var bar = new Bar { 
    Value = "Loser" };
                        barContext.Add(bar);
                        barContext.SaveChanges();
                    }

                    scope.Dispose();
                }
            }
        }

    }
}

调用测试代码

new TransactionScopeTest().Test();

以上，

• 用了常用的 ReadCommitted 隔离级别。
• 上述代码走到第一个 SaveChanges 方法的时候，Foo 表锁住，其他查询语句会等待；走到第二个 SaveChanges 方法的时候，Bar 表锁住，其他查询语句会等待。
• Dispose 之后，表数据未更新，Foo 跟 Bar 两张表的其他查询语句正常执行。

再做个测试

using Microsoft.EntityFrameworkCore;
using System.Transactions;
using System.Linq;
using System;
using System.Threading.Tasks;
using System.Collections.Generic;

namespace LocalAppTest
{ 
   
    public class TransactionScopeTest
    { 
   
        public DbContextOptions<FooDbContext> FooOptions;
        public DbContextOptions<BarDbContext> BarOptions;

        public TransactionScopeTest()
        { 
   
            FooOptions = (new DbContextOptionsBuilder<FooDbContext>()).UseSqlServer("server=localhost;database=Learning;integrated security=true;").Options;
            BarOptions = (new DbContextOptionsBuilder<BarDbContext>()).UseSqlServer("server=localhost;database=Learning;integrated security=true;").Options;
        }       
        public void Test2()
        { 
   
            var tasks = new List<Task>();

            int i = 0;
            while (i < 100)
            { 
   
                tasks.Add(Task.Run(() =>
                { 
   
                    using (var scope = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions { 
    IsolationLevel = IsolationLevel.ReadCommitted }))
                    { 
   
                        using (var fooContext = new FooDbContext(FooOptions))
                        { 
   
                            var records = fooContext.Foo.ToList();

                            var foo = new Foo { 
    Value = Guid.NewGuid().ToString() };
                            fooContext.Add(foo);
                            fooContext.SaveChanges();

                            scope.Complete();
                        }
                    }
                }));

                i++;
            }

            Task.WaitAll(tasks.ToArray());
        }

    }
}

调用测试代码

new TransactionScopeTest().Test2();

Test2方法里面启用了100个线程，每个线程做两件事情：1.查询Foo表的数据；2.新增一条数据。执行下来，ReadCommitted 隔离级别下，没有发生死锁的现象。
把上述隔离级别改成 Serializable 后，再次执行，当某个线程占用资源的时候，其他线程会抛出异常，不再执行。

先记录到这。