QuickCore/Quick.Core.Entity.UnitOfWork.pas at master · exilon/QuickCore · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
{ **************************** }
{      Quick.Core Library      }
{      Unit of Work Pattern    }
{ **************************** }
{ Author: QuickCore Team       }
{ **************************** }
unit Quick.Core.Entity.UnitOfWork;

{$i QuickCore.inc}

interface

uses
  System.SysUtils,
  Quick.Core.Entity;

type
  IUnitOfWork = interface
  ['{D7F2A3B1-9C4E-4F2D-8B6A-1E5C7D0F3A8B}']
    procedure BeginTransaction;
    procedure Commit;
    procedure Rollback;
    { Execute aProc inside a transaction. Returns True on success (commits),
      False if an exception occurs (rolls back and swallows the exception). }
    function Execute(aProc : TProc) : Boolean;
  end;

  TUnitOfWork = class(TInterfacedObject, IUnitOfWork)
  private
    fContext : IDBContext;
  public
    constructor Create(aContext : IDBContext);
    procedure BeginTransaction;
    procedure Commit;
    procedure Rollback;
    function Execute(aProc : TProc) : Boolean;
  end;

implementation

{ TUnitOfWork }

constructor TUnitOfWork.Create(aContext : IDBContext);
begin
  fContext := aContext;
end;

procedure TUnitOfWork.BeginTransaction;
begin
  fContext.BeginTransaction;
end;

procedure TUnitOfWork.Commit;
begin
  fContext.CommitTransaction;
end;

procedure TUnitOfWork.Rollback;
begin
  fContext.RollbackTransaction;
end;

function TUnitOfWork.Execute(aProc : TProc) : Boolean;
begin
  Result := False;
  fContext.BeginTransaction;
  try
    aProc();
    fContext.CommitTransaction;
    Result := True;
  except
    fContext.RollbackTransaction;
  end;
end;

end.