async Task <List <AuditLog> > LoadAuditInfo()
        {
            // chargement asynchrone des traces d'audit des sociétés
            if (_companyIds.Length == 0)
            {
                return(new List <AuditLog>());
            }

            _logger.Log($"Fetching {_companyIds.Length} audit info from {_client.BaseUrl}");
            var webTaskMonitor = WebTaskMonitorFactory.Build <AuditLog>(_logger);

            for (var i = 0; i < _companyIds.Length; i++)
            {
                var companyId = _companyIds[i];
                // appel asynchrone des API Highlight
                var task = new HighlightAuditTask(companyId, () => _client.GetAuditForCompany(companyId));
                _logger.Log($"   Starting task #{task.Id} for audit info for company {companyId}...");
                webTaskMonitor.Add(task);
            }

            // récupération des résultats
            var results = await webTaskMonitor.GetResults();

            return(results.ToList());
        }
        // chargement des résultats d'applications
        async Task <List <AppInfo> > LoadAppInfo()
        {
            if (_domainIds.Length == 0 && _appIds.Count == 0)
            {
                return(new List <AppInfo>());
            }

            // identification des applis portées par les domaines spécifiés
            var allAppIds = new Dictionary <string, AppId>();

            if (_domainIds.Length > 0)
            {
                _logger.Log($"Fetching {_domainIds.Length} domain(s) from {_client.BaseUrl}");
                for (var i = 0; i < _domainIds.Length; i++)
                {
                    var domainId = _domainIds[i];
                    _logger.Log($"   Fetching domain {domainId}...");
                    var domainAppIds = await _client.GetAppIdsForDomain(domainId);

                    for (var j = 0; j < domainAppIds.Count; j++)
                    {
                        var app = domainAppIds[j];
                        if (!allAppIds.ContainsKey(app.Id))
                        {
                            app.DomainId = domainId;
                            allAppIds.Add(app.Id, app);
                        }
                    }
                }
            }

            // chargement asynchrone des résultats d'analyse des applications
            // si aucun ID d'application n'a été spécifié, toutes les applis des domaines spécifiés seront chargées
            // sinon, uniquement les applications spécifiées seront chargées si elles appartiennent bien aux domaines spécifiés
            if (_appIds.Count == 0)
            {
                _appIds.UnionWith(allAppIds.Keys);
            }

            _logger.Log($"Fetching {_appIds.Count} applications from {_client.BaseUrl}");
            var webTaskMonitor = WebTaskMonitorFactory.Build <AppInfo>(_logger);

            foreach (var app in allAppIds.Values.Where(_ => _appIds.Contains(_.Id)))
            {
                // appel asynchrone des API Highlight
                var task = new HighlightAppInfoTask(_client.BaseUrl, app, () => _client.GetAppInfoForApp(app.DomainId, app.Id));
                _logger.Log($"   Starting task #{task.Id} for application {app.Id} / {app.Name}...");
                webTaskMonitor.Add(task);
            }

            // récupération des résultats
            var results = await webTaskMonitor.GetResults();

            return(results.OrderByDescending(app => app.CurrentMetrics?.BusinessImpact ?? 0).ToList());
        }