using System;

using System.Threading.Tasks;

using LazyCache;

using LazyCache.Providers;

using Microsoft.Extensions.Caching.Memory;

using Microsoft.Extensions.Options;

​

// Barebones skeleton mimicking relevant logic in SecurityService

public class SecurityService

{

    private readonly IAppCache _cache;

    public bool ThrowException { get; set; } = true;

    public SecurityService()

    {

        ICacheProvider provider = new MemoryCacheProvider(new MemoryCache(new OptionsWrapper<MemoryCacheOptions>(new MemoryCacheOptions())));

        _cache = new CachingService(provider);

    }

    public async Task<string> GetTemporalLoginCertificateAsync()

    {

        string cert = await _cache.GetOrAddAsync(

            "ca",

            async () => await MethodThatCouldThrowAsync().ConfigureAwait(false),

            DateTimeOffset.MaxValue,

            ExpirationMode.LazyExpiration).ConfigureAwait(false);

        return cert;

    }

    public async Task<string> MethodThatCouldThrowAsync()

    {

        if (ThrowException)

        {

            throw new Exception("exception thrown");

        }

        await Task.Yield();

        return "here is the certificate!!";

    }

}

​

// Test client

public class Program

{

    public static void Main()

    {

        SecurityService service = new SecurityService();

        service.ThrowException = true;

        Console.WriteLine("throw exception: " + service.ThrowException);

        TryLogCertificate(service);

        service.ThrowException = false;

        Console.WriteLine("throw exception: " + service.ThrowException);

        TryLogCertificate(service);

    }

    public static void TryLogCertificate(SecurityService service)

    {

        try

        {

            string cert = service.GetTemporalLoginCertificateAsync().GetAwaiter().GetResult();

            Console.WriteLine(cert);

        }

        catch (Exception ex)

        {

            Console.WriteLine(ex.Message);

        }

    }

}