How to use Dispose method of PuppeteerSharp.Helpers.TempDirectory class

1using System;
2using System.IO;
3using System.Threading;
4using System.Threading.Tasks;
5using PathHelper = System.IO.Path;
6
7namespace PuppeteerSharp.Helpers
8{
9    /// <summary>
10    /// Represents a directory that is deleted on disposal.
11    /// </summary>
12    internal class TempDirectory : IDisposable
13    {
14        private Task _deleteTask;
15
16        public TempDirectory()
17            : this(PathHelper.Combine(PathHelper.GetTempPath(), PathHelper.GetRandomFileName()))
18        { }
19
20        public TempDirectory(string path)
21        {
22            if (string.IsNullOrEmpty(path))
23            {
24                throw new ArgumentException("Path must be specified", nameof(path));
25            }
26
27            Directory.CreateDirectory(path);
28            this.Path = path;
29        }
30
31        ~TempDirectory()
32        {
33            Dispose(false);
34        }
35
36        public string Path { get; }
37
38        public void Dispose()
39        {
40            GC.SuppressFinalize(this);
41            Dispose(true);
42        }
43
44        protected void Dispose(bool disposing)
45        {
46            if (_deleteTask == null)
47            {
48                _ = DeleteAsync();
49            }
50        }
51
52        public override string ToString() => Path;
53
54        public Task DeleteAsync(CancellationToken cancellationToken = default)
55            => _deleteTask ?? (_deleteTask = DeleteAsync(Path, CancellationToken.None));
56
57        private static async Task DeleteAsync(string path, CancellationToken cancellationToken = default)
58        {
59            const int minDelayInMsec = 200;
60            const int maxDelayInMsec = 8000;
61
62            var retryDelay = minDelayInMsec;
63            while (true)
64            {
65                if (!Directory.Exists(path))
66                {
67                    return;
68                }
69
70                cancellationToken.ThrowIfCancellationRequested();
71                try
72                {
73                    Directory.Delete(path, true);
74                    return;
75                }
76                catch
77                {
78                    await Task.Delay(retryDelay, cancellationToken).ConfigureAwait(false);
79                    if (retryDelay < maxDelayInMsec)
80                    {
81                        retryDelay = Math.Min(2 * retryDelay, maxDelayInMsec);
82                    }
83                }
84            }
85        }
86    }
87}
88

Source: TempDirectory.cs

using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using PathHelper = System.IO.Path;

namespace PuppeteerSharp.Helpers
{
    /// <summary>
    /// Represents a directory that is deleted on disposal.
    /// </summary>
    internal class TempDirectory : IDisposable
    {
        private Task _deleteTask;

        public TempDirectory()
            : this(PathHelper.Combine(PathHelper.GetTempPath(), PathHelper.GetRandomFileName()))
        { }

        public TempDirectory(string path)
        {
            if (string.IsNullOrEmpty(path))
            {
                throw new ArgumentException("Path must be specified", nameof(path));
            }

            Directory.CreateDirectory(path);
            this.Path = path;
        }

        ~TempDirectory()
        {
            Dispose(false);
        }

        public string Path { get; }

        public void Dispose()
        {
            GC.SuppressFinalize(this);
            Dispose(true);
        }

        protected void Dispose(bool disposing)
        {
            if (_deleteTask == null)
            {
                _ = DeleteAsync();
            }
        }

        public override string ToString() => Path;

        public Task DeleteAsync(CancellationToken cancellationToken = default)
            => _deleteTask ?? (_deleteTask = DeleteAsync(Path, CancellationToken.None));

        private static async Task DeleteAsync(string path, CancellationToken cancellationToken = default)
        {
            const int minDelayInMsec = 200;
            const int maxDelayInMsec = 8000;

            var retryDelay = minDelayInMsec;
            while (true)
            {
                if (!Directory.Exists(path))
                {
                    return;
                }

                cancellationToken.ThrowIfCancellationRequested();
                try
                {
                    Directory.Delete(path, true);
                    return;
                }
                catch
                {
                    await Task.Delay(retryDelay, cancellationToken).ConfigureAwait(false);
                    if (retryDelay < maxDelayInMsec)
                    {
                        retryDelay = Math.Min(2 * retryDelay, maxDelayInMsec);
                    }
                }
            }
        }
    }
}