SmartStoreNET/src/Libraries/SmartStore.Data/Caching/CacheTransactionInterceptor.cs at 3.x · mherweb/SmartStoreNET · 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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Data.Entity.Infrastructure.Interception;
using System.Linq;

namespace SmartStore.Data.Caching
{
	public class CacheTransactionInterceptor : IDbTransactionInterceptor
	{
		private readonly ConcurrentDictionary<DbTransaction, List<string>> _affectedSetsInTransaction = new ConcurrentDictionary<DbTransaction, List<string>>();
		private readonly IDbCache _cache;

		public CacheTransactionInterceptor(IDbCache cache)
		{
			Guard.NotNull(cache, nameof(cache));

			_cache = cache;
		}

		public virtual bool GetItem(DbTransaction transaction, string key, out object value)
		{
			if (transaction == null)
			{
				return _cache.TryGet(key, out value);
			}

			value = null;

			return false;
		}

		public virtual void PutItem(DbTransaction transaction, string key, object value, IEnumerable<string> dependentEntitySets, TimeSpan? duration)
		{
			if (transaction == null)
			{
				_cache.Put(key, value, dependentEntitySets, duration);
			}
		}

		public virtual void InvalidateSets(DbTransaction transaction, IEnumerable<string> entitySets)
		{
			if (transaction == null)
			{
				_cache.InvalidateSets(entitySets);
				_cache.RequestInvalidateSets(entitySets);
			}
			else
			{
				AddAffectedEntitySets(transaction, entitySets);
			}
		}

		protected void AddAffectedEntitySets(DbTransaction transaction, IEnumerable<string> affectedEntitySets)
		{
			Guard.NotNull(transaction, nameof(transaction));
			Guard.NotNull(affectedEntitySets, nameof(affectedEntitySets));

			var entitySets = _affectedSetsInTransaction.GetOrAdd(transaction, new List<string>());
			entitySets.AddRange(affectedEntitySets);
		}

		private IEnumerable<string> RemoveAffectedEntitySets(DbTransaction transaction)
		{
			List<string> affectedEntitySets;

			_affectedSetsInTransaction.TryRemove(transaction, out affectedEntitySets);

			return affectedEntitySets;
		}

		public void Committed(DbTransaction transaction, DbTransactionInterceptionContext interceptionContext)
		{
			var entitySets = RemoveAffectedEntitySets(transaction);

			if (entitySets != null)
			{
				_cache.InvalidateSets(entitySets);
				_cache.RequestInvalidateSets(entitySets);
			}
		}

		public void Committing(DbTransaction transaction, DbTransactionInterceptionContext interceptionContext)
		{
		}

		public void ConnectionGetting(DbTransaction transaction, DbTransactionInterceptionContext<DbConnection> interceptionContext)
		{
		}

		public void ConnectionGot(DbTransaction transaction, DbTransactionInterceptionContext<DbConnection> interceptionContext)
		{
		}

		public void Disposed(DbTransaction transaction, DbTransactionInterceptionContext interceptionContext)
		{
		}

		public void Disposing(DbTransaction transaction, DbTransactionInterceptionContext interceptionContext)
		{
		}

		public void IsolationLevelGetting(DbTransaction transaction, DbTransactionInterceptionContext<IsolationLevel> interceptionContext)
		{
		}

		public void IsolationLevelGot(DbTransaction transaction, DbTransactionInterceptionContext<IsolationLevel> interceptionContext)
		{
		}

		public void RolledBack(DbTransaction transaction, DbTransactionInterceptionContext interceptionContext)
		{
			RemoveAffectedEntitySets(transaction);
		}

		public void RollingBack(DbTransaction transaction, DbTransactionInterceptionContext interceptionContext)
		{
		}
	}
}