public TransactionInformation(Transaction transaction, TKey key, TValue previousValue, bool newEntry, ConcurrentTransactionalDictionary <TKey, TValue> owner)
{
this.key = key;
this.NewEntry = newEntry;
this.owner = owner;
this.PreviousValue = previousValue;
this.transaction = transaction;
this.transaction.TransactionCompleted += Fx.ThunkTransactionEventHandler((object s, TransactionEventArgs e) => {
bool status = e.Transaction.TransactionInformation.Status == TransactionStatus.Committed;
bool flag = false;
TValue tValue = default(TValue);
lock (this.owner.syncLock)
{
this.owner.pendingTransactions.Remove(this.key);
if (!status)
{
if (!this.NewEntry)
{
this.owner.internalDictionary[this.key] = this.PreviousValue;
}
else
{
this.owner.internalDictionary.Remove(this.key);
}
}
if (this.waiters != null)
{
flag = this.owner.internalDictionary.TryGetValue(this.key, out tValue);
}
}
if (this.waiters != null)
{
while (this.waiters.Count > 0)
{
ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter transactionalAsyncWaiter = this.waiters.Dequeue();
ActionItem.Schedule((object w) => ((ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter)w).Signal(flag, tValue), transactionalAsyncWaiter);
}
}
});
}
public IAsyncResult BeginTryGetValue(TKey key, TimeSpan timeout, AsyncCallback callback, object state)
{
ConcurrentTransactionalDictionary <TKey, TValue> .TransactionInformation transactionInformation;
TValue tValue;
IAsyncResult asyncResult;
string localIdentifier;
Transaction current = Transaction.Current;
if (current != null)
{
localIdentifier = current.TransactionInformation.LocalIdentifier;
}
else
{
localIdentifier = null;
}
string str = localIdentifier;
lock (this.syncLock)
{
if (!this.pendingTransactions.TryGetValue(key, out transactionInformation) || string.Equals(transactionInformation.TransactionId, str, StringComparison.OrdinalIgnoreCase))
{
bool flag = this.internalDictionary.TryGetValue(key, out tValue);
return(new CompletedAsyncResult <bool, TValue>(flag, tValue, callback, state));
}
else
{
ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter transactionalAsyncWaiter = new ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter(callback, state);
transactionInformation.Waiters.Enqueue(transactionalAsyncWaiter);
transactionalAsyncWaiter.StartTimer(timeout);
asyncResult = transactionalAsyncWaiter;
}
}
return(asyncResult);
}
public static new Tuple <bool, TValue> End(IAsyncResult result)
{
ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter transactionalAsyncWaiter = AsyncResult.End <ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter>(result);
return(new Tuple <bool, TValue>(transactionalAsyncWaiter.keyFound, transactionalAsyncWaiter.@value));
}
private static void OnWaiterSignaled(IAsyncResult result)
{
ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter asyncState = (ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter)result.AsyncState;
Exception timeoutException = null;
try
{
if (!AsyncWaiter.End(result))
{
timeoutException = new TimeoutException();
}
}
catch (OperationCanceledException operationCanceledException)
{
timeoutException = operationCanceledException;
}
asyncState.Complete(false, timeoutException);
}
public void Clear()
{
lock (this.syncLock)
{
foreach (ConcurrentTransactionalDictionary <TKey, TValue> .TransactionInformation value in this.pendingTransactions.Values)
{
if (!value.HasWaiters)
{
continue;
}
while (value.Waiters.Count > 0)
{
ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter transactionalAsyncWaiter = value.Waiters.Dequeue();
ActionItem.Schedule((object w) => ((ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter)w).Cancel(), transactionalAsyncWaiter);
}
}
this.internalDictionary.Clear();
this.pendingTransactions.Clear();
}
}
