Outlook Addin - Runtime Exceptions

Exception thrown: 'System.Runtime.InteropServices.COMException' in OutlookMacrosV2.dll
Exception thrown: 'System.ArgumentException' in OutlookMacrosV2.dll
Exception thrown: 'System.ArgumentException' in OutlookMacrosV2.dll
Exception thrown: 'System.ArgumentException' in OutlookMacrosV2.dll
Exception thrown: 'System.ArgumentException' in OutlookMacrosV2.dll
Exception thrown: 'System.ArgumentException' in OutlookMacrosV2.dll
Exception thrown: 'System.ArgumentException' in OutlookMacrosV2.dll
Exception thrown: 'System.ArgumentException' in OutlookMacrosV2.dll

public class GarbageCollectorDaemon
{
    private static readonly SemaphoreSlim CollectionSemaphore = new SemaphoreSlim(1, 1);
    private static readonly Lazy<Timer> LazyTimer = new Lazy<Timer>(CreateTimer, LazyThreadSafetyMode.ExecutionAndPublication);

    // The interval to force garbage collection.
    private static readonly TimeSpan Interval = TimeSpan.FromMinutes(45);

    // How long to wait before seeing if the garbage collection thread is finished.
    private static readonly TimeSpan DelayInterval = TimeSpan.FromMilliseconds(100);

    // The maximum amount of time to wait for the garbage collection thread to finish.
    private static readonly TimeSpan MaxWaitTime = TimeSpan.FromSeconds(3);

    public static Timer Timer => LazyTimer.Value;

    public static Timer Initialize()
    {
        return LazyTimer.Value;
    }

    /// <summary>
    /// Safely calls Garbage collection by putting it on a separate thread and aborting that thread if it runs for too long.
    /// </summary>
    /// <returns>A boolean indicating if GC.Collect() was called.</returns>
    public static async Task<bool> SafelyCollectAsync()
    {
        var collectionPerformed = false;

        // Don't queue up requests, just enter if it's not being executed; otherwise skip.
        if (await CollectionSemaphore.WaitAsync(0))
        {
            try
            {
                var threadTimer = new Stopwatch();
                var gcThread = new Thread(UnsafeRelease);

                try
                {
                    gcThread.Start();
                    threadTimer.Start();

                    // GC.Collect() was called, so return true.
                    collectionPerformed = true;

                    while (gcThread.IsAlive && threadTimer.Elapsed < MaxWaitTime)
                    {
                        await Task.Delay(DelayInterval);
                    }
                }
                finally
                {
                    threadTimer.Stop();

                    // If we're still alive when we get here, kill the thread.
                    if (gcThread.IsAlive)
                    {
                        gcThread.Abort();
                    }
                }
            }
            finally
            {
                CollectionSemaphore.Release();
            }
        }
        else
        {
            // Logger.Warn("Did not initialize garbage collection as it was already executing.");
        }

        return collectionPerformed;
    }

    private static Timer CreateTimer()
    {
        var timer = new Timer
        {
            Interval = Interval.TotalMilliseconds,
            AutoReset = true,
            Enabled = true
        };
        timer.Elapsed += OnTimedEventAsync;

        return timer;
    }

    private static async void OnTimedEventAsync(object source, ElapsedEventArgs e)
    {
        await SafelyCollectAsync();
    }

    /// <summary>
    /// The below code is not guaranteed to return and may block indefinitely.  Ensure you call from a thread you can abort.
    /// </summary>
    private static void UnsafeRelease()
    {
        try
        {
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
            GC.WaitForPendingFinalizers();
        }
        catch (ThreadAbortException exception)
        {
            // Logger.Error(exception, "Garbage collection was aborted by the controlling thread.");
        }
        catch(Exception exception)
        {
            // Logger.Error(exception, "There was an exception thrown during garbage collection.");
        }
    }
}