25：事务处理 Transaction 应用

最新推荐文章于 2022-10-08 15:57:16 发布
最新推荐文章于 2022-10-08 15:57:16 发布
阅读量317 收藏 1
点赞数 2
分类专栏： c#进阶学习 文章标签： 数据库 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43235056/article/details/121118514
版权

目录

EnTerpriseServices类库

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Transactions;

namespace 隔离级别
{
    class Program
    {
        static void Main(string[] args)
        {
            //脏读：读取了另一个事务正在改变的记录
            //不可重复度：当数据在事务中读取，而该事务运行的同时，另一个事务修改了相同的记录
            //幻读：当一个事务中读取这些记录，另一个事务添加一个属于该范围的新数据

            //可以通过IsolationLevel枚举定义隔离级别

            var options = new TransactionOptions {
                IsolationLevel = IsolationLevel.ReadCommitted,
                Timeout = TimeSpan.FromSeconds(90)
            };

            using (var scope=new TransactionScope(TransactionScopeOption.Required,options))
            {

            }

        }
    }
}

SqlTransaction

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 事务处理
{
    //要么全部完成，要么都不完成
    //事务常用于数据库，但利用Transactions名称空中的类
    //事务处理阶段：激活阶段》准备阶段》提交阶段
    //有ACID属性

    class Program
    {
        static void Main(string[] args)
        {

        }


        public class StudentData {

            public async Task AddStudentAsync(Student student) {

                var connection = new SqlConnection("");
                await connection.OpenAsync();

                //开始事务
                SqlTransaction tx = connection.BeginTransaction();
                try
                {

                    SqlCommand command = connection.CreateCommand();
                    //绑定事务
                    command.Transaction = tx;

                    command.CommandText = "insert into students " +
                        "(FirstName,LastName,Company) values " +
                        "(@FirstName,@LastName,@Company)";

                    command.Parameters.AddWithValue("@FirstName", student.FirstName);
                    command.Parameters.AddWithValue("@LastName", student.LastName);
                    command.Parameters.AddWithValue("@Company", student.Company);

                    await command.ExecuteNonQueryAsync();

                    //提交事务
                    tx.Commit();
                }
                catch (Exception)
                {
                    //回滚事务
                    tx.Rollback();
                }
                finally {

                    connection.Close();
                }

            }
        
        }

    }

    [Serializable]
    public class Student
    {

        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Company { get; set; }
        public int Id { get; set; }

        public override string ToString()
        {
            return String.Format("{0} {1}", FirstName, LastName);
        }
    }
}

Transactions类库

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Transactions;

namespace Transactions类库
{
    class Program
    {
        static void Main(string[] args)
        {
            TransactionFun transactionFun = new TransactionFun();
             transactionFun.CommittableTransactionAsync();

            #region 事务的升级
            #endregion

            #region 依赖事务
            //使用依赖事务，可以影响来自多个任务或线程的某个事务
            TransactionFun.DependentTransaction();
            #endregion
        }
    }
    //获取事务的工具类
    public static class Utilities
    {

        public static bool AbortTx()
        {

            Console.Write("Abort the Transaction (y/n)?");

            return Console.ReadLine().ToLower().Equals("y");
        }

        public static void DisplayTransactionInformation(string title,
           TransactionInformation ti)
        {

            Contract.Requires<ArgumentNullException>(ti != null);
            Console.WriteLine(title);
            Console.WriteLine("Creation time :{0:T}", ti.CreationTime);
            Console.WriteLine("Status:{0}", ti.Status);
            Console.WriteLine("Local ID:{0}", ti.LocalIdentifier);
            Console.WriteLine("Distributed ID:{0}", ti.DistributedIdentifier);
            Console.WriteLine();
        }
    }

    public class TransactionFun
    {

