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

Added experimental async event handlers

Browse Source
This commit is contained in:
RogueException
2015-12-02 07:03:13 -04:00
parent 72e43227bf
commit 7237c6b3bf
19 changed files with 673 additions and 442 deletions
Download Patch File Download Diff File Expand all files Collapse all files

428
src/Discord.Net.Modules/ModuleManager.cs
View File

@@ -3,45 +3,74 @@ using System;
using System.Collections.Concurrent; using System.Collections.Concurrent;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Threading.Tasks;
namespace Discord.Modules namespace Discord.Modules
{ {
public class ModuleManager public class ModuleManager
{ {
public event EventHandler<ServerEventArgs> ServerEnabled; /*public event AsyncEventHandler<ServerEventArgs> ServerEnabled { add { _serverEnabled.Add(value); } remove { _serverEnabled.Remove(value); } }
public event EventHandler<ServerEventArgs> ServerDisabled; private readonly AsyncEvent<ServerEventArgs> _serverEnabled = new AsyncEvent<ServerEventArgs>(nameof(ServerEnabled));
public event EventHandler<ChannelEventArgs> ChannelEnabled; public event AsyncEventHandler<ServerEventArgs> ServerDisabled { add { _serverDisabled.Add(value); } remove { _serverDisabled.Remove(value); } }
public event EventHandler<ChannelEventArgs> ChannelDisabled; private readonly AsyncEvent<ServerEventArgs> _serverDisabled = new AsyncEvent<ServerEventArgs>(nameof(ServerDisabled));
public event AsyncEventHandler<ChannelEventArgs> ChannelEnabled { add { _channelEnabled.Add(value); } remove { _channelEnabled.Remove(value); } }
private readonly AsyncEvent<ChannelEventArgs> _channelEnabled = new AsyncEvent<ChannelEventArgs>(nameof(ChannelEnabled));
public event AsyncEventHandler<ChannelEventArgs> ChannelDisabled { add { _channelDisabled.Add(value); } remove { _channelDisabled.Remove(value); } }
private readonly AsyncEvent<ChannelEventArgs> _channelDisabled = new AsyncEvent<ChannelEventArgs>(nameof(ChannelDisabled));*/
public event EventHandler<ServerEventArgs> LeftServer; public event AsyncEventHandler<ServerEventArgs> LeftServer { add { _leftServer.Add(value); } remove { _leftServer.Remove(value); } }
public event EventHandler<ServerEventArgs> ServerUpdated; private readonly AsyncEvent<ServerEventArgs> _leftServer = new AsyncEvent<ServerEventArgs>(nameof(LeftServer));
public event EventHandler<ServerEventArgs> ServerUnavailable; public event AsyncEventHandler<ServerEventArgs> ServerUpdated { add { _serverUpdated.Add(value); } remove { _serverUpdated.Remove(value); } }
public event EventHandler<ServerEventArgs> ServerAvailable; private readonly AsyncEvent<ServerEventArgs> _serverUpdated = new AsyncEvent<ServerEventArgs>(nameof(ServerUpdated));
public event AsyncEventHandler<ServerEventArgs> ServerUnavailable { add { _serverUnavailable.Add(value); } remove { _serverUnavailable.Remove(value); } }
private readonly AsyncEvent<ServerEventArgs> _serverUnavailable = new AsyncEvent<ServerEventArgs>(nameof(ServerUnavailable));
public event AsyncEventHandler<ServerEventArgs> ServerAvailable { add { _serverAvailable.Add(value); } remove { _serverAvailable.Remove(value); } }
private readonly AsyncEvent<ServerEventArgs> _serverAvailable = new AsyncEvent<ServerEventArgs>(nameof(ServerAvailable));
public event EventHandler<BanEventArgs> UserBanned; public event AsyncEventHandler<BanEventArgs> UserBanned { add { _userBanned.Add(value); } remove { _userBanned.Remove(value); } }
public event EventHandler<BanEventArgs> UserUnbanned; private readonly AsyncEvent<BanEventArgs> _userBanned = new AsyncEvent<BanEventArgs>(nameof(UserBanned));
public event AsyncEventHandler<BanEventArgs> UserUnbanned { add { _userUnbanned.Add(value); } remove { _userUnbanned.Remove(value); } }
private readonly AsyncEvent<BanEventArgs> _userUnbanned = new AsyncEvent<BanEventArgs>(nameof(UserUnbanned));
public event EventHandler<ChannelEventArgs> ChannelCreated; public event AsyncEventHandler<ChannelEventArgs> ChannelCreated { add { _channelCreated.Add(value); } remove { _channelCreated.Remove(value); } }
public event EventHandler<ChannelEventArgs> ChannelDestroyed; private readonly AsyncEvent<ChannelEventArgs> _channelCreated = new AsyncEvent<ChannelEventArgs>(nameof(ChannelCreated));
public event EventHandler<ChannelEventArgs> ChannelUpdated; public event AsyncEventHandler<ChannelEventArgs> ChannelDestroyed { add { _channelDestroyed.Add(value); } remove { _channelDestroyed.Remove(value); } }
private readonly AsyncEvent<ChannelEventArgs> _channelDestroyed = new AsyncEvent<ChannelEventArgs>(nameof(ChannelDestroyed));
public event AsyncEventHandler<ChannelEventArgs> ChannelUpdated { add { _channelUpdated.Add(value); } remove { _channelUpdated.Remove(value); } }
private readonly AsyncEvent<ChannelEventArgs> _channelUpdated = new AsyncEvent<ChannelEventArgs>(nameof(ChannelUpdated));
public event EventHandler<RoleEventArgs> RoleCreated; public event AsyncEventHandler<RoleEventArgs> RoleCreated { add { _roleCreated.Add(value); } remove { _roleCreated.Remove(value); } }
public event EventHandler<RoleEventArgs> RoleUpdated; private readonly AsyncEvent<RoleEventArgs> _roleCreated = new AsyncEvent<RoleEventArgs>(nameof(RoleCreated));
public event EventHandler<RoleEventArgs> RoleDeleted; public event AsyncEventHandler<RoleEventArgs> RoleUpdated { add { _roleUpdated.Add(value); } remove { _roleUpdated.Remove(value); } }
private readonly AsyncEvent<RoleEventArgs> _roleUpdated = new AsyncEvent<RoleEventArgs>(nameof(RoleUpdated));
public event AsyncEventHandler<RoleEventArgs> RoleDeleted { add { _roleDeleted.Add(value); } remove { _roleDeleted.Remove(value); } }
private readonly AsyncEvent<RoleEventArgs> _roleDeleted = new AsyncEvent<RoleEventArgs>(nameof(RoleDeleted));
public event EventHandler<UserEventArgs> UserJoined; public event AsyncEventHandler<UserEventArgs> UserJoined { add { _userJoined.Add(value); } remove { _userJoined.Remove(value); } }
public event EventHandler<UserEventArgs> UserLeft; private readonly AsyncEvent<UserEventArgs> _userJoined = new AsyncEvent<UserEventArgs>(nameof(UserJoined));
public event EventHandler<UserEventArgs> UserUpdated; public event AsyncEventHandler<UserEventArgs> UserLeft { add { _userLeft.Add(value); } remove { _userLeft.Remove(value); } }
public event EventHandler<UserEventArgs> UserPresenceUpdated; private readonly AsyncEvent<UserEventArgs> _userLeft = new AsyncEvent<UserEventArgs>(nameof(UserLeft));
public event EventHandler<UserEventArgs> UserVoiceStateUpdated; public event AsyncEventHandler<UserEventArgs> UserUpdated { add { _userUpdated.Add(value); } remove { _userUpdated.Remove(value); } }
public event EventHandler<UserChannelEventArgs> UserIsTypingUpdated; private readonly AsyncEvent<UserEventArgs> _userUpdated = new AsyncEvent<UserEventArgs>(nameof(UserUpdated));
public event EventHandler<UserIsSpeakingEventArgs> UserIsSpeakingUpdated; public event AsyncEventHandler<UserEventArgs> UserPresenceUpdated { add { _userPresenceUpdated.Add(value); } remove { _userPresenceUpdated.Remove(value); } }
private readonly AsyncEvent<UserEventArgs> _userPresenceUpdated = new AsyncEvent<UserEventArgs>(nameof(UserPresenceUpdated));
public event AsyncEventHandler<UserEventArgs> UserVoiceStateUpdated { add { _userVoiceStateUpdated.Add(value); } remove { _userVoiceStateUpdated.Remove(value); } }
private readonly AsyncEvent<UserEventArgs> _userVoiceStateUpdated = new AsyncEvent<UserEventArgs>(nameof(UserVoiceStateUpdated));
public event AsyncEventHandler<UserChannelEventArgs> UserIsTypingUpdated { add { _userIsTypingUpdated.Add(value); } remove { _userIsTypingUpdated.Remove(value); } }
private readonly AsyncEvent<UserChannelEventArgs> _userIsTypingUpdated = new AsyncEvent<UserChannelEventArgs>(nameof(UserIsTypingUpdated));
public event AsyncEventHandler<UserIsSpeakingEventArgs> UserIsSpeakingUpdated { add { _userIsSpeakingUpdated.Add(value); } remove { _userIsSpeakingUpdated.Remove(value); } }
private readonly AsyncEvent<UserIsSpeakingEventArgs> _userIsSpeakingUpdated = new AsyncEvent<UserIsSpeakingEventArgs>(nameof(UserIsSpeakingUpdated));
public event EventHandler<MessageEventArgs> MessageReceived; public event AsyncEventHandler<MessageEventArgs> MessageReceived { add { _messageReceived.Add(value); } remove { _messageReceived.Remove(value); } }
public event EventHandler<MessageEventArgs> MessageSent; private readonly AsyncEvent<MessageEventArgs> _messageReceived = new AsyncEvent<MessageEventArgs>(nameof(MessageReceived));
public event EventHandler<MessageEventArgs> MessageDeleted; public event AsyncEventHandler<MessageEventArgs> MessageSent { add { _messageSent.Add(value); } remove { _messageSent.Remove(value); } }
public event EventHandler<MessageEventArgs> MessageUpdated; private readonly AsyncEvent<MessageEventArgs> _messageSent = new AsyncEvent<MessageEventArgs>(nameof(MessageSent));
public event EventHandler<MessageEventArgs> MessageReadRemotely; public event AsyncEventHandler<MessageEventArgs> MessageDeleted { add { _messageDeleted.Add(value); } remove { _messageDeleted.Remove(value); } }
private readonly AsyncEvent<MessageEventArgs> _messageDeleted = new AsyncEvent<MessageEventArgs>(nameof(MessageDeleted));
public event AsyncEventHandler<MessageEventArgs> MessageUpdated { add { _messageUpdated.Add(value); } remove { _messageUpdated.Remove(value); } }
private readonly AsyncEvent<MessageEventArgs> _messageUpdated = new AsyncEvent<MessageEventArgs>(nameof(MessageUpdated));
public event AsyncEventHandler<MessageEventArgs> MessageReadRemotely { add { _messageReadRemotely.Add(value); } remove { _messageReadRemotely.Remove(value); } }
private readonly AsyncEvent<MessageEventArgs> _messageReadRemotely = new AsyncEvent<MessageEventArgs>(nameof(MessageReadRemotely));
private readonly DiscordClient _client; private readonly DiscordClient _client;
private readonly string _name, _id; private readonly string _name, _id;
@@ -76,38 +105,167 @@ namespace Discord.Modules
if (_allowAll || _useServerWhitelist) //Server-only events if (_allowAll || _useServerWhitelist) //Server-only events
{ {
client.ChannelCreated += (s, e) => { if (ChannelCreated != null && HasServer(e.Server)) ChannelCreated(s, e); }; client.ChannelCreated += (s, e) =>
{
if (_channelCreated.Any && HasServer(e.Server))
return _channelCreated.Invoke(s, e);
return TaskHelper.CompletedTask;
};
client.UserVoiceStateUpdated += (s, e) => { if (UserVoiceStateUpdated != null && HasServer(e.Server)) UserVoiceStateUpdated(s, e); }; client.UserVoiceStateUpdated += (s, e) =>
client.UserIsSpeakingUpdated += (s, e) => { if (UserIsSpeakingUpdated != null && HasServer(e.Server)) UserIsSpeakingUpdated(s, e); }; {
if (_userVoiceStateUpdated.Any && HasServer(e.Server))
return _userVoiceStateUpdated.Invoke(s, e);
return TaskHelper.CompletedTask;
};
client.UserIsSpeakingUpdated += (s, e) =>
{
if (_userIsSpeakingUpdated.Any && HasServer(e.Server))
return _userIsSpeakingUpdated.Invoke(s, e);
return TaskHelper.CompletedTask;
};
} }
client.ChannelDestroyed += (s, e) => { if (ChannelDestroyed != null && HasChannel(e.Channel)) ChannelDestroyed(s, e); }; client.ChannelDestroyed += (s, e) =>
client.ChannelUpdated += (s, e) => { if (ChannelUpdated != null && HasChannel(e.Channel)) ChannelUpdated(s, e); }; {
if (_channelDestroyed.Any && HasChannel(e.Channel))
return _channelDestroyed.Invoke(s, e);
return TaskHelper.CompletedTask;
};
client.ChannelUpdated += (s, e) =>
{
if (_channelUpdated.Any && HasChannel(e.Channel))
return _channelUpdated.Invoke(s, e);
return TaskHelper.CompletedTask;
};
client.MessageReceived += (s, e) => { if (MessageReceived != null && HasChannel(e.Channel)) MessageReceived(s, e); }; client.MessageReceived += (s, e) =>
client.MessageSent += (s, e) => { if (MessageSent != null && HasChannel(e.Channel)) MessageSent(s, e); }; {
client.MessageDeleted += (s, e) => { if (MessageDeleted != null && HasChannel(e.Channel)) MessageDeleted(s, e); }; if (_messageReceived.Any && HasChannel(e.Channel))
client.MessageUpdated += (s, e) => { if (MessageUpdated != null && HasChannel(e.Channel)) MessageUpdated(s, e); }; return _messageReceived.Invoke(s, e);
client.MessageReadRemotely += (s, e) => { if (MessageReadRemotely != null && HasChannel(e.Channel)) MessageReadRemotely(s, e); }; return TaskHelper.CompletedTask;
};
client.MessageSent += (s, e) =>
{
if (_messageSent.Any && HasChannel(e.Channel))
return _messageSent.Invoke(s, e);
return TaskHelper.CompletedTask;
};
client.MessageDeleted += (s, e) =>
{
if (_messageDeleted.Any && HasChannel(e.Channel))
return _messageDeleted.Invoke(s, e);
return TaskHelper.CompletedTask;
};
client.MessageUpdated += (s, e) =>
{
if (_messageUpdated.Any && HasChannel(e.Channel))
return _messageUpdated.Invoke(s, e);
return TaskHelper.CompletedTask;
};
client.MessageReadRemotely += (s, e) =>
{
if (_messageReadRemotely.Any && HasChannel(e.Channel))
return _messageReadRemotely.Invoke(s, e);
return TaskHelper.CompletedTask;
};
client.RoleCreated += (s, e) => { if (RoleCreated != null && HasIndirectServer(e.Server)) RoleCreated(s, e); }; client.RoleCreated += (s, e) =>
client.RoleUpdated += (s, e) => { if (RoleUpdated != null && HasIndirectServer(e.Server)) RoleUpdated(s, e); }; {
client.RoleDeleted += (s, e) => { if (RoleDeleted != null && HasIndirectServer(e.Server)) RoleDeleted(s, e); }; if (_roleCreated.Any && HasIndirectServer(e.Server))
return _roleCreated.Invoke(s, e);
return TaskHelper.CompletedTask;
};
client.RoleUpdated += (s, e) =>
{
if (_roleUpdated.Any && HasIndirectServer(e.Server))
return _roleUpdated.Invoke(s, e);
return TaskHelper.CompletedTask;
};
client.RoleDeleted += (s, e) =>
{
if (_roleDeleted.Any && HasIndirectServer(e.Server))
return _roleDeleted.Invoke(s, e);
return TaskHelper.CompletedTask;
};
client.LeftServer += (s, e) => { if (LeftServer != null && HasIndirectServer(e.Server)) { DisableServer(e.Server); LeftServer(s, e); } }; client.LeftServer += (s, e) =>
client.ServerUpdated += (s, e) => { if (ServerUpdated != null && HasIndirectServer(e.Server)) ServerUpdated(s, e); }; {
client.ServerUnavailable += (s, e) => { if (ServerUnavailable != null && HasIndirectServer(e.Server)) ServerUnavailable(s, e); }; if (_leftServer.Any && HasIndirectServer(e.Server))
client.ServerAvailable += (s, e) => { if (ServerAvailable != null && HasIndirectServer(e.Server)) ServerAvailable(s, e); }; {
DisableServer(e.Server);
return _leftServer.Invoke(s, e);
}
return TaskHelper.CompletedTask;
};
client.ServerUpdated += (s, e) =>
{
if (_serverUpdated.Any && HasIndirectServer(e.Server))
return _serverUpdated.Invoke(s, e);
return TaskHelper.CompletedTask;
};
client.ServerUnavailable += (s, e) =>
{
if (_serverUnavailable.Any && HasIndirectServer(e.Server))
return _serverUnavailable.Invoke(s, e);
return TaskHelper.CompletedTask;
};
client.ServerAvailable += (s, e) =>
{
if (_serverAvailable.Any && HasIndirectServer(e.Server))
return _serverAvailable.Invoke(s, e);
return TaskHelper.CompletedTask;
};
client.UserJoined += (s, e) => { if (UserJoined != null && HasIndirectServer(e.Server)) UserJoined(s, e); }; client.UserJoined += (s, e) =>
client.UserLeft += (s, e) => { if (UserLeft != null && HasIndirectServer(e.Server)) UserLeft(s, e); }; {
client.UserUpdated += (s, e) => { if (UserUpdated != null && HasIndirectServer(e.Server)) UserUpdated(s, e); }; if (_userJoined.Any && HasIndirectServer(e.Server))
client.UserIsTypingUpdated += (s, e) => { if (UserIsSpeakingUpdated != null && HasChannel(e.Channel)) UserIsTypingUpdated(s, e); }; return _userJoined.Invoke(s, e);
return TaskHelper.CompletedTask;
};
client.UserLeft += (s, e) =>
{
if (_userLeft.Any && HasIndirectServer(e.Server))
return _userLeft.Invoke(s, e);
return TaskHelper.CompletedTask;
};
client.UserUpdated += (s, e) =>
{
if (_userUpdated.Any && HasIndirectServer(e.Server))
return _userUpdated.Invoke(s, e);
return TaskHelper.CompletedTask;
};
client.UserIsTypingUpdated += (s, e) =>
{
if (_userIsTypingUpdated.Any && HasChannel(e.Channel))
return _userIsTypingUpdated.Invoke(s, e);
return TaskHelper.CompletedTask;
};
client.UserIsSpeakingUpdated += (s, e) =>
{
if (_userIsSpeakingUpdated.Any && HasChannel(e.Channel))
return _userIsSpeakingUpdated.Invoke(s, e);
return TaskHelper.CompletedTask;
};
//TODO: We aren't getting events from UserPresence if AllowPrivate is enabled, but the server we know that user through isn't on the whitelist //TODO: We aren't getting events from UserPresence if AllowPrivate is enabled, but the server we know that user through isn't on the whitelist
client.UserPresenceUpdated += (s, e) => { if (UserPresenceUpdated != null && HasIndirectServer(e.Server)) UserPresenceUpdated(s, e); }; client.UserPresenceUpdated += (s, e) =>
client.UserBanned += (s, e) => { if (UserBanned != null && HasIndirectServer(e.Server)) UserBanned(s, e); }; {
client.UserUnbanned += (s, e) => { if (UserUnbanned != null && HasIndirectServer(e.Server)) UserUnbanned(s, e); }; if (_userPresenceUpdated.Any && HasIndirectServer(e.Server))
return _userPresenceUpdated.Invoke(s, e);
return TaskHelper.CompletedTask;
};
client.UserBanned += (s, e) =>
{
if (_userBanned.Any && HasIndirectServer(e.Server))
return _userBanned.Invoke(s, e);
return TaskHelper.CompletedTask;
};
client.UserUnbanned += (s, e) =>
{
if (_userUnbanned.Any && HasIndirectServer(e.Server))
return _userUnbanned.Invoke(s, e);
return TaskHelper.CompletedTask;
};
} }
public void CreateCommands(string prefix, Action<CommandGroupBuilder> config) public void CreateCommands(string prefix, Action<CommandGroupBuilder> config)
@@ -127,82 +285,49 @@ namespace Discord.Modules
if (!_useServerWhitelist) throw new InvalidOperationException("This module is not configured to use a server whitelist."); if (!_useServerWhitelist) throw new InvalidOperationException("This module is not configured to use a server whitelist.");
lock (this) lock (this)
return EnableServerInternal(server); return _enabledServers.TryAdd(server.Id, server);
} }
public void EnableServers(IEnumerable<Server> servers) public bool EnableServers(IEnumerable<Server> servers)
{ {
if (servers == null) throw new ArgumentNullException(nameof(servers)); if (servers == null) throw new ArgumentNullException(nameof(servers));
if (servers.Contains(null)) throw new ArgumentException("Collection cannot contain null.", nameof(servers)); if (servers.Contains(null)) throw new ArgumentException("Collection cannot contain null.", nameof(servers));
if (!_useServerWhitelist) throw new InvalidOperationException("This module is not configured to use a server whitelist."); if (!_useServerWhitelist) throw new InvalidOperationException("This module is not configured to use a server whitelist.");
bool result = false;
lock (this) lock (this)
{ {
foreach (var server in servers) foreach (var server in servers)
EnableServerInternal(server); {
if (_enabledServers.TryAdd(server.Id, server))
result |= true;
}
} }
return result;
} }
private bool EnableServerInternal(Server server)
{
if (_enabledServers.TryAdd(server.Id, server))
{
if (ServerEnabled != null)
ServerEnabled(this, new ServerEventArgs(server));
return true;
}
return false;
}
public bool DisableServer(Server server)
{
if (server == null) throw new ArgumentNullException(nameof(server));
if (!_useServerWhitelist) throw new InvalidOperationException("This module is not configured to use a server whitelist.");
lock (this)
{
if (_enabledServers.TryRemove(server.Id, out server))
{
if (ServerDisabled != null)
ServerDisabled(this, new ServerEventArgs(server));
return true;
}
return false;
}
}
public void DisableAllServers()
{
if (!_useServerWhitelist) throw new InvalidOperationException("This module is not configured to use a server whitelist.");
lock (this)
{
if (ServerDisabled != null)
{
foreach (var server in _enabledServers)
ServerDisabled(this, new ServerEventArgs(server.Value));
}
_enabledServers.Clear();
}
}
public bool EnableChannel(Channel channel) public bool EnableChannel(Channel channel)
{ {
if (channel == null) throw new ArgumentNullException(nameof(channel)); if (channel == null) throw new ArgumentNullException(nameof(channel));
if (!_useChannelWhitelist) throw new InvalidOperationException("This module is not configured to use a channel whitelist."); if (!_useChannelWhitelist) throw new InvalidOperationException("This module is not configured to use a channel whitelist.");
lock (this) lock (this)
return EnableChannelInternal(channel); return EnableChannelInternal(channel);
} }
public void EnableChannels(IEnumerable<Channel> channels) public bool EnableChannels(IEnumerable<Channel> channels)
{ {
if (channels == null) throw new ArgumentNullException(nameof(channels)); if (channels == null) throw new ArgumentNullException(nameof(channels));
if (channels.Contains(null)) throw new ArgumentException("Collection cannot contain null.", nameof(channels)); if (channels.Contains(null)) throw new ArgumentException("Collection cannot contain null.", nameof(channels));
if (!_useChannelWhitelist) throw new InvalidOperationException("This module is not configured to use a channel whitelist."); if (!_useChannelWhitelist) throw new InvalidOperationException("This module is not configured to use a channel whitelist.");
bool result = false;
lock (this) lock (this)
{ {
foreach (var channel in channels) foreach (var channel in channels)
EnableChannelInternal(channel); {
} if (EnableChannelInternal(channel))
result |= true;
}
}
return result;
} }
private bool EnableChannelInternal(Channel channel) private bool EnableChannelInternal(Channel channel)
{ {
@@ -216,65 +341,96 @@ namespace Discord.Modules
value++; value++;
_indirectServers[server.Id] = value; _indirectServers[server.Id] = value;
} }
if (ChannelEnabled != null)
ChannelEnabled(this, new ChannelEventArgs(channel));
return true; return true;
} }
return false; return false;
} }
public bool DisableServer(Server server)
{
if (server == null) throw new ArgumentNullException(nameof(server));
if (!_useServerWhitelist) throw new InvalidOperationException("This module is not configured to use a server whitelist.");
lock (this)
return _enabledServers.TryRemove(server.Id, out server);
}
public bool DisableServers(IEnumerable<Server> servers)
{
if (servers == null) throw new ArgumentNullException(nameof(servers));
if (servers.Contains(null)) throw new ArgumentException("Collection cannot contain null.", nameof(servers));
if (!_useServerWhitelist) throw new InvalidOperationException("This module is not configured to use a server whitelist.");
bool result = false;
lock (this)
{
foreach (var server in servers)
{
Server ignored;
if (_enabledServers.TryRemove(server.Id, out ignored))
result |= true;
}
}
return result;
}
public bool DisableChannel(Channel channel) public bool DisableChannel(Channel channel)
{ {
if (channel == null) throw new ArgumentNullException(nameof(channel)); if (channel == null) throw new ArgumentNullException(nameof(channel));
if (!_useChannelWhitelist) throw new InvalidOperationException("This module is not configured to use a channel whitelist."); if (!_useChannelWhitelist) throw new InvalidOperationException("This module is not configured to use a channel whitelist.");
lock (this)
return DisableChannelInternal(channel);
}
public bool DisableChannels(IEnumerable<Channel> channels)
{
if (channels == null) throw new ArgumentNullException(nameof(channels));
if (channels.Contains(null)) throw new ArgumentException("Collection cannot contain null.", nameof(channels));
if (!_useChannelWhitelist) throw new InvalidOperationException("This module is not configured to use a channel whitelist.");
bool result = false;
lock (this) lock (this)
{ {
Channel ignored; foreach (var channel in channels)
if (_enabledChannels.TryRemove(channel.Id, out ignored)) result |= DisableChannelInternal(channel);
}
return result;
}
private bool DisableChannelInternal(Channel channel)
{
Channel ignored;
if (_enabledChannels.TryRemove(channel.Id, out ignored))
{
var server = channel.Server;
if (server != null)
{ {
var server = channel.Server; int value = 0;
if (server != null) if (_indirectServers.TryGetValue(server.Id, out value))
{ {
int value = 0;
_indirectServers.TryGetValue(server.Id, out value);
value--; value--;
if (value <= 0) if (value <= 0)
_indirectServers.TryRemove(server.Id, out value); _indirectServers.TryRemove(server.Id, out value);
else else
_indirectServers[server.Id] = value; _indirectServers[server.Id] = value;
} }
if (ChannelDisabled != null)
ChannelDisabled(this, new ChannelEventArgs(channel));
return true;
} }
return false; return true;
} }
return false;
} }
public void DisableAllChannels() public bool DisableAll()
{
if (!_useChannelWhitelist) throw new InvalidOperationException("This module is not configured to use a channel whitelist.");
lock (this)
{
if (ChannelDisabled != null)
{
foreach (var channel in _enabledChannels)
ChannelDisabled(this, new ChannelEventArgs(channel.Value));
}
_enabledChannels.Clear();
_indirectServers.Clear();
}
}
public void DisableAll()
{ {
bool result = false;
if (_useServerWhitelist) if (_useServerWhitelist)
DisableAllServers(); {
result |= _enabledServers.Count != 0;
_enabledServers.Clear();
}
if (_useChannelWhitelist) if (_useChannelWhitelist)
DisableAllChannels(); {
} result |= _enabledServers.Count != 0;
_enabledChannels.Clear();
}
return result;
}
internal bool HasServer(Server server) => internal bool HasServer(Server server) =>
_allowAll || _allowAll ||

