Coding Faster With dotNetTips Spargine - September 2021 Release

var cipherText = EncryptionHelper.SimpleEncrypt("TestString", "TestKey");
var plainText = EncryptionHelper.SimpleDecrypt(cipherText, "TestKey");

AesEncrypt(string plainText, byte[] key, byte[] iv)
AesDecrypt(string cipherText, byte[] key, byte[] iv)

var list = Singleton<ObservableList<string>>.Instance;

private async Task Fire(string input) 
{
    this._fireResult = input;
    Console.WriteLine(input);
    await Task.Delay(1);
}

private async Task < string > FireWithReturn(string input) 
{
    this._fireResult = input;
    Console.WriteLine(input);
    await Task.Delay(1);
    return input;
}

#1
TaskHelper.RunSync(() => this.Fire("Test Message"));

#2
var cancelToken = new CancellationTokenSource().Token;
TaskHelper.RunSync(() => this.Fire("Test Message", cancellationToken: cancelToken);

#3
TaskHelper.RunSync(() => this.FireWithReturn("Test Message"));

#4
var cancelToken = new CancellationTokenSource().Token;
TaskHelper.RunSync(() => this.FireWithReturn("Test Message"), cancellationToken: cancelToken);

With some of these methods, you can also use TaskCreationOptions, TaskContinutationOptions, and TaskScheduler.

Recommendation to API Developers

My recommendation to API developers is that unless .NET goes 100% async (like some languages are), then please also provide a synchronous version of the methods too.

Fire and Forget Async Methods

In the same article by Rick Strahl, he showed a great way to fire and forget async methods. I’ve wanted something like this for a long time. The code that I added to TaskExtensions in Core is very simple to use and I test it with the same Fire() method.

#1
this.Fire("Test Message").FireAndForget();

#2
Action<Exception> exAction = (Exception ex) => Debug.WriteLine(ex.Message);
this.Fire("Test Message").FireAndForget(exAction);

Safely Searching a Directory

One issue with the methods in .NET to search for files is that if you choose SearchOption.AllDirectories and the user does not have access to even one of the sub-directories, the entire call will fail. For me, I just want it to ignore the errors and keep processing. I’ve added a new method called SafeDirectoryContainsAny() method in the DirectoryHelper class that returns a list of directories that contains any files from the search patterns.

Here is an example of how to use it.

var searchFolders = new List < DirectoryInfo > ();
searchFolders.Add(new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.CommonProgramFiles)));
searchFolders.Add(new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.MyMusic)));
searchFolders.Add(new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)));
searchFolders.Add(new DirectoryInfo(Environment.GetEnvironmentVariable(EnvironmentKey.TEMP.ToString())));
var directories = new List < DirectoryInfo > ();

foreach(var directory in searchFolders) 
{
    if (DirectoryHelper.SafeDirectoryContainsAny(directory, SearchOption.AllDirectories, "*.txt", "*.tmp", "*.doc", "*.docx", "*.dll")) 
    {
        directories.Add(directory);
    }
}

How to Create a Thread-Safe Queue

Back in version 4 of the .NET Framework, the team added a thread-safe queue (FIFO) called ConcurrentQueue. In .NET Core 3, they added another new class that can also be used as a thread-safe FIFO queue called Channel. Thinking of performance, I wondered which one would be faster. So, in the Core assembly, I created a new type called ChannelQueue. Its methods and properties are:

• Count(): Retrieves the current number of items in the queue.
• ListenAsync(): Listens for new items added to the queue.
• Lock(): Locks the queue so no more items can be added. This must be called to complete ListenAsync().
• ReadAsync(): Reads a single item from the queue.
• WriteAsync(): Add an item or an entire collection to the queue.

Example

Here is how to use the method read and write methods.

var queue = new ChannelQueue < PersonProper > ();
var people = RandomData.GeneratePersonCollection < PersonProper > (100);
var token = CancellationToken.None;

/// Write
foreach(var person in people) 
{
    await queue.WriteAsync(person, token);
}

/// Read
do 
{
    var item = await queue.ReadAsync(token);
} while (queue.Count > 0);

Benchmark Results

I found the benchmark results for these two types of queues interesting. These are the results of adding an item to the queue.

As you can see, adding an item to the ConcurrentQueue is much, much fast than adding an item to the ChannelQueue. This test did not include two threads adding items to the queue at the same time. I wanted to test two threads retrieving items from the queues. Those results are below.

The benchmark results show that reading items from the queues by using two threads is close to the same performance.

Even More New Code

Here are some more new methods added to this release:

• PickRandom<T>() for ReadOnlySpan<T>.
• BytesToString() for ReadOnlySpan<byte>.
• IsAsciiDigit() in StringExtensions.
• IsAsciiWhitespace() in StringExtensions.
• TryValidateParam() for ReadOnlySpan<T> in Validate.
• TryValidateParam() for Span<T> in Validate.

Breaking Changes

I noticed that the custom collection types in Spargine, were in the dotNetTips.Spargine.5 project, but they really should be in the dotNetTips.Spargine.Core assembly for greater reuse, so I moved them. Those classes are,

• ConcurrentHashSet
• DistinctConcurrentBag
• FastSortedList
• ObservableList
• DistinctBlockingCollection

Summary

I hope you will check out these methods or any of the others in the assemblies. I am also looking for contributors to these .NET 5 projects. If you have any comments or suggestions, please comment below.