How do IDisposable and IAsyncDisposable both work together?

Question

The class below is not sealed, which means it is considered inheritable. I took IDisposable/IAsyncDisposable implementation from here and I'm trying to understand why the .Dispose calls are duplicated in both Dispose and DisposeAsync. Will someone be able to explain to me how it works more deeply/or I would say low level, so I actually know how to use it in future?

public class Client : IDisposable, IAsyncDisposable
{
    private readonly ILogger<Client> _logger;
    private readonly Channel<string> _outputChannel;
    private ClientWebSocket? _clientWebSocket;
    private CancellationTokenSource? _cancellationSource;
    private Task _receiving = Task.CompletedTask;
    private Task _sending = Task.CompletedTask;

    public Client(ILoggerFactory? loggerFactory = default)
    {
        _logger = (loggerFactory ?? NullLoggerFactory.Instance).CreateLogger<Client>();
    }

    public bool IsDisposed { get; protected set; }

    ...

    /// <summary>
    ///     Checks if this object has been disposed.
    /// </summary>
    /// <exception cref="ObjectDisposedException">Thrown if the object has been disposed.</exception>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    protected void DoDisposeChecks()
    {
        if (IsDisposed)
        {
            throw new ObjectDisposedException(nameof(Client));
        }
    }

    /// <summary>
    ///     Disposes of managed and unmanaged resources.
    /// </summary>
    /// <param name="disposeManaged">A value indicating whether or not to dispose of managed resources.</param>
    protected virtual void Dispose(bool disposeManaged)
    {
        if (IsDisposed)
        {
            return;
        }

        if (disposeManaged)
        {
            _logger.LogDebug("Socket {Id} is disposing", Id);

            _clientWebSocket?.Dispose();
            _cancellationSource?.Dispose();

            _outputChannel.Writer.TryComplete();

            _logger.LogDebug("Socket {Id} disposed", Id);
        }

        IsDisposed = true;
    }

    /// <summary>
    ///     Asynchronously disposes of managed resources.
    /// </summary>
    /// <returns>A task representing the asynchronous operation.</returns>
    protected virtual ValueTask DisposeAsyncCore()
    {
        if (IsDisposed)
        {
            return default;
        }

        _logger.LogDebug("Socket {Id} is disposing", Id);

        _clientWebSocket?.Dispose();
        _cancellationSource?.Dispose();

        _outputChannel.Writer.TryComplete();

        _logger.LogDebug("Socket {Id} disposed", Id);

        IsDisposed = true;

        return default;
    }

    /// <inheritdoc />
    public async ValueTask DisposeAsync()
    {
        await DisposeAsyncCore().ConfigureAwait(false);
        Dispose(false);
        GC.SuppressFinalize(this);
    }

    /// <inheritdoc />
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
}