3
src/Discord.Net.Net45/Discord.Net.csproj
View File

@@ -205,6 +205,9 @@
<Compile Include="..\Discord.Net\Helpers\AsyncCollection.cs"> <Compile Include="..\Discord.Net\Helpers\AsyncCollection.cs">
<Link>Helpers\AsyncCollection.cs</Link> <Link>Helpers\AsyncCollection.cs</Link>
</Compile> </Compile>
<Compile Include="..\Discord.Net\Helpers\AsyncEvent.cs">
<Link>Helpers\AsyncEvent.cs</Link>
</Compile>
<Compile Include="..\Discord.Net\Helpers\BitHelper.cs"> <Compile Include="..\Discord.Net\Helpers\BitHelper.cs">
<Link>Helpers\BitHelper.cs</Link> <Link>Helpers\BitHelper.cs</Link>
</Compile> </Compile>

32
src/Discord.Net/DiscordClient.Channels.cs
View File

@@ -46,24 +46,20 @@ namespace Discord
public partial class DiscordClient public partial class DiscordClient
{ {
public event EventHandler<ChannelEventArgs> ChannelCreated; public event AsyncEventHandler<ChannelEventArgs> ChannelCreated { add { _channelCreated.Add(value); } remove { _channelCreated.Remove(value); } }
private void RaiseChannelCreated(Channel channel) private readonly AsyncEvent<ChannelEventArgs> _channelCreated = new AsyncEvent<ChannelEventArgs>(nameof(ChannelCreated));
{ private Task RaiseChannelCreated(Channel channel)
if (ChannelCreated != null) => RaiseEvent(_channelCreated, new ChannelEventArgs(channel));
RaiseEvent(nameof(ChannelCreated), () => ChannelCreated(this, new ChannelEventArgs(channel)));
} public event AsyncEventHandler<ChannelEventArgs> ChannelDestroyed { add { _channelDestroyed.Add(value); } remove { _channelDestroyed.Remove(value); } }
public event EventHandler<ChannelEventArgs> ChannelDestroyed; private readonly AsyncEvent<ChannelEventArgs> _channelDestroyed = new AsyncEvent<ChannelEventArgs>(nameof(ChannelDestroyed));
private void RaiseChannelDestroyed(Channel channel) private Task RaiseChannelDestroyed(Channel channel)
{ => RaiseEvent(_channelDestroyed, new ChannelEventArgs(channel));
if (ChannelDestroyed != null)
RaiseEvent(nameof(ChannelDestroyed), () => ChannelDestroyed(this, new ChannelEventArgs(channel))); public event AsyncEventHandler<ChannelEventArgs> ChannelUpdated { add { _channelUpdated.Add(value); } remove { _channelUpdated.Remove(value); } }
} private readonly AsyncEvent<ChannelEventArgs> _channelUpdated = new AsyncEvent<ChannelEventArgs>(nameof(ChannelUpdated));
public event EventHandler<ChannelEventArgs> ChannelUpdated; private Task RaiseChannelUpdated(Channel channel)
private void RaiseChannelUpdated(Channel channel) => RaiseEvent(_channelUpdated, new ChannelEventArgs(channel));
{
if (ChannelUpdated != null)
RaiseEvent(nameof(ChannelUpdated), () => ChannelUpdated(this, new ChannelEventArgs(channel)));
}
/// <summary> Returns a collection of all servers this client is a member of. </summary> /// <summary> Returns a collection of all servers this client is a member of. </summary>
public IEnumerable<Channel> PrivateChannels { get { CheckReady(); return _channels.PrivateChannels; } } public IEnumerable<Channel> PrivateChannels { get { CheckReady(); return _channels.PrivateChannels; } }

58
src/Discord.Net/DiscordClient.Messages.cs
View File

@@ -50,36 +50,30 @@ namespace Discord
{ {
public const int MaxMessageSize = 2000; public const int MaxMessageSize = 2000;
public event EventHandler<MessageEventArgs> MessageReceived; public event AsyncEventHandler<MessageEventArgs> MessageReceived { add { _messageReceived.Add(value); } remove { _messageReceived.Remove(value); } }
private void RaiseMessageReceived(Message msg) private readonly AsyncEvent<MessageEventArgs> _messageReceived = new AsyncEvent<MessageEventArgs>(nameof(MessageReceived));
{ private Task RaiseMessageReceived(Message msg)
if (MessageReceived != null) => RaiseEvent(_messageReceived, new MessageEventArgs(msg));
RaiseEvent(nameof(MessageReceived), () => MessageReceived(this, new MessageEventArgs(msg)));
} public event AsyncEventHandler<MessageEventArgs> MessageSent { add { _messageSent.Add(value); } remove { _messageSent.Remove(value); } }
public event EventHandler<MessageEventArgs> MessageSent; private readonly AsyncEvent<MessageEventArgs> _messageSent = new AsyncEvent<MessageEventArgs>(nameof(MessageSent));
private void RaiseMessageSent(Message msg) private Task RaiseMessageSent(Message msg)
{ => RaiseEvent(_messageSent, new MessageEventArgs(msg));
if (MessageSent != null)
RaiseEvent(nameof(MessageSent), () => MessageSent(this, new MessageEventArgs(msg))); public event AsyncEventHandler<MessageEventArgs> MessageDeleted { add { _messageDeleted.Add(value); } remove { _messageDeleted.Remove(value); } }
} private readonly AsyncEvent<MessageEventArgs> _messageDeleted = new AsyncEvent<MessageEventArgs>(nameof(MessageDeleted));
public event EventHandler<MessageEventArgs> MessageDeleted; private Task RaiseMessageDeleted(Message msg)
private void RaiseMessageDeleted(Message msg) => RaiseEvent(_messageDeleted, new MessageEventArgs(msg));
{
if (MessageDeleted != null) public event AsyncEventHandler<MessageEventArgs> MessageUpdated { add { _messageUpdated.Add(value); } remove { _messageUpdated.Remove(value); } }
RaiseEvent(nameof(MessageDeleted), () => MessageDeleted(this, new MessageEventArgs(msg))); private readonly AsyncEvent<MessageEventArgs> _messageUpdated = new AsyncEvent<MessageEventArgs>(nameof(MessageUpdated));
} private Task RaiseMessageUpdated(Message msg)
public event EventHandler<MessageEventArgs> MessageUpdated; => RaiseEvent(_messageUpdated, new MessageEventArgs(msg));
private void RaiseMessageUpdated(Message msg)
{ public event AsyncEventHandler<MessageEventArgs> MessageReadRemotely { add { _messageReadRemotely.Add(value); } remove { _messageReadRemotely.Remove(value); } }
if (MessageUpdated != null) private readonly AsyncEvent<MessageEventArgs> _messageReadRemotely = new AsyncEvent<MessageEventArgs>(nameof(MessageReadRemotely));
RaiseEvent(nameof(MessageUpdated), () => MessageUpdated(this, new MessageEventArgs(msg))); private Task RaiseMessageReadRemotely(Message msg)
} => RaiseEvent(_messageReadRemotely, new MessageEventArgs(msg));
public event EventHandler<MessageEventArgs> MessageReadRemotely;
private void RaiseMessageReadRemotely(Message msg)
{
if (MessageReadRemotely != null)
RaiseEvent(nameof(MessageReadRemotely), () => MessageReadRemotely(this, new MessageEventArgs(msg)));
}
internal Messages Messages => _messages; internal Messages Messages => _messages;
private readonly Messages _messages; private readonly Messages _messages;
@@ -158,7 +152,7 @@ namespace Discord
var model = await _api.SendMessage(channel.Id, text, mentionedUsers.Select(x => x.Id), null, isTextToSpeech).ConfigureAwait(false); var model = await _api.SendMessage(channel.Id, text, mentionedUsers.Select(x => x.Id), null, isTextToSpeech).ConfigureAwait(false);
msg = _messages.GetOrAdd(model.Id, channel.Id, model.Author.Id); msg = _messages.GetOrAdd(model.Id, channel.Id, model.Author.Id);
msg.Update(model); msg.Update(model);
RaiseMessageSent(msg); await RaiseMessageSent(msg);
} }
return msg; return msg;
} }
@@ -331,7 +325,7 @@ namespace Discord
} }
else else
msg.State = MessageState.Failed; msg.State = MessageState.Failed;
RaiseMessageSent(msg); await RaiseMessageSent(msg);
} }
await Task.Delay(interval).ConfigureAwait(false); await Task.Delay(interval).ConfigureAwait(false);
} }

