コード例 #1
0
        public async Task ProcessQueueMessageAsync(string message, CancellationToken cancellationToken)
        {
            if (_eventWriteService == null || message == null || message.Length == 0)
            {
                return;
            }

            try
            {
                _logger.LogInformation("Processing message.");
                var events = new List <IEvent>();

                using var jsonDocument = JsonDocument.Parse(message);
                var root = jsonDocument.RootElement;
                if (root.ValueKind == JsonValueKind.Array)
                {
                    var indexedEntities = root.ToObject <List <EventMessage> >()
                                          .SelectMany(e => EventTableEntity.IndexEvent(e));
                    events.AddRange(indexedEntities);
                }
                else if (root.ValueKind == JsonValueKind.Object)
                {
                    var eventMessage = root.ToObject <EventMessage>();
                    events.AddRange(EventTableEntity.IndexEvent(eventMessage));
                }

                await _eventWriteService.CreateManyAsync(events);

                _logger.LogInformation("Processed message.");
            }
            catch (JsonException)
            {
                _logger.LogError("JsonReaderException: Unable to parse message.");
            }
        }
コード例 #2
0
        public async Task ProcessQueueMessageAsync([QueueTrigger("event")] string message,
                                                   CancellationToken cancellationToken, ILogger logger)
        {
            if (_eventWriteService == null || message == null || message.Length == 0)
            {
                return;
            }

            try
            {
                logger.LogInformation("Processing message.");
                var events = new List <IEvent>();

                var token = JToken.Parse(message);
                if (token is JArray)
                {
                    var indexedEntities = token.ToObject <List <EventMessage> >()
                                          .SelectMany(e => EventTableEntity.IndexEvent(e));
                    events.AddRange(indexedEntities);
                }
                else if (token is JObject)
                {
                    var eventMessage = token.ToObject <EventMessage>();
                    events.AddRange(EventTableEntity.IndexEvent(eventMessage));
                }

                await _eventWriteService.CreateManyAsync(events);

                logger.LogInformation("Processed message.");
            }
            catch (JsonReaderException)
            {
                logger.LogError("JsonReaderException: Unable to parse message.");
            }
            catch (JsonSerializationException)
            {
                logger.LogError("JsonSerializationException: Unable to serialize token.");
            }
            catch (Exception e)
            {
                logger.LogError(e, "Exception occurred. " + e.Message);
                throw e;
            }
        }
コード例 #3
0
        public async static Task ProcessQueueMessageAsync([QueueTrigger("event")] string message,
                                                          TextWriter logger, CancellationToken cancellationToken)
        {
            if (_eventWriteService == null || message == null || message.Length == 0)
            {
                return;
            }

            try
            {
                var events = new List <IEvent>();

                var token = JToken.Parse(message);
                if (token is JArray)
                {
                    var indexedEntities = token.ToObject <List <EventMessage> >()
                                          .SelectMany(e => EventTableEntity.IndexEvent(e));
                    events.AddRange(indexedEntities);
                }
                else if (token is JObject)
                {
                    var eventMessage = token.ToObject <EventMessage>();
                    events.AddRange(EventTableEntity.IndexEvent(eventMessage));
                }

                await _eventWriteService.CreateManyAsync(events);
            }
            catch (JsonReaderException)
            {
                await logger.WriteLineAsync("JsonReaderException: Unable to parse message.");
            }
            catch (JsonSerializationException)
            {
                await logger.WriteLineAsync("JsonSerializationException: Unable to serialize token.");
            }
        }