I know this is almost a year old however, you can use a CacheHelper class like you would for module data:

using DotNetNuke.Common.Utilities;
...

public class CacheHelper
{
    public static bool CacheExists(string key)
    {
        return DataCache.GetCache(key) != null;
    }

    public static void SetCache<T>(T toSet, string key)
    {
        DataCache.SetCache(key, toSet);
    }

    public static T GetItemFromCache<T>(string key)
    {
        return (T)DataCache.GetCache(key);
    }
}

Then in the API, you would call the static functions to check if there is cache, or if you need to collect the data from the source. You'll need to supply some sort of key. Here is an example for collecting Events from calendars in Office 365

[AllowAnonymous]
[HttpGet]
public async Task<HttpResponseMessage> GetCalendarViews(string UserPrimaries, string start, string end)
{
    var Events = new List<GraphEvent>();
    if (CacheHelper.CacheExists(UserPrimaries))
    {
        Events.AddRange(CacheHelper.GetItemFromCache< List<GraphEvent>>(UserPrimaries));
    }
    else
    {
        // make data calls and get Graph Events
        ...
        CacheHelper.SetCache(Events, UserPrimaries);
    }

    return new HttpResponseMessage()
    {
        StatusCode = HttpStatusCode.OK,
        Content = new StringContent(Events.ToJson(), System.Text.Encoding.UTF8, "application/json")
    };
}

Happy DNNing

Posted By Ryan Jagdfeld on 9/6/2023 5:51 AM

I know this is almost a year old however, you can use a CacheHelper class like you would for module data:

using DotNetNuke.Common.Utilities;
...

public class CacheHelper
{
    public static bool CacheExists(string key)
    {
        return DataCache.GetCache(key) != null;
    }

    public static void SetCache(T toSet, string key)
    {
        DataCache.SetCache(key, toSet);
    }

    public static T GetItemFromCache(string key)
    {
        return (T)DataCache.GetCache(key);
    }
}

Then in the API, you would call the static functions to check if there is cache, or if you need to collect the data from the source. You'll need to supply some sort of key. Here is an example for collecting Events from calendars in Office 365

[AllowAnonymous]
[HttpGet]
public async Task GetCalendarViews(string UserPrimaries, string start, string end)
{
    var Events = new List();
    if (CacheHelper.CacheExists(UserPrimaries))
    {
        Events.AddRange(CacheHelper.GetItemFromCache< List>(UserPrimaries));
    }
    else
    {
        // make data calls and get Graph Events
        ...
        CacheHelper.SetCache(Events, UserPrimaries);
    }

    return new HttpResponseMessage()
    {
        StatusCode = HttpStatusCode.OK,
        Content = new StringContent(Events.ToJson(), System.Text.Encoding.UTF8, "application/json")
    };
}

Happy DNNing

Nice catch on finding and responding to this old question... This is always helpful to our community.  Thank you!  💪🏽 

 

Ryan's solution works well but does not protect against a scenario where DNN's cache is cleared and the API endpoint is down. Clearing the cached API data in this scenario would break the application. Is there a way to call the API endpoint before clearing the cached API data and only proceed with clearing that cache if the API call was successful and can be immediately re-cached? I looked into the DNNCacheDependency parameter for the SetCache method, but I'm not sure it accomodates this scenario.

I have done something similar in the past. It is a pattern that goes by multiple names "cache stack" or "cache castle" or "Tiered Caching", "Multi-level caching". I remember building this all by hand and then finding a Nuget package that did just that (can't remember the name now)...

Basically, you have multiple caches.
Cache A Is fast, in-memory and is guaranteed to expire in say 20 minutes or whatever you consider is fresh enough.
Cache B could be in memory, disc, or database and is refreshed periodically but does not auto-expire, a scheduled task will refresh it every10 minutes let's say. If that API call fails, it stays as is.
Finaly Cache A feeds of off cache B instead of the actual source that could be down or brittle.

That way in most scenarios you get proper cache and source, but if the source of truth goes down, you get the last info obtained.