NServiceBus.DateTimeExtensions.ToUtcDateTime C# (CSharp) Method

        public static DateTime ToUtcDateTime(string wireFormattedString)
        {
            Guard.AgainstNullAndEmpty(nameof(wireFormattedString), wireFormattedString);

            if (wireFormattedString.Length != format.Length)
            {
                throw new FormatException(errorMessage);
            }

            var year = 0;
            var month = 0;
            var day = 0;
            var hour = 0;
            var minute = 0;
            var second = 0;
            var microSecond = 0;

            for (var i = 0; i < format.Length; i++)
            {
                var digit = wireFormattedString[i];

                switch (format[i])
                {
                    case 'y':
                        if (digit < '0' || digit > '9') throw new FormatException(errorMessage);
                        year = year * 10 + (digit - '0');
                        break;

                    case 'M':
                        if (digit < '0' || digit > '9') throw new FormatException(errorMessage);
                        month = month * 10 + (digit - '0');
                        break;

                    case 'd':
                        if (digit < '0' || digit > '9') throw new FormatException(errorMessage);
                        day = day * 10 + (digit - '0');
                        break;

                    case 'H':
                        if (digit < '0' || digit > '9') throw new FormatException(errorMessage);
                        hour = hour * 10 + (digit - '0');
                        break;

                    case 'm':
                        if (digit < '0' || digit > '9') throw new FormatException(errorMessage);
                        minute = minute * 10 + (digit - '0');
                        break;

                    case 's':
                        if (digit < '0' || digit > '9') throw new FormatException(errorMessage);
                        second = second * 10 + (digit - '0');
                        break;

                    case 'f':
                        if (digit < '0' || digit > '9') throw new FormatException(errorMessage);
                        microSecond = microSecond * 10 + (digit - '0');
                        break;
                }
            }

            return new DateTime(year, month, day, hour, minute, second, DateTimeKind.Utc).AddMicroseconds(microSecond);
        }

        public async Task Invoke(MessageContext context)
        {
            var sagaId = Guid.Empty;

            string sagaIdString;

            if (context.Headers.TryGetValue(Headers.SagaId, out sagaIdString))
            {
                sagaId = Guid.Parse(sagaIdString);
            }

            if (context.Headers.ContainsKey(TimeoutManagerHeaders.ClearTimeouts))
            {
                if (sagaId == Guid.Empty)
                {
                    throw new InvalidOperationException("Invalid saga id specified, clear timeouts is only supported for saga instances");
                }

                await persister.RemoveTimeoutBy(sagaId, context.Context).ConfigureAwait(false);
            }
            else
            {
                string expire;
                if (!context.Headers.TryGetValue(TimeoutManagerHeaders.Expire, out expire))
                {
                    throw new InvalidOperationException("Non timeout message arrived at the timeout manager, id:" + context.MessageId);
                }

                var destination = GetReplyToAddress(context);

                string routeExpiredTimeoutTo;
                if (context.Headers.TryGetValue(TimeoutManagerHeaders.RouteExpiredTimeoutTo, out routeExpiredTimeoutTo))
                {
                    destination = routeExpiredTimeoutTo;
                }

                var data = new TimeoutData
                {
                    Destination          = destination,
                    SagaId               = sagaId,
                    State                = context.Body,
                    Time                 = DateTimeExtensions.ToUtcDateTime(expire),
                    Headers              = context.Headers,
                    OwningTimeoutManager = owningTimeoutManager
                };

                if (data.Time.AddSeconds(-1) <= DateTime.UtcNow)
                {
                    var outgoingMessage    = new OutgoingMessage(context.MessageId, data.Headers, data.State);
                    var transportOperation = new TransportOperation(outgoingMessage, new UnicastAddressTag(data.Destination));
                    await dispatcher.Dispatch(new TransportOperations(transportOperation), context.TransportTransaction, context.Context).ConfigureAwait(false);

                    return;
                }

                await persister.Add(data, context.Context).ConfigureAwait(false);

                poller.NewTimeoutRegistered(data.Time);
            }
        }