Comparar texto

Encuentra la diferencia entre dos archivos de texto

Editor live

Ocultar espacios en blanco

Ocultar sin cambios

Sin ajuste de línea

Vista

Nivel de detalle

Estilos de texto

Resaltado de sintaxis

Diffchecker Desktop La forma más segura de usar Diffchecker. ¡Obtén la app de Diffchecker Desktop: tus diffs nunca salen de tu computadora!Obtener Desktop

Untitled Diff

Creado hace 5 añosEl diff nunca expira

3 eliminaciones

Líneas
Total
Eliminado

Caracteres
Total
Eliminado

Para continuar usando esta función, actualice a Diffchecker Pro Ver precios

201 líneas

22 adiciones

Líneas
Total
Añadido

Caracteres
Total
Añadido

Para continuar usando esta función, actualice a Diffchecker Pro Ver precios

208 líneas

* 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));

}

Diferencias guardadas

Texto original

Abrir archivo

/*
 *  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));
        }
    }
}

Texto modificado

Abrir archivo

/*
 *  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));
        }
    }
}