使用 Newtonsoft.Json 和 System.Text.Json 与 C# 和 VB 反序列化 Json 流

await using (Stream stream = File.OpenRead(filename))
{
    // do work here...
}

Using stream As Stream = File.OpenRead(filename)

    ' do work here...
    
End Using

await using (Stream httpStream = await new HttpClient().GetStreamAsync(this._url)
    .ConfigureAwait(false))
{
    // do work here...
}

Using stream = Await New HttpClient().GetStreamAsync(_url).ConfigureAwait(false)

    ' do work here...
    
End Using

using TextReader textReader = new StreamReader(stream);
using JsonReader jsonReader = new JsonTextReader(textReader);

// pass the reader and file stream 
await using (stream.ConfigureAwait(false))
{
    // do work here...
}

' set up the stream readers
Using textReader As TextReader = New StreamReader(stream)
    Using jsonReader As JsonReader = New JsonTextReader(textReader)

        ' do work here...
    
    End Using
End Using

using Newtonsoft.Json;

this._jsonSerializerSettings = new();
this._serializer = JsonSerializer.Create(this._jsonSerializerSettings);

// open the _file as a stream
await using Stream stream = File.OpenRead(filename);

// set up the stream readers
using TextReader textReader = new StreamReader(stream);
using JsonReader jsonReader = new JsonTextReader(textReader);

await using (stream.ConfigureAwait(false))
{
    // move to the start of the array and read the stream
    await jsonReader.ReadAsync().ConfigureAwait(false);
 
    while (await jsonReader.ReadAsync().ConfigureAwait(false) &&
           jsonReader.TokenType != JsonToken.EndArray)
    {
        Contact? contact = this._serializer!.Deserialize<Contact>(jsonReader);
        Process(contact!);
    }
}

Imports Newtonsoft.Json

_jsonSerializerSettings = New JsonSerializerSettings()
_serializer = JsonSerializer.Create(_jsonSerializerSettings)

' open the _file as a stream
Using stream As Stream = File.OpenRead(filename)

    ' set up the stream readers
    Using textReader As TextReader = New StreamReader(stream)
        Using jsonReader As JsonReader = New JsonTextReader(textReader)

            ' move to the start of the array and read the stream
            Await jsonReader.ReadAsync().ConfigureAwait(False)

            While Await jsonReader.ReadAsync().ConfigureAwait(False) AndAlso
                  jsonReader.TokenType <> JsonToken.EndArray

                Dim contact = _serializer.Deserialize(Of Contact)(jsonReader)
                Process(contact)

            End While

        End Using
    End Using

End Using

private void Process(Contact? item)
{
    // process and store the data model
    this._count++;
}

Private Sub Process(item As Contact)

    ' process and store the data model
    _count += 1

End Sub

using Common.Helpers;
using Contacts.NewtonSoft.Json.Models;
using Newtonsoft.Json;

internal class Program
{
    #region Fields

    private readonly IFilePathHelper _fileHelper = new FilePathHelper("Resources");

    private JsonSerializer? _serializer;
    private JsonSerializerSettings? _jsonSerializerSettings;

    private int _count;
    private readonly string _file = "Mock_Contacts1.json";

    #endregion

    #region Methods

    private static async Task Main()
        => await new Program().Execute().ConfigureAwait(false);

    private async Task Execute()
    {
        Console.WriteLine($"Reading {this._file}");

        this._jsonSerializerSettings = new();
        this._serializer = JsonSerializer.Create(this._jsonSerializerSettings);

        // open the _file as a stream
        await using FileStream stream = 
              File.OpenRead(this._fileHelper.Resolve(this._file));

        Console.WriteLine($"Processing: {this._file}");

        // set up the stream readers
        using TextReader textReader = new StreamReader(stream);
        using JsonReader jsonReader = new JsonTextReader(textReader);

        await using (stream.ConfigureAwait(false))
        {
            // move to start of first object
            await jsonReader.ReadAsync().ConfigureAwait(false);
            
            while (await jsonReader.ReadAsync().ConfigureAwait(false) &&
                   jsonReader.TokenType != JsonToken.EndArray)
            {
                Contact? contact = this._serializer!.Deserialize<Contact>(jsonReader);
                Process(contact!);
            }
        }

        // report results
        Console.WriteLine($"Contacts: {this._count:N0}");
        Console.WriteLine("Finished");
    }

    private void Process(Contact? item)
    {
        // process and store the data model
        this._count++;
    }

    #endregion
}

Imports System.IO
Imports Common.Helpers
Imports Newtonsoft.Json
Imports NewtonsoftContact.Models

Module Program

#Region "Fields"

    Private ReadOnly _fileHelper As FilePathHelper = New FilePathHelper("Resources")

    Private _serializer As JsonSerializer
    Private _jsonSerializerSettings As JsonSerializerSettings

    Private _count As Integer
    Private ReadOnly _file As String = "Mock_Contacts1.json"

#End Region

#Region "Methods"

    Sub Main(args As String())
        Console.WriteLine($"Reading {_file}")
        ExecuteAsync(args).GetAwaiter.GetResult()
        Console.WriteLine("Finished")
    End Sub

    Private Async Function ExecuteAsync(args As String()) As Task

        _jsonSerializerSettings = New JsonSerializerSettings()
        _serializer = JsonSerializer.Create(_jsonSerializerSettings)

        ' open the _file as a stream
        Using stream As Stream = File.OpenRead(_fileHelper.Resolve(_file))

            ' set up the stream readers
            Using textReader As TextReader = New StreamReader(stream)
                Using jsonReader As JsonReader = New JsonTextReader(textReader)

                    ' move to the start of the array and read the stream
                    Await jsonReader.ReadAsync().ConfigureAwait(False)

                    While Await jsonReader.ReadAsync().ConfigureAwait(False) AndAlso
                          jsonReader.TokenType <> JsonToken.EndArray

                        Dim contact = _serializer.Deserialize(Of Contact)(jsonReader)
                        Process(contact)

                    End While

                End Using
            End Using

        End Using

        ' report results
        Console.WriteLine($"Contacts: {_count:N0}")

    End Function

    Private Sub Process(item As Contact)

        ' process and store the data model
        _count += 1

    End Sub

#End Region

End Module

using Common.Settings;
using Contacts.NewtonSoft.Json.Models;
using Newtonsoft.Json;

internal class Program
{
    #region Fields

    private JsonSerializer? _serializer;
    private JsonSerializerSettings? _jsonSerializerSettings;

    private int _count;
    private string _url = "https://{0}/download/MOCK1";

    #endregion

    #region Methods

    private static async Task Main()
        => await new Program().Execute().ConfigureAwait(false);