        public async Task AddStudentAsync(Student student, Transaction tx)
        {

            Contract.Requires<ArgumentNullException>(student != null);

            var connection = new SqlConnection("");
            await connection.OpenAsync();
            try
            {

                if (tx != null)
                {
                    //登记分布式事务
                    connection.EnlistTransaction(tx);

                    SqlCommand command = connection.CreateCommand();
                    command.CommandText = "";
                    command.Parameters.AddWithValue("@FirstName", student.FirstName);

                    await command.ExecuteNonQueryAsync();
                }
            }
            catch (Exception)
            {

                throw;
            }
            finally
            {

                connection.Close();
            }
        }
        //提交事务等
        public async Task CommittableTransactionAsync()
        {

            var tx = new CommittableTransaction();
            Utilities.DisplayTransactionInformation("TX created", tx.TransactionInformation);


            try
            {
                var s1 = new Student { };
                await AddStudentAsync(s1, tx);

                if (Utilities.AbortTx())
                {

                }

                tx.Commit();
            }
            catch (Exception)
            {

                tx.Rollback();
            }

            Utilities.DisplayTransactionInformation("TX completed", tx.TransactionInformation);

        }


        static void TxTask(object obj) { 
        
            var tx= obj as DependentTransaction;
            Utilities.DisplayTransactionInformation("Dependent Transaction", tx.TransactionInformation);

            Thread.Sleep(3000);
            tx.Complete();

            Utilities.DisplayTransactionInformation("Dependent TX Complete", tx.TransactionInformation);

        }

        public static void DependentTransaction() {

            //1.创建一个根事务
            var tx = new CommittableTransaction();
            Utilities.DisplayTransactionInformation("Root tx created", tx.TransactionInformation);

            //2.DependentCloneOption有两个值，如果根事务在依赖事务提交之前完成，这个选项很重要。RollbackIfNotComplete：如果依赖事务没有
            //在根事务提交之前调用了Complete，事务就会终止。BlockCommitUntilComplete：Commit就会等待所有依赖事务定义的结果
            Task.Factory.StartNew(TxTask, tx.DependentClone(DependentCloneOption.BlockCommitUntilComplete));
            try
            {

                if (Utilities.AbortTx())
                {

                }
                tx.Commit();
            }
            catch (Exception)
            {

                tx.Rollback();
            }

            Utilities.DisplayTransactionInformation("tx finished", tx.TransactionInformation);

        }

    }




    [Serializable]
    public class Student
    {

        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Company { get; set; }
        public int Id { get; set; }

        public override string ToString()
        {
            return String.Format("{0} {1}", FirstName, LastName);
        }
    }
}

隔离级别

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Transactions;

namespace 隔离级别
{
    class Program
    {
        static void Main(string[] args)
        {
            //脏读：读取了另一个事务正在改变的记录
            //不可重复度：当数据在事务中读取，而该事务运行的同时，另一个事务修改了相同的记录
            //幻读：当一个事务中读取这些记录，另一个事务添加一个属于该范围的新数据

            //可以通过IsolationLevel枚举定义隔离级别

            var options = new TransactionOptions {
                IsolationLevel = IsolationLevel.ReadCommitted,
                Timeout = TimeSpan.FromSeconds(90)
            };

            using (var scope=new TransactionScope(TransactionScopeOption.Required,options))
            {

            }

        }
    }
}

环境事务

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Transactions;

namespace 环境事务
{
    class Program
    {
        static void Main(string[] args)
        {
            //使用环境事务就不需要手动连接登记事务
            txFunc.TransactionScopeAsync();

            #region 嵌套的作用域和环境事务
            //嵌套的作用域和环境事务
            using (var scope = new TransactionScope())
            {
                Transaction.Current.TransactionCompleted += txFunc.OnTransactionCompleted;

                Utilities.DisplayTransactionInformation("Ambient TX created",
                      Transaction.Current.TransactionInformation);

                //TransactionScopeOption的值不同，判断是否使用同一作用域
                using (var scope2 = new TransactionScope(TransactionScopeOption.RequiresNew))
                {
                    Transaction.Current.TransactionCompleted += txFunc.OnTransactionCompleted;

                    Utilities.DisplayTransactionInformation("Inner transaction Scope",
                          Transaction.Current.TransactionInformation);

                    scope2.Complete();
                }

                scope.Complete();
            }
            #endregion

        }
    }
    //获取事务的工具类
    public static class Utilities
    {