32
src/Discord.Net/DiscordClient.Roles.cs
View File

@@ -25,24 +25,20 @@ namespace Discord
public partial class DiscordClient public partial class DiscordClient
{ {
public event EventHandler<RoleEventArgs> RoleCreated; public event AsyncEventHandler<RoleEventArgs> RoleCreated { add { _roleCreated.Add(value); } remove { _roleCreated.Remove(value); } }
private void RaiseRoleCreated(Role role) private readonly AsyncEvent<RoleEventArgs> _roleCreated = new AsyncEvent<RoleEventArgs>(nameof(RoleCreated));
{ private Task RaiseRoleCreated(Role role)
if (RoleCreated != null) => RaiseEvent(_roleCreated, new RoleEventArgs(role));
RaiseEvent(nameof(RoleCreated), () => RoleCreated(this, new RoleEventArgs(role)));
} public event AsyncEventHandler<RoleEventArgs> RoleUpdated { add { _roleUpdated.Add(value); } remove { _roleUpdated.Remove(value); } }
public event EventHandler<RoleEventArgs> RoleUpdated; private readonly AsyncEvent<RoleEventArgs> _roleUpdated = new AsyncEvent<RoleEventArgs>(nameof(RoleUpdated));
private void RaiseRoleDeleted(Role role) private Task RaiseRoleUpdated(Role role)
{ => RaiseEvent(_roleUpdated, new RoleEventArgs(role));
if (RoleDeleted != null)
RaiseEvent(nameof(RoleDeleted), () => RoleDeleted(this, new RoleEventArgs(role))); public event AsyncEventHandler<RoleEventArgs> RoleDeleted { add { _roleDeleted.Add(value); } remove { _roleDeleted.Remove(value); } }
} private readonly AsyncEvent<RoleEventArgs> _roleDeleted = new AsyncEvent<RoleEventArgs>(nameof(RoleDeleted));
public event EventHandler<RoleEventArgs> RoleDeleted; private Task RaiseRoleDeleted(Role role)
private void RaiseRoleUpdated(Role role) => RaiseEvent(_roleDeleted, new RoleEventArgs(role));
{
if (RoleUpdated != null)
RaiseEvent(nameof(RoleUpdated), () => RoleUpdated(this, new RoleEventArgs(role)));
}
internal Roles Roles => _roles; internal Roles Roles => _roles;
private readonly Roles _roles; private readonly Roles _roles;

55
src/Discord.Net/DiscordClient.Servers.cs
View File

@@ -25,36 +25,31 @@ namespace Discord
public partial class DiscordClient public partial class DiscordClient
{ {
public event EventHandler<ServerEventArgs> JoinedServer; public event AsyncEventHandler<ServerEventArgs> JoinedServer { add { _joinedServer.Add(value); } remove { _joinedServer.Remove(value); } }
private void RaiseJoinedServer(Server server) private readonly AsyncEvent<ServerEventArgs> _joinedServer = new AsyncEvent<ServerEventArgs>(nameof(JoinedServer));
{ private Task RaiseJoinedServer(Server server)
if (JoinedServer != null) => RaiseEvent(_joinedServer, new ServerEventArgs(server));
RaiseEvent(nameof(JoinedServer), () => JoinedServer(this, new ServerEventArgs(server)));
} public event AsyncEventHandler<ServerEventArgs> LeftServer { add { _leftServer.Add(value); } remove { _leftServer.Remove(value); } }
public event EventHandler<ServerEventArgs> LeftServer; private readonly AsyncEvent<ServerEventArgs> _leftServer = new AsyncEvent<ServerEventArgs>(nameof(LeftServer));
private void RaiseLeftServer(Server server) private Task RaiseLeftServer(Server server)
{ => RaiseEvent(_leftServer, new ServerEventArgs(server));
if (LeftServer != null)
RaiseEvent(nameof(LeftServer), () => LeftServer(this, new ServerEventArgs(server))); public event AsyncEventHandler<ServerEventArgs> ServerUpdated { add { _serverUpdated.Add(value); } remove { _serverUpdated.Remove(value); } }
} private readonly AsyncEvent<ServerEventArgs> _serverUpdated = new AsyncEvent<ServerEventArgs>(nameof(ServerUpdated));
public event EventHandler<ServerEventArgs> ServerUpdated; private Task RaiseServerUpdated(Server server)
private void RaiseServerUpdated(Server server) => RaiseEvent(_serverUpdated, new ServerEventArgs(server));
{
if (ServerUpdated != null) public event AsyncEventHandler<ServerEventArgs> ServerAvailable { add { _serverAvailable.Add(value); } remove { _serverAvailable.Remove(value); } }
RaiseEvent(nameof(ServerUpdated), () => ServerUpdated(this, new ServerEventArgs(server))); private readonly AsyncEvent<ServerEventArgs> _serverAvailable = new AsyncEvent<ServerEventArgs>(nameof(ServerAvailable));
} private Task RaiseServerAvailable(Server server)
public event EventHandler<ServerEventArgs> ServerUnavailable; => RaiseEvent(_serverAvailable, new ServerEventArgs(server));
private void RaiseServerUnavailable(Server server)
{ public event AsyncEventHandler<ServerEventArgs> ServerUnavailable { add { _serverUnavailable.Add(value); } remove { _serverUnavailable.Remove(value); } }
if (ServerUnavailable != null) private readonly AsyncEvent<ServerEventArgs> _serverUnavailable = new AsyncEvent<ServerEventArgs>(nameof(ServerUnavailable));
RaiseEvent(nameof(ServerUnavailable), () => ServerUnavailable(this, new ServerEventArgs(server))); private Task RaiseServerUnavailable(Server server)
} => RaiseEvent(_serverUnavailable, new ServerEventArgs(server));
public event EventHandler<ServerEventArgs> ServerAvailable;
private void RaiseServerAvailable(Server server)
{
if (ServerAvailable != null)
RaiseEvent(nameof(ServerAvailable), () => ServerAvailable(this, new ServerEventArgs(server)));
}
/// <summary> Returns a collection of all servers this client is a member of. </summary> /// <summary> Returns a collection of all servers this client is a member of. </summary>
public IEnumerable<Server> AllServers { get { CheckReady(); return _servers; } } public IEnumerable<Server> AllServers { get { CheckReady(); return _servers; } }

119
src/Discord.Net/DiscordClient.Users.cs
View File

@@ -45,6 +45,16 @@ namespace Discord
Channel = channel; Channel = channel;
} }
} }
public class UserIsTypingEventArgs : UserChannelEventArgs
{
public bool IsTyping { get; }
public UserIsTypingEventArgs(User user, Channel channel, bool isTyping)
: base(user, channel)
{
IsTyping = isTyping;
}
}
public class UserIsSpeakingEventArgs : UserChannelEventArgs public class UserIsSpeakingEventArgs : UserChannelEventArgs
{ {
public bool IsSpeaking { get; } public bool IsSpeaking { get; }
@@ -69,66 +79,55 @@ namespace Discord
public partial class DiscordClient public partial class DiscordClient
{ {
public event EventHandler<UserEventArgs> UserJoined; public event AsyncEventHandler<UserEventArgs> UserJoined { add { _userJoined.Add(value); } remove { _userJoined.Remove(value); } }
private void RaiseUserJoined(User user) private readonly AsyncEvent<UserEventArgs> _userJoined = new AsyncEvent<UserEventArgs>(nameof(UserJoined));
{ private Task RaiseUserJoined(User user)
if (UserJoined != null) => RaiseEvent(_userJoined, new UserEventArgs(user));
RaiseEvent(nameof(UserJoined), () => UserJoined(this, new UserEventArgs(user)));
} public event AsyncEventHandler<UserEventArgs> UserLeft { add { _userLeft.Add(value); } remove { _userLeft.Remove(value); } }
public event EventHandler<UserEventArgs> UserLeft; private readonly AsyncEvent<UserEventArgs> _userLeft = new AsyncEvent<UserEventArgs>(nameof(UserLeft));
private void RaiseUserLeft(User user) private Task RaiseUserLeft(User user)
{ => RaiseEvent(_userLeft, new UserEventArgs(user));
if (UserLeft != null)
RaiseEvent(nameof(UserLeft), () => UserLeft(this, new UserEventArgs(user))); public event AsyncEventHandler<UserEventArgs> UserUpdated { add { _userUpdated.Add(value); } remove { _userUpdated.Remove(value); } }
} private readonly AsyncEvent<UserEventArgs> _userUpdated = new AsyncEvent<UserEventArgs>(nameof(UserUpdated));
public event EventHandler<UserEventArgs> UserUpdated; private Task RaiseUserUpdated(User user)
private void RaiseUserUpdated(User user) => RaiseEvent(_userUpdated, new UserEventArgs(user));
{
if (UserUpdated != null) public event AsyncEventHandler<UserEventArgs> UserPresenceUpdated { add { _userPresenceUpdated.Add(value); } remove { _userPresenceUpdated.Remove(value); } }
RaiseEvent(nameof(UserUpdated), () => UserUpdated(this, new UserEventArgs(user))); private readonly AsyncEvent<UserEventArgs> _userPresenceUpdated = new AsyncEvent<UserEventArgs>(nameof(UserPresenceUpdated));
} private Task RaiseUserPresenceUpdated(User user)
public event EventHandler<UserEventArgs> UserPresenceUpdated; => RaiseEvent(_userPresenceUpdated, new UserEventArgs(user));
private void RaiseUserPresenceUpdated(User user)
{ public event AsyncEventHandler<UserEventArgs> UserVoiceStateUpdated { add { _userVoiceStateUpdated.Add(value); } remove { _userVoiceStateUpdated.Remove(value); } }
if (UserPresenceUpdated != null) private readonly AsyncEvent<UserEventArgs> _userVoiceStateUpdated = new AsyncEvent<UserEventArgs>(nameof(UserVoiceStateUpdated));
RaiseEvent(nameof(UserPresenceUpdated), () => UserPresenceUpdated(this, new UserEventArgs(user))); private Task RaiseUserVoiceStateUpdated(User user)
} => RaiseEvent(_userVoiceStateUpdated, new UserEventArgs(user));
public event EventHandler<UserEventArgs> UserVoiceStateUpdated;
private void RaiseUserVoiceStateUpdated(User user) public event AsyncEventHandler<UserIsTypingEventArgs> UserIsTypingUpdated { add { _userIsTypingUpdated.Add(value); } remove { _userIsTypingUpdated.Remove(value); } }
{ private readonly AsyncEvent<UserIsTypingEventArgs> _userIsTypingUpdated = new AsyncEvent<UserIsTypingEventArgs>(nameof(UserIsTypingUpdated));
if (UserVoiceStateUpdated != null) private Task RaiseUserIsTypingUpdated(User user, Channel channel, bool isTyping)
RaiseEvent(nameof(UserVoiceStateUpdated), () => UserVoiceStateUpdated(this, new UserEventArgs(user))); => RaiseEvent(_userIsTypingUpdated, new UserIsTypingEventArgs(user, channel, isTyping));
}
public event EventHandler<UserChannelEventArgs> UserIsTypingUpdated; public event AsyncEventHandler<UserIsSpeakingEventArgs> UserIsSpeakingUpdated { add { _userIsSpeakingUpdated.Add(value); } remove { _userIsSpeakingUpdated.Remove(value); } }
private void RaiseUserIsTyping(User user, Channel channel) private readonly AsyncEvent<UserIsSpeakingEventArgs> _userIsSpeakingUpdated = new AsyncEvent<UserIsSpeakingEventArgs>(nameof(UserIsSpeakingUpdated));
{ private Task RaiseUserIsSpeakingUpdated(User user, Channel channel, bool isSpeaking)
if (UserIsTypingUpdated != null) => RaiseEvent(_userIsSpeakingUpdated, new UserIsSpeakingEventArgs(user, channel, isSpeaking));
RaiseEvent(nameof(UserIsTypingUpdated), () => UserIsTypingUpdated(this, new UserChannelEventArgs(user, channel)));
} public event AsyncEventHandler<EventArgs> ProfileUpdated { add { _profileUpdated.Add(value); } remove { _profileUpdated.Remove(value); } }
public event EventHandler<UserIsSpeakingEventArgs> UserIsSpeakingUpdated; private readonly AsyncEvent<EventArgs> _profileUpdated = new AsyncEvent<EventArgs>(nameof(ProfileUpdated));
private void RaiseUserIsSpeaking(User user, Channel channel, bool isSpeaking) private Task RaiseProfileUpdated()
{ => RaiseEvent(_profileUpdated, EventArgs.Empty);
if (UserIsSpeakingUpdated != null)
RaiseEvent(nameof(UserIsSpeakingUpdated), () => UserIsSpeakingUpdated(this, new UserIsSpeakingEventArgs(user, channel, isSpeaking))); public event AsyncEventHandler<BanEventArgs> UserBanned { add { _userBanned.Add(value); } remove { _userBanned.Remove(value); } }
} private readonly AsyncEvent<BanEventArgs> _userBanned = new AsyncEvent<BanEventArgs>(nameof(UserBanned));
public event EventHandler ProfileUpdated; private Task RaiseUserBanned(long userId, Server server)
private void RaiseProfileUpdated() => RaiseEvent(_userBanned, new BanEventArgs(userId, server));
{
if (ProfileUpdated != null) public event AsyncEventHandler<BanEventArgs> UserUnbanned { add { _userUnbanned.Add(value); } remove { _userUnbanned.Remove(value); } }
RaiseEvent(nameof(ProfileUpdated), () => ProfileUpdated(this, EventArgs.Empty)); private readonly AsyncEvent<BanEventArgs> _userUnbanned = new AsyncEvent<BanEventArgs>(nameof(UserUnbanned));
} private Task RaiseUserUnbanned(long userId, Server server)
public event EventHandler<BanEventArgs> UserBanned; => RaiseEvent(_userUnbanned, new BanEventArgs(userId, server));
private void RaiseUserBanned(long userId, Server server)
{
if (UserBanned != null)
RaiseEvent(nameof(UserBanned), () => UserBanned(this, new BanEventArgs(userId, server)));
}
public event EventHandler<BanEventArgs> UserUnbanned;
private void RaiseUserUnbanned(long userId, Server server)
{
if (UserUnbanned != null)
RaiseEvent(nameof(UserUnbanned), () => UserUnbanned(this, new BanEventArgs(userId, server)));
}
/// <summary> Returns the current logged-in user in a private channel. </summary> /// <summary> Returns the current logged-in user in a private channel. </summary>
internal User PrivateUser => _privateUser; internal User PrivateUser => _privateUser;

3
src/Discord.Net/DiscordClient.Voice.cs
View File

@@ -43,7 +43,8 @@ namespace Discord
client.LogMessage += (s, e) => client.LogMessage += (s, e) =>
{ {
if (e.Source != LogMessageSource.DataWebSocket) if (e.Source != LogMessageSource.DataWebSocket)
RaiseOnLog(e.Severity, e.Source, $"(#{client.Config.VoiceClientId}) {e.Message}", e.Exception); return RaiseLogMessage(e.Severity, e.Source, $"(#{client.Config.VoiceClientId}) {e.Message}", e.Exception);
return TaskHelper.CompletedTask;
}; };
await client.Connect(_gateway, _token).ConfigureAwait(false); await client.Connect(_gateway, _token).ConfigureAwait(false);
return client; return client;

162
src/Discord.Net/DiscordClient.cs
View File

@@ -60,7 +60,7 @@ namespace Discord
await SendStatus().ConfigureAwait(false); await SendStatus().ConfigureAwait(false);
}; };
VoiceDisconnected += (s, e) => VoiceDisconnected += async (s, e) =>
{ {
var server = _servers[e.ServerId]; var server = _servers[e.ServerId];
if (server != null) if (server != null)
@@ -70,7 +70,7 @@ namespace Discord
if (member.IsSpeaking) if (member.IsSpeaking)
{ {
member.IsSpeaking = false; member.IsSpeaking = false;
RaiseUserIsSpeaking(member, _channels[_voiceSocket.CurrentChannelId], false); await RaiseUserIsSpeakingUpdated(member, _channels[_voiceSocket.CurrentChannelId], false);
} }
} }
} }
@@ -78,89 +78,89 @@ namespace Discord
if (_config.LogLevel >= LogMessageSeverity.Info) if (_config.LogLevel >= LogMessageSeverity.Info)
{ {
JoinedServer += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, JoinedServer += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
$"Server Created: {e.Server?.Name ?? "[Private]"}"); $"Server Created: {e.Server?.Name ?? "[Private]"}");
LeftServer += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, LeftServer += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
$"Server Destroyed: {e.Server?.Name ?? "[Private]"}"); $"Server Destroyed: {e.Server?.Name ?? "[Private]"}");
ServerUpdated += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, ServerUpdated += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
$"Server Updated: {e.Server?.Name ?? "[Private]"}"); $"Server Updated: {e.Server?.Name ?? "[Private]"}");
ServerAvailable += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, ServerAvailable += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
$"Server Available: {e.Server?.Name ?? "[Private]"}"); $"Server Available: {e.Server?.Name ?? "[Private]"}");
ServerUnavailable += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, ServerUnavailable += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
$"Server Unavailable: {e.Server?.Name ?? "[Private]"}"); $"Server Unavailable: {e.Server?.Name ?? "[Private]"}");
ChannelCreated += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, ChannelCreated += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
$"Channel Created: {e.Server?.Name ?? "[Private]"}/{e.Channel?.Name}"); $"Channel Created: {e.Server?.Name ?? "[Private]"}/{e.Channel?.Name}");
ChannelDestroyed += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, ChannelDestroyed += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
$"Channel Destroyed: {e.Server?.Name ?? "[Private]"}/{e.Channel?.Name}"); $"Channel Destroyed: {e.Server?.Name ?? "[Private]"}/{e.Channel?.Name}");
ChannelUpdated += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, ChannelUpdated += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
$"Channel Updated: {e.Server?.Name ?? "[Private]"}/{e.Channel?.Name}"); $"Channel Updated: {e.Server?.Name ?? "[Private]"}/{e.Channel?.Name}");
MessageReceived += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, MessageReceived += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
$"Message Received: {e.Server?.Name ?? "[Private]"}/{e.Channel?.Name}/{e.Message?.Id}"); $"Message Received: {e.Server?.Name ?? "[Private]"}/{e.Channel?.Name}/{e.Message?.Id}");
MessageDeleted += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, MessageDeleted += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
$"Message Deleted: {e.Server?.Name ?? "[Private]"}/{e.Channel?.Name}/{e.Message?.Id}"); $"Message Deleted: {e.Server?.Name ?? "[Private]"}/{e.Channel?.Name}/{e.Message?.Id}");
MessageUpdated += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, MessageUpdated += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
$"Message Update: {e.Server?.Name ?? "[Private]"}/{e.Channel?.Name}/{e.Message?.Id}"); $"Message Update: {e.Server?.Name ?? "[Private]"}/{e.Channel?.Name}/{e.Message?.Id}");
RoleCreated += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, RoleCreated += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
$"Role Created: {e.Server?.Name ?? "[Private]"}/{e.Role?.Name}"); $"Role Created: {e.Server?.Name ?? "[Private]"}/{e.Role?.Name}");
RoleUpdated += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, RoleUpdated += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
$"Role Updated: {e.Server?.Name ?? "[Private]"}/{e.Role?.Name}"); $"Role Updated: {e.Server?.Name ?? "[Private]"}/{e.Role?.Name}");
RoleDeleted += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, RoleDeleted += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
$"Role Deleted: {e.Server?.Name ?? "[Private]"}/{e.Role?.Name}"); $"Role Deleted: {e.Server?.Name ?? "[Private]"}/{e.Role?.Name}");
UserBanned += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, UserBanned += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
$"Banned User: {e.Server?.Name ?? "[Private]" }/{e.UserId}"); $"Banned User: {e.Server?.Name ?? "[Private]" }/{e.UserId}");
UserUnbanned += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, UserUnbanned += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
$"Unbanned User: {e.Server?.Name ?? "[Private]"}/{e.UserId}"); $"Unbanned User: {e.Server?.Name ?? "[Private]"}/{e.UserId}");
UserJoined += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, UserJoined += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
$"User Joined: {e.Server?.Name ?? "[Private]"}/{e.User.Name}"); $"User Joined: {e.Server?.Name ?? "[Private]"}/{e.User.Name}");
UserLeft += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, UserLeft += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
$"User Left: {e.Server?.Name ?? "[Private]"}/{e.User.Name}"); $"User Left: {e.Server?.Name ?? "[Private]"}/{e.User.Name}");
UserUpdated += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, UserUpdated += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
$"User Updated: {e.Server?.Name ?? "[Private]"}/{e.User.Name}"); $"User Updated: {e.Server?.Name ?? "[Private]"}/{e.User.Name}");
UserVoiceStateUpdated += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, UserVoiceStateUpdated += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
$"User Updated (Voice State): {e.Server?.Name ?? "[Private]"}/{e.User.Name}"); $"User Updated (Voice State): {e.Server?.Name ?? "[Private]"}/{e.User.Name}");
ProfileUpdated += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.Client, ProfileUpdated += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.Client,
"Profile Updated"); "Profile Updated");
} }
if (_config.LogLevel >= LogMessageSeverity.Verbose) if (_config.LogLevel >= LogMessageSeverity.Verbose)
{ {
UserIsTypingUpdated += (s, e) => RaiseOnLog(LogMessageSeverity.Verbose, LogMessageSource.Client, UserIsTypingUpdated += (s, e) => RaiseLogMessage(LogMessageSeverity.Verbose, LogMessageSource.Client,
$"User Updated (Is Typing): {e.Server?.Name ?? "[Private]"}/{e.Channel?.Name}/{e.User?.Name}"); $"User Updated (Is Typing): {e.Server?.Name ?? "[Private]"}/{e.Channel?.Name}/{e.User?.Name}");
MessageReadRemotely += (s, e) => RaiseOnLog(LogMessageSeverity.Verbose, LogMessageSource.Client, MessageReadRemotely += (s, e) => RaiseLogMessage(LogMessageSeverity.Verbose, LogMessageSource.Client,
$"Read Message (Remotely): {e.Server?.Name ?? "[Private]"}/{e.Channel?.Name}/{e.Message?.Id}"); $"Read Message (Remotely): {e.Server?.Name ?? "[Private]"}/{e.Channel?.Name}/{e.Message?.Id}");
MessageSent += (s, e) => RaiseOnLog(LogMessageSeverity.Verbose, LogMessageSource.Client, MessageSent += (s, e) => RaiseLogMessage(LogMessageSeverity.Verbose, LogMessageSource.Client,
$"Sent Message: {e.Server?.Name ?? "[Private]"}/{e.Channel?.Name}/{e.Message?.Id}"); $"Sent Message: {e.Server?.Name ?? "[Private]"}/{e.Channel?.Name}/{e.Message?.Id}");
UserPresenceUpdated += (s, e) => RaiseOnLog(LogMessageSeverity.Verbose, LogMessageSource.Client, UserPresenceUpdated += (s, e) => RaiseLogMessage(LogMessageSeverity.Verbose, LogMessageSource.Client,
$"User Updated (Presence): {e.Server?.Name ?? "[Private]"}/{e.User?.Name}"); $"User Updated (Presence): {e.Server?.Name ?? "[Private]"}/{e.User?.Name}");
_api.RestClient.OnRequest += (s, e) => _api.RestClient.OnRequest += (s, e) =>
{ {
if (e.Payload != null) if (e.Payload != null)
RaiseOnLog(LogMessageSeverity.Verbose, LogMessageSource.Rest, $"{e.Method} {e.Path}: {Math.Round(e.ElapsedMilliseconds, 2)} ms ({e.Payload})"); RaiseLogMessage(LogMessageSeverity.Verbose, LogMessageSource.Rest, $"{e.Method} {e.Path}: {Math.Round(e.ElapsedMilliseconds, 2)} ms ({e.Payload})");
else else
RaiseOnLog(LogMessageSeverity.Verbose, LogMessageSource.Rest, $"{e.Method} {e.Path}: {Math.Round(e.ElapsedMilliseconds, 2)} ms"); RaiseLogMessage(LogMessageSeverity.Verbose, LogMessageSource.Rest, $"{e.Method} {e.Path}: {Math.Round(e.ElapsedMilliseconds, 2)} ms");
}; };
} }
if (_config.LogLevel >= LogMessageSeverity.Debug) if (_config.LogLevel >= LogMessageSeverity.Debug)
{ {
_channels.ItemCreated += (s, e) => RaiseOnLog(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Created Channel {IdConvert.ToString(e.Item.Server?.Id) ?? "[Private]"}/{e.Item.Id}"); _channels.ItemCreated += (s, e) => RaiseLogMessage(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Created Channel {IdConvert.ToString(e.Item.Server?.Id) ?? "[Private]"}/{e.Item.Id}");
_channels.ItemDestroyed += (s, e) => RaiseOnLog(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Destroyed Channel {IdConvert.ToString(e.Item.Server?.Id) ?? "[Private]"}/{e.Item.Id}"); _channels.ItemDestroyed += (s, e) => RaiseLogMessage(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Destroyed Channel {IdConvert.ToString(e.Item.Server?.Id) ?? "[Private]"}/{e.Item.Id}");
_channels.Cleared += (s, e) => RaiseOnLog(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Cleared Channels"); _channels.Cleared += (s, e) => RaiseLogMessage(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Cleared Channels");
_users.ItemCreated += (s, e) => RaiseOnLog(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Created User {IdConvert.ToString(e.Item.Server?.Id) ?? "[Private]"}/{e.Item.Id}"); _users.ItemCreated += (s, e) => RaiseLogMessage(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Created User {IdConvert.ToString(e.Item.Server?.Id) ?? "[Private]"}/{e.Item.Id}");
_users.ItemDestroyed += (s, e) => RaiseOnLog(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Destroyed User {IdConvert.ToString(e.Item.Server?.Id) ?? "[Private]"}/{e.Item.Id}"); _users.ItemDestroyed += (s, e) => RaiseLogMessage(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Destroyed User {IdConvert.ToString(e.Item.Server?.Id) ?? "[Private]"}/{e.Item.Id}");
_users.Cleared += (s, e) => RaiseOnLog(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Cleared Users"); _users.Cleared += (s, e) => RaiseLogMessage(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Cleared Users");
_messages.ItemCreated += (s, e) => RaiseOnLog(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Created Message {IdConvert.ToString(e.Item.Server?.Id) ?? "[Private]"}/{e.Item.Channel.Id}/{e.Item.Id}"); _messages.ItemCreated += (s, e) => RaiseLogMessage(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Created Message {IdConvert.ToString(e.Item.Server?.Id) ?? "[Private]"}/{e.Item.Channel.Id}/{e.Item.Id}");
_messages.ItemDestroyed += (s, e) => RaiseOnLog(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Destroyed Message {IdConvert.ToString(e.Item.Server?.Id) ?? "[Private]"}/{e.Item.Channel.Id}/{e.Item.Id}"); _messages.ItemDestroyed += (s, e) => RaiseLogMessage(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Destroyed Message {IdConvert.ToString(e.Item.Server?.Id) ?? "[Private]"}/{e.Item.Channel.Id}/{e.Item.Id}");
_messages.ItemRemapped += (s, e) => RaiseOnLog(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Remapped Message {IdConvert.ToString(e.Item.Server?.Id) ?? "[Private]"}/{e.Item.Channel.Id}/[{e.OldId} -> {e.NewId}]"); _messages.ItemRemapped += (s, e) => RaiseLogMessage(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Remapped Message {IdConvert.ToString(e.Item.Server?.Id) ?? "[Private]"}/{e.Item.Channel.Id}/[{e.OldId} -> {e.NewId}]");
_messages.Cleared += (s, e) => RaiseOnLog(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Cleared Messages"); _messages.Cleared += (s, e) => RaiseLogMessage(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Cleared Messages");
_roles.ItemCreated += (s, e) => RaiseOnLog(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Created Role {IdConvert.ToString(e.Item.Server?.Id) ?? "[Private]"}/{e.Item.Id}"); _roles.ItemCreated += (s, e) => RaiseLogMessage(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Created Role {IdConvert.ToString(e.Item.Server?.Id) ?? "[Private]"}/{e.Item.Id}");
_roles.ItemDestroyed += (s, e) => RaiseOnLog(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Destroyed Role {IdConvert.ToString(e.Item.Server?.Id) ?? "[Private]"}/{e.Item.Id}"); _roles.ItemDestroyed += (s, e) => RaiseLogMessage(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Destroyed Role {IdConvert.ToString(e.Item.Server?.Id) ?? "[Private]"}/{e.Item.Id}");
_roles.Cleared += (s, e) => RaiseOnLog(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Cleared Roles"); _roles.Cleared += (s, e) => RaiseLogMessage(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Cleared Roles");
_servers.ItemCreated += (s, e) => RaiseOnLog(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Created Server {e.Item.Id}"); _servers.ItemCreated += (s, e) => RaiseLogMessage(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Created Server {e.Item.Id}");
_servers.ItemDestroyed += (s, e) => RaiseOnLog(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Destroyed Server {e.Item.Id}"); _servers.ItemDestroyed += (s, e) => RaiseLogMessage(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Destroyed Server {e.Item.Id}");
_servers.Cleared += (s, e) => RaiseOnLog(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Cleared Servers"); _servers.Cleared += (s, e) => RaiseLogMessage(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Cleared Servers");
_globalUsers.ItemCreated += (s, e) => RaiseOnLog(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Created User {e.Item.Id}"); _globalUsers.ItemCreated += (s, e) => RaiseLogMessage(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Created User {e.Item.Id}");
_globalUsers.ItemDestroyed += (s, e) => RaiseOnLog(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Destroyed User {e.Item.Id}"); _globalUsers.ItemDestroyed += (s, e) => RaiseLogMessage(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Destroyed User {e.Item.Id}");
_globalUsers.Cleared += (s, e) => RaiseOnLog(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Cleared Users"); _globalUsers.Cleared += (s, e) => RaiseLogMessage(LogMessageSeverity.Debug, LogMessageSource.Cache, $"Cleared Users");
} }
if (Config.UseMessageQueue) if (Config.UseMessageQueue)
@@ -172,7 +172,7 @@ namespace Discord
internal override VoiceWebSocket CreateVoiceSocket() internal override VoiceWebSocket CreateVoiceSocket()
{ {
var socket = base.CreateVoiceSocket(); var socket = base.CreateVoiceSocket();
socket.IsSpeaking += (s, e) => socket.IsSpeaking += async (s, e) =>
{ {
if (_voiceSocket.State == WebSocketState.Connected) if (_voiceSocket.State == WebSocketState.Connected)
{ {
@@ -182,7 +182,7 @@ namespace Discord
{ {
user.IsSpeaking = value; user.IsSpeaking = value;
var channel = _channels[_voiceSocket.CurrentChannelId]; var channel = _channels[_voiceSocket.CurrentChannelId];
RaiseUserIsSpeaking(user, channel, value); await RaiseUserIsSpeakingUpdated(user, channel, value);
if (Config.TrackActivity) if (Config.TrackActivity)
user.UpdateActivity(); user.UpdateActivity();
} }
@@ -209,7 +209,7 @@ namespace Discord
.ConfigureAwait(false); .ConfigureAwait(false);
token = response.Token; token = response.Token;
if (_config.LogLevel >= LogMessageSeverity.Verbose) if (_config.LogLevel >= LogMessageSeverity.Verbose)
RaiseOnLog(LogMessageSeverity.Verbose, LogMessageSource.Client, "Login successful, got token."); await RaiseLogMessage(LogMessageSeverity.Verbose, LogMessageSource.Client, "Login successful, got token.");
} }
catch (TaskCanceledException) { throw new TimeoutException(); } catch (TaskCanceledException) { throw new TimeoutException(); }
@@ -231,7 +231,7 @@ namespace Discord
.ConfigureAwait(false) .ConfigureAwait(false)
).Url; ).Url;
if (_config.LogLevel >= LogMessageSeverity.Verbose) if (_config.LogLevel >= LogMessageSeverity.Verbose)
RaiseOnLog(LogMessageSeverity.Verbose, LogMessageSource.Client, $"Websocket endpoint: {gateway}"); await RaiseLogMessage(LogMessageSeverity.Verbose, LogMessageSource.Client, $"Websocket endpoint: {gateway}");
await base.Connect(gateway, token) await base.Connect(gateway, token)
.Timeout(_config.ConnectionTimeout) .Timeout(_config.ConnectionTimeout)
@@ -350,9 +350,9 @@ namespace Discord
var server = _servers.GetOrAdd(data.Id); var server = _servers.GetOrAdd(data.Id);
server.Update(data); server.Update(data);
if (data.Unavailable == false) if (data.Unavailable == false)
RaiseServerAvailable(server); await RaiseServerAvailable(server);
else else
RaiseJoinedServer(server); await RaiseJoinedServer(server);
} }
} }
break; break;
@@ -363,7 +363,7 @@ namespace Discord
if (server != null) if (server != null)
{ {
server.Update(data); server.Update(data);
RaiseServerUpdated(server); await RaiseServerUpdated(server);
} }
} }
break; break;
@@ -374,9 +374,9 @@ namespace Discord
if (server != null) if (server != null)
{ {
if (data.Unavailable == true) if (data.Unavailable == true)
RaiseServerUnavailable(server); await RaiseServerUnavailable(server);
else else
RaiseLeftServer(server); await RaiseLeftServer(server);
} }
} }
break; break;
@@ -395,7 +395,7 @@ namespace Discord
else else
channel = _channels.GetOrAdd(data.Id, data.GuildId, null); channel = _channels.GetOrAdd(data.Id, data.GuildId, null);
channel.Update(data); channel.Update(data);
RaiseChannelCreated(channel); await RaiseChannelCreated(channel);
} }
break; break;
case "CHANNEL_UPDATE": case "CHANNEL_UPDATE":
@@ -405,7 +405,7 @@ namespace Discord
if (channel != null) if (channel != null)
{ {
channel.Update(data); channel.Update(data);
RaiseChannelUpdated(channel); await RaiseChannelUpdated(channel);
} }
} }
break; break;
@@ -414,7 +414,7 @@ namespace Discord
var data = e.Payload.ToObject<ChannelDeleteEvent>(_dataSocketSerializer); var data = e.Payload.ToObject<ChannelDeleteEvent>(_dataSocketSerializer);
var channel = _channels.TryRemove(data.Id); var channel = _channels.TryRemove(data.Id);
if (channel != null) if (channel != null)
RaiseChannelDestroyed(channel); await RaiseChannelDestroyed(channel);
} }
break; break;
@@ -426,7 +426,7 @@ namespace Discord
user.Update(data); user.Update(data);
if (Config.TrackActivity) if (Config.TrackActivity)
user.UpdateActivity(); user.UpdateActivity();
RaiseUserJoined(user); await RaiseUserJoined(user);
} }
break; break;
case "GUILD_MEMBER_UPDATE": case "GUILD_MEMBER_UPDATE":
@@ -436,7 +436,7 @@ namespace Discord
if (user != null) if (user != null)
{ {
user.Update(data); user.Update(data);
RaiseUserUpdated(user); await RaiseUserUpdated(user);
} }
} }
break; break;
@@ -445,7 +445,7 @@ namespace Discord
var data = e.Payload.ToObject<MemberRemoveEvent>(_dataSocketSerializer); var data = e.Payload.ToObject<MemberRemoveEvent>(_dataSocketSerializer);
var user = _users.TryRemove(data.UserId, data.GuildId); var user = _users.TryRemove(data.UserId, data.GuildId);
if (user != null) if (user != null)
RaiseUserLeft(user); await RaiseUserLeft(user);
} }
break; break;
case "GUILD_MEMBERS_CHUNK": case "GUILD_MEMBERS_CHUNK":
@@ -455,7 +455,7 @@ namespace Discord
{ {
var user = _users.GetOrAdd(memberData.User.Id, memberData.GuildId); var user = _users.GetOrAdd(memberData.User.Id, memberData.GuildId);
user.Update(memberData); user.Update(memberData);
//RaiseUserAdded(user); //await RaiseUserAdded(user);
} }
} }
break; break;
@@ -469,7 +469,7 @@ namespace Discord
var server = _servers[data.GuildId]; var server = _servers[data.GuildId];
if (server != null) if (server != null)
server.AddRole(role); server.AddRole(role);
RaiseRoleUpdated(role); await RaiseRoleUpdated(role);
} }
break; break;
case "GUILD_ROLE_UPDATE": case "GUILD_ROLE_UPDATE":
@@ -479,7 +479,7 @@ namespace Discord
if (role != null) if (role != null)
{ {
role.Update(data.Data); role.Update(data.Data);
RaiseRoleUpdated(role); await RaiseRoleUpdated(role);
} }
} }
break; break;
@@ -489,7 +489,7 @@ namespace Discord
var role = _roles.TryRemove(data.RoleId); var role = _roles.TryRemove(data.RoleId);
if (role != null) if (role != null)
{ {
RaiseRoleDeleted(role); await RaiseRoleDeleted(role);
var server = _servers[data.GuildId]; var server = _servers[data.GuildId];
if (server != null) if (server != null)
server.RemoveRole(role); server.RemoveRole(role);
@@ -506,7 +506,7 @@ namespace Discord
{ {
var id = data.User?.Id ?? data.UserId; var id = data.User?.Id ?? data.UserId;
server.AddBan(id); server.AddBan(id);
RaiseUserBanned(id, server); await RaiseUserBanned(id, server);
} }
} }
break; break;
@@ -518,7 +518,7 @@ namespace Discord
{ {
var id = data.User?.Id ?? data.UserId; var id = data.User?.Id ?? data.UserId;
if (server.RemoveBan(id)) if (server.RemoveBan(id))
RaiseUserUnbanned(id, server); await RaiseUserUnbanned(id, server);
} }
} }
break; break;
@@ -545,7 +545,7 @@ namespace Discord
} }
} }
RaiseMessageReceived(msg); await RaiseMessageReceived(msg);
if (Config.AckMessages && !isAuthor) if (Config.AckMessages && !isAuthor)
await _api.AckMessage(data.Id, data.ChannelId).ConfigureAwait(false); await _api.AckMessage(data.Id, data.ChannelId).ConfigureAwait(false);
@@ -558,7 +558,7 @@ namespace Discord
if (msg != null) if (msg != null)
{ {
msg.Update(data); msg.Update(data);
RaiseMessageUpdated(msg); await RaiseMessageUpdated(msg);
} }
} }
break; break;
@@ -567,7 +567,7 @@ namespace Discord
var data = e.Payload.ToObject<MessageDeleteEvent>(_dataSocketSerializer); var data = e.Payload.ToObject<MessageDeleteEvent>(_dataSocketSerializer);
var msg = _messages.TryRemove(data.Id); var msg = _messages.TryRemove(data.Id);
if (msg != null) if (msg != null)
RaiseMessageDeleted(msg); await RaiseMessageDeleted(msg);
} }
break; break;
case "MESSAGE_ACK": case "MESSAGE_ACK":
@@ -575,7 +575,7 @@ namespace Discord
var data = e.Payload.ToObject<MessageAckEvent>(_dataSocketSerializer); var data = e.Payload.ToObject<MessageAckEvent>(_dataSocketSerializer);
var msg = GetMessage(data.MessageId); var msg = GetMessage(data.MessageId);
if (msg != null) if (msg != null)
RaiseMessageReadRemotely(msg); await RaiseMessageReadRemotely(msg);
} }
break; break;
@@ -587,7 +587,7 @@ namespace Discord
if (user != null) if (user != null)
{ {
user.Update(data); user.Update(data);
RaiseUserPresenceUpdated(user); await RaiseUserPresenceUpdated(user);
} }
} }
break; break;
@@ -601,7 +601,7 @@ namespace Discord
if (user != null) if (user != null)
{ {
if (channel != null) if (channel != null)
RaiseUserIsTyping(user, channel); await RaiseUserIsTypingUpdated(user, channel, true);
} }
if (Config.TrackActivity) if (Config.TrackActivity)
@@ -627,10 +627,10 @@ namespace Discord
if (voiceChannel != null && data.ChannelId != voiceChannel.Id && user.IsSpeaking) if (voiceChannel != null && data.ChannelId != voiceChannel.Id && user.IsSpeaking)
{ {
user.IsSpeaking = false; user.IsSpeaking = false;
RaiseUserIsSpeaking(user, _channels[voiceChannel.Id], false); await RaiseUserIsSpeakingUpdated(user, _channels[voiceChannel.Id], false);
} }
user.Update(data); user.Update(data);
RaiseUserVoiceStateUpdated(user); await RaiseUserVoiceStateUpdated(user);
} }
} }
break; break;
@@ -643,7 +643,7 @@ namespace Discord
if (user != null) if (user != null)
{ {
user.Update(data); user.Update(data);
RaiseProfileUpdated(); await RaiseProfileUpdated();
} }
} }
break; break;
@@ -664,20 +664,20 @@ namespace Discord
//Others //Others
default: default:
RaiseOnLog(LogMessageSeverity.Warning, LogMessageSource.DataWebSocket, $"Unknown message type: {e.Type}"); await RaiseLogMessage(LogMessageSeverity.Warning, LogMessageSource.DataWebSocket, $"Unknown message type: {e.Type}");
break; break;
} }
} }
catch (Exception ex) catch (Exception ex)
{ {
RaiseOnLog(LogMessageSeverity.Error, LogMessageSource.Client, $"Error handling {e.Type} event: {ex.GetBaseException().Message}"); await RaiseLogMessage(LogMessageSeverity.Error, LogMessageSource.Client, $"Error handling {e.Type} event: {ex.GetBaseException().Message}");
} }
} }
private void SendInitialLog() private void SendInitialLog()
{ {
if (_config.LogLevel >= LogMessageSeverity.Verbose) if (_config.LogLevel >= LogMessageSeverity.Verbose)
RaiseOnLog(LogMessageSeverity.Verbose, LogMessageSource.Client, $"Config: {JsonConvert.SerializeObject(_config)}"); RaiseLogMessage(LogMessageSeverity.Verbose, LogMessageSource.Client, $"Config: {JsonConvert.SerializeObject(_config)}");
_sentInitialLog = true; _sentInitialLog = true;
} }

