github/Discord.Net
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added RequestOptions to RestClient methods. Added guild summary paging.

Browse Source
This commit is contained in:
RogueException
2017-03-31 03:01:49 -03:00
parent 5aa92f8954
commit 5e94b97024
10 changed files with 201 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/Discord.Net.Core/DiscordConfig.cs
View File

@@ -18,6 +18,7 @@ namespace Discord
public const int MaxMessageSize = 2000; public const int MaxMessageSize = 2000;
public const int MaxMessagesPerBatch = 100; public const int MaxMessagesPerBatch = 100;
public const int MaxUsersPerBatch = 1000; public const int MaxUsersPerBatch = 1000;
public const int MaxGuildsPerBatch = 100;
/// <summary> Gets or sets how a request should act in the case of an error, by default. </summary> /// <summary> Gets or sets how a request should act in the case of an error, by default. </summary>
public RetryMode DefaultRetryMode { get; set; } = RetryMode.AlwaysRetry; public RetryMode DefaultRetryMode { get; set; } = RetryMode.AlwaysRetry;

28
src/Discord.Net.Core/IDiscordClient.cs
View File

@@ -14,25 +14,25 @@ namespace Discord
Task StartAsync(); Task StartAsync();
Task StopAsync(); Task StopAsync();
Task<IApplication> GetApplicationInfoAsync(); Task<IApplication> GetApplicationInfoAsync(RequestOptions options = null);
Task<IChannel> GetChannelAsync(ulong id, CacheMode mode = CacheMode.AllowDownload); Task<IChannel> GetChannelAsync(ulong id, CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
Task<IReadOnlyCollection<IPrivateChannel>> GetPrivateChannelsAsync(CacheMode mode = CacheMode.AllowDownload); Task<IReadOnlyCollection<IPrivateChannel>> GetPrivateChannelsAsync(CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
Task<IReadOnlyCollection<IDMChannel>> GetDMChannelsAsync(CacheMode mode = CacheMode.AllowDownload); Task<IReadOnlyCollection<IDMChannel>> GetDMChannelsAsync(CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
Task<IReadOnlyCollection<IGroupChannel>> GetGroupChannelsAsync(CacheMode mode = CacheMode.AllowDownload); Task<IReadOnlyCollection<IGroupChannel>> GetGroupChannelsAsync(CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
Task<IReadOnlyCollection<IConnection>> GetConnectionsAsync(); Task<IReadOnlyCollection<IConnection>> GetConnectionsAsync(RequestOptions options = null);
Task<IGuild> GetGuildAsync(ulong id, CacheMode mode = CacheMode.AllowDownload); Task<IGuild> GetGuildAsync(ulong id, CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
Task<IReadOnlyCollection<IGuild>> GetGuildsAsync(CacheMode mode = CacheMode.AllowDownload); Task<IReadOnlyCollection<IGuild>> GetGuildsAsync(CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
Task<IGuild> CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon = null); Task<IGuild> CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon = null, RequestOptions options = null);
Task<IInvite> GetInviteAsync(string inviteId); Task<IInvite> GetInviteAsync(string inviteId, RequestOptions options = null);
Task<IUser> GetUserAsync(ulong id, CacheMode mode = CacheMode.AllowDownload); Task<IUser> GetUserAsync(ulong id, CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
Task<IUser> GetUserAsync(string username, string discriminator); Task<IUser> GetUserAsync(string username, string discriminator, RequestOptions options = null);
Task<IReadOnlyCollection<IVoiceRegion>> GetVoiceRegionsAsync(); Task<IReadOnlyCollection<IVoiceRegion>> GetVoiceRegionsAsync(RequestOptions options = null);
Task<IVoiceRegion> GetVoiceRegionAsync(string id); Task<IVoiceRegion> GetVoiceRegionAsync(string id, RequestOptions options = null);
} }
} }

9
src/Discord.Net.Rest/API/Rest/GetGuildSummariesParams.cs Normal file
View File

@@ -0,0 +1,9 @@
#pragma warning disable CS1591
namespace Discord.API.Rest
{
internal class GetGuildSummariesParams
{
public Optional<int> Limit { get; set; }
public Optional<ulong> AfterGuildId { get; set; }
}
}

28
src/Discord.Net.Rest/BaseDiscordClient.cs
View File

@@ -127,37 +127,37 @@ namespace Discord.Rest
ConnectionState IDiscordClient.ConnectionState => ConnectionState.Disconnected; ConnectionState IDiscordClient.ConnectionState => ConnectionState.Disconnected;
ISelfUser IDiscordClient.CurrentUser => CurrentUser; ISelfUser IDiscordClient.CurrentUser => CurrentUser;
Task<IApplication> IDiscordClient.GetApplicationInfoAsync() { throw new NotSupportedException(); } Task<IApplication> IDiscordClient.GetApplicationInfoAsync(RequestOptions options) { throw new NotSupportedException(); }
Task<IChannel> IDiscordClient.GetChannelAsync(ulong id, CacheMode mode) Task<IChannel> IDiscordClient.GetChannelAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IChannel>(null); => Task.FromResult<IChannel>(null);
Task<IReadOnlyCollection<IPrivateChannel>> IDiscordClient.GetPrivateChannelsAsync(CacheMode mode) Task<IReadOnlyCollection<IPrivateChannel>> IDiscordClient.GetPrivateChannelsAsync(CacheMode mode, RequestOptions options)
=> Task.FromResult<IReadOnlyCollection<IPrivateChannel>>(ImmutableArray.Create<IPrivateChannel>()); => Task.FromResult<IReadOnlyCollection<IPrivateChannel>>(ImmutableArray.Create<IPrivateChannel>());
Task<IReadOnlyCollection<IDMChannel>> IDiscordClient.GetDMChannelsAsync(CacheMode mode) Task<IReadOnlyCollection<IDMChannel>> IDiscordClient.GetDMChannelsAsync(CacheMode mode, RequestOptions options)
=> Task.FromResult<IReadOnlyCollection<IDMChannel>>(ImmutableArray.Create<IDMChannel>()); => Task.FromResult<IReadOnlyCollection<IDMChannel>>(ImmutableArray.Create<IDMChannel>());
Task<IReadOnlyCollection<IGroupChannel>> IDiscordClient.GetGroupChannelsAsync(CacheMode mode) Task<IReadOnlyCollection<IGroupChannel>> IDiscordClient.GetGroupChannelsAsync(CacheMode mode, RequestOptions options)
=> Task.FromResult<IReadOnlyCollection<IGroupChannel>>(ImmutableArray.Create<IGroupChannel>()); => Task.FromResult<IReadOnlyCollection<IGroupChannel>>(ImmutableArray.Create<IGroupChannel>());
Task<IReadOnlyCollection<IConnection>> IDiscordClient.GetConnectionsAsync() Task<IReadOnlyCollection<IConnection>> IDiscordClient.GetConnectionsAsync(RequestOptions options)
=> Task.FromResult<IReadOnlyCollection<IConnection>>(ImmutableArray.Create<IConnection>()); => Task.FromResult<IReadOnlyCollection<IConnection>>(ImmutableArray.Create<IConnection>());
Task<IInvite> IDiscordClient.GetInviteAsync(string inviteId) Task<IInvite> IDiscordClient.GetInviteAsync(string inviteId, RequestOptions options)
=> Task.FromResult<IInvite>(null); => Task.FromResult<IInvite>(null);
Task<IGuild> IDiscordClient.GetGuildAsync(ulong id, CacheMode mode) Task<IGuild> IDiscordClient.GetGuildAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IGuild>(null); => Task.FromResult<IGuild>(null);
Task<IReadOnlyCollection<IGuild>> IDiscordClient.GetGuildsAsync(CacheMode mode) Task<IReadOnlyCollection<IGuild>> IDiscordClient.GetGuildsAsync(CacheMode mode, RequestOptions options)
=> Task.FromResult<IReadOnlyCollection<IGuild>>(ImmutableArray.Create<IGuild>()); => Task.FromResult<IReadOnlyCollection<IGuild>>(ImmutableArray.Create<IGuild>());
Task<IGuild> IDiscordClient.CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon) { throw new NotSupportedException(); } Task<IGuild> IDiscordClient.CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon, RequestOptions options) { throw new NotSupportedException(); }
Task<IUser> IDiscordClient.GetUserAsync(ulong id, CacheMode mode) Task<IUser> IDiscordClient.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IUser>(null); => Task.FromResult<IUser>(null);
Task<IUser> IDiscordClient.GetUserAsync(string username, string discriminator) Task<IUser> IDiscordClient.GetUserAsync(string username, string discriminator, RequestOptions options)
=> Task.FromResult<IUser>(null); => Task.FromResult<IUser>(null);
Task<IReadOnlyCollection<IVoiceRegion>> IDiscordClient.GetVoiceRegionsAsync() Task<IReadOnlyCollection<IVoiceRegion>> IDiscordClient.GetVoiceRegionsAsync(RequestOptions options)
=> Task.FromResult<IReadOnlyCollection<IVoiceRegion>>(ImmutableArray.Create<IVoiceRegion>()); => Task.FromResult<IReadOnlyCollection<IVoiceRegion>>(ImmutableArray.Create<IVoiceRegion>());
Task<IVoiceRegion> IDiscordClient.GetVoiceRegionAsync(string id) Task<IVoiceRegion> IDiscordClient.GetVoiceRegionAsync(string id, RequestOptions options)
=> Task.FromResult<IVoiceRegion>(null); => Task.FromResult<IVoiceRegion>(null);
Task IDiscordClient.StartAsync() Task IDiscordClient.StartAsync()

