907 messaggi dal 11 febbraio 2013
ciao,
spero che qualcuno con esperienza riguardo al multithread possa darmi una mano

ho un semplice windows form dove leggo i dati da un database e li scrivo su un'altro
Il codice che ho scritto per le entita delle tabelle è con async/await .

Il bottone che esegue la routine è cosi



private async void BtnSync_Click(object sender, EventArgs e)
                {
                //Leggo collection da Company.db
                var readAgents = Task.Run(() => Agent.GetAgentAsync());
                var readAddressBooks = Task.Run(() => AddressBook.GetAddressBookAsync());
                ...

                await Task.WhenAll(
                     readAgents,
                     readAddressBooks,
                    ...
                 );
                //salvo collection su app.db
                var addAgenti = Task.Run(async () =>
                     AgenteApp.AddAgentiAppAsync(await AgenteApp.FillAgentiAppFromCompanyAsync(readAgents.Result))
                );
                var addRubriche = Task.Run(async () =>
                     RubricaApp.AddRubricheAppAsync(await RubricaApp.FillRubricheAppFromCompanyAsync(readAddressBooks.Result))
                );
               ...

                await Task.WhenAll(
                  addAgenti,
                  addRubriche,
                ...
                );
                
                MessageBox.Show($"End with {time}");
               }


Il codice funziona bene: è veloce e laddove ci sono chiavi esterne faccio un verifica incrementale del record per chiave dell'entita

Il mio problema è che vorrei implementare una progressbar per ogni tabella che viene processata
ma non so da dove partire e temo di finire con l'inficiare le performance della routine.

A dire il vero anche una sola progressbar riepilogativa mi crea alcune difficoltà.

Provando ad iterare le chiamate ho Task<Task> e mi blocco.

Mi basta uno spunto da seguire...

in ogni caso grazie
Modificato da jjchuck il 18 settembre 2019 12:41 -
907 messaggi dal 11 febbraio 2013
Dopo aver letto questo
https://devblogs.microsoft.com/dotnet/async-in-4-5-enabling-progress-and-cancellation-in-async-apis/

ho fatto cosi e sembra funzionare

var addEsistenze = Task.Run(async () => {
                var progrIndicator = new Progress<int>(EsistenzeProgress);
                var esistenzeApp = EsistenzaApp.FillEsistenzeAppFromCompanyAsync(await readStocks, progrIndicator);
                await EsistenzaApp.AddEsistenzeAppAsync(await esistenzeApp);
            });

private void EsistenzeProgress(int progress)
        {
            progrBarEsistenze.Value = progress;
        }

public static async Task<IEnumerable<EsistenzaApp>> FillEsistenzeAppFromCompanyAsync(
            IEnumerable<ProductStock> stocks, IProgress<int> progress)
        {
            int totalCount = stocks.Count();
             await Task.Run(() =>
            {
                int counter = 1;
                foreach (var stock in stocks)
                {
                    var esistenzaApp = new EsistenzaApp();
                    Mapper.Map(stock, esistenzaApp);
                    _esistenze.Add(esistenzaApp);

                    if (progress != null)
                        progress.Report((counter * 100 / totalCount));

                    counter++;
                }
            });
            return _esistenze;
        }


Non avendo mai usato IProgress spero di aver fatto bene
Se vedete delle incongruenze per favore fatemi sapere dove sbaglio
grazie
Modificato da jjchuck il 22 settembre 2019 11:17 -

Torna al forum | Feed RSS

ASPItalia.com non è responsabile per il contenuto dei messaggi presenti su questo servizio, non avendo nessun controllo sui messaggi postati nei propri forum, che rappresentano l'espressione del pensiero degli autori.