75
src/Discord.Net/DiscordWSClient.Events.cs
View File

@@ -1,4 +1,5 @@
using System; using System;
using System.Threading.Tasks;
namespace Discord namespace Discord
{ {
@@ -32,6 +33,15 @@ namespace Discord
Error = error; Error = error;
} }
} }
public class VoiceConnectedEventArgs : EventArgs
{
public readonly long ServerId;
internal VoiceConnectedEventArgs(long serverId)
{
ServerId = serverId;
}
}
public class VoiceDisconnectedEventArgs : DisconnectedEventArgs public class VoiceDisconnectedEventArgs : DisconnectedEventArgs
{ {
public readonly long ServerId; public readonly long ServerId;
@@ -58,7 +68,7 @@ namespace Discord
} }
} }
public sealed class VoicePacketEventArgs public sealed class VoicePacketEventArgs : EventArgs
{ {
public long UserId { get; } public long UserId { get; }
public long ChannelId { get; } public long ChannelId { get; }
@@ -77,43 +87,34 @@ namespace Discord
public partial class DiscordWSClient public partial class DiscordWSClient
{ {
public event EventHandler Connected; public event AsyncEventHandler<EventArgs> Connected { add { _connected.Add(value); } remove { _connected.Remove(value); } }
private void RaiseConnected() private readonly AsyncEvent<EventArgs> _connected = new AsyncEvent<EventArgs>(nameof(Connected));
{ protected Task RaiseConnected()
if (Connected != null) => RaiseEvent(_connected, EventArgs.Empty);
RaiseEvent(nameof(Connected), () => Connected(this, EventArgs.Empty));
}
public event EventHandler<DisconnectedEventArgs> Disconnected;
private void RaiseDisconnected(DisconnectedEventArgs e)
{
if (Disconnected != null)
RaiseEvent(nameof(Disconnected), () => Disconnected(this, e));
}
public event EventHandler<LogMessageEventArgs> LogMessage;
internal void RaiseOnLog(LogMessageSeverity severity, LogMessageSource source, string message, Exception exception = null)
{
if (LogMessage != null)
RaiseEvent(nameof(LogMessage), () => LogMessage(this, new LogMessageEventArgs(severity, source, message, exception)));
}
public event EventHandler VoiceConnected; public event AsyncEventHandler<DisconnectedEventArgs> Disconnected { add { _disconnected.Add(value); } remove { _disconnected.Remove(value); } }
private void RaiseVoiceConnected() private readonly AsyncEvent<DisconnectedEventArgs> _disconnected = new AsyncEvent<DisconnectedEventArgs>(nameof(Disconnected));
{ protected Task RaiseDisconnected(DisconnectedEventArgs e)
if (VoiceConnected != null) => RaiseEvent(_disconnected, e);
RaiseEvent(nameof(VoiceConnected), () => VoiceConnected(this, EventArgs.Empty));
}
public event EventHandler<VoiceDisconnectedEventArgs> VoiceDisconnected;
private void RaiseVoiceDisconnected(long serverId, DisconnectedEventArgs e)
{
if (VoiceDisconnected != null)
RaiseEvent(nameof(VoiceDisconnected), () => VoiceDisconnected(this, new VoiceDisconnectedEventArgs(serverId, e)));
}
public event EventHandler<VoicePacketEventArgs> OnVoicePacket; public event AsyncEventHandler<VoiceConnectedEventArgs> VoiceConnected { add { _voiceConnected.Add(value); } remove { _voiceConnected.Remove(value); } }
internal void RaiseOnVoicePacket(VoicePacketEventArgs e) private readonly AsyncEvent<VoiceConnectedEventArgs> _voiceConnected = new AsyncEvent<VoiceConnectedEventArgs>(nameof(VoiceConnected));
{ protected Task RaiseVoiceConnected(long serverId)
if (OnVoicePacket != null) => RaiseEvent(_voiceConnected, new VoiceConnectedEventArgs(serverId));
OnVoicePacket(this, e);
} public event AsyncEventHandler<VoiceDisconnectedEventArgs> VoiceDisconnected { add { _voiceDisconnected.Add(value); } remove { _voiceDisconnected.Remove(value); } }
private readonly AsyncEvent<VoiceDisconnectedEventArgs> _voiceDisconnected = new AsyncEvent<VoiceDisconnectedEventArgs>(nameof(VoiceDisconnected));
protected Task RaiseVoiceDisconnected(long serverId, DisconnectedEventArgs e)
=> RaiseEvent(_voiceDisconnected, new VoiceDisconnectedEventArgs(serverId, e));
public event AsyncEventHandler<LogMessageEventArgs> LogMessage { add { _logMessage.Add(value); } remove { _logMessage.Remove(value); } }
private readonly AsyncEvent<LogMessageEventArgs> _logMessage = new AsyncEvent<LogMessageEventArgs>(nameof(LogMessage));
protected Task RaiseLogMessage(LogMessageSeverity severity, LogMessageSource source, string message, Exception exception = null)
=> RaiseEvent(_logMessage, new LogMessageEventArgs(severity, source, message, exception));
public event AsyncEventHandler<VoicePacketEventArgs> VoiceReceived { add { _voiceReceived.Add(value); } remove { _voiceReceived.Remove(value); } }
private readonly AsyncEvent<VoicePacketEventArgs> _voiceReceived = new AsyncEvent<VoicePacketEventArgs>(nameof(VoiceReceived));
protected Task RaiseVoiceReceived(long userId, long channelId, byte[] buffer, int offset, int count)
=> RaiseEvent(_voiceReceived, new VoicePacketEventArgs(userId, channelId, buffer, offset, count));
} }
} }