92
src/Discord.Net.Rest/ClientHelper.cs
View File

@@ -10,80 +10,104 @@ namespace Discord.Rest
internal static class ClientHelper internal static class ClientHelper
{ {
//Applications //Applications
public static async Task<RestApplication> GetApplicationInfoAsync(BaseDiscordClient client) public static async Task<RestApplication> GetApplicationInfoAsync(BaseDiscordClient client, RequestOptions options)
{ {
var model = await client.ApiClient.GetMyApplicationAsync().ConfigureAwait(false); var model = await client.ApiClient.GetMyApplicationAsync(options).ConfigureAwait(false);
return RestApplication.Create(client, model); return RestApplication.Create(client, model);
} }
public static async Task<RestChannel> GetChannelAsync(BaseDiscordClient client, public static async Task<RestChannel> GetChannelAsync(BaseDiscordClient client,
ulong id) ulong id, RequestOptions options)
{ {
var model = await client.ApiClient.GetChannelAsync(id).ConfigureAwait(false); var model = await client.ApiClient.GetChannelAsync(id, options).ConfigureAwait(false);
if (model != null) if (model != null)
return RestChannel.Create(client, model); return RestChannel.Create(client, model);
return null; return null;
} }
public static async Task<IReadOnlyCollection<IRestPrivateChannel>> GetPrivateChannelsAsync(BaseDiscordClient client) public static async Task<IReadOnlyCollection<IRestPrivateChannel>> GetPrivateChannelsAsync(BaseDiscordClient client, RequestOptions options)
{ {
var models = await client.ApiClient.GetMyPrivateChannelsAsync().ConfigureAwait(false); var models = await client.ApiClient.GetMyPrivateChannelsAsync(options).ConfigureAwait(false);
return models.Select(x => RestChannel.CreatePrivate(client, x)).ToImmutableArray(); return models.Select(x => RestChannel.CreatePrivate(client, x)).ToImmutableArray();
} }
public static async Task<IReadOnlyCollection<RestDMChannel>> GetDMChannelsAsync(BaseDiscordClient client) public static async Task<IReadOnlyCollection<RestDMChannel>> GetDMChannelsAsync(BaseDiscordClient client, RequestOptions options)
{ {
var models = await client.ApiClient.GetMyPrivateChannelsAsync().ConfigureAwait(false); var models = await client.ApiClient.GetMyPrivateChannelsAsync(options).ConfigureAwait(false);
return models return models
.Where(x => x.Type == ChannelType.DM) .Where(x => x.Type == ChannelType.DM)
.Select(x => RestDMChannel.Create(client, x)).ToImmutableArray(); .Select(x => RestDMChannel.Create(client, x)).ToImmutableArray();
} }
public static async Task<IReadOnlyCollection<RestGroupChannel>> GetGroupChannelsAsync(BaseDiscordClient client) public static async Task<IReadOnlyCollection<RestGroupChannel>> GetGroupChannelsAsync(BaseDiscordClient client, RequestOptions options)
{ {
var models = await client.ApiClient.GetMyPrivateChannelsAsync().ConfigureAwait(false); var models = await client.ApiClient.GetMyPrivateChannelsAsync(options).ConfigureAwait(false);
return models return models
.Where(x => x.Type == ChannelType.Group) .Where(x => x.Type == ChannelType.Group)
.Select(x => RestGroupChannel.Create(client, x)).ToImmutableArray(); .Select(x => RestGroupChannel.Create(client, x)).ToImmutableArray();
} }
public static async Task<IReadOnlyCollection<RestConnection>> GetConnectionsAsync(BaseDiscordClient client) public static async Task<IReadOnlyCollection<RestConnection>> GetConnectionsAsync(BaseDiscordClient client, RequestOptions options)
{ {
var models = await client.ApiClient.GetMyConnectionsAsync().ConfigureAwait(false); var models = await client.ApiClient.GetMyConnectionsAsync(options).ConfigureAwait(false);
return models.Select(x => RestConnection.Create(x)).ToImmutableArray(); return models.Select(x => RestConnection.Create(x)).ToImmutableArray();
} }
public static async Task<RestInvite> GetInviteAsync(BaseDiscordClient client, public static async Task<RestInvite> GetInviteAsync(BaseDiscordClient client,
string inviteId) string inviteId, RequestOptions options)
{ {
var model = await client.ApiClient.GetInviteAsync(inviteId).ConfigureAwait(false); var model = await client.ApiClient.GetInviteAsync(inviteId, options).ConfigureAwait(false);
if (model != null) if (model != null)
return RestInvite.Create(client, null, null, model); return RestInvite.Create(client, null, null, model);
return null; return null;
} }
public static async Task<RestGuild> GetGuildAsync(BaseDiscordClient client, public static async Task<RestGuild> GetGuildAsync(BaseDiscordClient client,
ulong id) ulong id, RequestOptions options)
{ {
var model = await client.ApiClient.GetGuildAsync(id).ConfigureAwait(false); var model = await client.ApiClient.GetGuildAsync(id, options).ConfigureAwait(false);
if (model != null) if (model != null)
return RestGuild.Create(client, model); return RestGuild.Create(client, model);
return null; return null;
} }
public static async Task<RestGuildEmbed?> GetGuildEmbedAsync(BaseDiscordClient client, public static async Task<RestGuildEmbed?> GetGuildEmbedAsync(BaseDiscordClient client,
ulong id) ulong id, RequestOptions options)
{ {
var model = await client.ApiClient.GetGuildEmbedAsync(id).ConfigureAwait(false); var model = await client.ApiClient.GetGuildEmbedAsync(id, options).ConfigureAwait(false);
if (model != null) if (model != null)
return RestGuildEmbed.Create(model); return RestGuildEmbed.Create(model);
return null; return null;
} }
public static async Task<IReadOnlyCollection<RestUserGuild>> GetGuildSummariesAsync(BaseDiscordClient client) public static IAsyncEnumerable<IReadOnlyCollection<RestUserGuild>> GetGuildSummariesAsync(BaseDiscordClient client,
ulong? fromGuildId, int? limit, RequestOptions options)
{ {
var models = await client.ApiClient.GetMyGuildsAsync().ConfigureAwait(false); return new PagedAsyncEnumerable<RestUserGuild>(
return models.Select(x => RestUserGuild.Create(client, x)).ToImmutableArray(); DiscordConfig.MaxUsersPerBatch,
async (info, ct) =>
{
var args = new GetGuildSummariesParams
{
Limit = info.PageSize
};
if (info.Position != null)
args.AfterGuildId = info.Position.Value;
var models = await client.ApiClient.GetMyGuildsAsync(args, options).ConfigureAwait(false);
return models
.Select(x => RestUserGuild.Create(client, x))
.ToImmutableArray();
},
nextPage: (info, lastPage) =>
{
if (lastPage.Count != DiscordConfig.MaxMessagesPerBatch)
return false;
info.Position = lastPage.Max(x => x.Id);
return true;
},
start: fromGuildId,
count: limit
);
} }
public static async Task<IReadOnlyCollection<RestGuild>> GetGuildsAsync(BaseDiscordClient client) public static async Task<IReadOnlyCollection<RestGuild>> GetGuildsAsync(BaseDiscordClient client, RequestOptions options)
{ {
var summaryModels = await client.ApiClient.GetMyGuildsAsync().ConfigureAwait(false); var summaryModels = await GetGuildSummariesAsync(client, null, null, options).Flatten();
var guilds = ImmutableArray.CreateBuilder<RestGuild>(summaryModels.Count); var guilds = ImmutableArray.CreateBuilder<RestGuild>();
foreach (var summaryModel in summaryModels) foreach (var summaryModel in summaryModels)
{ {
var guildModel = await client.ApiClient.GetGuildAsync(summaryModel.Id).ConfigureAwait(false); var guildModel = await client.ApiClient.GetGuildAsync(summaryModel.Id).ConfigureAwait(false);
@@ -93,39 +117,39 @@ namespace Discord.Rest
return guilds.ToImmutable(); return guilds.ToImmutable();
} }
public static async Task<RestGuild> CreateGuildAsync(BaseDiscordClient client, public static async Task<RestGuild> CreateGuildAsync(BaseDiscordClient client,
string name, IVoiceRegion region, Stream jpegIcon = null) string name, IVoiceRegion region, Stream jpegIcon, RequestOptions options)
{ {
var args = new CreateGuildParams(name, region.Id); var args = new CreateGuildParams(name, region.Id);
var model = await client.ApiClient.CreateGuildAsync(args).ConfigureAwait(false); var model = await client.ApiClient.CreateGuildAsync(args, options).ConfigureAwait(false);
return RestGuild.Create(client, model); return RestGuild.Create(client, model);
} }
public static async Task<RestUser> GetUserAsync(BaseDiscordClient client, public static async Task<RestUser> GetUserAsync(BaseDiscordClient client,
ulong id) ulong id, RequestOptions options)
{ {
var model = await client.ApiClient.GetUserAsync(id).ConfigureAwait(false); var model = await client.ApiClient.GetUserAsync(id, options).ConfigureAwait(false);
if (model != null) if (model != null)
return RestUser.Create(client, model); return RestUser.Create(client, model);
return null; return null;
} }
public static async Task<RestGuildUser> GetGuildUserAsync(BaseDiscordClient client, public static async Task<RestGuildUser> GetGuildUserAsync(BaseDiscordClient client,
ulong guildId, ulong id) ulong guildId, ulong id, RequestOptions options)
{ {
var model = await client.ApiClient.GetGuildMemberAsync(guildId, id).ConfigureAwait(false); var model = await client.ApiClient.GetGuildMemberAsync(guildId, id, options).ConfigureAwait(false);
if (model != null) if (model != null)
return RestGuildUser.Create(client, new RestGuild(client, guildId), model); return RestGuildUser.Create(client, new RestGuild(client, guildId), model);
return null; return null;
} }
public static async Task<IReadOnlyCollection<RestVoiceRegion>> GetVoiceRegionsAsync(BaseDiscordClient client) public static async Task<IReadOnlyCollection<RestVoiceRegion>> GetVoiceRegionsAsync(BaseDiscordClient client, RequestOptions options)
{ {
var models = await client.ApiClient.GetVoiceRegionsAsync().ConfigureAwait(false); var models = await client.ApiClient.GetVoiceRegionsAsync(options).ConfigureAwait(false);
return models.Select(x => RestVoiceRegion.Create(client, x)).ToImmutableArray(); return models.Select(x => RestVoiceRegion.Create(client, x)).ToImmutableArray();
} }
public static async Task<RestVoiceRegion> GetVoiceRegionAsync(BaseDiscordClient client, public static async Task<RestVoiceRegion> GetVoiceRegionAsync(BaseDiscordClient client,
string id) string id, RequestOptions options)
{ {
var models = await client.ApiClient.GetVoiceRegionsAsync().ConfigureAwait(false); var models = await client.ApiClient.GetVoiceRegionsAsync(options).ConfigureAwait(false);
return models.Select(x => RestVoiceRegion.Create(client, x)).Where(x => x.Id == id).FirstOrDefault(); return models.Select(x => RestVoiceRegion.Create(client, x)).Where(x => x.Id == id).FirstOrDefault();
} }
} }

12
src/Discord.Net.Rest/DiscordRestApiClient.cs
View File

@@ -1087,10 +1087,18 @@ namespace Discord.API
options = RequestOptions.CreateOrClone(options); options = RequestOptions.CreateOrClone(options);
return await SendAsync<IReadOnlyCollection<Channel>>("GET", () => "users/@me/channels", new BucketIds(), options: options).ConfigureAwait(false); return await SendAsync<IReadOnlyCollection<Channel>>("GET", () => "users/@me/channels", new BucketIds(), options: options).ConfigureAwait(false);
} }
public async Task<IReadOnlyCollection<UserGuild>> GetMyGuildsAsync(RequestOptions options = null) public async Task<IReadOnlyCollection<UserGuild>> GetMyGuildsAsync(GetGuildSummariesParams args, RequestOptions options = null)
{ {
Preconditions.NotNull(args, nameof(args));
Preconditions.GreaterThan(args.Limit, 0, nameof(args.Limit));
Preconditions.AtMost(args.Limit, DiscordConfig.MaxGuildsPerBatch, nameof(args.Limit));
Preconditions.GreaterThan(args.AfterGuildId, 0, nameof(args.AfterGuildId));
options = RequestOptions.CreateOrClone(options); options = RequestOptions.CreateOrClone(options);
return await SendAsync<IReadOnlyCollection<UserGuild>>("GET", () => "users/@me/guilds", new BucketIds(), options: options).ConfigureAwait(false);
int limit = args.Limit.GetValueOrDefault(int.MaxValue);
ulong afterGuildId = args.AfterGuildId.GetValueOrDefault(0);
return await SendAsync<IReadOnlyCollection<UserGuild>>("GET", () => $"users/@me/guilds?limit={limit}&after={afterGuildId}", new BucketIds(), options: options).ConfigureAwait(false);
} }
public async Task<Application> GetMyApplicationAsync(RequestOptions options = null) public async Task<Application> GetMyApplicationAsync(RequestOptions options = null)
{ {

119
src/Discord.Net.Rest/DiscordRestClient.cs
View File

@@ -35,127 +35,130 @@ namespace Discord.Rest
} }
/// <inheritdoc /> /// <inheritdoc />
public async Task<RestApplication> GetApplicationInfoAsync() public async Task<RestApplication> GetApplicationInfoAsync(RequestOptions options = null)
{ {
return _applicationInfo ?? (_applicationInfo = await ClientHelper.GetApplicationInfoAsync(this)); return _applicationInfo ?? (_applicationInfo = await ClientHelper.GetApplicationInfoAsync(this, options));
} }
/// <inheritdoc /> /// <inheritdoc />
public Task<RestChannel> GetChannelAsync(ulong id) public Task<RestChannel> GetChannelAsync(ulong id, RequestOptions options = null)
=> ClientHelper.GetChannelAsync(this, id); => ClientHelper.GetChannelAsync(this, id, options);
/// <inheritdoc /> /// <inheritdoc />
public Task<IReadOnlyCollection<IRestPrivateChannel>> GetPrivateChannelsAsync() public Task<IReadOnlyCollection<IRestPrivateChannel>> GetPrivateChannelsAsync(RequestOptions options = null)
=> ClientHelper.GetPrivateChannelsAsync(this); => ClientHelper.GetPrivateChannelsAsync(this, options);
public Task<IReadOnlyCollection<RestDMChannel>> GetDMChannelsAsync() public Task<IReadOnlyCollection<RestDMChannel>> GetDMChannelsAsync(RequestOptions options = null)
=> ClientHelper.GetDMChannelsAsync(this); => ClientHelper.GetDMChannelsAsync(this, options);
public Task<IReadOnlyCollection<RestGroupChannel>> GetGroupChannelsAsync() public Task<IReadOnlyCollection<RestGroupChannel>> GetGroupChannelsAsync(RequestOptions options = null)
=> ClientHelper.GetGroupChannelsAsync(this); => ClientHelper.GetGroupChannelsAsync(this, options);
/// <inheritdoc /> /// <inheritdoc />
public Task<IReadOnlyCollection<RestConnection>> GetConnectionsAsync() public Task<IReadOnlyCollection<RestConnection>> GetConnectionsAsync(RequestOptions options = null)
=> ClientHelper.GetConnectionsAsync(this); => ClientHelper.GetConnectionsAsync(this, options);
/// <inheritdoc /> /// <inheritdoc />
public Task<RestInvite> GetInviteAsync(string inviteId) public Task<RestInvite> GetInviteAsync(string inviteId, RequestOptions options = null)
=> ClientHelper.GetInviteAsync(this, inviteId); => ClientHelper.GetInviteAsync(this, inviteId, options);
/// <inheritdoc /> /// <inheritdoc />
public Task<RestGuild> GetGuildAsync(ulong id) public Task<RestGuild> GetGuildAsync(ulong id, RequestOptions options = null)
=> ClientHelper.GetGuildAsync(this, id); => ClientHelper.GetGuildAsync(this, id, options);
/// <inheritdoc /> /// <inheritdoc />
public Task<RestGuildEmbed?> GetGuildEmbedAsync(ulong id) public Task<RestGuildEmbed?> GetGuildEmbedAsync(ulong id, RequestOptions options = null)
=> ClientHelper.GetGuildEmbedAsync(this, id); => ClientHelper.GetGuildEmbedAsync(this, id, options);
/// <inheritdoc /> /// <inheritdoc />
public Task<IReadOnlyCollection<RestUserGuild>> GetGuildSummariesAsync() public IAsyncEnumerable<IReadOnlyCollection<RestUserGuild>> GetGuildSummariesAsync(RequestOptions options = null)
=> ClientHelper.GetGuildSummariesAsync(this); => ClientHelper.GetGuildSummariesAsync(this, null, null, options);
/// <inheritdoc /> /// <inheritdoc />
public Task<IReadOnlyCollection<RestGuild>> GetGuildsAsync() public IAsyncEnumerable<IReadOnlyCollection<RestUserGuild>> GetGuildSummariesAsync(ulong fromGuildId, int limit, RequestOptions options = null)
=> ClientHelper.GetGuildsAsync(this); => ClientHelper.GetGuildSummariesAsync(this, fromGuildId, limit, options);
/// <inheritdoc /> /// <inheritdoc />
public Task<RestGuild> CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon = null) public Task<IReadOnlyCollection<RestGuild>> GetGuildsAsync(RequestOptions options = null)
=> ClientHelper.CreateGuildAsync(this, name, region, jpegIcon); => ClientHelper.GetGuildsAsync(this, options);
/// <inheritdoc />
public Task<RestGuild> CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon = null, RequestOptions options = null)
=> ClientHelper.CreateGuildAsync(this, name, region, jpegIcon, options);
/// <inheritdoc /> /// <inheritdoc />
public Task<RestUser> GetUserAsync(ulong id) public Task<RestUser> GetUserAsync(ulong id, RequestOptions options = null)
=> ClientHelper.GetUserAsync(this, id); => ClientHelper.GetUserAsync(this, id, options);
/// <inheritdoc /> /// <inheritdoc />
public Task<RestGuildUser> GetGuildUserAsync(ulong guildId, ulong id) public Task<RestGuildUser> GetGuildUserAsync(ulong guildId, ulong id, RequestOptions options = null)
=> ClientHelper.GetGuildUserAsync(this, guildId, id); => ClientHelper.GetGuildUserAsync(this, guildId, id, options);
/// <inheritdoc /> /// <inheritdoc />
public Task<IReadOnlyCollection<RestVoiceRegion>> GetVoiceRegionsAsync() public Task<IReadOnlyCollection<RestVoiceRegion>> GetVoiceRegionsAsync(RequestOptions options = null)
=> ClientHelper.GetVoiceRegionsAsync(this); => ClientHelper.GetVoiceRegionsAsync(this, options);
/// <inheritdoc /> /// <inheritdoc />
public Task<RestVoiceRegion> GetVoiceRegionAsync(string id) public Task<RestVoiceRegion> GetVoiceRegionAsync(string id, RequestOptions options = null)
=> ClientHelper.GetVoiceRegionAsync(this, id); => ClientHelper.GetVoiceRegionAsync(this, id, options);
//IDiscordClient //IDiscordClient
async Task<IApplication> IDiscordClient.GetApplicationInfoAsync() async Task<IApplication> IDiscordClient.GetApplicationInfoAsync(RequestOptions options)
=> await GetApplicationInfoAsync().ConfigureAwait(false); => await GetApplicationInfoAsync(options).ConfigureAwait(false);
async Task<IChannel> IDiscordClient.GetChannelAsync(ulong id, CacheMode mode) async Task<IChannel> IDiscordClient.GetChannelAsync(ulong id, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return await GetChannelAsync(id).ConfigureAwait(false); return await GetChannelAsync(id, options).ConfigureAwait(false);
else else
return null; return null;
} }
async Task<IReadOnlyCollection<IPrivateChannel>> IDiscordClient.GetPrivateChannelsAsync(CacheMode mode) async Task<IReadOnlyCollection<IPrivateChannel>> IDiscordClient.GetPrivateChannelsAsync(CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return await GetPrivateChannelsAsync().ConfigureAwait(false); return await GetPrivateChannelsAsync(options).ConfigureAwait(false);
else else
return ImmutableArray.Create<IPrivateChannel>(); return ImmutableArray.Create<IPrivateChannel>();
} }
async Task<IReadOnlyCollection<IDMChannel>> IDiscordClient.GetDMChannelsAsync(CacheMode mode) async Task<IReadOnlyCollection<IDMChannel>> IDiscordClient.GetDMChannelsAsync(CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return await GetDMChannelsAsync().ConfigureAwait(false); return await GetDMChannelsAsync(options).ConfigureAwait(false);
else else
return ImmutableArray.Create<IDMChannel>(); return ImmutableArray.Create<IDMChannel>();
} }
async Task<IReadOnlyCollection<IGroupChannel>> IDiscordClient.GetGroupChannelsAsync(CacheMode mode) async Task<IReadOnlyCollection<IGroupChannel>> IDiscordClient.GetGroupChannelsAsync(CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return await GetGroupChannelsAsync().ConfigureAwait(false); return await GetGroupChannelsAsync(options).ConfigureAwait(false);
else else
return ImmutableArray.Create<IGroupChannel>(); return ImmutableArray.Create<IGroupChannel>();
} }
async Task<IReadOnlyCollection<IConnection>> IDiscordClient.GetConnectionsAsync() async Task<IReadOnlyCollection<IConnection>> IDiscordClient.GetConnectionsAsync(RequestOptions options)
=> await GetConnectionsAsync().ConfigureAwait(false); => await GetConnectionsAsync(options).ConfigureAwait(false);
async Task<IInvite> IDiscordClient.GetInviteAsync(string inviteId) async Task<IInvite> IDiscordClient.GetInviteAsync(string inviteId, RequestOptions options)
=> await GetInviteAsync(inviteId).ConfigureAwait(false); => await GetInviteAsync(inviteId, options).ConfigureAwait(false);
async Task<IGuild> IDiscordClient.GetGuildAsync(ulong id, CacheMode mode) async Task<IGuild> IDiscordClient.GetGuildAsync(ulong id, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return await GetGuildAsync(id).ConfigureAwait(false); return await GetGuildAsync(id, options).ConfigureAwait(false);
else else
return null; return null;
} }
async Task<IReadOnlyCollection<IGuild>> IDiscordClient.GetGuildsAsync(CacheMode mode) async Task<IReadOnlyCollection<IGuild>> IDiscordClient.GetGuildsAsync(CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return await GetGuildsAsync().ConfigureAwait(false); return await GetGuildsAsync(options).ConfigureAwait(false);
else else
return ImmutableArray.Create<IGuild>(); return ImmutableArray.Create<IGuild>();
} }
async Task<IGuild> IDiscordClient.CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon) async Task<IGuild> IDiscordClient.CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon, RequestOptions options)
=> await CreateGuildAsync(name, region, jpegIcon).ConfigureAwait(false); => await CreateGuildAsync(name, region, jpegIcon, options).ConfigureAwait(false);
async Task<IUser> IDiscordClient.GetUserAsync(ulong id, CacheMode mode) async Task<IUser> IDiscordClient.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return await GetUserAsync(id).ConfigureAwait(false); return await GetUserAsync(id, options).ConfigureAwait(false);
else else
return null; return null;
} }
async Task<IReadOnlyCollection<IVoiceRegion>> IDiscordClient.GetVoiceRegionsAsync() async Task<IReadOnlyCollection<IVoiceRegion>> IDiscordClient.GetVoiceRegionsAsync(RequestOptions options)
=> await GetVoiceRegionsAsync().ConfigureAwait(false); => await GetVoiceRegionsAsync(options).ConfigureAwait(false);
async Task<IVoiceRegion> IDiscordClient.GetVoiceRegionAsync(string id) async Task<IVoiceRegion> IDiscordClient.GetVoiceRegionAsync(string id, RequestOptions options)
=> await GetVoiceRegionAsync(id).ConfigureAwait(false); => await GetVoiceRegionAsync(id, options).ConfigureAwait(false);
} }
} }