        public static bool AbortTx()
        {

            Console.Write("Abort the Transaction (y/n)?");

            return Console.ReadLine().ToLower().Equals("y");
        }

        public static void DisplayTransactionInformation(string title,
           TransactionInformation ti)
        {

            System.Diagnostics.Contracts.Contract.Requires<ArgumentNullException>(ti != null);
            Console.WriteLine(title);
            Console.WriteLine("Creation time :{0:T}", ti.CreationTime);
            Console.WriteLine("Status:{0}", ti.Status);
            Console.WriteLine("Local ID:{0}", ti.LocalIdentifier);
            Console.WriteLine("Distributed ID:{0}", ti.DistributedIdentifier);
            Console.WriteLine();
        }
    }

    public class txFunc
    {
        public static async Task TransactionScopeAsync()
        {
            using (var scope = new TransactionScope())
            {
                Transaction.Current.TransactionCompleted += OnTransactionCompleted;

                Utilities.DisplayTransactionInformation("Ambient TX created",
                      Transaction.Current.TransactionInformation);

                var s1 = new Student
                {
                    FirstName = "Angela",
                    LastName = "Nagel",
                    Company = "Kantine M101"
                };
                var db = new StudentData();
                await db.AddStudentAsync(s1);

                if (!Utilities.AbortTx())
                    scope.Complete();
                else
                    Console.WriteLine("transaction will be aborted");

            } // scope.Dispose()

        }

        public static void OnTransactionCompleted(object sender, TransactionEventArgs e)
        {

            Utilities.DisplayTransactionInformation("", e.Transaction.TransactionInformation);

        }

    }
    public class StudentData
    {

        public async Task AddStudentAsync(Student student)
        {

            var connection = new SqlConnection("");
            await connection.OpenAsync();

            //开始事务
            SqlTransaction tx = connection.BeginTransaction();
            try
            {

                SqlCommand command = connection.CreateCommand();
                //绑定事务
                command.Transaction = tx;

                command.CommandText = "insert into students " +
                    "(FirstName,LastName,Company) values " +
                    "(@FirstName,@LastName,@Company)";

                command.Parameters.AddWithValue("@FirstName", student.FirstName);
                command.Parameters.AddWithValue("@LastName", student.LastName);
                command.Parameters.AddWithValue("@Company", student.Company);

                await command.ExecuteNonQueryAsync();

                //提交事务
                tx.Commit();
            }
            catch (Exception)
            {
                //回滚事务
                tx.Rollback();
            }
            finally
            {

                connection.Close();
            }

        }

    }
    [Serializable]
    public class Student
    {

        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Company { get; set; }
        public int Id { get; set; }