    private async Task Execute()
    {
        // point to the correct host URL in appsettings.json file
        this._url = this._url.Build();

        // initialize the serializer
        this._jsonSerializerSettings = new();
        this._serializer = JsonSerializer.Create(this._jsonSerializerSettings);

        // open the stream
        Console.WriteLine($"Connecting to stream: {this._url}");

        Stream? stream;

        try
        {
            stream = await new HttpClient().GetStreamAsync(this._url);
        }
        catch (Exception)
        {
            Console.WriteLine($"Failed to open stream {this._url}. 
            Please check that the remote server is active.");
            return;
        }

        if (stream is null)
        {
            Console.WriteLine($"Failed to open stream {this._url}");
            return;
        }

        Console.WriteLine($"Processing: {this._url}");

        // set up the stream readers
        using TextReader textReader = new StreamReader(stream);
        using JsonReader jsonReader = new JsonTextReader(textReader);

        await using (stream.ConfigureAwait(false))
        {
            // move to start of first object
            await jsonReader.ReadAsync().ConfigureAwait(false);
            
            while (await jsonReader.ReadAsync().ConfigureAwait(false) &&
                   jsonReader.TokenType != JsonToken.EndArray)
            {
                Contact? contact = this._serializer!.Deserialize<contact>(jsonReader);
                Process(contact!);
            }
        }

        // manually clean up connection
        stream.Close();
        await stream.DisposeAsync().ConfigureAwait(false);

        // report results
        Console.WriteLine($"Contacts: {this._count:N0}");
        Console.WriteLine("Finished");
    }

    private void Process(Contact? item)
    {
        // process and store the data model
        this._count++;
    }

    #endregion
}

Imports System.IO
Imports System.Net.Http
Imports Common.Settings
Imports Newtonsoft.Json
Imports NewtonsoftContact.Remote.Models

Module Program

#Region "Fields"

    Private _serializer As JsonSerializer
    Private _jsonSerializerSettings As JsonSerializerSettings

    Private _count As Integer
    Private _url As String = "https://{0}/download/MOCK1"

#End Region

#Region "Methods"

    Sub Main(args As String())
        ExecuteAsync(args).GetAwaiter.GetResult()
        Console.WriteLine("Finished")
    End Sub

    Private Async Function ExecuteAsync(args As String()) As Task

        ' point to the correct host URL in appsettings.json file
        _url = _url.Build()

        _jsonSerializerSettings = New JsonSerializerSettings()
        _serializer = JsonSerializer.Create(_jsonSerializerSettings)

        ' open the stream
        Console.WriteLine($"Connecting to stream: {_url}")

        Dim stream As Stream

        Try

            stream = Await New HttpClient().GetStreamAsync(_url)

        Catch ex As Exception