33
src/Discord.Net/DiscordWSClient.cs
View File

@@ -69,7 +69,7 @@ namespace Discord
_dataSocketSerializer.Error += (s, e) => _dataSocketSerializer.Error += (s, e) =>
{ {
e.ErrorContext.Handled = true; e.ErrorContext.Handled = true;
RaiseOnLog(LogMessageSeverity.Error, LogMessageSource.DataWebSocket, "Serialization Failed", e.ErrorContext.Error); RaiseLogMessage(LogMessageSeverity.Error, LogMessageSource.DataWebSocket, "Serialization Failed", e.ErrorContext.Error);
}; };
#endif #endif
@@ -82,7 +82,7 @@ namespace Discord
_voiceSocketSerializer.Error += (s, e) => _voiceSocketSerializer.Error += (s, e) =>
{ {
e.ErrorContext.Handled = true; e.ErrorContext.Handled = true;
RaiseOnLog(LogMessageSeverity.Error, LogMessageSource.VoiceWebSocket, "Serialization Failed", e.ErrorContext.Error); RaiseLogMessage(LogMessageSeverity.Error, LogMessageSource.VoiceWebSocket, "Serialization Failed", e.ErrorContext.Error);
}; };
#endif #endif
@@ -106,16 +106,16 @@ namespace Discord
; ;
socket.Disconnected += async (s, e) => socket.Disconnected += async (s, e) =>
{ {
RaiseDisconnected(e); await RaiseDisconnected(e);
if (e.WasUnexpected) if (e.WasUnexpected)
await socket.Reconnect(_token).ConfigureAwait(false); await socket.Reconnect(_token).ConfigureAwait(false);
}; };
socket.LogMessage += (s, e) => RaiseOnLog(e.Severity, LogMessageSource.DataWebSocket, e.Message, e.Exception); socket.LogMessage += (s, e) => RaiseLogMessage(e.Severity, LogMessageSource.DataWebSocket, e.Message, e.Exception);
if (_config.LogLevel >= LogMessageSeverity.Info) if (_config.LogLevel >= LogMessageSeverity.Info)
{ {
socket.Connected += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.DataWebSocket, "Connected"); socket.Connected += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.DataWebSocket, "Connected");
socket.Disconnected += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.DataWebSocket, "Disconnected"); socket.Disconnected += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.DataWebSocket, "Disconnected");
} }
socket.ReceivedEvent += async (s, e) => await OnReceivedEvent(e).ConfigureAwait(false); socket.ReceivedEvent += async (s, e) => await OnReceivedEvent(e).ConfigureAwait(false);
@@ -124,19 +124,19 @@ namespace Discord
internal virtual VoiceWebSocket CreateVoiceSocket() internal virtual VoiceWebSocket CreateVoiceSocket()
{ {
var socket = new VoiceWebSocket(this); var socket = new VoiceWebSocket(this);
socket.Connected += (s, e) => RaiseVoiceConnected(); socket.Connected += (s, e) => RaiseVoiceConnected(socket.CurrentServerId.Value);
socket.Disconnected += async (s, e) => socket.Disconnected += async (s, e) =>
{ {
RaiseVoiceDisconnected(socket.CurrentServerId.Value, e); await RaiseVoiceDisconnected(socket.CurrentServerId.Value, e);
if (e.WasUnexpected) if (e.WasUnexpected)
await socket.Reconnect().ConfigureAwait(false); await socket.Reconnect().ConfigureAwait(false);
}; };
socket.LogMessage += (s, e) => RaiseOnLog(e.Severity, LogMessageSource.VoiceWebSocket, e.Message, e.Exception); socket.LogMessage += (s, e) => RaiseLogMessage(e.Severity, LogMessageSource.VoiceWebSocket, e.Message, e.Exception);
if (_config.LogLevel >= LogMessageSeverity.Info) if (_config.LogLevel >= LogMessageSeverity.Info)
{ {
socket.Connected += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.VoiceWebSocket, "Connected"); socket.Connected += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.VoiceWebSocket, "Connected");
socket.Disconnected += (s, e) => RaiseOnLog(LogMessageSeverity.Info, LogMessageSource.VoiceWebSocket, "Disconnected"); socket.Disconnected += (s, e) => RaiseLogMessage(LogMessageSeverity.Info, LogMessageSource.VoiceWebSocket, "Disconnected");
} }
return socket; return socket;
@@ -315,14 +315,15 @@ namespace Discord
if (checkVoice && _config.VoiceMode == DiscordVoiceMode.Disabled) if (checkVoice && _config.VoiceMode == DiscordVoiceMode.Disabled)
throw new InvalidOperationException("Voice is not enabled for this client."); throw new InvalidOperationException("Voice is not enabled for this client.");
} }
protected void RaiseEvent(string name, Action action) internal async Task RaiseEvent<T>(AsyncEvent<T> eventHandler, T eventArgs)
where T : EventArgs
{ {
try { action(); } try { await eventHandler.Invoke(this, eventArgs); }
catch (Exception ex) catch (Exception ex)
{ {
var ex2 = ex.GetBaseException(); var ex2 = ex.GetBaseException();
RaiseOnLog(LogMessageSeverity.Error, LogMessageSource.Client, await RaiseLogMessage(LogMessageSeverity.Error, LogMessageSource.Client,
$"{name}'s handler raised {ex2.GetType().Name}: ${ex2.Message}", ex); $"{eventHandler.Name}'s handler raised {ex2.GetType().Name}: ${ex2.Message}", ex);
} }
} }
@@ -351,7 +352,7 @@ namespace Discord
} }
catch (Exception ex) catch (Exception ex)
{ {
RaiseOnLog(LogMessageSeverity.Error, LogMessageSource.Client, $"Error handling {e.Type} event: {ex.GetBaseException().Message}"); await RaiseLogMessage(LogMessageSeverity.Error, LogMessageSource.Client, $"Error handling {e.Type} event: {ex.GetBaseException().Message}");
} }
} }
} }

