DSharpPlus · Plerx2493 · Oct 9, 2023 · Oct 9, 2023 · Oct 9, 2023 · Oct 10, 2023
diff --git a/DSharpPlus.CommandsNext/Attributes/RequireBotPermissionsAttribute.cs b/DSharpPlus.CommandsNext/Attributes/RequireBotPermissionsAttribute.cs
@@ -48,7 +48,7 @@ public override async Task<bool> ExecuteCheckAsync(CommandContext ctx, bool help
             return true;
         }
 
-        Permissions pbot = ctx.Channel.PermissionsFor(bot);
+        Permissions pbot = await ctx.Channel.PermissionsForMemberAsync(bot);
 
         return (pbot & Permissions.Administrator) != 0 ? true : (pbot & this.Permissions) == this.Permissions;
     }

diff --git a/DSharpPlus.CommandsNext/Attributes/RequirePermissionsAttribute.cs b/DSharpPlus.CommandsNext/Attributes/RequirePermissionsAttribute.cs
@@ -43,15 +43,15 @@ public override async Task<bool> ExecuteCheckAsync(CommandContext ctx, bool help
             return false;
         }
 
-        Permissions pusr = ctx.Channel.PermissionsFor(usr);
+        Permissions pusr = await ctx.Channel.PermissionsForMemberAsync(usr);
 
         DSharpPlus.Entities.DiscordMember bot = await ctx.Guild.GetMemberAsync(ctx.Client.CurrentUser.Id);
         if (bot == null)
         {
             return false;
         }
 
-        Permissions pbot = ctx.Channel.PermissionsFor(bot);
+        Permissions pbot = await ctx.Channel.PermissionsForMemberAsync(bot);
 
         bool usrok = ctx.Guild.OwnerId == usr.Id;
         bool botok = ctx.Guild.OwnerId == bot.Id;

diff --git a/DSharpPlus.CommandsNext/Attributes/RequireUserPermissionsAttribute.cs b/DSharpPlus.CommandsNext/Attributes/RequireUserPermissionsAttribute.cs
@@ -30,28 +30,26 @@ public RequireUserPermissionsAttribute(Permissions permissions, bool ignoreDms =
         this.IgnoreDms = ignoreDms;
     }
 
-    public override Task<bool> ExecuteCheckAsync(CommandContext ctx, bool help)
+    public async override Task<bool> ExecuteCheckAsync(CommandContext ctx, bool help)
     {
         if (ctx.Guild == null)
         {
-            return Task.FromResult(this.IgnoreDms);
+            return this.IgnoreDms;
         }
 
         DSharpPlus.Entities.DiscordMember? usr = ctx.Member;
         if (usr == null)
         {
-            return Task.FromResult(false);
+            return false;
         }
 
         if (usr.Id == ctx.Guild.OwnerId)
         {
-            return Task.FromResult(true);
+            return true;
         }
 
-        Permissions pusr = ctx.Channel.PermissionsFor(usr);
+        Permissions pusr = await ctx.Channel.PermissionsForMemberAsync(usr);
 
-        return (pusr & Permissions.Administrator) != 0
-            ? Task.FromResult(true)
-            : (pusr & this.Permissions) == this.Permissions ? Task.FromResult(true) : Task.FromResult(false);
+        return (pusr & Permissions.Administrator) != 0 || (pusr & this.Permissions) == this.Permissions;
     }
 }
diff --git a/DSharpPlus.CommandsNext/CommandsNextExtension.cs b/DSharpPlus.CommandsNext/CommandsNextExtension.cs
@@ -131,7 +131,7 @@ internal CommandsNextExtension(CommandsNextConfiguration cfg)
 
         Type t = typeof(CommandsNextExtension);
         IEnumerable<MethodInfo> ms = t.GetTypeInfo().DeclaredMethods;
-        MethodInfo? m = ms.FirstOrDefault(xm => xm.Name == nameof(ConvertArgument) && xm.ContainsGenericParameters && !xm.IsStatic && xm.IsPublic);
+        MethodInfo? m = ms.FirstOrDefault(xm => xm.Name == nameof(ConvertArgumentAsync) && xm.ContainsGenericParameters && !xm.IsStatic && xm.IsPublic);
         this.ConvertGeneric = m;
     }
 
