public async Task FireReminderAsync()

in src/Microsoft.ServiceFabric.Actors/Runtime/ActorManager.cs [397:473]
66 lines of code
9 McCabe index (conditional complexity)

        public async Task FireReminderAsync(ActorReminder reminder)
        {
            var rearmTimer = true;

            try
            {
                using (var actorScope = this.GetActor(reminder.OwnerActorId, true, false))
                {
                    var actorBase = actorScope.Actor;

                    // if Actor is deleted, reminder should not be fired or armed again.
                    // Its an optimization so that we don't fire the reminder if the actor
                    // is marked for deletion.
                    if (actorBase.MarkedForDeletion)
                    {
                        rearmTimer = false;
                        return;
                    }

                    if (this.actorService.ActorTypeInformation.IsRemindable)
                    {
                        var actor = (IRemindable)actorBase;

                        await this.DispatchToActorAsync<byte[]>(
                            reminder.OwnerActorId,
                            this.reminderMethodContext,
                            false,
                            async (
                                a,
                                cancellationTkn) =>
                            {
                                await
                                    actor.ReceiveReminderAsync(
                                        reminder.Name,
                                        reminder.State,
                                        reminder.DueTime,
                                        reminder.Period);

                                return null;
                            },
                            Guid.NewGuid().ToString(),
                            false,
                            CancellationToken.None);
                    }
                }
            }
            catch (ActorDeletedException)
            {
                rearmTimer = false;
            }
            catch (Exception e)
            {
                ActorTrace.Source.WriteWarningWithId(
                    TraceType,
                    this.traceId,
                    "Firing reminder {0} for actor {1} caused exception: {2}",
                    reminder.Name,
                    reminder.OwnerActorId,
                    e.ToString());
            }

            // User may delete or update reminder during ReceiveReminderAsync() call.
            // Rearm only if it is still valid.
            if (reminder.IsValid() && rearmTimer)
            {
                if (this.ActorService.Settings.ReminderSettings.AutoDeleteOneTimeReminders &&
                    this.IsOneTimeReminder(reminder))
                {
                    await this.UnregisterOneTimeReminderAsync(reminder);
                }
                else
                {
                    await this.UpdateReminderLastCompletedTimeAsync(reminder);
                    reminder.ArmTimer(reminder.Period);
                }
            }
        }