85
src/Discord.Net/Helpers/AsyncEvent.cs Normal file
View File

@@ -0,0 +1,85 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace Discord
{
public delegate Task AsyncEventHandler<T>(object sender, T eventArgs);
public class AsyncEvent<T>
where T : EventArgs
{
private List<AsyncEventHandler<T>> _handlers;
private Dictionary<EventHandler<T>, AsyncEventHandler<T>> _mapping;
public bool Any { get; private set; }
public string Name { get; }
public AsyncEvent(string name)
{
Name = name;
_handlers = new List<AsyncEventHandler<T>>();
_mapping = new Dictionary<EventHandler<T>, AsyncEventHandler<T>>();
}
public void Add(AsyncEventHandler<T> handler)
{
lock (_handlers)
{
_handlers.Add(handler);
Any = true;
}
}
public void Add(EventHandler<T> handler)
{
lock (_handlers)
{
AsyncEventHandler<T> func = (s, e) =>
{
handler(s, e);
return TaskHelper.CompletedTask;
};
_mapping[handler] = func;
_handlers.Add(func);
Any = true;
}
}
public void Remove(AsyncEventHandler<T> handler)
{
lock (_handlers)
{
_handlers.Remove(handler);
Any = _handlers.Count != 0;
}
}
public void Remove(EventHandler<T> handler)
{
lock (_handlers)
{
AsyncEventHandler<T> func;
if (_mapping.TryGetValue(handler, out func))
{
_handlers.Remove(func);
_mapping.Remove(handler);
}
Any = _handlers.Count != 0;
}
}
public void Clear()
{
lock (_handlers)
{
_handlers.Clear();
_mapping.Clear();
Any = false;
}
}
public Task Invoke(object sender, T args)
{
return Task.WhenAll(_handlers.Select(x => x(sender, args)).ToArray());
}
}
}

