コード例 #1
0
        private async Task VisitPayloadsAsync(MiniParseResult miniParseResult)
        {
            var payloads = miniParseResult.Model.Payloads;

            // Loop all payloads except CounterPayload and visit
            var exceptionInformation = new ConcurrentQueue <(string details, Exception exception)>();

            foreach (var payload in payloads.Where(p => !(p is CounterPayload)))
            {
                try
                {
                    payload.Visit(this);
                }
                catch (Exception ex)
                {
                    exceptionInformation.Enqueue((payload.GetType().Name, ex));
                }
            }

            var counterDataList = new List <CounterData>();

            foreach (var counterPayload in payloads.OfType <CounterPayload>())
            {
                if (TryMapCounterPayload(miniParseResult, counterPayload, out CounterData counterData))
                {
                    counterDataList.Add(counterData);
                }
            }

            try
            {
                await _counterService.StoreAsync(_correlationId, counterDataList);
            }
            catch (Exception ex)
            {
                exceptionInformation.Enqueue((nameof(CounterPayload), ex));
            }

            // Only throw exception when all counters fail
            if (payloads.Count > 0 && exceptionInformation.Count == payloads.Count)
            {
                throw new AggregateException(exceptionInformation.Select(x => x.exception));
            }

            // Else just log as error
            foreach (var info in exceptionInformation)
            {
                _logger.LogError(info.exception, $"Error storing Payload '{info.details}'");
            }
        }
コード例 #2
0
        private static async Task RunAsync(ILogger logger, ICounterStoreService service, string path)
        {
            int    roundAtMinutes = 5;
            string sn             = Path.GetFileNameWithoutExtension(path).Substring(0, 13);

            string[] counterIds = { "0181", "0182", "0281", "0282", "2421" };

            var list = new Dictionary <string, IList <CounterData> >();

            foreach (var counterId in counterIds)
            {
                var result = ReadFile(logger, path + counterId + ".qbx", sn, int.Parse(counterId));

                list.Add(counterId, result);
            }

            int batchValue = 12345;
            var values     = list.Values.SelectMany(v => v).ToList();
            var f          = values.First();
            var l          = values.Last();

            logger.LogInformation($"First: {f} and Last = {l}");

            var grouped = from v in values
                          group v by new
            {
                v.SerialNumber,
                v.CounterId,
                MeasureTimeRounded = v.MeasureTime.Truncate(TimeSpan.FromMinutes(roundAtMinutes))
            }
            into g
                select new CounterData
            {
                SerialNumber = g.Key.SerialNumber,
                CounterId    = g.Key.CounterId,
                MeasureTime  = g.Key.MeasureTimeRounded,
                PulseValue   = g.Max(s => s.PulseValue)
            };

            var sorted           = grouped.OrderBy(k => k.MeasureTime).ToList();
            var sortedAndGrouped = sorted.GroupBy(s => s.MeasureTime).ToList();

            Console.WriteLine($"values           Count = {values.Count}");
            Console.WriteLine($"sorted           Count = {sorted.Count}");
            Console.WriteLine($"sortedAndGrouped Count = {sortedAndGrouped.Count}");

            int i     = 1;
            var batch = new List <CounterData>();

            foreach (var grp in sortedAndGrouped)
            {
                string guid = Guid.NewGuid().ToString();
                foreach (var x in grp)
                {
                    if (batch.Count < batchValue)
                    {
                        batch.Add(x);
                    }
                    else
                    {
                        Console.WriteLine($"{(100.0 * i) / sortedAndGrouped.Count:F}%");

                        await service.StoreAsync(guid, batch);

                        batch.Clear();
                    }
                }

                i = i + 1;
            }
        }