        public override string ToString()
        {
            return String.Format("{0} {1}", FirstName, LastName);
        }
    }
}
阚不透
关注
专栏目录
查oracle事务超时时间,ORA-24756: 事务处理不存在 分析
weixin_33419842的博客
04-03 1501
问题描述：河南在2009年4月28日早09：23出现柜面交易如CDM，FIX，CARDTLR等服务堵塞，且排队不断增加，后通过down掉FIX、CARDTLR服务后使资源得到释放，在事后的分析中，我们发现在出现异常堵塞时，产生了tuxedo和数据库通讯异常的日志，xa_NULL02232009.trc，查看日志内出现问题的pid,发现均为绿卡通的相关服务id日志内容是多个：092345.42108...
论文笔记 S-Store: Streaming Meets Transaction Processing
05-17
《S-Store: Streaming Meets Transaction Processing》这篇论文探讨了一个重要的议题：如何将流处理（Streaming）与事务处理（Transaction Processing）相结合，以提供高效、实时的数据管理解决方案。这篇论文笔记...
Transaction 事务简单详解
Fanqi0928的博客
02-21 743
Transaction 也就是所谓的事务了，通俗理解就是一件事情。从小，父母就教育我们，做事情要有始有终，不能半途而废。事务也是这样，不能做一半就不做了，要么做完，要么就不做。也就是说，事务必须是一个不可分割的整体，就像我们在化学课里学到的原子，原子是构成物质的最小单位。于是，人们就归纳出事务的第一个特性：原子性（Atomicity）。 特别是在数据库领域，事务是一个...
步步为营 C# 技术漫谈 七、事务处理(Transaction)
weixin_33742618的博客
01-08 229
概述 事务必须具有原子性、一致性、隔离性和持久性。虽然首字母缩写词容易记忆，但是每个词的含义不是很明显。以下是简要说明。   ●    原子性（Atomicity）：原子性可确保要么执行所有更新，要么什么也不发生。由于事务中的原子性保障，开发人员不必编写代码来处理更新成功而另一个没有成功的情况。   ●    一致性（Consistency）：一致性意味着事务的结果使得系统保持一致状态...
事务Transaction
双鬼带单
11-06 1549
文章目录为什么写这系列的文章事务概念ACID并发事务导致的问题脏读(Dirty Read)非重复读(Nonrepeatable Read)幻读(Phantom Reads)丢失修改(Lost Update)事务隔离读未提交(Read Uncommitted)读已提交(Read Committed)可重复读(Repeatable Read)：串行读(Serializable) 为什么写这系列的文章 ...
事务处理 Transaction
Wayne_C的Blog
09-12 829
<br />      事务开始之后，对数据库所有的更改操作要么全部成功，如果有一条操作出错，则所有的操作全部取消，即将数据恢复成事务开始之前的状态，通过事务保证对数据库的一系列修改能够全部同步完成，不成功便成仁<br />    事务处理被封装成SqlTransaction类的对象，在一个被打开的SqlConnection对象中，可以通过BeginTransaction()方法来获取SqlTransaction对象<br />    SqlTransaction对象执行Commit()方法时，向数据库提交
Transaction事务管理
编程小透明的博客
04-10 636
    我们在实际业务场景中，经常会遇到数据频繁修改读取的问题。在同一时刻，不同的业务逻辑对同一个表数据进行修改，这种冲突很可能造成数据不可挽回的错乱，所以我们需要用事务来对数据进行管理。     事务（Transaction）：构成单一逻辑工作单元的操作集合         DBMS中的用户程序，DBMS外的可执行程序，对数据库的读/写操作序列     事务的特性－ACID：        ...