4
src/Discord.Net/Helpers/TaskHelper.cs
View File

@@ -7,7 +7,11 @@ namespace Discord
public static Task CompletedTask { get; } public static Task CompletedTask { get; }
static TaskHelper() static TaskHelper()
{ {
#if DOTNET5_4
CompletedTask = Task.CompletedTask;
#else
CompletedTask = Task.Delay(0); CompletedTask = Task.Delay(0);
#endif
} }
} }
} }

6
src/Discord.Net/Net/WebSockets/DataWebSocket.cs
View File

@@ -72,7 +72,7 @@ namespace Discord.Net.WebSockets
catch (OperationCanceledException) { throw; } catch (OperationCanceledException) { throw; }
catch (Exception ex) catch (Exception ex)
{ {
RaiseOnLog(LogMessageSeverity.Error, $"Reconnect failed: {ex.GetBaseException().Message}"); RaiseLogMessage(LogMessageSeverity.Error, $"Reconnect failed: {ex.GetBaseException().Message}");
//Net is down? We can keep trying to reconnect until the user runs Disconnect() //Net is down? We can keep trying to reconnect until the user runs Disconnect()
await Task.Delay(_client.Config.FailedReconnectDelay, cancelToken).ConfigureAwait(false); await Task.Delay(_client.Config.FailedReconnectDelay, cancelToken).ConfigureAwait(false);
} }
@@ -117,14 +117,14 @@ namespace Discord.Net.WebSockets
{ {
Host = payload.Url; Host = payload.Url;
if (_logLevel >= LogMessageSeverity.Info) if (_logLevel >= LogMessageSeverity.Info)
RaiseOnLog(LogMessageSeverity.Info, "Redirected to " + payload.Url); RaiseLogMessage(LogMessageSeverity.Info, "Redirected to " + payload.Url);
await Redirect(payload.Url).ConfigureAwait(false); await Redirect(payload.Url).ConfigureAwait(false);
} }
} }
break; break;
default: default:
if (_logLevel >= LogMessageSeverity.Warning) if (_logLevel >= LogMessageSeverity.Warning)
RaiseOnLog(LogMessageSeverity.Warning, $"Unknown Opcode: {opCode}"); RaiseLogMessage(LogMessageSeverity.Warning, $"Unknown Opcode: {opCode}");
break; break;
} }
} }