2
src/Discord.Net.Rpc/DiscordRpcClient.cs
View File

@@ -468,7 +468,7 @@ namespace Discord.Rpc
//IDiscordClient //IDiscordClient
ConnectionState IDiscordClient.ConnectionState => _connection.State; ConnectionState IDiscordClient.ConnectionState => _connection.State;
Task<IApplication> IDiscordClient.GetApplicationInfoAsync() => Task.FromResult<IApplication>(ApplicationInfo); Task<IApplication> IDiscordClient.GetApplicationInfoAsync(RequestOptions options) => Task.FromResult<IApplication>(ApplicationInfo);
async Task IDiscordClient.StartAsync() async Task IDiscordClient.StartAsync()
=> await StartAsync().ConfigureAwait(false); => await StartAsync().ConfigureAwait(false);

30
src/Discord.Net.WebSocket/DiscordShardedClient.cs
View File

@@ -145,7 +145,7 @@ namespace Discord.WebSocket
public SocketGuild GetGuild(ulong id) => GetShardFor(id).GetGuild(id); public SocketGuild GetGuild(ulong id) => GetShardFor(id).GetGuild(id);
/// <inheritdoc /> /// <inheritdoc />
public Task<RestGuild> CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon = null) public Task<RestGuild> CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon = null)
=> ClientHelper.CreateGuildAsync(this, name, region, jpegIcon); => ClientHelper.CreateGuildAsync(this, name, region, jpegIcon, new RequestOptions());
/// <inheritdoc /> /// <inheritdoc />
public SocketChannel GetChannel(ulong id) public SocketChannel GetChannel(ulong id)
@@ -176,7 +176,7 @@ namespace Discord.WebSocket
/// <inheritdoc /> /// <inheritdoc />
public Task<IReadOnlyCollection<RestConnection>> GetConnectionsAsync() public Task<IReadOnlyCollection<RestConnection>> GetConnectionsAsync()
=> ClientHelper.GetConnectionsAsync(this); => ClientHelper.GetConnectionsAsync(this, new RequestOptions());
private IEnumerable<SocketGuild> GetGuilds() private IEnumerable<SocketGuild> GetGuilds()
{ {
@@ -196,7 +196,7 @@ namespace Discord.WebSocket
/// <inheritdoc /> /// <inheritdoc />
public Task<RestInvite> GetInviteAsync(string inviteId) public Task<RestInvite> GetInviteAsync(string inviteId)
=> ClientHelper.GetInviteAsync(this, inviteId); => ClientHelper.GetInviteAsync(this, inviteId, new RequestOptions());
/// <inheritdoc /> /// <inheritdoc />
public SocketUser GetUser(ulong id) public SocketUser GetUser(ulong id)
@@ -314,35 +314,35 @@ namespace Discord.WebSocket
} }
//IDiscordClient //IDiscordClient
async Task<IApplication> IDiscordClient.GetApplicationInfoAsync() async Task<IApplication> IDiscordClient.GetApplicationInfoAsync(RequestOptions options)
=> await GetApplicationInfoAsync().ConfigureAwait(false); => await GetApplicationInfoAsync().ConfigureAwait(false);
Task<IChannel> IDiscordClient.GetChannelAsync(ulong id, CacheMode mode) Task<IChannel> IDiscordClient.GetChannelAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IChannel>(GetChannel(id)); => Task.FromResult<IChannel>(GetChannel(id));
Task<IReadOnlyCollection<IPrivateChannel>> IDiscordClient.GetPrivateChannelsAsync(CacheMode mode) Task<IReadOnlyCollection<IPrivateChannel>> IDiscordClient.GetPrivateChannelsAsync(CacheMode mode, RequestOptions options)
=> Task.FromResult<IReadOnlyCollection<IPrivateChannel>>(PrivateChannels); => Task.FromResult<IReadOnlyCollection<IPrivateChannel>>(PrivateChannels);
async Task<IReadOnlyCollection<IConnection>> IDiscordClient.GetConnectionsAsync() async Task<IReadOnlyCollection<IConnection>> IDiscordClient.GetConnectionsAsync(RequestOptions options)
=> await GetConnectionsAsync().ConfigureAwait(false); => await GetConnectionsAsync().ConfigureAwait(false);
async Task<IInvite> IDiscordClient.GetInviteAsync(string inviteId) async Task<IInvite> IDiscordClient.GetInviteAsync(string inviteId, RequestOptions options)
=> await GetInviteAsync(inviteId).ConfigureAwait(false); => await GetInviteAsync(inviteId).ConfigureAwait(false);
Task<IGuild> IDiscordClient.GetGuildAsync(ulong id, CacheMode mode) Task<IGuild> IDiscordClient.GetGuildAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IGuild>(GetGuild(id)); => Task.FromResult<IGuild>(GetGuild(id));
Task<IReadOnlyCollection<IGuild>> IDiscordClient.GetGuildsAsync(CacheMode mode) Task<IReadOnlyCollection<IGuild>> IDiscordClient.GetGuildsAsync(CacheMode mode, RequestOptions options)
=> Task.FromResult<IReadOnlyCollection<IGuild>>(Guilds); => Task.FromResult<IReadOnlyCollection<IGuild>>(Guilds);
async Task<IGuild> IDiscordClient.CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon) async Task<IGuild> IDiscordClient.CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon, RequestOptions options)
=> await CreateGuildAsync(name, region, jpegIcon).ConfigureAwait(false); => await CreateGuildAsync(name, region, jpegIcon).ConfigureAwait(false);
Task<IUser> IDiscordClient.GetUserAsync(ulong id, CacheMode mode) Task<IUser> IDiscordClient.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IUser>(GetUser(id)); => Task.FromResult<IUser>(GetUser(id));
Task<IUser> IDiscordClient.GetUserAsync(string username, string discriminator) Task<IUser> IDiscordClient.GetUserAsync(string username, string discriminator, RequestOptions options)
=> Task.FromResult<IUser>(GetUser(username, discriminator)); => Task.FromResult<IUser>(GetUser(username, discriminator));
Task<IReadOnlyCollection<IVoiceRegion>> IDiscordClient.GetVoiceRegionsAsync() Task<IReadOnlyCollection<IVoiceRegion>> IDiscordClient.GetVoiceRegionsAsync(RequestOptions options)
=> Task.FromResult<IReadOnlyCollection<IVoiceRegion>>(VoiceRegions); => Task.FromResult<IReadOnlyCollection<IVoiceRegion>>(VoiceRegions);
Task<IVoiceRegion> IDiscordClient.GetVoiceRegionAsync(string id) Task<IVoiceRegion> IDiscordClient.GetVoiceRegionAsync(string id, RequestOptions options)
=> Task.FromResult<IVoiceRegion>(GetVoiceRegion(id)); => Task.FromResult<IVoiceRegion>(GetVoiceRegion(id));
} }
} }

