工作单元模式

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

namespace UnitOfWork
{
    public interface IUnitOfWorkRepository
    {
        void NewItem(object item);
        void UpdatedItem(object item);
        void DeletedItem(object item);
    }
    public interface IUnitOfWork
    {
        void RegisterAdded(object entity, IUnitOfWorkRepository repository);
        void RegisterChanged(object entity, IUnitOfWorkRepository repository);
        void RegisterRemoved(object entity, IUnitOfWorkRepository repository);
        void Commit();
    }
    public class UnitOfWork : IUnitOfWork
    {
        private Dictionary<object, IUnitOfWorkRepository> addedEntities;
        private Dictionary<object, IUnitOfWorkRepository> changedEntities;
        private Dictionary<object, IUnitOfWorkRepository> deletedEntities;

        ///<summary>
        /// 实例化工作单元
        ///</summary>
        public UnitOfWork()
        {
            this.addedEntities = new Dictionary<object,
            IUnitOfWorkRepository>();
            this.changedEntities = new Dictionary<object,
            IUnitOfWorkRepository>();
            this.deletedEntities = new Dictionary<object,
            IUnitOfWorkRepository>();
        }

        #region IUnitOfWork 方法

        ///<summary>
        /// 注册添加操作
        ///</summary>
        ///<param name="entity"></param>
        ///<param name="repository"></param>
        public void RegisterAdded(object entity, IUnitOfWorkRepository repository)
        {
            this.addedEntities.Add(entity, repository);
        }
        ///<summary>
        /// 注册更改操作
        ///</summary>
        ///<param name="entity"></param>
        ///<param name="repository"></param>
        public void RegisterChanged(object entity, IUnitOfWorkRepository repository)
        {
            this.changedEntities.Add(entity, repository);
        }
        ///<summary>
        /// 注册删除操作
        ///</summary>
        ///<param name="entity"></param>
        ///<param name="repository"></param>
        public void RegisterRemoved(object entity, IUnitOfWorkRepository repository)
        {
            this.deletedEntities.Add(entity, repository);
        }

        ///<summary>
        /// 执行内存列表保存的操作
        ///</summary>
        public void Commit()
        {
            using (TransactionScope scope = new TransactionScope())
            {
                foreach (object entity in this.deletedEntities.Keys)
                {
                    this.deletedEntities[entity].DeletedItem(entity);
                }

                foreach (object entity in this.addedEntities.Keys)
                {
                    this.addedEntities[entity].NewItem(entity);
                }

                foreach (object entity in this.changedEntities.Keys)
                {
                    this.changedEntities[entity].UpdatedItem(entity);
                }

                scope.Complete();
            }

            this.deletedEntities.Clear();
            this.addedEntities.Clear();
            this.changedEntities.Clear();
        }

        #endregion
    }
    public class TestRepository : IUnitOfWorkRepository
    {
        private IUnitOfWork unitOfWork;
        private IUnitOfWork TestUnitOfWork
        {
            get { return this.unitOfWork; }
        }

        public TestRepository(IUnitOfWork unitOfWork)
        {
            this.unitOfWork = unitOfWork;

        }
        public void Add(object _object)
        {
            TestUnitOfWork.RegisterAdded(_object, this);

            Console.WriteLine("注册添加数据" + _object);

        }
        public void Delete(object _object)
        {
            TestUnitOfWork.RegisterRemoved(_object, this);
            Console.WriteLine("注册删除数据" + _object);
        }
        public void update(object _object)
        {
            TestUnitOfWork.RegisterChanged(_object, this);
            Console.WriteLine("注册更新数据" + _object);
        }

        public void NewItem(object _object)
        {
            Console.WriteLine("执行添加数据" + _object);
        }

        public void UpdatedItem(object _object)
        {
            Console.WriteLine("执行更新数据" + _object);
        }

        public void DeletedItem(object _object)
        {
            Console.WriteLine("执行删除数据" + _object);
        }

    }
    public class TestServer
    {
        private static IUnitOfWork unitOfWork;
        private static TestRepository _TestRepository;
        static TestServer()
        {
            TestServer.unitOfWork = new UnitOfWork();
            _TestRepository = new TestRepository(unitOfWork);

        }
        public static void Add()
        {
            _TestRepository.Add(1);
            _TestRepository.Add(2);
            _TestRepository.Add(3);
            _TestRepository.Add(4);
            _TestRepository.Add(5);
            unitOfWork.Commit();
        }

        public static void Add(object _object)
        {
            _TestRepository.Add(_object);
            _TestRepository.Delete(_object);
            _TestRepository.update(_object);
            unitOfWork.Commit();

        }
        public static void Delete(object _object)
        {
            _TestRepository.Delete(_object);
            unitOfWork.Commit();
        }
        public static void Update(object _object)
        {
            _TestRepository.update(_object);
            unitOfWork.Commit();
        }

    }
}
namespace ConsoleApplication3
{

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

            TestServer.Add(1);
            Console.WriteLine("----------------------------");
            TestServer.Add();

            Console.ReadKey();

        }
    }
}

原文地址:https://www.cnblogs.com/kexb/p/9095489.html

时间: 2024-11-14 12:28:14

工作单元模式的相关文章

MVC+EF 理解和实现仓储模式和工作单元模式

MVC+EF 理解和实现仓储模式和工作单元模式 原文:Understanding Repository and Unit of Work Pattern and Implementing Generic Repository in ASP.NET MVC using Entity Framework 文章介绍 在这篇文章中,我们试着来理解Repository(下文简称仓储)和Unit of Work(下文简称工作单元)模式.同时我们使用ASP.NET MVC和Entity Framework 搭