@@ -949,7 +949,7 @@ public async Task DefaultHelpAsync(CommandContext ctx, [Description("Command to
     /// <param name="cmd">Command to execute.</param>
     /// <param name="rawArguments">Raw arguments to pass to command.</param>
     /// <returns>Created fake context.</returns>
-    public CommandContext CreateFakeContext(DiscordUser actor, DiscordChannel channel, string messageContents, string prefix, Command cmd, string? rawArguments = null)
+    public async Task<CommandContext> CreateFakeContextAsync(DiscordUser actor, DiscordChannel channel, string messageContents, string prefix, Command cmd, string? rawArguments = null)
     {
         DateTimeOffset epoch = new DateTimeOffset(2015, 1, 1, 0, 0, 0, TimeSpan.Zero);
         DateTimeOffset now = DateTimeOffset.UtcNow;
@@ -987,7 +987,14 @@ public CommandContext CreateFakeContext(DiscordUser actor, DiscordChannel channe
             }
             else
             {
-                mentionedUsers = Utilities.GetUserMentions(msg).Select(this.Client.GetCachedOrEmptyUserInternal).ToList();
+                foreach (ulong mentionedUserId in Utilities.GetUserMentions(msg))
+                {
+                    DiscordUser? User = await this.Client.TryGetCachedUserInternalAsync(mentionedUserId);
+                    if (User is not null)
+                    {
+                        mentionedUsers.Add(User);
+                    }
+                }
             }
         }
 
@@ -1026,7 +1033,7 @@ public CommandContext CreateFakeContext(DiscordUser actor, DiscordChannel channe
     /// <param name="value">Value to convert.</param>
     /// <param name="ctx">Context in which to convert to.</param>
     /// <returns>Converted object.</returns>
-    public async Task<object> ConvertArgument<T>(string value, CommandContext ctx)
+    public async Task<object> ConvertArgumentAsync<T>(string value, CommandContext ctx)
     {
         Type t = typeof(T);
         if (!this.ArgumentConverters.ContainsKey(t))
@@ -1050,7 +1057,7 @@ public async Task<object> ConvertArgument<T>(string value, CommandContext ctx)
     /// <param name="ctx">Context in which to convert to.</param>
     /// <param name="type">Type to convert to.</param>
     /// <returns>Converted object.</returns>
-    public async Task<object> ConvertArgument(string? value, CommandContext ctx, Type type)
+    public async Task<object> ConvertArgumentAsync(string? value, CommandContext ctx, Type type)
     {
         MethodInfo m = this.ConvertGeneric.MakeGenericMethod(type);
         try

diff --git a/DSharpPlus.CommandsNext/CommandsNextUtilities.cs b/DSharpPlus.CommandsNext/CommandsNextUtilities.cs
@@ -269,7 +269,7 @@ internal static async Task<ArgumentBindingResult> BindArgumentsAsync(CommandCont
                 {
                     try
                     {
-                        array.SetValue(await ctx.CommandsNext.ConvertArgument(rawArgumentList[i], ctx, arg.Type), i - start);
+                        array.SetValue(await ctx.CommandsNext.ConvertArgumentAsync(rawArgumentList[i], ctx, arg.Type), i - start);
                     }
                     catch (Exception ex)
                     {
@@ -285,7 +285,7 @@ internal static async Task<ArgumentBindingResult> BindArgumentsAsync(CommandCont
             {
                 try
                 {
-                    args[i + 2] = rawArgumentList[i] != null ? await ctx.CommandsNext.ConvertArgument(rawArgumentList[i], ctx, arg.Type) : arg.DefaultValue;
+                    args[i + 2] = rawArgumentList[i] != null ? await ctx.CommandsNext.ConvertArgumentAsync(rawArgumentList[i], ctx, arg.Type) : arg.DefaultValue;
                 }
                 catch (Exception ex)
                 {

diff --git a/DSharpPlus.CommandsNext/Converters/EntityConverters.cs b/DSharpPlus.CommandsNext/Converters/EntityConverters.cs
@@ -36,7 +36,7 @@ async Task<Optional<DiscordUser>> IArgumentConverter<DiscordUser>.ConvertAsync(s
         string un = di != -1 ? value.Substring(0, di) : value;
         string? dv = di != -1 ? value.Substring(di + 1) : null;
 
-        System.Collections.Generic.IEnumerable<DiscordMember> us = ctx.Client.Guilds.Values
+        System.Collections.Generic.IEnumerable<DiscordMember> us = ctx.Client._guildIds.Values
             .SelectMany(xkvp => xkvp.Members.Values).Where(xm =>
                 xm.Username.Equals(un, cs ? StringComparison.InvariantCulture : StringComparison.InvariantCultureIgnoreCase) &&
                 ((dv != null && xm.Discriminator == dv) || dv == null));
@@ -137,14 +137,14 @@ Task<Optional<DiscordThreadChannel>> IArgumentConverter<DiscordThreadChannel>.Co
     {
         if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out ulong threadId))
         {
-            DiscordThreadChannel result = ctx.Client.InternalGetCachedThread(threadId);
+            DiscordThreadChannel result = ctx.Client.InternalGetCachedThreadAsync(threadId);
             return Task.FromResult(result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordThreadChannel>());
         }
 
         Match m = ThreadRegex.Match(value);
         if (m.Success && ulong.TryParse(m.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out threadId))
         {
-            DiscordThreadChannel result = ctx.Client.InternalGetCachedThread(threadId);
+            DiscordThreadChannel result = ctx.Client.InternalGetCachedThreadAsync(threadId);
             return Task.FromResult(result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordThreadChannel>());
         }
 
@@ -199,14 +199,14 @@ Task<Optional<DiscordGuild>> IArgumentConverter<DiscordGuild>.ConvertAsync(strin
     {
         if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out ulong gid))
         {
-            return ctx.Client.Guilds.TryGetValue(gid, out DiscordGuild? result)
+            return ctx.Client._guildIds.TryGetValue(gid, out DiscordGuild? result)
                 ? Task.FromResult(Optional.FromValue(result))
                 : Task.FromResult(Optional.FromNoValue<DiscordGuild>());
         }
 
         bool cs = ctx.Config.CaseSensitive;
 
-        DiscordGuild? gld = ctx.Client.Guilds.Values.FirstOrDefault(xg =>
+        DiscordGuild? gld = ctx.Client._guildIds.Values.FirstOrDefault(xg =>
             xg.Name.Equals(value, cs ? StringComparison.InvariantCulture : StringComparison.InvariantCultureIgnoreCase));
         return Task.FromResult(gld != null ? Optional.FromValue(gld) : Optional.FromNoValue<DiscordGuild>());
     }
@@ -286,7 +286,7 @@ Task<Optional<DiscordEmoji>> IArgumentConverter<DiscordEmoji>.ConvertAsync(strin
 
             return !ulong.TryParse(sid, NumberStyles.Integer, CultureInfo.InvariantCulture, out ulong id)
                 ? Task.FromResult(Optional.FromNoValue<DiscordEmoji>())
-                : DiscordEmoji.TryFromGuildEmote(ctx.Client, id, out emoji)
+                : DiscordEmoji.TryFromGuildEmoteAsync(ctx.Client, id, out emoji)
                 ? Task.FromResult(Optional.FromValue(emoji))
                 : Task.FromResult(Optional.FromValue(new DiscordEmoji
                 {

diff --git a/DSharpPlus.Rest/DiscordRestClient.cs b/DSharpPlus.Rest/DiscordRestClient.cs
@@ -11,17 +11,10 @@
 
 namespace DSharpPlus;
 
+using Caching;
+
 public class DiscordRestClient : BaseDiscordClient
 {
-    /// <summary>
-    /// Gets the dictionary of guilds cached by this client.
-    /// </summary>
-    public override IReadOnlyDictionary<ulong, DiscordGuild> Guilds
-        => this._guilds_lazy.Value;
-
-    internal Dictionary<ulong, DiscordGuild> _guilds = new();
-    private Lazy<IReadOnlyDictionary<ulong, DiscordGuild>> _guilds_lazy;
-
     public DiscordRestClient(DiscordConfiguration config) : base(config) => this._disposed = false;
 
     /// <summary>
@@ -31,11 +24,11 @@ public override IReadOnlyDictionary<ulong, DiscordGuild> Guilds
     public async Task InitializeCacheAsync()
     {
         await base.InitializeAsync();
-        this._guilds_lazy = new Lazy<IReadOnlyDictionary<ulong, DiscordGuild>>(() => new ReadOnlyDictionary<ulong, DiscordGuild>(this._guilds));
         IReadOnlyList<DiscordGuild> gs = await this.ApiClient.GetCurrentUserGuildsAsync(100, null, null);
-        foreach (DiscordGuild g in gs)
+        foreach (DiscordGuild guild in gs)
         {
-            this._guilds[g.Id] = g;
+            this._guildIds.Add(guild.Id);
+            await this.Cache.AddGuildAsync(guild);
         }
     }
 
@@ -412,7 +405,7 @@ public async Task<IReadOnlyList<DiscordMember>> ListGuildMembersAsync(ulong guil
                     Discord = this
                 };
 
-                this.UpdateUserCache(usr);
+                await this.Cache.AddUserAsync(usr);
             }
 
             recmbr.AddRange(tms.Select(xtm => new DiscordMember(xtm) { Discord = this, _guild_id = guild_id }));
@@ -2312,7 +2305,6 @@ public override void Dispose()
         }
 
         this._disposed = true;
-        this._guilds = null;
         this.ApiClient?._rest?.Dispose();
     }
 }
diff --git a/DSharpPlus.VoiceNext/VoiceNextConnection.cs b/DSharpPlus.VoiceNext/VoiceNextConnection.cs
@@ -960,7 +960,7 @@ private async Task HandleDispatch(JObject jo)
                 // No longer spam, Discord supposedly doesn't send many of these
                 this.Discord.Logger.LogTrace(VoiceNextEvents.VoiceDispatch, "Received SPEAKING (OP5)");
                 VoiceSpeakingPayload spd = opp.ToDiscordObject<VoiceSpeakingPayload>();
-                bool foundUserInCache = this.Discord.TryGetCachedUserInternal(spd.UserId.Value, out DiscordUser? resolvedUser);
+                bool foundUserInCache = this.Discord.TryGetCachedUserInternalAsync(spd.UserId.Value, out DiscordUser? resolvedUser);
                 UserSpeakingEventArgs spk = new UserSpeakingEventArgs
                 {
                     Speaking = spd.Speaking,

diff --git a/DSharpPlus/Caching/CacheConfiguration.cs b/DSharpPlus/Caching/CacheConfiguration.cs
@@ -0,0 +1,22 @@
+namespace DSharpPlus.Caching;
+
+using System;
+using System.Collections.Generic;
+using DSharpPlus.Entities;
+
+/// <summary>
+/// Configuration for the cache how long to keep items in the cache. This configuration is only used by <see cref="DiscordMemoryCache"/> and is ignored if you provide your own implementation of <see cref="IDiscordCache"/>.
+/// </summary>
+/// <remarks>The default implementation of <see cref="IDiscordCache"/> only supports timebased expiration </remarks>
+public record CacheConfiguration
+{
+    public Dictionary<Type, CacheEntryOptions> MemoryCacheEntryOptions { get; set; } = new()
+    {
+        {typeof(DiscordGuild), new CacheEntryOptions(){SlidingExpiration = TimeSpan.FromMinutes(60)}},
+        {typeof(DiscordChannel), new CacheEntryOptions(){SlidingExpiration = TimeSpan.FromMinutes(60)}},
+        {typeof(DiscordMessage), new CacheEntryOptions(){SlidingExpiration = TimeSpan.FromMinutes(60)}},
+        {typeof(DiscordMember), new CacheEntryOptions(){SlidingExpiration = TimeSpan.FromMinutes(60)}},
+        {typeof(DiscordUser), new CacheEntryOptions(){SlidingExpiration = TimeSpan.FromMinutes(60)}},
+        {typeof(DiscordPresence), new CacheEntryOptions(){SlidingExpiration = TimeSpan.FromMinutes(60)}}
+    };
+}
diff --git a/DSharpPlus/Caching/CacheEntryOptions.cs b/DSharpPlus/Caching/CacheEntryOptions.cs
@@ -0,0 +1,54 @@
+namespace DSharpPlus.Caching;
+
+using System;
+using Microsoft.Extensions.Caching.Memory;
+
+public class CacheEntryOptions
+{
+    /// <summary>
+    /// Sliding expiration for the cache entry
+    /// </summary>
+    /// <exception cref="ArgumentOutOfRangeException"></exception>
+    public TimeSpan? SlidingExpiration { get; set; }
+
+
+    /// <summary>
+    /// Absolute expiration for the cache entry relative to creation
+    /// </summary>
+    /// <exception cref="ArgumentOutOfRangeException"></exception>
+
+    public TimeSpan? AbsoluteExpirationRelativeToCreation { get; set; }
+
+
+    internal MemoryCacheEntryOptions ToMemoryCacheEntryOptions()
+    {
+        if (this.AbsoluteExpirationRelativeToCreation is null && this.SlidingExpiration is null)
+        {
+            throw new ArgumentException("Either SlidingExpiration or AbsoluteExpirationRelativeToCreation must be set");
+        }
+
+        if 
+        (
+            this.AbsoluteExpirationRelativeToCreation is not null &&
+            this.SlidingExpiration is not null &&
+            this.AbsoluteExpirationRelativeToCreation < this.SlidingExpiration
+        )
+        {
+            throw new ArgumentException("AbsoluteExpirationRelativeToCreation must be greater than SlidingExpiration");
+        }
+
+        MemoryCacheEntryOptions options = new();
+
+        if (this.AbsoluteExpirationRelativeToCreation is not null)
+        {
+            options.AbsoluteExpirationRelativeToNow = this.AbsoluteExpirationRelativeToCreation;
+        }
+
+        if (this.SlidingExpiration is not null)
+        {
+            options.SlidingExpiration = this.SlidingExpiration;
+        }
+
+        return options;
+    }
+}