Montagem assíncrona de um objeto complexo
É necessária uma verificação de integridade, pois ainda não estou familiarizado com as nuances por trás de async / await e como eles se relacionam com o código Task / TPL mais tradicional.
Eu tenho uma camada de repositório de alto nível que está montando um objeto de negócios de vários repositórios de nível inferior. Como uma decisão de negócios, estamos fazendo pesquisas por chave na camada de dados e montando o objeto de composição no código. No código a seguir, "Account" é o objeto de negócios e os vários objetos _tAccountXXXRepo são todos padronizados de forma semelhante a este (estamos usando NPoco):
public class T_AccountMapperRepository : BaseNPocoRepository<T_AccountMapper>
, IRetrieveMany<T_AccountMapper>
, IRetrieve<AccountId, T_AccountMapper>
{
public T_AccountMapperRepository(IDatabase database) : base(database)
{
}
public async Task<T_AccountMapper> Retrieve(AccountId input)
{
return await Database.QueryAsync<T_AccountMapper>()
.First(x => x.AccountId == input)
.ConfigureAwait(false);
}
}
O código para buscar os diferentes valores pode ser executado logicamente em paralelo, e estou me perguntando se esta implementação é o padrão correto para fazer isso: (os vários métodos sendo chamados no objeto Account também são thread-safe)
public async Task<Account> Retrieve(AccountId input1, DateTime input2)
{
var account = new Account();
await Task.WhenAll(
_tAccountMapperRepo.Retrieve(input1)
.ContinueWith(async result => account.SetAccountMap(await TranslateAccountMap(result))),
_tPaymentRedirectionRepo.Retrieve(input1, input2)
.ContinueWith(async result => account.ChangePayerToAccount(await TranslatePaymentRedirection(result))),
_tAccountAncestorRepo.Retrieve(input1, input2)
.ContinueWith(async result => await _tAccountMapperRepo.Retrieve((await result).AncestorId))
.ContinueWith(async result => account.MoveAccountToNewParentAccountMap(await TranslateAccountMap(await result))),
_tAccountRepo.Retrieve(input1)
.ContinueWith(async result => await _tAccountTypeRepo.Retrieve((await result).TypeId))
.ContinueWith(async result => account.SetAccountType(await TranslateAccountType(await result)))
);
return account;
}
Qualquer método rotulado com TranslateXXX é semelhante a este:
private static async Task<AccountMap> TranslateAccountMap(Task<T_AccountMapper> mapTask)
{
if (!mapTask.IsCompletedSuccessfully)
throw new InvalidOperationException(nameof(mapTask), mapTask.Exception);
var map = await mapTask;
return new AccountMap(map.AccountId, map.Login, map.Namespace);
}
Minhas principais preocupações são misturar Task e async / await, e se meu async & awaiting está ou não reintroduzindo um elemento de sincronicidade no que espero tornar um processo muito assíncrono. Meu objetivo final é que o maior número possível de propriedades sejam buscadas em paralelo e montadas
Respostas
Quanto a mim, parece bom, exceto uma coisa. Você já concluiu Taskem .ContinueWithbloco, portanto, você pode usar .Resultentão em vez de awaite evitar asynca máquina de estado redundante .
A propósito, se você estiver usando async/await, provavelmente não há necessidade de continuação.
Considere esta implementação livre de continuação do primeiro Task.WhenAll()trabalho.
public async Task<Account> Retrieve(AccountId input1, DateTime input2)
{
var account = new Account();
// probably try-catch wrapper maybe useful here as replacement of !mapTask.IsCompletedSuccessfully
await Task.WhenAll((Func<Task>)(async () =>
{
T_AccountMapper map = await _tAccountMapperRepo.Retrieve(input1);
// continuation:
AccountMap accountMap = new AccountMap(map.AccountId, map.Login, map.Namespace);
account.SetAccountMap(accountMap);
})
//, (Func<Task>)(async() => {...})
);
return account;
}
Como você pode ver, o TranslateAccountMapmétodo não é mais necessário.
Finalmente, depende de você.
PS Aqui está um link útil .
Com base no feedback da aepot e nas lições da Orientação Async AspNetCore , refatorei o código da seguinte maneira:
public async Task<Account> RetrieveAsync(AccountId input1, DateTime input2)
{
Account account = new Account();
await Task.WhenAll(
SetAccountMap(account, input1, input2),
ChangePayer(account, input1, input2),
SetParentMap(account, input1, input2),
SetAccountType(account, input1, input2)
);
return account;
}
private async Task SetAccountType(Account account, AccountId accountId, DateTime dateTime)
{
var baseAccount = await _tAccountRepo.RetrieveAsync(accountId);
var accountType = await _tAccountTypeRepo.RetrieveAsync(baseAccount.TypeId);
var convertedAccountType = _accountTypeConverter.Convert(accountType);
account.SetAccountType(convertedAccountType);
}
private async Task SetParentMap(Account account, AccountId accountId, DateTime dateTime)
{
var accountAncestor = await _tAccountAncestorRepo.RetrieveAsync(accountId, dateTime);
var accountMap = await _tAccountMapperRepo.RetrieveAsync(accountAncestor.DescendentId);
var convertedAccountMap = _accountMapConverter.Convert(accountMap);
account.MoveAccountToNewParentAccountMap(convertedAccountMap);
}
private async Task ChangePayer(Account account, AccountId accountId, DateTime dateTime)
{
var paymentRedirection = await _tPaymentRedirectionRepo.RetrieveAsync(accountId, dateTime);
var convertedPaymentRedirection = _paymentRedirectionConverter.Convert(paymentRedirection);
account.ChangePayerToAccount(convertedPaymentRedirection);
}
private async Task SetAccountMap(Account account, AccountId accountId, DateTime dateTime)
{
var accountMap = await _tAccountMapperRepo.RetrieveAsync(accountId);
var convertedAccountMap = _accountMapConverter.Convert(accountMap);
account.SetAccountMap(convertedAccountMap);
}
Aqui, tenho duas versões alternativas do código revisado de Bryan Boettcher.
Em sua versão, existem 4 funções ETL e elas estão sendo executadas simultaneamente.
Em minhas soluções, apenas a parte de extração está sendo executada simultaneamente. As partes de Transformação e Carregamento são executadas sequencialmente.
Alternativa # 1
Por favor, tenha em mente que eu tinha que usar algumas compostas nomes de tipo (como: AccountType, PaymentRedirection) porque eu não poderia dizer os tipos exatos com base no código fornecido.
public async Task<Account> RetrieveAsync(AccountId accountId, DateTime dateTime)
{
//Extract
var accountTypeJob = RetrieveAccountType(accountId);
var paymentRedirectionJob = RetrievePaymentRedirection(accountId, dateTime);
var accountMapJob = RetrieveAccountMap(accountId);
var parentAccountMapJob = RetrieveAccountMapForParent(accountId, dateTime);
//Transform
var accountType = await accountTypeJob;
var convertedAccountType = _accountTypeConverter.Convert(accountType);
var paymentRedirection = await paymentRedirectionJob;
var convertedPaymentRedirection = _paymentRedirectionConverter.Convert(paymentRedirection);
var accountMap = await accountMapJob;
var convertedAccountMap = _accountMapConverter.Convert(accountMap);
var parentAccountMap = await parentAccountMapJob;
var convertedParentAccountMap = _accountMapConverter.Convert(parentAccountMap);
//Load
var account = new Account();
account.SetAccountType(convertedAccountType);
account.ChangePayerToAccount(convertedPaymentRedirection);
account.SetAccountMap(convertedAccountMap);
account.MoveAccountToNewParentAccountMap(convertedParentAccountMap);
return account;
}
private async Task<AccountType> RetrieveAccountType(AccountId accountId)
{
var baseAccount = await _tAccountRepo.RetrieveAsync(accountId);
return await _tAccountTypeRepo.RetrieveAsync(baseAccount.TypeId);
}
private async Task<AccountMap> RetrieveAccountMapForParent(AccountId accountId, DateTime dateTime)
{
var accountAncestor = await _tAccountAncestorRepo.RetrieveAsync(accountId, dateTime);
return await _tAccountMapperRepo.RetrieveAsync(accountAncestor.DescendentId);
}
private async Task<PaymentRedirection> RetrievePaymentRedirection(AccountId accountId, DateTime dateTime)
{
return await _tPaymentRedirectionRepo.RetrieveAsync(accountId, dateTime);
}
private async Task<AccountMap> RetrieveAccountMap(AccountId accountId)
{
return await _tAccountMapperRepo.RetrieveAsync(accountId);
}
Como você pode ver, tenho 4 RetrieveXYZfunções e estas são responsáveis por carregar os dados. Suponho que sejam operações de E / S, portanto, não são vinculadas à CPU (a simultaneidade não é limitada pelos núcleos disponíveis).
Durante a fase de Extração , eu inicio todos os Tasks, portanto, não há necessidade de chamar explicitamente o Task.WhenAllNa fase de transformação , eu acesso os dados recuperados por meio das awaitpalavras - chave.
Alternativa # 2
Com uma função auxiliar simples, podemos tornar a RetrieveAsyncfunção mais organizada e concisa.
public static class TaskExtensions
{
public static async Task<(T1, T2, T3, T4)> WhenAll<T1, T2, T3, T4>(Task<T1> t1, Task<T2> t2, Task<T3> t3, Task<T4> t4)
{
return (await t1, await t2, await t3, await t4);
}
}
Tirando vantagem desse método auxiliar, a nova versão do RetrieveAsyncficaria assim:
public async Task<Account> RetrieveAsync(AccountId accountId, DateTime dateTime)
{
//Extract
var (accountType, paymentRedirection, accountMap, parentAccountMap) = await TaskExtensions.WhenAll(
RetrieveAccountType(accountId), RetrievePaymentRedirection(accountId, dateTime),
RetrieveAccountMap(accountId), RetrieveAccountMapForParent(accountId, dateTime));
//Transform
var convertedAccountType = _accountTypeConverter.Convert(accountType);
var convertedPaymentRedirection = _paymentRedirectionConverter.Convert(paymentRedirection);
var convertedAccountMap = _accountMapConverter.Convert(accountMap);
var convertedParentAccountMap = _accountMapConverter.Convert(parentAccountMap);
//Load
var account = new Account();
account.SetAccountType(convertedAccountType);
account.ChangePayerToAccount(convertedPaymentRedirection);
account.SetAccountMap(convertedAccountMap);
account.MoveAccountToNewParentAccountMap(convertedParentAccountMap);
return account;
}
Vantagens
- Apenas as operações vinculadas a I / O estão sendo executadas simultaneamente
- Cada função auxiliar tem responsabilidade única
- A função de nível superior atua como um coordenador
- Não há recurso compartilhado, então não precisamos nos preocupar muito com thread-safety
Desvantagens
- Se as partes de transformação e / ou carga também forem limitadas por E / S, essa abordagem seria mais lenta
- Ele não depende do integrado em
Task.WhenAllvez de depender dosValueTuplerecursos de desconstrução do C # 7, portanto, não pode ser usado em versões mais antigas do .NET Framework.