.NET应用架构设计—工作单元模式(摆脱过程式代码的重要思想,逆袭DDD)

阅读目录: 1.背景介绍 2.过程式代码的真正困境 3.工作单元模式的简单示例 4.总结 1.背景介绍 一直都在谈论面向对象开发,但是开发企业应用系统时,使用面向对象开发最大的问题就是在于,多个对象之间的互操作需要涉及数据库操作.两个业务逻辑对象彼此之间需要互相调用,如果之间的互相操作是在一个业务事务范围内的,很容易完成,但是如果本次业务逻辑操作涉及到多个业务对象一起协作完成时问题就来了. 在以往,我们使用过程式的代码(事务脚本模式),将所有与本次业务事务范围内相关的所有逻辑都写在一个大的代码中

[.NET领域驱动设计实战系列]专题五:网上书店规约模式、工作单元模式的引入以及购物车的实现

一.前言 在前面2篇博文中,我分别介绍了规约模式和工作单元模式,有了前面2篇博文的铺垫之后,下面就具体看看如何把这两种模式引入到之前的网上书店案例里. 二.规约模式的引入 在第三专题我们已经详细介绍了什么是规约模式,没看过的朋友首先去了解下.下面让我们一起看看如何在网上书店案例中引入规约模式.在网上书店案例中规约模式的实现兼容了2种模式的实现,兼容了传统和轻量的实现,包括传统模式的实现,主要是为了实现一些共有规约的重用,不然的话可能就要重复写这些表达式.下面让我们具体看看在该项目中的实现. 首先

工作单元模式(java)

个人理解:工作单元模式是为了解决事务性问题,即保证数据修改提交的一致性. 晚上在看到工作单元模式时,觉得比较有意思,看到的基本都是c#实现的,本着学习的态度,使用java语言实现,实现出来才发现有点蹩脚,权当记录,有时间再完善. 1 package com.xiaolu.unitofwork; 2 3 import com.xiaolu.domain.AggrateRoot; 4 import com.xiaolu.repository.UnitOfWorkRepository; 5 6 /**

【.Net设计模式系列】工作单元(Unit Of Work)模式 ( 二 )

回顾 在上一篇博客[.Net设计模式系列]仓储(Repository)模式 ( 一 ) 中,通过各位兄台的评论中,可以看出在设计上还有很多的问题,在这里特别感谢 @横竖都溢 @ 浮云飞梦 2位兄台对博文中存在的问题给予指出,并提供出好的解决方案,同时也感谢其他园友的支持.欢迎各位园友对博文中出现的错误或者是设计误区给予指出,一方面防止“误人子弟”,另一方面则可以让大家共同成长. 对于上一篇博客,只是给大家提供了一种对于小型项目数据访问层的一种实现方式,通过Sql语句和传递参数来实现CRUD.并未

工作单元(Unit Of Work)模式 ( 二 )

转自 http://www.cnblogs.com/retop/p/5193394.html 理论介绍 在进行数据库添加.修改.删除时,为了保证事务的一致性,即操作要么全部成功,要么全部失败.例如银行A.B两个账户的转账业务.一方失败都会导致事务的不完整性,从而事务回滚.而工作单元模式可以跟踪事务,在操作完成时对事务进行统一提交. 理论参考:http://martinfowler.com/eaaCatalog/unitOfWork.html 具体实践 首先,讲解下设计思想:领域层通过相应的库实现

换个角度说工作单元(Unit Of Work):创建、持有与API调用

看到一些工作单元的介绍,有两种感觉,第一种是很学院,说了等于没说,我估计很多都是没有自己引入到实际的项目中去,第二种是告诉我一种结果,说这就是工作单元,但是没说为什么要这么使用.所以,本篇想要探讨的是:为什么工作单元要这么用.首先,要想将工作单元引入到自己的项目中去,急需要解决的一个问题是:工作单元的生命周期,即: 1:工作单元被谁创建,何时消亡? 2:工作单元被谁们持有? 3:工作单元的 4 个 API( MakeNew.MakeDirty.MakeRemoved.Commit )被谁调用?

[Abp 源码分析]六、工作单元的实现

0.简介 在 Abp 框架内部实现了工作单元,在这里讲解一下,什么是工作单元? Unit Of Work(工作单元)模式用来维护一个由已经被业务事物修改(增加.删除或更新)的业务对象组成的列表.Unit ?Of Work模式负责协调这些修改的持久化工作以及所有标记的并发问题.在数据访问层中采用Unit Of Work模式带来的好处是能够确保数据完整性.如果在持久化一系列业务对象(他们属于同一个事物)的过程中出现问题,那么应该将所有的修改回滚,以确保数据始终处于有效状态. 而在 Abp 的内部则是

工作单元 — Unit Of Work

在进行数据库添加.修改.删除时,为了保证事务的一致性,即操作要么全部成功,要么全部失败.例如银行A.B两个账户的转账业务.一方失败都会导致事务的不完整性,从而事务回滚.而工作单元模式可以跟踪事务,在操作完成时对事务进行统一提交. 具体实践 首先,讲解下设计思想:领域层通过相应的库实现泛型仓储接口来持久化聚合类,之后在抽象库中将对泛型仓储接口提供基础实现,并将对应的实体转化为SQl语句.这样领域层就不需要操作Sql语句即可完成CRUD操作,同时使用工作单元对事务进行统一提交. 1)定义仓储接口,包