36
src/Discord.Net.WebSocket/DiscordSocketClient.cs
View File

@@ -237,7 +237,7 @@ namespace Discord.WebSocket
/// <inheritdoc /> /// <inheritdoc />
public async Task<RestApplication> GetApplicationInfoAsync() public async Task<RestApplication> GetApplicationInfoAsync()
{ {
return _applicationInfo ?? (_applicationInfo = await ClientHelper.GetApplicationInfoAsync(this)); return _applicationInfo ?? (_applicationInfo = await ClientHelper.GetApplicationInfoAsync(this, new RequestOptions()));
} }
/// <inheritdoc /> /// <inheritdoc />
@@ -247,7 +247,7 @@ namespace Discord.WebSocket
} }
/// <inheritdoc /> /// <inheritdoc />
public Task<RestGuild> CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon = null) public Task<RestGuild> CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon = null)
=> ClientHelper.CreateGuildAsync(this, name, region, jpegIcon); => ClientHelper.CreateGuildAsync(this, name, region, jpegIcon, new RequestOptions());
/// <inheritdoc /> /// <inheritdoc />
public SocketChannel GetChannel(ulong id) public SocketChannel GetChannel(ulong id)
@@ -257,11 +257,11 @@ namespace Discord.WebSocket
/// <inheritdoc /> /// <inheritdoc />
public Task<IReadOnlyCollection<RestConnection>> GetConnectionsAsync() public Task<IReadOnlyCollection<RestConnection>> GetConnectionsAsync()
=> ClientHelper.GetConnectionsAsync(this); => ClientHelper.GetConnectionsAsync(this, new RequestOptions());
/// <inheritdoc /> /// <inheritdoc />
public Task<RestInvite> GetInviteAsync(string inviteId) public Task<RestInvite> GetInviteAsync(string inviteId)
=> ClientHelper.GetInviteAsync(this, inviteId); => ClientHelper.GetInviteAsync(this, inviteId, new RequestOptions());
/// <inheritdoc /> /// <inheritdoc />
public SocketUser GetUser(ulong id) public SocketUser GetUser(ulong id)
@@ -1726,39 +1726,39 @@ namespace Discord.WebSocket
} }
//IDiscordClient //IDiscordClient
async Task<IApplication> IDiscordClient.GetApplicationInfoAsync() async Task<IApplication> IDiscordClient.GetApplicationInfoAsync(RequestOptions options)
=> await GetApplicationInfoAsync().ConfigureAwait(false); => await GetApplicationInfoAsync().ConfigureAwait(false);
Task<IChannel> IDiscordClient.GetChannelAsync(ulong id, CacheMode mode) Task<IChannel> IDiscordClient.GetChannelAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IChannel>(GetChannel(id)); => Task.FromResult<IChannel>(GetChannel(id));
Task<IReadOnlyCollection<IPrivateChannel>> IDiscordClient.GetPrivateChannelsAsync(CacheMode mode) Task<IReadOnlyCollection<IPrivateChannel>> IDiscordClient.GetPrivateChannelsAsync(CacheMode mode, RequestOptions options)
=> Task.FromResult<IReadOnlyCollection<IPrivateChannel>>(PrivateChannels); => Task.FromResult<IReadOnlyCollection<IPrivateChannel>>(PrivateChannels);
Task<IReadOnlyCollection<IDMChannel>> IDiscordClient.GetDMChannelsAsync(CacheMode mode) Task<IReadOnlyCollection<IDMChannel>> IDiscordClient.GetDMChannelsAsync(CacheMode mode, RequestOptions options)
=> Task.FromResult<IReadOnlyCollection<IDMChannel>>(DMChannels); => Task.FromResult<IReadOnlyCollection<IDMChannel>>(DMChannels);
Task<IReadOnlyCollection<IGroupChannel>> IDiscordClient.GetGroupChannelsAsync(CacheMode mode) Task<IReadOnlyCollection<IGroupChannel>> IDiscordClient.GetGroupChannelsAsync(CacheMode mode, RequestOptions options)
=> Task.FromResult<IReadOnlyCollection<IGroupChannel>>(GroupChannels); => Task.FromResult<IReadOnlyCollection<IGroupChannel>>(GroupChannels);
async Task<IReadOnlyCollection<IConnection>> IDiscordClient.GetConnectionsAsync() async Task<IReadOnlyCollection<IConnection>> IDiscordClient.GetConnectionsAsync(RequestOptions options)
=> await GetConnectionsAsync().ConfigureAwait(false); => await GetConnectionsAsync().ConfigureAwait(false);
async Task<IInvite> IDiscordClient.GetInviteAsync(string inviteId) async Task<IInvite> IDiscordClient.GetInviteAsync(string inviteId, RequestOptions options)
=> await GetInviteAsync(inviteId).ConfigureAwait(false); => await GetInviteAsync(inviteId).ConfigureAwait(false);
Task<IGuild> IDiscordClient.GetGuildAsync(ulong id, CacheMode mode) Task<IGuild> IDiscordClient.GetGuildAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IGuild>(GetGuild(id)); => Task.FromResult<IGuild>(GetGuild(id));
Task<IReadOnlyCollection<IGuild>> IDiscordClient.GetGuildsAsync(CacheMode mode) Task<IReadOnlyCollection<IGuild>> IDiscordClient.GetGuildsAsync(CacheMode mode, RequestOptions options)
=> Task.FromResult<IReadOnlyCollection<IGuild>>(Guilds); => Task.FromResult<IReadOnlyCollection<IGuild>>(Guilds);
async Task<IGuild> IDiscordClient.CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon) async Task<IGuild> IDiscordClient.CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon, RequestOptions options)
=> await CreateGuildAsync(name, region, jpegIcon).ConfigureAwait(false); => await CreateGuildAsync(name, region, jpegIcon).ConfigureAwait(false);
Task<IUser> IDiscordClient.GetUserAsync(ulong id, CacheMode mode) Task<IUser> IDiscordClient.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IUser>(GetUser(id)); => Task.FromResult<IUser>(GetUser(id));
Task<IUser> IDiscordClient.GetUserAsync(string username, string discriminator) Task<IUser> IDiscordClient.GetUserAsync(string username, string discriminator, RequestOptions options)
=> Task.FromResult<IUser>(GetUser(username, discriminator)); => Task.FromResult<IUser>(GetUser(username, discriminator));
Task<IReadOnlyCollection<IVoiceRegion>> IDiscordClient.GetVoiceRegionsAsync() Task<IReadOnlyCollection<IVoiceRegion>> IDiscordClient.GetVoiceRegionsAsync(RequestOptions options)
=> Task.FromResult<IReadOnlyCollection<IVoiceRegion>>(VoiceRegions); => Task.FromResult<IReadOnlyCollection<IVoiceRegion>>(VoiceRegions);
Task<IVoiceRegion> IDiscordClient.GetVoiceRegionAsync(string id) Task<IVoiceRegion> IDiscordClient.GetVoiceRegionAsync(string id, RequestOptions options)
=> Task.FromResult<IVoiceRegion>(GetVoiceRegion(id)); => Task.FromResult<IVoiceRegion>(GetVoiceRegion(id));
async Task IDiscordClient.StartAsync() async Task IDiscordClient.StartAsync()