8
src/Discord.Net/Net/WebSockets/VoiceWebSocket.cs
View File

@@ -107,7 +107,7 @@ namespace Discord.Net.WebSockets
catch (OperationCanceledException) { throw; } catch (OperationCanceledException) { throw; }
catch (Exception ex) catch (Exception ex)
{ {
RaiseOnLog(LogMessageSeverity.Error, $"Reconnect failed: {ex.GetBaseException().Message}"); RaiseLogMessage(LogMessageSeverity.Error, $"Reconnect failed: {ex.GetBaseException().Message}");
//Net is down? We can keep trying to reconnect until the user runs Disconnect() //Net is down? We can keep trying to reconnect until the user runs Disconnect()
await Task.Delay(_client.Config.FailedReconnectDelay, cancelToken).ConfigureAwait(false); await Task.Delay(_client.Config.FailedReconnectDelay, cancelToken).ConfigureAwait(false);
} }
@@ -282,7 +282,7 @@ namespace Discord.Net.WebSockets
} }
/*if (_logLevel >= LogMessageSeverity.Debug) /*if (_logLevel >= LogMessageSeverity.Debug)
RaiseOnLog(LogMessageSeverity.Debug, $"Received {buffer.Length - 12} bytes.");*/ RaiseLogMessage(LogMessageSeverity.Debug, $"Received {buffer.Length - 12} bytes.");*/
long userId; long userId;
if (_ssrcMapping.TryGetValue(ssrc, out userId)) if (_ssrcMapping.TryGetValue(ssrc, out userId))
@@ -404,7 +404,7 @@ namespace Discord.Net.WebSockets
} }
catch (SocketException ex) catch (SocketException ex)
{ {
RaiseOnLog(LogMessageSeverity.Error, "Failed to send UDP packet.", ex); RaiseLogMessage(LogMessageSeverity.Error, "Failed to send UDP packet.", ex);
} }
hasFrame = false; hasFrame = false;
} }
@@ -511,7 +511,7 @@ namespace Discord.Net.WebSockets
break; break;
default: default:
if (_logLevel >= LogMessageSeverity.Warning) if (_logLevel >= LogMessageSeverity.Warning)
RaiseOnLog(LogMessageSeverity.Warning, $"Unknown Opcode: {opCode}"); RaiseLogMessage(LogMessageSeverity.Warning, $"Unknown Opcode: {opCode}");
break; break;
} }
} }

2
src/Discord.Net/Net/WebSockets/WebSocket.Events.cs
View File

@@ -18,7 +18,7 @@ namespace Discord.Net.WebSockets
} }
public event EventHandler<LogMessageEventArgs> LogMessage; public event EventHandler<LogMessageEventArgs> LogMessage;
internal void RaiseOnLog(LogMessageSeverity severity, string message, Exception exception = null) internal void RaiseLogMessage(LogMessageSeverity severity, string message, Exception exception = null)
{ {
if (LogMessage != null) if (LogMessage != null)
LogMessage(this, new LogMessageEventArgs(severity, LogMessageSource.Unknown, message, exception)); LogMessage(this, new LogMessageEventArgs(severity, LogMessageSource.Unknown, message, exception));

4
src/Discord.Net/Net/WebSockets/WebSocket.cs
View File

@@ -204,7 +204,7 @@ namespace Discord.Net.WebSockets
protected virtual Task ProcessMessage(string json) protected virtual Task ProcessMessage(string json)
{ {
if (_logLevel >= LogMessageSeverity.Debug) if (_logLevel >= LogMessageSeverity.Debug)
RaiseOnLog(LogMessageSeverity.Debug, $"In: {json}"); RaiseLogMessage(LogMessageSeverity.Debug, $"In: {json}");
return TaskHelper.CompletedTask; return TaskHelper.CompletedTask;
} }
protected abstract object GetKeepAlive(); protected abstract object GetKeepAlive();
@@ -213,7 +213,7 @@ namespace Discord.Net.WebSockets
{ {
string json = JsonConvert.SerializeObject(message); string json = JsonConvert.SerializeObject(message);
if (_logLevel >= LogMessageSeverity.Debug) if (_logLevel >= LogMessageSeverity.Debug)
RaiseOnLog(LogMessageSeverity.Debug, $"Out: " + json); RaiseLogMessage(LogMessageSeverity.Debug, $"Out: " + json);
_engine.QueueMessage(json); _engine.QueueMessage(json);
} }

2
src/Discord.Net/Net/WebSockets/WebSocketSharpEngine.cs
View File

@@ -51,7 +51,7 @@ namespace Discord.Net.WebSockets
}; };
_webSocket.OnError += async (s, e) => _webSocket.OnError += async (s, e) =>
{ {
_parent.RaiseOnLog(LogMessageSeverity.Error, e.Exception?.GetBaseException()?.Message ?? e.Message); _parent.RaiseLogMessage(LogMessageSeverity.Error, e.Exception?.GetBaseException()?.Message ?? e.Message);
await _parent.DisconnectInternal(e.Exception, skipAwait: true).ConfigureAwait(false); await _parent.DisconnectInternal(e.Exception, skipAwait: true).ConfigureAwait(false);
}; };
_webSocket.OnClose += async (s, e) => _webSocket.OnClose += async (s, e) =>

4
test/Discord.Net.Tests/Tests.cs
View File

@@ -9,7 +9,7 @@ namespace Discord.Tests
{ {
//TODO: Tests are massively incomplete and out of date, needing a full rewrite //TODO: Tests are massively incomplete and out of date, needing a full rewrite
[TestClass] /*[TestClass]
public class Tests public class Tests
{ {
private const int EventTimeout = 5000; //Max time in milliseconds to wait for an event response from our test actions private const int EventTimeout = 5000; //Max time in milliseconds to wait for an event response from our test actions
@@ -167,5 +167,5 @@ namespace Discord.Tests
{ {
Task.WaitAll(tasks.Where(x => x != null).SelectMany(x => x).ToArray()); Task.WaitAll(tasks.Where(x => x != null).SelectMany(x => x).ToArray());
} }
} }*/
} }