laravel 解决多库下的DB::transaction()事务失效问题
10-16
在 Laravel 应用程序中，如果使用了多个数据库配置（例如 `mysql` 和 `mysql2`），并且在 `DB::transaction()` 块内执行针对不同数据库的操作，事务可能不会按预期工作。例如，以下代码可能导致事务失效： ```php ...
PDO::inTransaction讲解
10-17
在现代的软件开发中，与数据库的交互是必不可少的一部分，而在数据库操作中，事务管理是确保数据一致性和完整性的...在开发涉及数据库操作的应用程序时，正确使用这个方法，可以使得错误处理和事务管理更加高效和清晰。
C#事务处理（Execute Transaction）实例解析
09-04
在实际应用中，事务处理通常用于更复杂的操作，例如涉及多个表的更新、删除或插入操作。在这些情况下，事务可以确保即使在部分操作失败的情况下，也不会影响整个业务流程的完整性。 总之，C#的`Execute Transaction...
事务(Transaction)详解
weixin_44582492的博客
06-03 648
事务(Transaction)详解
spring事务@Transactional在同一个类中的方法调用不生效
johnhuster的专栏
11-30 7592
转载自：https://www.jianshu.com/p/2e4e1007edf2 spring提供了非常强大的事务管理机制，之前一直以为只要在想要加注解的方法上加个@Transactional注解就万事大吉了 但是今天发现这样做在某些情况下会有bug，导致事务无法生效。 当这个方法被同一个类调用的时候，spring无法将这个方法加到事务管理中。 我们来看一下生效时候和不生效时候调用...
Spring同一个class类中的@Transactional事务调用另一个事务不生效的解决方案
最新发布
ChuaWi98的博客
10-08 3252
同一个class类，在事务方法中调用另外一个事务方法，被调用方法的事务不生效
Spring同一个类事务处理
tsp150600的博客
05-18 2294
Spring同一个类事务处理同一个类不同方法事务可以传播（需要满足事务的前提）同一个类两个不同方法调用（注解方式）同一个类两个不同方法调用（注解方式，父方法捕捉了异常）同一个类两个不同方法调用（注解方式，父方法未使用事务）同一个类两个不同方法调用（子方法编码事务方式，父方法未使用事务）同一个类两个不同方法调用（子方法编码事务方式，父方法使用注解事务）结论 同一个类不同方法事务可以传播（需要满足事务的前提） 你好！查看一些博客说，同一个类的不同标有事务注解的方法不可以传播。今天就以身试法，尝试一下，不同情况下
同一个类中无事务方法调用同一个类的有事务方法问题原因及其解决方法
liuguang212的博客
03-06 3671
无事务a()方法中调用同一个类的有事务b()方法问题原因及其解决方法 在Spring管理的项目中，方法B使用了Transactional注解，试图实现事务性。但当同一个class中的方法A调用方法B时，会发现方法B中的异常不再导致回滚，也即事务失效了。 当这个方法被同一个类调用的时候，spring无法将这个方法加到事务管理中。 public class UserService extends Ba...
Spring的事务（Transaction）
陌守
02-23 1万+
Spring的事务（Transaction） 问题： 1、什么是事务？ 事务是指一组SQL语句的集合，集合中有多条SQL语句，可以是insert、update、select、delete，希望这些SQL语句执行是一致的，作为一个整体执行。要么都成功，要么都失败。 2、什么时候想到使用事务？ （1）当操作设计多个表，或者是多个SQL语句的insert、update、delete。需要保证这些语句都是成功才能完成功能，或者都失败是符合要求的。（要么都成功，要么都失败） （2）事务在java开发中如何运用？
同一个类中@Transactional 事务失效
qq_40202111的博客
03-25 2036
1.在同一个类中一个没有事务 A 的方法调用另个有事务 B 的方法，那么那个有事务 B 的方法是失效的； public class test { public void a() { /* … */ } @Transactional public void b() { this.a(); } } 2.如果有事务 A 方法调用没有（或者有）事务...
Spring嵌套事务之同一个类中，一个方法调用另外一个有事务的方法
qq_33274797的博客
10-04 5763
前段时间，朋友问了我一个问题，说有一个service类中，有一个A()和B(), A()没有添加事务,B() 添加了一个默认的事务，那么如果B()抛出异常，那么A()B()是否会回滚？ 今天就回顾以下这个问题，看看到底如何？回顾这个问题之前，需要先了解下事务的传播行为，事务的传播 行为共7种如下： PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务,最常见的选择。 PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行.
MySQL——事务(Transaction)详解
热门推荐
浅然的专栏
03-23 23万+
该博客详解MySQL中的事务 一、事务定义 Transaction 事务：一个最小的不可再分的工作单元；通常一个事务对应一个完整的业务(例如银行账户转账业务，该业务就是一个最小的工作单元) 一个完整的业务需要批量的DML(insert、update、delete)语句共同联合完成 事务只和DML语句有关，或者说DML语句才有事务。这个和业务逻辑有关，业务逻辑不同，DML语句的个数不同...
C# SqlTransaction详解：事务处理与示例代码
在实际应用中，事务处理是确保数据一致性的关键，尤其是在多用户环境中。正确使用SqlTransaction可以防止脏读、不可重复读和幻读等问题，维护数据库的一致性。同时，需要注意的是，事务处理可能会增加数据库的锁竞争...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值