Closing Channels in Visual Basic .NET

Closing channels is not a direct concept in Visual Basic .NET. However, we can simulate similar behavior using a BlockingCollection and a CancellationTokenSource. This example demonstrates how to communicate work completion between threads.

Imports System
Imports System.Threading
Imports System.Collections.Concurrent

Module ClosingChannels
    Sub Main()
        Dim jobs As New BlockingCollection(Of Integer)()
        Dim cts As New CancellationTokenSource()

        ' Here's the worker thread. It repeatedly takes items from 'jobs'.
        ' When the collection is marked as complete, it will exit the loop.
        Dim worker = Task.Run(
            Sub()
                Try
                    While True
                        Dim job As Integer
                        If jobs.TryTake(job, Timeout.Infinite, cts.Token) Then
                            Console.WriteLine($"received job {job}")
                        Else
                            Console.WriteLine("received all jobs")
                            Exit While
                        End If
                    End While
                Catch ex As OperationCanceledException
                    Console.WriteLine("Worker was cancelled")
                End Try
            End Sub, cts.Token)

        ' This sends 3 jobs to the worker over the 'jobs' collection,
        ' then marks it as complete.
        For j As Integer = 1 To 3
            jobs.Add(j)
            Console.WriteLine($"sent job {j}")
        Next
        jobs.CompleteAdding()
        Console.WriteLine("sent all jobs")

        ' We await the worker using the Task.Wait method.
        worker.Wait()

        ' Trying to take from a completed collection will return false.
        Dim moreJobs As Integer
        Dim ok = jobs.TryTake(moreJobs)
        Console.WriteLine($"received more jobs: {ok}")
    End Sub
End Module

In this Visual Basic .NET example, we use a BlockingCollection(Of Integer) to simulate a channel. The CompleteAdding() method is used to indicate that no more items will be added to the collection, similar to closing a channel in Go.

The worker thread runs in a separate Task and continuously takes items from the jobs collection until it’s marked as complete. This is analogous to the goroutine in the original Go code.

We use a CancellationTokenSource to provide a way to cancel the worker task if needed, which is not directly shown in this example but is a common pattern in .NET for managing long-running operations.

The main thread adds jobs to the collection and then marks it as complete. It then waits for the worker task to finish using Task.Wait().

Finally, we attempt to take another item from the completed collection to demonstrate that it behaves similarly to a closed channel in Go.

To run this program, save it as ClosingChannels.vb and compile it using the Visual Basic compiler:

$ vbc ClosingChannels.vb
$ mono ClosingChannels.exe
sent job 1
received job 1
sent job 2
received job 2
sent job 3
received job 3
sent all jobs
received all jobs
received more jobs: False

This example demonstrates how to achieve similar functionality to closing channels in Go using Visual Basic .NET’s concurrency primitives.

Non Blocking Channel Operations in Visual Basic .NET

Range Over Channels in Visual Basic .NET

Learn X By Example

Title here

Closing Channels in Visual Basic .NET