Texte vergleichen

Finden Sie den Unterschied zwischen zwei Textdateien

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Onlinewerkzeuge

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

Untitled Diff

Created 4 years agoDiff never expires

Lines
Total
Removed

Words
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

201 lines

Lines
Total
Added

Words
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

208 lines

* File: DiscordClientWrapper.cs

* File: DiscordShardedClientWrapper.cs

* Author: Angelo Breuer

* The MIT License (MIT)

* Copyright (c) Angelo Breuer 2020

* Copyright (c) Angelo Breuer 2021

* Permission is hereby granted, free of charge, to any person obtaining a copy

* of this software and associated documentation files (the "Software"), to deal

* in the Software without restriction, including without limitation the rights

* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

* copies of the Software, and to permit persons to whom the Software is

* furnished to do so, subject to the following conditions:

* The above copyright notice and this permission notice shall be included in

* all copies or substantial portions of the Software.

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

* THE SOFTWARE.

namespace Lavalink4NET.DSharpPlus

{

using System;

using System.Collections.Generic;

using System.Linq;

using System.Threading.Tasks;

using global::DSharpPlus;

using global::DSharpPlus.EventArgs;

using Lavalink4NET.Events;

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

/// <summary>

/// A wrapper for the discord client from the "DSharpPlus" discord client library. (https://github.com/DSharpPlus/DSharpPlus)

/// A wrapper for the discord sharded client from the "DSharpPlus" discord client library. (https://github.com/DSharpPlus/DSharpPlus)

/// </summary>

public sealed class DiscordClientWrapper : IDiscordClientWrapper, IDisposable

public sealed class DiscordShardedClientWrapper : IDiscordClientWrapper, IDisposable

{

private readonly DiscordClient _client;

private readonly DiscordShardedClient _client;

private bool _disposed;

/// <summary>

/// Initializes a new instance of the <see cref="DiscordClientWrapper"/> class.

/// </summary>

/// <param name="client">the sharded discord client</param>

/// <exception cref="ArgumentNullException">

/// thrown if the specified <paramref name="client"/> is <see langword="null"/>.

/// </exception>

public DiscordClientWrapper(DiscordClient client)

public DiscordShardedClientWrapper(DiscordShardedClient client)

{

_client = client ?? throw new ArgumentNullException(nameof(client));

_client.VoiceStateUpdated += OnVoiceStateUpdated;

_client.VoiceServerUpdated += OnVoiceServerUpdated;

}

/// <inheritdoc/>

public event AsyncEventHandler<VoiceServer>? VoiceServerUpdated;

/// <inheritdoc/>

public event AsyncEventHandler<Events.VoiceStateUpdateEventArgs>? VoiceStateUpdated;

/// <inheritdoc/>

public ulong CurrentUserId

{

get

{

EnsureNotDisposed();

return _client.CurrentUser.Id;

}

/// <inheritdoc/>

public int ShardCount

{

get

{

EnsureNotDisposed();

return _client.ShardCount;

return _client.ShardClients.Count;

}

/// <inheritdoc/>

public void Dispose()

{

if (_disposed)

{

return;

}

_disposed = true;

_client.VoiceStateUpdated -= OnVoiceStateUpdated;

_client.VoiceServerUpdated -= OnVoiceServerUpdated;

}

/// <inheritdoc/>

/// <exception cref="ObjectDisposedException">thrown if the instance is disposed</exception>

public async Task<IEnumerable<ulong>> GetChannelUsersAsync(ulong guildId, ulong voiceChannelId)

{

EnsureNotDisposed();

var guild = await _client.GetGuildAsync(guildId)

var shard = _client.GetShard(guildId)

?? throw new InvalidOperationException("Shard is not served by this client.");

var guild = await shard.GetGuildAsync(guildId).ConfigureAwait(false)

?? throw new ArgumentException("Invalid or inaccessible guild: " + guildId, nameof(guildId));

var channel = guild.GetChannel(voiceChannelId)

?? throw new ArgumentException("Invalid or inaccessible voice channel: " + voiceChannelId, nameof(voiceChannelId));

return channel.Users.Select(s => s.Id);

}

/// <inheritdoc/>

/// <exception cref="ObjectDisposedException">thrown if the instance is disposed</exception>

public async Task InitializeAsync()

{

EnsureNotDisposed();

var startTime = DateTimeOffset.UtcNow;

// await until current user arrived

while (_client.CurrentUser is null)

{

await Task.Delay(10);

await Task.Delay(10).ConfigureAwait(false);

// timeout exceeded

if (DateTimeOffset.UtcNow - startTime > TimeSpan.FromSeconds(10))

{

throw new TimeoutException("Waited 10 seconds for current user to arrive! Make sure you start " +

"the discord client, before initializing the discord wrapper!");

}

/// <inheritdoc/>

/// <exception cref="ObjectDisposedException">thrown if the instance is disposed</exception>

public async Task SendVoiceUpdateAsync(ulong guildId, ulong? voiceChannelId, bool selfDeaf = false, bool selfMute = false)

{

EnsureNotDisposed();

var payload = new JObject();

var data = new VoiceStateUpdatePayload(guildId, voiceChannelId, selfMute, selfDeaf);

payload.Add("op", 4);

payload.Add("d", JObject.FromObject(data));

var message = JsonConvert.SerializeObject(payload, Formatting.None);

await _client.GetWebSocketClient().SendMessageAsync(message);

var shard = _client.GetShard(guildId)

?? throw new InvalidOperationException("Shard is not served by this client.");

await shard.GetWebSocketClient().SendMessageAsync(message).ConfigureAwait(false);

}

/// <summary>

/// Throws an <see cref="ObjectDisposedException"/> if the <see

/// cref="DiscordClientWrapper"/> is disposed.

/// </summary>

/// <exception cref="ObjectDisposedException">thrown if the instance is disposed</exception>

private void EnsureNotDisposed()

{

if (_disposed)

{

throw new ObjectDisposedException(nameof(DiscordClientWrapper));

}

/// <inheritdoc/>

/// <exception cref="ObjectDisposedException">thrown if the instance is disposed</exception>

private Task OnVoiceServerUpdated(DiscordClient _, VoiceServerUpdateEventArgs voiceServer)

{

EnsureNotDisposed();

var args = new VoiceServer(voiceServer.Guild.Id, voiceServer.GetVoiceToken(), voiceServer.Endpoint);

return VoiceServerUpdated.InvokeAsync(this, args);

}

/// <inheritdoc/>

/// <exception cref="ObjectDisposedException">thrown if the instance is disposed</exception>

private Task OnVoiceStateUpdated(DiscordClient _, global::DSharpPlus.EventArgs.VoiceStateUpdateEventArgs eventArgs)

{

EnsureNotDisposed();

// session id is the same as the resume key so DSharpPlus should be able to give us the

// session key in either before or after voice state

var sessionId = eventArgs.Before?.GetSessionId() ?? eventArgs.After.GetSessionId();

// create voice state

var voiceState = new VoiceState(

voiceChannelId: eventArgs.After?.Channel?.Id,

guildId: eventArgs.Guild.Id,

voiceSessionId: sessionId);

// invoke event

return VoiceStateUpdated.InvokeAsync(this,

new Events.VoiceStateUpdateEventArgs(eventArgs.User.Id, voiceState));

}

Gespeicherten Diffs

Original text

Datei öffnen

/*
 *  File:   DiscordClientWrapper.cs
 *  Author: Angelo Breuer
 *
 *  The MIT License (MIT)
 *
 *  Copyright (c) Angelo Breuer 2020
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
 *  in the Software without restriction, including without limitation the rights
 *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 *  copies of the Software, and to permit persons to whom the Software is
 *  furnished to do so, subject to the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included in
 *  all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 *  THE SOFTWARE.
 */

namespace Lavalink4NET.DSharpPlus
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Threading.Tasks;
    using global::DSharpPlus;
    using global::DSharpPlus.EventArgs;
    using Lavalink4NET.Events;
    using Newtonsoft.Json;
    using Newtonsoft.Json.Linq;

/// <summary>
    ///     A wrapper for the discord client from the "DSharpPlus" discord client library. (https://github.com/DSharpPlus/DSharpPlus)
    /// </summary>
    public sealed class DiscordClientWrapper : IDiscordClientWrapper, IDisposable
    {
        private readonly DiscordClient _client;
        private bool _disposed;

/// <summary>
        ///     Initializes a new instance of the <see cref="DiscordClientWrapper"/> class.
        /// </summary>
        /// <param name="client">the sharded discord client</param>
        /// <exception cref="ArgumentNullException">
        ///     thrown if the specified <paramref name="client"/> is <see langword="null"/>.
        /// </exception>
        public DiscordClientWrapper(DiscordClient client)
        {
            _client = client ?? throw new ArgumentNullException(nameof(client));

_client.VoiceStateUpdated += OnVoiceStateUpdated;
            _client.VoiceServerUpdated += OnVoiceServerUpdated;
        }

/// <inheritdoc/>
        public event AsyncEventHandler<VoiceServer>? VoiceServerUpdated;

/// <inheritdoc/>
        public event AsyncEventHandler<Events.VoiceStateUpdateEventArgs>? VoiceStateUpdated;

/// <inheritdoc/>
        public ulong CurrentUserId
        {
            get
            {
                EnsureNotDisposed();
                return _client.CurrentUser.Id;
            }
        }

/// <inheritdoc/>
        public int ShardCount
        {
            get
            {
                EnsureNotDisposed();
                return _client.ShardCount;
            }
        }

/// <inheritdoc/>
        public void Dispose()
        {
            if (_disposed)
            {
                return;
            }

_disposed = true;

_client.VoiceStateUpdated -= OnVoiceStateUpdated;
            _client.VoiceServerUpdated -= OnVoiceServerUpdated;
        }

/// <inheritdoc/>
        /// <exception cref="ObjectDisposedException">thrown if the instance is disposed</exception>
        public async Task<IEnumerable<ulong>> GetChannelUsersAsync(ulong guildId, ulong voiceChannelId)
        {
            EnsureNotDisposed();

var guild = await _client.GetGuildAsync(guildId)
                ?? throw new ArgumentException("Invalid or inaccessible guild: " + guildId, nameof(guildId));

var channel = guild.GetChannel(voiceChannelId)
                ?? throw new ArgumentException("Invalid or inaccessible voice channel: " + voiceChannelId, nameof(voiceChannelId));

return channel.Users.Select(s => s.Id);
        }

/// <inheritdoc/>
        /// <exception cref="ObjectDisposedException">thrown if the instance is disposed</exception>
        public async Task InitializeAsync()
        {
            EnsureNotDisposed();

var startTime = DateTimeOffset.UtcNow;

// await until current user arrived
            while (_client.CurrentUser is null)
            {
                await Task.Delay(10);

// timeout exceeded
                if (DateTimeOffset.UtcNow - startTime > TimeSpan.FromSeconds(10))
                {
                    throw new TimeoutException("Waited 10 seconds for current user to arrive! Make sure you start " +
                        "the discord client, before initializing the discord wrapper!");
                }
            }
        }

/// <inheritdoc/>
        /// <exception cref="ObjectDisposedException">thrown if the instance is disposed</exception>
        public async Task SendVoiceUpdateAsync(ulong guildId, ulong? voiceChannelId, bool selfDeaf = false, bool selfMute = false)
        {
            EnsureNotDisposed();

var payload = new JObject();
            var data = new VoiceStateUpdatePayload(guildId, voiceChannelId, selfMute, selfDeaf);

payload.Add("op", 4);
            payload.Add("d", JObject.FromObject(data));

var message = JsonConvert.SerializeObject(payload, Formatting.None);
            await _client.GetWebSocketClient().SendMessageAsync(message);
        }

/// <summary>
        ///     Throws an <see cref="ObjectDisposedException"/> if the <see
        ///     cref="DiscordClientWrapper"/> is disposed.
        /// </summary>
        /// <exception cref="ObjectDisposedException">thrown if the instance is disposed</exception>
        private void EnsureNotDisposed()
        {
            if (_disposed)
            {
                throw new ObjectDisposedException(nameof(DiscordClientWrapper));
            }
        }

/// <inheritdoc/>
        /// <exception cref="ObjectDisposedException">thrown if the instance is disposed</exception>
        private Task OnVoiceServerUpdated(DiscordClient _, VoiceServerUpdateEventArgs voiceServer)
        {
            EnsureNotDisposed();

var args = new VoiceServer(voiceServer.Guild.Id, voiceServer.GetVoiceToken(), voiceServer.Endpoint);
            return VoiceServerUpdated.InvokeAsync(this, args);
        }

/// <inheritdoc/>
        /// <exception cref="ObjectDisposedException">thrown if the instance is disposed</exception>
        private Task OnVoiceStateUpdated(DiscordClient _, global::DSharpPlus.EventArgs.VoiceStateUpdateEventArgs eventArgs)
        {
            EnsureNotDisposed();

// session id is the same as the resume key so DSharpPlus should be able to give us the
            // session key in either before or after voice state
            var sessionId = eventArgs.Before?.GetSessionId() ?? eventArgs.After.GetSessionId();

// create voice state
            var voiceState = new VoiceState(
                voiceChannelId: eventArgs.After?.Channel?.Id,
                guildId: eventArgs.Guild.Id,
                voiceSessionId: sessionId);

// invoke event
            return VoiceStateUpdated.InvokeAsync(this,
                new Events.VoiceStateUpdateEventArgs(eventArgs.User.Id, voiceState));
        }
    }
}

Geänderter text

Datei öffnen

/*
 *  File:   DiscordShardedClientWrapper.cs
 *  Author: Angelo Breuer
 *
 *  The MIT License (MIT)
 *
 *  Copyright (c) Angelo Breuer 2021
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
 *  in the Software without restriction, including without limitation the rights
 *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 *  copies of the Software, and to permit persons to whom the Software is
 *  furnished to do so, subject to the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included in
 *  all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 *  THE SOFTWARE.
 */

/// <summary>
    ///     A wrapper for the discord sharded client from the "DSharpPlus" discord client library. (https://github.com/DSharpPlus/DSharpPlus)
    /// </summary>
    public sealed class DiscordShardedClientWrapper : IDiscordClientWrapper, IDisposable
    {
        private readonly DiscordShardedClient _client;
        private bool _disposed;

/// <summary>
        ///     Initializes a new instance of the <see cref="DiscordClientWrapper"/> class.
        /// </summary>
        /// <param name="client">the sharded discord client</param>
        /// <exception cref="ArgumentNullException">
        ///     thrown if the specified <paramref name="client"/> is <see langword="null"/>.
        /// </exception>
        public DiscordShardedClientWrapper(DiscordShardedClient client)
        {
            _client = client ?? throw new ArgumentNullException(nameof(client));

_client.VoiceStateUpdated += OnVoiceStateUpdated;
            _client.VoiceServerUpdated += OnVoiceServerUpdated;
        }

/// <inheritdoc/>
        public event AsyncEventHandler<VoiceServer>? VoiceServerUpdated;

/// <inheritdoc/>
        public event AsyncEventHandler<Events.VoiceStateUpdateEventArgs>? VoiceStateUpdated;

/// <inheritdoc/>
        public int ShardCount
        {
            get
            {
                EnsureNotDisposed();
                return _client.ShardClients.Count;
            }
        }

/// <inheritdoc/>
        public void Dispose()
        {
            if (_disposed)
            {
                return;
            }

_disposed = true;

_client.VoiceStateUpdated -= OnVoiceStateUpdated;
            _client.VoiceServerUpdated -= OnVoiceServerUpdated;
        }

var shard = _client.GetShard(guildId)
                ?? throw new InvalidOperationException("Shard is not served by this client.");

var guild = await shard.GetGuildAsync(guildId).ConfigureAwait(false)
                ?? throw new ArgumentException("Invalid or inaccessible guild: " + guildId, nameof(guildId));

var channel = guild.GetChannel(voiceChannelId)
                ?? throw new ArgumentException("Invalid or inaccessible voice channel: " + voiceChannelId, nameof(voiceChannelId));

return channel.Users.Select(s => s.Id);
        }

var startTime = DateTimeOffset.UtcNow;

// await until current user arrived
            while (_client.CurrentUser is null)
            {
                await Task.Delay(10).ConfigureAwait(false);

var payload = new JObject();
            var data = new VoiceStateUpdatePayload(guildId, voiceChannelId, selfMute, selfDeaf);

payload.Add("op", 4);
            payload.Add("d", JObject.FromObject(data));

var message = JsonConvert.SerializeObject(payload, Formatting.None);

var shard = _client.GetShard(guildId)
                ?? throw new InvalidOperationException("Shard is not served by this client.");

await shard.GetWebSocketClient().SendMessageAsync(message).ConfigureAwait(false);
        }

var args = new VoiceServer(voiceServer.Guild.Id, voiceServer.GetVoiceToken(), voiceServer.Endpoint);
            return VoiceServerUpdated.InvokeAsync(this, args);
        }

// invoke event
            return VoiceStateUpdated.InvokeAsync(this,
                new Events.VoiceStateUpdateEventArgs(eventArgs.User.Id, voiceState));
        }
    }
}