Exemple #1
0
        private static async Task OutputAsync(long bankAccountNo1, long bankAccountNo2, IScopedTransactionalDatabase transactionalStore)
        {
            BankAccount bankAccount1, bankAccount2;

            try
            {
                bankAccount1 = await transactionalStore.GetAsync <BankAccount>(p => p.Id == bankAccountNo1).FirstOrDefault();

                bankAccount2 = await transactionalStore.GetAsync <BankAccount>(p => p.Id == bankAccountNo2).FirstOrDefault();

                await transactionalStore.TryCommitAsync();
            }
            catch
            {
                await transactionalStore.RollbackAsync();

                throw;
            }

            await Console.Out.WriteLineAsync($"Account1 amount: {bankAccount1.Amount} should be {_ba1AmountComparand}");

            await Console.Out.WriteLineAsync($"Account2 amount: {bankAccount2.Amount} should be {_ba2AmountComparand}");

            await Console.Out.WriteLineAsync();

            await Console.Out.WriteLineAsync(bankAccount1.Amount == _ba1AmountComparand && bankAccount2.Amount == _ba2AmountComparand? "OK" : "NOT OK");
        }
Exemple #2
0
            public async Task <bool> WriteToDatabaseAsync(IScopedTransactionalDatabase transactionalDatabase, CancellationToken cancellation)
            {
                // Write touched target metadata to database
                foreach (var(originalMetadata, touchedMetadata) in _targetMetadataCache.Values.Where(p => p.Touched))
                {
                    var comparandMetdata = await transactionalDatabase.GetAsync <ProjectionTargetMetadata>(p => p.Id == (originalMetadata ?? touchedMetadata).Id).FirstOrDefault();

                    if (!MatchesByRevision(originalMetadata, comparandMetdata))
                    {
                        return(false);
                    }

                    if (touchedMetadata == null)
                    {
                        Assert(originalMetadata != null);

                        await transactionalDatabase.RemoveAsync(originalMetadata, cancellation);
                    }
                    else
                    {
                        touchedMetadata.MetadataRevision = originalMetadata?.MetadataRevision ?? 1;

                        await transactionalDatabase.StoreAsync(touchedMetadata, cancellation);
                    }
                }

                // TODO: Do we have to check whether the targets were updated concurrently?

                foreach (var targetToUpdate in _targetsToUpdate)
                {
                    await transactionalDatabase.StoreAsync(targetToUpdate, cancellation);
                }

                foreach (var targetToDelete in _targetsToDelete)
                {
                    await transactionalDatabase.RemoveAsync(targetToDelete, cancellation);
                }

                return(true);
            }