            Console.WriteLine($"Failed to open stream {_url}. 
            Please check that the remote server is active.")
            Return

        End Try

        If stream Is Nothing Then
            Console.WriteLine($"Failed to open stream {_url}")
            Return
        End If

        Console.WriteLine($"Processing: {_url}")

        ' set up the stream readers
        Using textReader As TextReader = New StreamReader(stream)
            Using jsonReader As JsonReader = New JsonTextReader(textReader)

                ' move to the start of the array and read the stream
                Await jsonReader.ReadAsync().ConfigureAwait(False)

                While Await jsonReader.ReadAsync().ConfigureAwait(False) AndAlso
                      jsonReader.TokenType <> JsonToken.EndArray

                    Dim contact = _serializer.Deserialize(Of Contact)(jsonReader)
                    Process(contact)

                End While

            End Using
        End Using

        ' manually clean up connection
        stream.Close()
        Await stream.DisposeAsync().ConfigureAwait(False)

        ' report results
        Console.WriteLine($"Contacts: {_count:N0}")

    End Function

    Private Sub Process(item As Contact)

        ' process and store the data model
        _count += 1

    End Sub

#End Region

End Module

using Newtonsoft.Json;

JsonSerializer _serializer = new();

// open the _file as a stream
await using FileStream stream = File.OpenRead(_filename);

// set up the stream readers
using TextReader textReader = new StreamReader(stream);
using JsonReader jsonReader = new JsonTextReader(textReader);

await using (stream.ConfigureAwait(false))
{
    // move to the start of the array and read the stream
    await jsonReader.ReadAsync().ConfigureAwait(false);
 
    // walk the collection of objects to the end of the collection   
    while (await jsonReader.ReadAsync().ConfigureAwait(false) &&
           jsonReader.TokenType != JsonToken.EndArray)
        await ProcessAsync(jsonReader).ConfigureAwait(false);
}

Imports Newtonsoft.Json

_jsonSerializerSettings = New JsonSerializerSettings()
_serializer = JsonSerializer.Create(_jsonSerializerSettings)

' open the _file as a stream
Using stream As Stream = File.OpenRead(_filename)

    ' set up the stream readers
    Using textReader As TextReader = New StreamReader(stream)
        Using jsonReader As JsonReader = New JsonTextReader(textReader)

            ' move to the start of the array and read the stream
            While Await jsonReader.ReadAsync().ConfigureAwait(False)

                Await ProcessAsync(jsonReader).ConfigureAwait(False)

            End While

        End Using
    End Using

End Using

// walk the stream
private async Task ProcessAsync(JsonReader jsonReader)
{
    // make sure we are looking at the correct json element
    if (jsonReader.TokenType != JsonToken.PropertyName)
        return;

    // process properties for data that we want
    if (jsonReader.GetString() == "categoryTreeVersion")
    {
        // get the value
        await jsonReader.ReadAsync().ConfigureAwait(false);

        string? version = jsonReader.GetString();
        Console.WriteLine($"Version: {version ?? "no value"}");
    }

    else if (jsonReader.GetString() == "categoryTreeId")
    {
        // get the value
        await jsonReader.ReadAsync().ConfigureAwait(false);

        string? id = jsonReader.GetString();
        Console.WriteLine($"Id:      {id ?? "no value"}");
    }

    else if (jsonReader.GetString() == "categoryAspects")
    {
        // move to the start of the array
        await jsonReader.ReadAsync().ConfigureAwait(false);

        // step through each complete object in the Json Array
        while (await jsonReader.ReadAsync().ConfigureAwait(false) &&
               jsonReader.TokenType != JsonToken.EndArray)
            ProcessCollection(jsonReader);
    }
}

'  walk the stream
Private Async Function ProcessAsync(jsonReader As JsonReader) As Task

    If jsonReader.TokenType <> JsonToken.PropertyName Then
        Return
    End If

    ' process properties for data that we want
    If jsonReader.GetString() = "categoryTreeVersion" Then

        ' get the value
        Await jsonReader.ReadAsync().ConfigureAwait(False)

        Dim version = jsonReader.GetString()
        Console.WriteLine($"Version: {If(version, "no value")}")

    End If

    If jsonReader.GetString() = "categoryTreeId" Then

        ' get the value
        Await jsonReader.ReadAsync().ConfigureAwait(False)

        Dim Id = jsonReader.GetString()
        Console.WriteLine($"Id: {If(Id, "no value")}")

    End If

    If jsonReader.GetString() = "categoryAspects" Then

        ' move to the start of the array
        Await jsonReader.ReadAsync().ConfigureAwait(False)

        'step through each complete object in the Json Array
        While Await jsonReader.ReadAsync().ConfigureAwait(False) AndAlso
              jsonReader.TokenType <> JsonToken.EndArray
            ProcessCollection(jsonReader)
        End While

    End If

End Function

private void ProcessCollection(JsonReader jsonReader)
{
    CategoryAspect? categoryAspect = 
            _serializer!.Deserialize<CategoryAspect>(jsonReader);

    // process and store the data model
    _count++;
} 

Private Sub ProcessCollection(jsonReader As JsonReader)

    Dim categoryAspect = _serializer.Deserialize(Of CategoryAspect)(jsonReader)

    ' process and store the data model
    _count += 1

End Sub

using ZipArchive zipArchive = new(File.OpenRead(_filename));

foreach (ZipArchiveEntry zipArchiveEntry in zipArchive.Entries)
{
    Console.WriteLine($"Processing: {_file} > {zipArchiveEntry.FullName}");

    await using Stream stream = zipArchiveEntry.Open();

    // set up the stream readers
    using TextReader textReader = new StreamReader(stream);
    using JsonReader jsonReader = new JsonTextReader(textReader);

     // do work here...
 }

Using zipArchive = New ZipArchive(File.OpenRead(_fileHelper.Resolve(_file)))

    For Each zipArchiveEntry As ZipArchiveEntry In zipArchive.Entries

        Console.WriteLine($"Processing: {_file} > {zipArchiveEntry.FullName}")

        Using stream As Stream = zipArchiveEntry.Open()

            ' set up the stream readers
            Using textReader As TextReader = New StreamReader(stream)
                Using jsonReader = New JsonTextReader(textReader)

                    ' do work here

                End Using

            End Using

        End Using

    Next

End Using

using ZipArchive zipArchive = new(File.OpenRead(_filename));

foreach (ZipArchiveEntry zipArchiveEntry in zipArchive.Entries)
{
    if (zipArchiveEntry.Name == "file_name_goes_here")
    {
        Console.WriteLine($"Processing: {_file} > {zipArchiveEntry.FullName}");

        // set up the stream readers
        await using Stream stream = zipArchiveEntry.Open();

        using TextReader textReader = new StreamReader(stream);
        using JsonReader jsonReader = new JsonTextReader(textReader);

        // do work here...
    }
}

Using zipArchive = New ZipArchive(File.OpenRead(_fileHelper.Resolve(_file)))

    For Each zipArchiveEntry As ZipArchiveEntry In zipArchive.Entries

        if zipArchiveEntry.Name == "file_name_goes_here" then

            Console.WriteLine($"Processing: {_file} > {zipArchiveEntry.FullName}")
    
            Using stream As Stream = zipArchiveEntry.Open()
    
                ' set up the stream readers
                Using textReader As TextReader = New StreamReader(stream)
                    Using jsonReader = New JsonTextReader(textReader)
    
                        ' do work here
    
                    End Using
                End Using

            End Using

        End If

    Next

End Using

using Common.Helpers;
using Ebay.NewtonSoft.Json.Models;
using Newtonsoft.Json;

internal class Program
{
    #region Fields

    private readonly IFilePathHelper _fileHelper =
                         new FilePathHelper("Resources");

    private JsonSerializer? _serializer;
    private JsonSerializerSettings? _jsonSerializerSettings;

    private int _count;
    private readonly string _file = "EBAY_US FetchItemAspectsResponse.json";

    #endregion

    #region Methods

    private static async Task Main()
        => await new Program().Execute().ConfigureAwait(false);

    private async Task Execute()
    {
        Console.WriteLine($"Reading {this._file}");

        this._jsonSerializerSettings = new();
        this._serializer = JsonSerializer.Create(this._jsonSerializerSettings);

        using ZipArchive zipArchive =
            new(File.OpenRead(this._fileHelper.Resolve(this._file)));

        foreach (ZipArchiveEntry zipArchiveEntry in zipArchive.Entries)
        {
            Console.WriteLine
            ($"Processing: {this._file} > {zipArchiveEntry.FullName}");

            await using Stream stream = zipArchiveEntry.Open();

            // set up the stream readers
            using TextReader textReader = new StreamReader(stream);
            using JsonReader jsonReader = new JsonTextReader(textReader);

            await using (stream.ConfigureAwait(false))
            {
                // move to the start of the array and read the stream
                while (await jsonReader.ReadAsync().ConfigureAwait(false))
                    await this.ProcessAsync(jsonReader).ConfigureAwait(false);
            }
        }

        // report results
        Console.WriteLine($"CategoryAspects: {this._count:N0}");
        Console.WriteLine("Finished");
    }

    private async Task ProcessAsync(JsonReader jsonReader)
    {
        if (jsonReader.TokenType != JsonToken.PropertyName) return;

        // process properties for data that we want

        if (jsonReader.GetString() == "categoryTreeVersion")
        {
            // get the value
            await jsonReader.ReadAsync().ConfigureAwait(false);

            string? version = jsonReader.GetString();
            Console.WriteLine($"Version: {version ?? "no value"}");
        }

        else if (jsonReader.GetString() == "categoryTreeId")
        {
            // get the value
            await jsonReader.ReadAsync().ConfigureAwait(false);

            string? id = jsonReader.GetString();
            Console.WriteLine($"Id:      {id ?? "no value"}");
        }

        else if (jsonReader.GetString() == "categoryAspects")
        {
            // move to the start of the array
            await jsonReader.ReadAsync().ConfigureAwait(false);

            // step through each complete object in the Json Array
            while (await jsonReader.ReadAsync().ConfigureAwait(false) &&
                   jsonReader.TokenType != JsonToken.EndArray)
                this.ProcessCollection(jsonReader);
        }
    }

    private void ProcessCollection(JsonReader jsonReader)
    {
        CategoryAspect? categoryAspect = 
        this._serializer!.Deserialize<categoryaspect>(jsonReader);

        // process and store the data model
        this._count++;
    } 

    #endregion
}

Imports System.IO
Imports System.IO.Compression
Imports Common.Helpers
Imports Newtonsoft.Json
Imports NewtonSoftZippedEbay.Models

' Mock_Json_Files

Module Program

#Region "Fields"

    Private ReadOnly _fileHelper As FilePathHelper =
                         New FilePathHelper("Resources")

    Private _serializer As JsonSerializer
    Private _jsonSerializerSettings As JsonSerializerSettings

    Private _count As Integer
    Private ReadOnly _file As String = "EBay CategoryAspects.zip"

#End Region

#Region "Methods"

    Sub Main(args As String())
        Console.WriteLine($"Reading {_file}")
        ExecuteAsync(args).GetAwaiter.GetResult()
        Console.WriteLine("Finished")
    End Sub

    Private Async Function ExecuteAsync(args As String()) As Task

        _jsonSerializerSettings = New JsonSerializerSettings()
        _serializer = JsonSerializer.Create(_jsonSerializerSettings)

        Using zipArchive = New ZipArchive(File.OpenRead(_fileHelper.Resolve(_file)))

            For Each zipArchiveEntry As ZipArchiveEntry In zipArchive.Entries

                Console.WriteLine($"Processing: {_file} > {zipArchiveEntry.FullName}")

                Using stream As Stream = zipArchiveEntry.Open()

                    ' set up the stream readers
                    Using textReader As TextReader = New StreamReader(stream)
                        Using jsonReader = New JsonTextReader(textReader)

                            ' move to the start of the array and read the stream
                            While Await jsonReader.ReadAsync().ConfigureAwait(False)

                                Await ProcessAsync(jsonReader).ConfigureAwait(False)

                            End While

                        End Using

                    End Using

                End Using

            Next

        End Using

        ' report results
        Console.WriteLine($"CategoryAspects: {_count:N0}")

    End Function

    Private Async Function ProcessAsync(jsonReader As JsonReader) As Task

        If jsonReader.TokenType <> JsonToken.PropertyName Then
            Return
        End If

        ' process properties for data that we want

        If jsonReader.GetString() = "categoryTreeVersion" Then

            ' get the value
            Await jsonReader.ReadAsync().ConfigureAwait(False)

            Dim version = jsonReader.GetString()
            Console.WriteLine($"Version: {If(version, "no value")}")

        End If

        If jsonReader.GetString() = "categoryTreeId" Then

            ' get the value
            Await jsonReader.ReadAsync().ConfigureAwait(False)

            Dim Id = jsonReader.GetString()
            Console.WriteLine($"Id: {If(Id, "no value")}")

        End If

        If jsonReader.GetString() = "categoryAspects" Then

            ' move to the start of the array
            Await jsonReader.ReadAsync().ConfigureAwait(False)

            'step through each complete object in the Json Array
            While Await jsonReader.ReadAsync().ConfigureAwait(False) AndAlso
                  jsonReader.TokenType <> JsonToken.EndArray
                ProcessCollection(jsonReader)
            End While

        End If

    End Function

    Private Sub ProcessCollection(jsonReader As JsonReader)

        Dim categoryAspect = _serializer.Deserialize(Of CategoryAspect)(jsonReader)

        ' process and store the data model
        _count += 1

    End Sub

#End Region

End Module

using System.Text.Json;

// open the _file as a stream
await using FileStream stream = File.OpenRead(filename);

// Deserialize the stream
List<Contact> contacts = await JsonSerializer.DeserializeAsync<List<Contact>>(stream);

Imports System.Text.Json

Using stream as FileStream = File.OpenRead(filename)

Dim contacts = JsonSerializer.DeserializeAsync(Of List(Of Contact))(stream)

using System.Text.Json;

// open ald load the file into memory
string rawJon = await File.ReadAllTextAsync(filename);

List<Contact> contacts = JsonSerializer.Deserialize<List<Contact>>(rawJon);

Imports System.Text.Json

Dim rawJson As String = Await File.ReadAllTextAsync(filename)

Dim contacts = JsonSerializer.Deserialize(Of List(Of Contact))(rawJson)

using System.Text.Json;

// open the _file as a stream
await using FileStream stream = File.OpenRead(filename);

await foreach 
(var Contact in JsonSerializer.DeserializeAsyncEnumerable<Contact>(stream))
{
    // do work here...
}

Imports System.Text.Json

_options = New JsonSerializerOptions()

' open the _file as a stream
Using stream As Stream = File.OpenRead(_fileHelper.Resolve(_file))

    Console.WriteLine($"Processing: {_file}")

    ' VB version of C#'s "await foreach(..)"
    Dim iterator = JsonSerializer.DeserializeAsyncEnumerable(Of Contact) _
            (stream, _options).GetAsyncEnumerator()

    Do While Await iterator.MoveNextAsync()
        Dim item = iterator.Current
        Process(item)
    Loop

    Await iterator.DisposeAsync()

End Using

using Common.Helpers;
using System.Text.Json;
using Contacts.System.Text.Json.Models;

internal class Program
{
    #region Fields

    private readonly IFilePathHelper _fileHelper =
                                   new FilePathHelper("Resources");

    private JsonSerializerOptions? _jsonSerializerOptions;

    private int _count;
    private readonly string _file = "Mock_Contacts1.json";

    #endregion

    #region Methods

    private static async Task Main()
        => await new Program().Execute().ConfigureAwait(false);

    private async Task Execute()
    {
        Console.WriteLine($"Reading {this._file}");

        this._jsonSerializerOptions = new();

        // open the _file as a stream
        await using FileStream stream =
                       File.OpenRead(this._fileHelper.Resolve(this._file));

        Console.WriteLine($"Processing: {this._file}");

        // deserialize the stream an object at a time...
        await foreach (Contact? item in
                JsonSerializer.DeserializeAsyncEnumerable<Contact>
                    (stream, this._jsonSerializerOptions))
            Process(item);

        // report results
        Console.WriteLine($"Contacts: {this._count:N0}");
        Console.WriteLine("Finished");
    }

    private void Process(Contact? item)
    {
        // process and store the data model
        this._count++;
    }

    #endregion
}

Imports System.IO
Imports System.Text.Json
Imports System.Text.Json.Stream
Imports Common.Helpers
Imports SystemTextJsonContact.Models

Module Program

#Region "Fields"

    Private ReadOnly _fileHelper As FilePathHelper =
                         New FilePathHelper("Resources")

    Private _options As JsonSerializerOptions

    Private _count As Integer
    Private ReadOnly _file As String = "Mock_Contacts1.json"

#End Region

#Region "Methods"

    Sub Main(args As String())
        Console.WriteLine($"Reading {_file}")
        MainAsync(args).GetAwaiter.GetResult()
        Console.WriteLine("Finished")
    End Sub

    Private Async Function MainAsync(args As String()) As Task

        _options = New JsonSerializerOptions()

        ' open the _file as a stream
        Using stream As Stream = File.OpenRead(_fileHelper.Resolve(_file))

            Console.WriteLine($"Processing: {_file}")

            ' VB version of C#'s "await foreach(..)"
            Dim iterator = JsonSerializer.DeserializeAsyncEnumerable(Of Contact) _
                    (stream, _options).GetAsyncEnumerator()

            While Await iterator.MoveNextAsync()

                Dim item = iterator.Current
                Process(item)

            End While

            Await iterator.DisposeAsync()

        End Using

        ' report results
        Console.WriteLine($"Contacts: {_count:N0}")

    End Function

    Private Sub Process(item As Contact)

        ' process and store the data model
        _count += 1

    End Sub

#End Region

End Module

using Utf8JsonAsyncStreamReader jsonReader = new Utf8JsonAsyncStreamReader(stream);

// do work here...

Using jsonReader As Utf8JsonAsyncStreamReader = New Utf8JsonAsyncStreamReader(stream)

    ' do work here...

End Using

public class ContactFileStreamDeserializer
    : JsonFileStreamObjectDeserializer<IContactFilesConfiguration>
{
 // code goes here
}

Public Class ContactFileStreamDeserializer
    Inherits JsonFileStreamObjectDeserializer(Of IFilesConfiguration)

    ' code goes here...

End Class

protected override async Task ProcessAsync
(JsonReader jsonReader, CancellationToken cancellationToken)
{
    if (this.BatchSize > 1)
        await this.DeserializeAsync<Contact>
        (jsonReader, this.BatchProcessAsync, cancellationToken)
            .ConfigureAwait(false);
    else
        await this.DeserializeAsync<Contact>
        (jsonReader, this.ItemProcessAsync, cancellationToken)
            .ConfigureAwait(false);
}

Protected Overrides Async Function ProcessAsync
   (jsonReader As JsonReader, cancellationToken As CancellationToken) As Task

    If BatchSize > 1 Then
        Await DeserializeAsync(Of Contact)
        (jsonReader, AddressOf BatchProcessAsync, cancellationToken)
    Else
        Await DeserializeAsync(Of Contact)
        (jsonReader, AddressOf ItemProcessAsync, cancellationToken)
    End If

End Function

IFilePathHelper fileHelper = new FilePathHelper(DataFolder)
IContactFilesConfiguration config = new ContactFilesConfiguration();
CancellationTokenSource cts = new();

var deserializer = new ContactFileStreamDeserializer(fileHelper, config)
{
    FileId = "MOCK1",
    FileAction = DeserializeActionType.Single,
    FailIfFileNotFound = true,
    CancellationTokenSource = cts
};

await deserializer.ProcessAsync().ConfigureAwait(false);

Dim fileHelper = New FilePathHelper(DataFolder)
Dim config = New ContactFilesConfiguration()
Dim cts As New CancellationTokenSource()

Dim deserializer = New ContactFileStreamDeserializer(fileHelper, config) With
{
    .FileId = "MOCK1",
    .FileAction = DeserializeActionType.Single,
    .FailIfFileNotFound = True,
    .CancellationTokenSource = cts
}

await deserializer.ProcessAsync().ConfigureAwait(False)

public class ContactFilesConfiguration : IContactFilesConfiguration
{
    #region Constructors

    public ContactFilesConfiguration()
    {
        this.Paths = new Dictionary<string, string>
        {
            ["MOCK1"] = "Mock_Contacts1.json",
            ["MOCK2"] = "Mock_Contacts2.json",
            ["MOCK3"] = "Mock_Contacts3.json",
        };
    }

    #endregion

    #region Properties
    
    public IDictionary<string, string> Paths { get; }

    #endregion
}

Public Class ContactFilesConfiguration
    Implements IContactFilesConfiguration

#Region "Constructors"

    Public Sub New()

        Paths = New Dictionary(Of String, String) From {
                {"MOCK1", "Mock_Contacts1.json"},
                {"MOCK2", "Mock_Contacts2.json"},
                {"MOCK3", "Mock_Contacts3.json"}
            }

    End Sub

#End Region

#Region "Properties"

    Public ReadOnly Property Paths As IDictionary(Of String, String) _
        Implements Configuration.IDataConfiguration.Paths

#End Region

End Class

public class ContactZipFilesConfiguration : IContactZipFilesConfiguration
{
    #region Constructors

    public ContactZipFilesConfiguration()
    {
        this.Paths = new Dictionary<string, string>
        {
            ["MOCK_ZIP"] = "Mock_Json_Files.zip",
        };
    }

    #endregion

    #region Properties
    
    public IDictionary<string, string> Paths { get; }

    #endregion
}

Public Class ContactZipFilesConfiguration
    Implements IContactZipFilesConfiguration

#Region "Constructors"

    Public Sub New()

        Paths = New Dictionary(Of String, String) From {
                {"MOCK_ZIP", "Mock_Json_Files.zip"}
            }

    End Sub

#End Region

#Region "Properties"

    Public ReadOnly Property Paths As IDictionary(Of String, String) _
        Implements Configuration.IDataConfiguration.Paths

#End Region

End Class

public class EbayCategoryAspectFileStreamDeserializer
    : JsonFileStreamPropertyDeserializer<IEbayCategoryAspectFilesConfiguration>
{
 // code goes here
}

Public Class EbayCategoryAspectFileStreamDeserializer
    Inherits JsonFileStreamObjectDeserializer(Of IEbayCategoryAspectFilesConfiguration)

    '  code goes here

End Class

protected override async Task ProcessAsync
(JsonReader jsonReader, CancellationToken cancellationToken)
{
    // process properties for data that we want
    switch (jsonReader.GetString())
    {
        case "categoryAspects":
            if (BatchSize > 1)
                await DeserializeAsync<CategoryAspect>
                (jsonReader, BatchProcessAsync, cancellationToken)
                    .ConfigureAwait(false);
            else
                await DeserializeAsync<CategoryAspect>
                (jsonReader, ItemProcessAsync, cancellationToken)
                    .ConfigureAwait(false);
            break;
        case "categoryTreeVersion":
        {
            // get the value
            await jsonReader.ReadAsync(cancellationToken).ConfigureAwait(false);

            string? version = jsonReader.GetString();
            Logger?.Emit(LogLevel.Information, $"Version: {version ?? "no value"}");
            break;
        }

        case "categoryTreeId":
        {
            // get the value
            await jsonReader.ReadAsync(cancellationToken).ConfigureAwait(false);

            string? id = jsonReader.GetString();
            Logger?.Emit(LogLevel.Information, $"Id: {id ?? "no value"}");
            break;
        }
    }
}

Protected Overrides Async Function ProcessAsync
  (jsonReader As JsonReader, cancellationToken As CancellationToken) As Task

    ' process properties for data that we want
    Select Case jsonReader.GetString()

        Case "categoryAspects"
            Await jsonReader.ReadAsync().ConfigureAwait(False)

            If BatchSize > 1 Then
                Await DeserializeAsync(Of CategoryAspect)(jsonReader,
                    AddressOf BatchProcessAsync, cancellationToken).
                    ConfigureAwait(False)
            Else
                Await DeserializeAsync(Of CategoryAspect)(jsonReader, 
                    AddressOf ItemProcessAsync, cancellationToken).
                    ConfigureAwait(False)
            End If

        Case "categoryTreeVersion"

            ' get the value
            Await jsonReader.ReadAsync().ConfigureAwait(False)

            Dim version = jsonReader.GetString()
            _logger.Emit(LogLevel.Information, $"Version: {If(version, "no value")}")

        Case "categoryTreeId"

            ' get the value
            Await jsonReader.ReadAsync().ConfigureAwait(False)

            Dim Id = jsonReader.GetString()
            _logger.Emit(LogLevel.Information, $"Id: {If(Id, "no value")}")

    End Select

End Function

IFilePathHelper fileHelper = new FilePathHelper(DataFolder)
IEbayCategoryAspectFilesConfiguration config = 
                   new EbayCategoryAspectFilesConfiguration();
CancellationTokenSource cts = new();

var deserializer = new EbayCategoryAspectFileStreamDeserializer(fileHelper, config)
{
    MarketplaceId = "EBAY_US",
    FileAction = DeserializeActionType.Single,
    FailIfFileNotFound = true,
    CancellationTokenSource = cts
};

await deserializer.ProcessAsync().ConfigureAwait(false);

Dim fileHelper = New FilePathHelper(DataFolder)
Dim config = New ContactFilesConfiguration()
Dim cts As New CancellationTokenSource()

Dim deserializer = 
    New EbayCategoryAspectFileStreamDeserializer(fileHelper, config) With
{
    .MarketplaceId = "EBAY_US",
    .FileAction = DeserializeActionType.Single,
    .FailIfFileNotFound = True,
    .CancellationTokenSource = cts
}

await deserializer.ProcessAsync().ConfigureAwait(False)

public class ContactFileStreamDeserializer
    : JsonFileStreamObjectDeserializer<IContactFilesConfiguration>
{
 // code goes here
}

Public Class ContactFileStreamDeserializer
    Inherits JsonFileStreamObjectDeserializer(Of IFilesConfiguration)

    ' code goes here...

End Class

protected override async Task ProcessAsync
          (Stream stream, CancellationToken cancellationToken)
{
    if (this.BatchSize > 1)
        await this.DeserializeAsync<Contact>
        (stream, this.BatchProcessAsync, cancellationToken)
            .ConfigureAwait(false);
    else
        await this.DeserializeAsync<Contact>
        (stream, this.ItemProcessAsync, cancellationToken)
            .ConfigureAwait(false);
}

Protected Overrides Async Function ProcessAsync
          (stream As Stream, cancellationToken As CancellationToken) As Task

    If BatchSize > 1 Then
        Await DeserializeAsync(Of Contact)(stream,
            AddressOf BatchProcessAsync, cancellationToken).
            ConfigureAwait(False)
    Else
        Await DeserializeAsync(Of Contact)(stream,
            AddressOf ItemProcessAsync, cancellationToken).
            ConfigureAwait(False)
    End If

End Function

IFilePathHelper fileHelper = new FilePathHelper(DataFolder)
IContactFilesConfiguration config = new ContactFilesConfiguration();
CancellationTokenSource cts = new();

var deserializer = new ContactFileStreamDeserializer(filePathHelper, config)
{
    FileId = "MOCK1",
    FileAction = DeserializeActionType.Single,
    FailIfFileNotFound = true,
    CancellationTokenSource = cancellationTokenSource
};

await deserializer.ProcessAsync().ConfigureAwait(false);

Dim fileHelper = New FilePathHelper(DataFolder)
Dim config = New ContactFilesConfiguration()
Dim cts As New CancellationTokenSource()

Dim deserializer = New ContactFileStreamDeserializer(fileHelper, config) With
{
    .FileId = "MOCK1",
    .FileAction = DeserializeActionType.Single,
    .FailIfFileNotFound = True,
    .CancellationTokenSource = cts
}

await deserializer.ProcessAsync().ConfigureAwait(False)

public class EbayCategoryAspectFileStreamDeserializer
    : JsonFileStreamPropertyDeserializer<IEbayCategoryAspectFilesConfiguration>
{
 // code goes here
}

Public Class EbayCategoryAspectFileStreamDeserializer
    Inherits JsonFileStreamObjectDeserializer(Of IEbayCategoryAspectFilesConfiguration)

    ' code goes here...

End Class

protected override async Task ProcessAsync
(Utf8JsonAsyncStreamReader jsonReader, CancellationToken cancellationToken)
{
    // process properties for data that we want
    switch (jsonReader.GetString())
    {
        case "categoryAspects":
            if (BatchSize > 1)
                await DeserializeAsync<CategoryAspect>
                      (jsonReader, BatchProcessAsync, cancellationToken)
                    .ConfigureAwait(false);
            else
                await DeserializeAsync<CategoryAspect>
                      (jsonReader, ItemProcessAsync, cancellationToken)
                    .ConfigureAwait(false);
            break;
        case "categoryTreeVersion":
        {
            // get the value
            await jsonReader.ReadAsync(cancellationToken).ConfigureAwait(false);

            string? version = jsonReader.GetString();
            Logger?.Emit(LogLevel.Information, $"Version: {version ?? "no value"}");
            break;
        }

        case "categoryTreeId":
        {
            // get the value
            await jsonReader.ReadAsync(cancellationToken).ConfigureAwait(false);

            string? id = jsonReader.GetString();
            Logger?.Emit(LogLevel.Information, $"Id: {id ?? "no value"}");
            break;
        }
    }
}

Protected Overrides Async Function ProcessAsync
(jsonReader As Utf8JsonAsyncStreamReader, 
 cancellationToken As CancellationToken) As Task

    ' process properties for data that we want
    Select Case jsonReader.GetString()

        Case "categoryAspects"
            Await jsonReader.ReadAsync().ConfigureAwait(False)

            If BatchSize > 1 Then
                Await DeserializeAsync(Of CategoryAspect)(jsonReader,
                    AddressOf BatchProcessAsync, cancellationToken).
                    ConfigureAwait(false)
            Else
                Await DeserializeAsync(Of CategoryAspect)(jsonReader,
                    AddressOf ItemProcessAsync, cancellationToken).
                    ConfigureAwait(false)
            End If

        Case "categoryTreeVersion"

            ' get the value
            Await jsonReader.ReadAsync().ConfigureAwait(False)

            Dim version = jsonReader.GetString()
            _logger.Emit(LogLevel.Information, $"Version: {If(version, "no value")}")

        Case "categoryTreeId"

            ' get the value
            Await jsonReader.ReadAsync().ConfigureAwait(False)

            Dim Id = jsonReader.GetString()
            _logger.Emit(LogLevel.Information, $"Id: {If(Id, "no value")}")

    End Select

End Function

IFilePathHelper fileHelper = new FilePathHelper(DataFolder)
IEbayCategoryAspectFilesConfiguration config = 
                        new EbayCategoryAspectFilesConfiguration();
CancellationTokenSource cts = new();

var deserializer = new EbayCategoryAspectFileStreamDeserializer(fileHelper, config)
{
    MarketplaceId = "EBAY_US",
    FileAction = DeserializeActionType.Single,
    FailIfFileNotFound = true,
    CancellationTokenSource = cts
};

await deserializer.ProcessAsync().ConfigureAwait(false);

Dim fileHelper = New FilePathHelper(DataFolder)
Dim config = New ContactFilesConfiguration()
Dim cts As New CancellationTokenSource()

Dim deserializer = New EbayCategoryAspectFileStreamDeserializer(fileHelper, config) With
{
    .MarketplaceId = "EBAY_US",
    .FileAction = DeserializeActionType.Single,
    .FailIfFileNotFound = True,
    .CancellationTokenSource = cts
}

await deserializer.ProcessAsync().ConfigureAwait(False)

// Generate an ActionDelegate key
protected string GetActionKey(DeserializeActionType fileType)
        => $"{fileType}";

protected abstract Dictionary<string, Func<Task>> ActionDelegatesFactory();

// Execute an ActionDelegate based on configuration settings
protected virtual async ValueTask ExecuteActionDelegateAsync(string key)
{
    Dictionary<string, Func<Task>> ActionDelegates = this.ActionDelegatesFactory();

    if (!ActionDelegates.ContainsKey(key))
    {
        KeyNotFoundException exception = new($"The '{this.FileAction}' 
                                               Action was not found!");
        this.Logger?.Emit(LogLevel.Error, "Invalid Action!", exception);

        throw exception;
    }

    await ActionDelegates[key]().ConfigureAwait(false);
}

' Generate an ActionDelegate key
Protected Function GetActionKey(fileType As DeserializeActionType) As String

    Return $"{fileType}"

End Function

' abstract members/variables are not allowed
Protected MustOverride Function ActionDelegatesFactory() _
                       As Dictionary(Of String, Func(Of Task))

' Execute an ActionDelegate based on configuration settings
Protected Overridable Async Function _
          ExecuteActionDelegateAsync(key As String) As Task

    Dim ActionDelegates = ActionDelegatesFactory()

    If Not ActionDelegates.ContainsKey(key) Then
        Dim exception = New KeyNotFoundException_
                        ($"The '{Me.FileAction}' Action was not found!")
        Me._logger.Emit(LogLevel.Error, "Invalid Action!", exception)

        Throw exception
    End If

    Await ActionDelegates(key)().ConfigureAwait(False)

End Function

// Main Entry Point
public override async ValueTask ProcessAsync()
    => await this.ExecuteActionDelegateAsync(this.GetActionKey(this.FileAction))
        .ConfigureAwait(false);

// Handler for parent class to process json fragments
protected abstract Task ProcessAsync(JsonReader jsonReader, 
                                     CancellationToken cancellationToken);

// Map configuration settings to Actions
protected override Dictionary<string, Func<Task>> ActionDelegatesFactory()
    => new()
    {
        [this.GetActionKey(DeserializeActionType.Single)] = ()
            => this.ProcessActionAsync
            (this._configuration!.Paths[this.ConfigurationFileKey!], 
             this.ProcessAsync,
             this.CancellationTokenSource?.Token ?? default),

        [this.GetActionKey(DeserializeActionType.Multiple)] = ()
            => this.ProcessActionAsync
            (this._configuration!, this.ProcessAsync, 
             this.CancellationTokenSource?.Token ?? default),
    };

' Main Entry Point
Public Overrides Async Function ProcessAsync() As Task

    Await Me.ExecuteActionDelegateAsync_
             (Me.GetActionKey(Me.FileAction)).ConfigureAwait(False)

End Function

' Handler for parent class
Protected MustOverride Overloads Function ProcessAsync_
   (jsonReader As JsonReader, cancellationToken As CancellationToken) As Task

' Map configuration settings to Actions
Protected Overrides Function ActionDelegatesFactory() _
                    As Dictionary(Of String, Func(Of Task))

    Return New Dictionary(Of String, Func(Of Task)) From {
        {Me.GetActionKey(DeserializeActionType.Single), _
                         AddressOf Me.SingleShimAsync},
        {Me.GetActionKey(DeserializeActionType.Multiple), _
                         AddressOf Me.MultipleShimAsync}
    }

End Function

#Region "ActionDelegatesFactory Shims"

Private Async Function SingleShimAsync() As Task

    Await Me.ProcessActionAsync(
            Me._configuration.Paths(Me.ConfigurationFileKey),
            AddressOf Me.ProcessAsync,
            If(Me.CancellationTokenSource Is Nothing, _
               Nothing, Me.CancellationTokenSource.Token)) _
            .ConfigureAwait(False)

End Function

Private Async Function MultipleShimAsync() As Task

    Await Me.ProcessActionAsync(
            Me._configuration,
            AddressOf Me.ProcessAsync,
            If(Me.CancellationTokenSource Is Nothing, _
               Nothing, Me.CancellationTokenSource.Token)) _
            .ConfigureAwait(False)

End Function

#End Region

// Main Entry Point
public override async ValueTask ProcessAsync()
    => await this.ExecuteActionDelegateAsync
       (this.GetActionKey(this.ZipFileAction, this.FileAction))
        .ConfigureAwait(false);

#region Processors

// Generate an ActionDelegate key
private string GetActionKey(DeserializeActionType zipFileType, 
                            DeserializeActionType fileType)
    => $"{zipFileType}{this.GetActionKey(fileType)}";

// Execute an ActionDelegate based on configuration settings
protected override async ValueTask ExecuteActionDelegateAsync(string key)
{
    Dictionary<string, Func<Task>> ActionDelegates = this.ActionDelegatesFactory();

    if (!ActionDelegates.ContainsKey(key))
    {
        KeyNotFoundException exception =
            new KeyNotFoundException
            ($"The zip '{this.ZipFileAction} ' or file '{this.FileAction}' 
            Action(s) not found!");
        this.Logger?.Emit(LogLevel.Error, "Invalid Action!", exception);

        throw exception;
    }

    await ActionDelegates[key]().ConfigureAwait(false);
}

// Map configuration settings to Actions
protected override Dictionary<string, Func<Task>> ActionDelegatesFactory()
    => new()
    {
        [this.GetActionKey(DeserializeActionType.Single, 
         DeserializeActionType.Single)] = ()
            => this.ProcessZipActionAsync
                (this._zipConfiguration.Paths[this.ConfigurationZipFileKey!],
                 this._configuration!.Paths[this.ConfigurationFileKey!], 
                 this.ProcessAsync,
                 this.CancellationTokenSource?.Token ?? default),

        [this.GetActionKey(DeserializeActionType.Multiple, 
         DeserializeActionType.Single)] = ()
            => this.ProcessZipActionAsync
                (this._zipConfiguration, 
                 this._configuration!.Paths[this.ConfigurationFileKey!],
                 this.ProcessAsync, this.CancellationTokenSource?.Token ?? default),

        [this.GetActionKey(DeserializeActionType.Single, 
         DeserializeActionType.Multiple)] = ()
            => ProcessZipActionAsync
                (this._zipConfiguration.Paths[this.ConfigurationZipFileKey!],
                 this._configuration!, this.ProcessAsync,
                 this.CancellationTokenSource?.Token ?? default),

        [this.GetActionKey(DeserializeActionType.Multiple, 
                           DeserializeActionType.Multiple)] = ()
            => this.ProcessZipActionAsync
                (this._zipConfiguration, this.ProcessAsync,
                 this.CancellationTokenSource?.Token ?? default),
    };

' Main Entry Point
Public Overrides Async Function ProcessAsync() As Task

    Await Me.ExecuteActionDelegateAsync(Me.GetActionKey_
             (Me.ZipFileAction, Me.FileAction)).ConfigureAwait(False)

End Function

' Generate an ActionDelegate key
Private Shadows Function GetActionKey(zipFileType As DeserializeActionType, _
                                      fileType As DeserializeActionType) As String

	Return $"{zipFileType}{MyBase.GetActionKey(fileType)}"

End Function

' Execute an ActionDelegate based on configuration settings
Protected Overrides Async Function ExecuteActionDelegateAsync(key As String) As Task

	Dim ActionDelegates = ActionDelegatesFactory()

	If Not ActionDelegates.ContainsKey(key) Then
		Dim exception = New KeyNotFoundException($"The zip '{Me.ZipFileAction} ' _
                        or file '{Me.FileAction}' Action(s) not found!")
		Me._logger.Emit(LogLevel.Error, "Invalid Action!", exception)

		Throw exception
	End If

	Await ActionDelegates(key)().ConfigureAwait(False)

End Function

' Map configuration settings to Actions
Protected Overrides Function ActionDelegatesFactory() _
          As Dictionary(Of String, Func(Of Task))

	Return New Dictionary(Of String, Func(Of Task)) From {
			{Me.GetActionKey(DeserializeActionType.Single, _
             DeserializeActionType.Single),
			 AddressOf Me.SingleSingleShimAsync},
			{Me.GetActionKey(DeserializeActionType.Single, _
             DeserializeActionType.Multiple),
			 AddressOf Me.SingleMultipleShimAsync},
			{Me.GetActionKey(DeserializeActionType.Multiple, _
             DeserializeActionType.Single),
			 AddressOf Me.MultipleSingleShimAsync},
			{Me.GetActionKey(DeserializeActionType.Multiple, _
             DeserializeActionType.Multiple),
			 AddressOf Me.MultipleMultipleShimAsync}
		}

End Function

#Region "ActionDelegatesFactory Shims"

' NOTE: VB does not support inline delegates 
' with parameters in Dictionaries like C#, only method references, 
' so shims are used to wrap method calls with parameters
Private Async Function SingleSingleShimAsync() As Task

	Await Me.ProcessZipActionAsync(
		Me._zipConfiguration.Paths(Me.ConfigurationZipFileKey),
		Me._configuration.Paths(Me.ConfigurationFileKey),
		AddressOf Me.ProcessAsync,
		If(Me.CancellationTokenSource Is Nothing, Nothing, _
           Me.CancellationTokenSource.Token))
		ConfigureAwait(False)

End Function

Private Async Function MultipleSingleShimAsync() As Task

	Await Me.ProcessZipActionAsync(
		Me._zipConfiguration,
		Me._configuration.Paths(Me.ConfigurationFileKey),
		AddressOf Me.ProcessAsync,
		If(Me.CancellationTokenSource Is Nothing, Nothing, _
           Me.CancellationTokenSource.Token)).
		ConfigureAwait(False)

End Function

Private Async Function SingleMultipleShimAsync() As Task

	Await Me.ProcessZipActionAsync(
		Me._zipConfiguration.Paths(Me.ConfigurationZipFileKey),
		Me._configuration,
		AddressOf Me.ProcessAsync,
		If(Me.CancellationTokenSource Is Nothing, Nothing, _
           Me.CancellationTokenSource.Token)).
		ConfigureAwait(False)

End Function

Private Async Function MultipleMultipleShimAsync() As Task

	Await Me.ProcessZipActionAsync(
		Me._zipConfiguration,
		AddressOf Me.ProcessAsync,
		If(Me.CancellationTokenSource Is Nothing, Nothing, _
           Me.CancellationTokenSource.Token)).
		ConfigureAwait(False)

End Function

#End Region

public static class TaskExtensions
{
    // executing async method wrapper to capture the results, 
    // handle cancellation, and capture any exceptions
    public static Task TaskAwaiter(this ValueTask valueTask, 
    CancellationTokenSource? cancellationTokenSource = default, int delay = 2000)
    {
        //emulate a user cancellation in x milliseconds
        cancellationTokenSource?.CancelAfter(delay);

        // get a reference to the running task
        Task task = valueTask.AsTask();
    
        while (!task.GetAwaiter().IsCompleted && 
               cancellationTokenSource?.IsCancellationRequested != true)
        {
            // waiting ...
        }

        // we need to capture the task & a snapshot of the statuses before returning
        return task;
    }
}

Public Module TaskExtensions

    ' executing async method wrapper to capture the results, 
    ' handle cancellation, and capture any exceptions
    <Extension>
    Public Function TaskAwaiter(task As Task, _
    Optional cancellationTokenSource As CancellationTokenSource = Nothing, _
    Optional delay As Integer = 2000) As Task

        ' emulate a user cancellation in x milliseconds
        cancellationTokenSource?.CancelAfter(delay)

        While Not task.GetAwaiter().IsCompleted AndAlso
              ((cancellationTokenSource Is Nothing) _
               OrElse cancellationTokenSource.IsCancellationRequested <> True)
            'waiting...
        End While

        ' we need to capture the task & a snapshot of the statuses before returning
        Return task

    End Function

End Module

private const int SimulatedDelay = 5; // must be less than actual execution time
 
[Fact]
void Live_File_Single_Cancellation()
{
    CancellationTokenSource cts = new();

    Task task = this.Execute(this._liveDeserializer, TestFileKey, 
                             DeserializeActionType.Single, false, cts);

    if (cts.Token.IsCancellationRequested)
        this._logger.Emit(LogLevel.Warning, "Cancellation was requested");

    task.IsCompleted.Should().BeFalse();

    cts.IsCancellationRequested.Should().BeTrue();
    this._liveDeserializer.CancellationTokenSource!
        .IsCancellationRequested.Should().BeTrue();
    this._liveDeserializer.CancellationTokenSource!.Should().Be(cts);
}

private Task Execute
(
    IContactFileStreamDeserializer deserializer,
    string fileKey,
    DeserializeActionType fileAction,
    bool failIfFileNotFound,
    CancellationTokenSource? cts = default,
    int delay = SimulatedDelay
)
{
    deserializer.FileId = fileKey;
    deserializer.FileAction = fileAction;
    deserializer.FailIfFileNotFound = failIfFileNotFound;
    deserializer.CancellationTokenSource = cts;

    // we need to capture the Task
    return deserializer.ProcessAsync().TaskAwaiter(cts, delay);
}

Private Const SimulatedDelay As Integer = 5 ' must be less than actual execution time

<Fact>
Sub Live_File_Single_Cancellation()

    Dim cts = New CancellationTokenSource()

    Dim task As Task = Me.Execute(Me._liveDeserializer, _
             TestFileKey, DeserializeActionType.Single, False, cts)

    If cts.Token.IsCancellationRequested Then
        Me._logger.Emit(LogLevel.Warning, "Cancellation was requested")
    End If

    task.IsCompleted.Should().BeFalse()

    cts.IsCancellationRequested.Should().BeTrue()
    Me._liveDeserializer.CancellationTokenSource._
        IsCancellationRequested.Should().BeTrue()
    Me._liveDeserializer.CancellationTokenSource.Should().Be(cts)

End Sub

Function Execute _
(
        deserializer As IContactFileStreamDeserializer,
        fileKey As String,
        fileAction As DeserializeActionType,
        failIfFileNotFound As Boolean,
        Optional cts As CancellationTokenSource = Nothing,
        Optional delay As Integer = SimulatedDelay
) As Task

    deserializer.FileId = fileKey
    deserializer.FileAction = fileAction
    deserializer.FailIfFileNotFound = failIfFileNotFound
    deserializer.CancellationTokenSource = cts

    ' we need to capture the Task
    Return deserializer.ProcessAsync().TaskAwaiter(cts, delay)

End Function