Removing usages of obsolete RegisterProcess method calls

Author: RogerKratz

Src/NHibernate.Envers/Synchronization/AuditProcessManager.cs

@@ -1,6 +1,9 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using NHibernate.Action;
 using NHibernate.Envers.RevisionInfo;
 using NHibernate.Event;
 
@@ -27,18 +30,49 @@ public AuditProcess Get(IEventSource session)
 				// No worries about registering a transaction twice - a transaction is single thread
 				auditProcess = new AuditProcess(_revisionInfoGenerator, session);
 				_auditProcesses[transaction] = auditProcess;
-
-				session.ActionQueue.RegisterProcess(() =>
-				                                    	{
-						                                    if(_auditProcesses.TryGetValue(transaction, out var currentProcess))
-																		{
-																			currentProcess.DoBeforeTransactionCompletion();
-																		}
-				                                    	});
-				session.ActionQueue.RegisterProcess(success => _auditProcesses.Remove(transaction));
+				var tranProcess = new transactionCompletionProcess(_auditProcesses, transaction);
+				session.ActionQueue.RegisterProcess((IBeforeTransactionCompletionProcess)tranProcess);
+				session.ActionQueue.RegisterProcess((IAfterTransactionCompletionProcess)tranProcess);
 			}
 
 			return auditProcess;
 		}
+
+		private class transactionCompletionProcess : IBeforeTransactionCompletionProcess, IAfterTransactionCompletionProcess
+		{
+			private readonly IDictionary<ITransaction, AuditProcess> _auditProcesses;
+			private readonly ITransaction _transaction;
+
+			public transactionCompletionProcess(IDictionary<ITransaction, AuditProcess> auditProcesses, ITransaction transaction)
+			{
+				_auditProcesses = auditProcesses;
+				_transaction = transaction;
+			}
+			
+			public void ExecuteBeforeTransactionCompletion()
+			{
+				if(_auditProcesses.TryGetValue(_transaction, out var currentProcess))
+				{
+					currentProcess.DoBeforeTransactionCompletion();
+				}
+			}
+			
+			public void ExecuteAfterTransactionCompletion(bool success)
+			{
+				_auditProcesses.Remove(_transaction);
+			}
+
+			public Task ExecuteBeforeTransactionCompletionAsync(CancellationToken cancellationToken)
+			{
+				ExecuteBeforeTransactionCompletion();
+				return Task.CompletedTask;
+			}
+
+			public Task ExecuteAfterTransactionCompletionAsync(bool success, CancellationToken cancellationToken)
+			{
+				ExecuteAfterTransactionCompletion(success);
+				return Task.CompletedTask;
+			}
+		}
 	}
 }

Src/NHibernate.Envers/Synchronization/SessionCacheCleaner.cs

@@ -1,4 +1,7 @@
-using NHibernate.Event;
+using System.Threading;
+using System.Threading.Tasks;
+using NHibernate.Action;
+using NHibernate.Event;
 
 namespace NHibernate.Envers.Synchronization
 {
@@ -16,13 +19,33 @@ public static class SessionCacheCleaner
 		/// <param name="data">Audit data that shall be evicted (e.g. revision data or entity snapshot)</param>
 		public static void ScheduleAuditDataRemoval(ISession session, object data)
 		{
-			((IEventSource)session).ActionQueue.RegisterProcess(success =>
-			                                                    	{
-																						if(session.IsOpen)
-																						{
-																							session.Evict(data);
-																						}
-			                                                    	});
+			((IEventSource)session).ActionQueue.RegisterProcess(new cleanupAfterTranProcess(session, data));
+		}
+
+		private class cleanupAfterTranProcess : IAfterTransactionCompletionProcess
+		{
+			private readonly ISession _session;
+			private readonly object _data;
+
+			public cleanupAfterTranProcess(ISession session, object data)
+			{
+				_session = session;
+				_data = data;
+			}
+			
+			public void ExecuteAfterTransactionCompletion(bool success)
+			{
+				if(_session.IsOpen)
+				{
+					_session.Evict(_data);
+				}
+			}
+
+			public Task ExecuteAfterTransactionCompletionAsync(bool success, CancellationToken cancellationToken)
+			{
+				ExecuteAfterTransactionCompletion(success);
+				return Task.CompletedTask;
+			}
 		}
 	}
 }