visual basic async task

Announcing the Async CTP for Visual Basic (and also Iterators!)

October 28th, 2010 0 0

We’re very happy to announce today the Async CTP for Visual Basic and C#.

• Async CTP homepage : http://msdn.com/vstudio/async
• Installer : http://go.microsoft.com/fwlink/?LinkId=203690
• Async discussion forums : http://social.msdn.microsoft.com/Forums/en-US/async/threads

Asynchronous programming is something that helps make your UI more responsive, especially in applications that interact with databases or network or disk. It’s also used to make ASP servers scale better. And it’s the natural way to program in Silverlight.

Until now, asynchronous programming has also been prohibitively hard, “not worth the investment”-hard. But with the Async CTP we’ve made asynchronous programming easy enough that developers should routinely consider asynchrony for most of their applications .

Async is a true “parity” feature between VB and C#. We had the same designers develop it in VB and C# at the same time, and the same developers implement the feature for both compilers, and even the same unit tests for both. The end result is a feature that’s keyword-for-keyword identical in both languages (and probably bug-for-bug compatible in the CTP…)

We’re also very happy to announce that iterators are coming to VB, and are included in the Async CTP! That’s because async and iterators are deeply related (and inside the compiler they’re implemented with 99% the same codebase). We’ll write further posts about iterators.

A real-world example of asynchrony

“A waiter’s job is to wait on a table until the patrons have finished their meal. If you want to serve two tables concurrently, you must hire two waiters.”

Q. That sentence is obviously wrong. What is the flaw?

A. You don’t need two waiters! A single waiter can easily serve two tables concurrently, just by switching between them.

Why am I talking about waiters? Think of the waiter as a thread , and the table as a method that it executes . Traditionally, when you wanted to do two things at the same time (e.g. keep the UI responsive while downloading a file) then you’d have used two threads. But it’s inefficient to create extra threads (hire waiters), and you had to jump through hoops to update the UI from the background thread (make sure that the waiters don’t conflict).

Let’s see what the waiter really does, written using VB Async:

Async Function WaitOnTablesAsync() As System.Threading.Tasks. Task ( Of Decimal )     Dim takings As Decimal = 0D     While Not TimeToGoHome         DeliverMenus()         Await GetOrdersAsync()         Await WaitForKitchenAsync()         GetFoodFromKitchen()         GiveFoodToPatrons()         Await WaitForPatronsToFinish()         takings += Await GetPayment()     End While     Return takings End Function

Async Sub Button1_Click() Handles Button1.Click     Dim takings As Decimal = Await WaitOnTablesAsync()     MessageBox .Show( “Shift finished; took {0}” , takings) End Sub

Things to notice in this code:

• At each Await keyword, the waiter (thread) suspends execution of the method he’s currently in. He can go off to do other work, like responding to UI events. When the thing he’s awaiting has completed, and he’s free, then he resumes his method.
• The WaitOnTablesAsync function has the modifier Async . This modifier allows it to have Await expressions inside.
• WaitOnTablesAsync returns a Task ( Of Decimal ) . It actually returns this task promptly at its first Await expression. The task is a placeholder for the work and return value that the waiter will eventually return when he’s finished.
• Button1_Click can also Await that Task . Once again, when this task has completed, then Button1_Click can resume and it shows the message-box.

What is asynchrony? (and what isn’t it?)

Asynchrony means “not [a-] at the same time [-synchronous]”. It means that the the async function gives back a Task immediately, but that Task is just a placeholder: the real result will be delivered sometime later.

Asynchrony does not mean “running on a background thread” . Running on a background thread is one way to implement asynchrony, but it’s not the only way, and it’s often not the best way.

There are no additional threads in the above code. There’s only a single thread, the UI thread. The Async modifier does not create additional threads. All it does is mark a method as asynchronous (and allow it to Await). If you want to do work on a background thread, you will have to do so explicitly using TaskEx .Run :

Await TaskEx .Run( Sub ()                      ‘ long-running CPU work can go here                  End Sub )

Asynchrony in practice

I read this on a blog recently. It also has a subtle flaw. What is the flaw?

“A good practice in creating responsive applications is to make sure your main UI thread does the minimum amount of work. Any potentially long task that may hang your application should be handled in a different thread. Typical examples of such tasks are network operations, which involve unpredictable delays.”

Private Async Sub Button1_Click() Handles Button1.Click     Dim url = “http://blogs.msdn.com/lucian/rss.aspx”     Dim wc As New WebClient     Dim result As String = Await wc .DownloadStringTaskAsync(url)     Dim rss As XDocument = XDocument .Parse(result)     MessageBox .Show(rss.DescendantNodes.Count) End Sub

If you can spot the flaw in the above sentence, or if you can follow this code and understand why it allows the UI to stay responsive, then you’re ready to start coding with the Async CTP!

There’s a lot more to read on the subject of asynchrony:

• The async CTP homepage: http://msdn.com/vstudio/async
• Soma’s blog-post: http://blogs.msdn.com/b/somasegar/archive/2010/10/28/making-asynchronous-programming-easy.aspx
• Jason Zander’s blog-post: http://blogs.msdn.com/b/jasonz/archive/2010/10/05/tutorial-pic-viewer-revisited-on-the-async-ctp.aspx
• Eric Lippert’s C# blog series on async: http://blogs.msdn.com/b/ericlippert/archive/tags/async
• Parallel Framework Extensions Team blog series: http://blogs.msdn.com/b/pfxteam/archive/tags/async/
• Lucian Wischik’s VB series on async+iterators: http://blogs.msdn.com/b/lucian/archive/tags/async/

Leave a comment Cancel reply

Log in to start the discussion.

Insert/edit link

Enter the destination URL

Or link to existing content

# Task-based asynchronous pattern

# basic usage of async/await.

You can start some slow process in parallel and then collect the results when they are done:

After two seconds both the results will be available.

# Using TAP with LINQ

You can create an IEnumerable of Task by passing AddressOf AsyncMethod to the LINQ Select method and then start and wait all the results with Task.WhenAll

If your method has parameters matching the previous LINQ chain call, they will be automatically mapped.

To map different arguments you can replace AddressOf Method with a lambda:

← Using BackgroundWorker Debugging your application →

Visual Basic .NET Language

• Getting started with Visual Basic .NET Language
• Learn Tutorial
• Awesome Book
• Awesome Community
• Awesome Course
• Awesome Tutorial
• Awesome YouTube
• BackgroundWorker
• ByVal and ByRef keywords
• Connection Handling
• Data Access
• Debugging your application
• Declaring variables
• Dictionaries
• Disposable objects
• Error Handling
• Extension methods
• File Handling
• File/Folder Compression
• Google Maps in a Windows Form
• Introduction to Syntax
• Multithreading
• NullReferenceException
• OOP Keywords
• Option Explicit
• Option Infer
• Option Strict
• Reading compressed textfile on-the-fly
• Short-Circuiting Operators (AndAlso - OrElse)
• Task-based asynchronous pattern
• Basic usage of Async/Await
• Using TAP with LINQ
• Type conversion
• Unit Testing in VB.NET
• Using axWindowsMediaPlayer in VB.Net
• Using BackgroundWorker
• Using Statement
• Visual Basic 14.0 Features
• WinForms SpellCheckBox
• Working with Windows Forms
• WPF XAML Data Binding

Visual Basic .NET Language Task-based asynchronous pattern Basic usage of Async/Await

Fastest entity framework extensions.

You can start some slow process in parallel and then collect the results when they are done:

After two seconds both the results will be available.

Got any Visual Basic .NET Language Question?

• Advertise with us
• Cookie Policy
• Privacy Policy

Get monthly updates about new articles, cheatsheets, and tricks.

This browser is no longer supported.

Upgrade to Microsoft Edge to take advantage of the latest features, security updates, and technical support.

Using Async for File Access (Visual Basic)

• 11 contributors

You can use the Async feature to access files. By using the Async feature, you can call into asynchronous methods without using callbacks or splitting your code across multiple methods or lambda expressions. To make synchronous code asynchronous, you just call an asynchronous method instead of a synchronous method and add a few keywords to the code.

You might consider the following reasons for adding asynchrony to file access calls:

Asynchrony makes UI applications more responsive because the UI thread that launches the operation can perform other work. If the UI thread must execute code that takes a long time (for example, more than 50 milliseconds), the UI may freeze until the I/O is complete and the UI thread can again process keyboard and mouse input and other events.

Asynchrony improves the scalability of ASP.NET and other server-based applications by reducing the need for threads. If the application uses a dedicated thread per response and a thousand requests are being handled simultaneously, a thousand threads are needed. Asynchronous operations often don’t need to use a thread during the wait. They use the existing I/O completion thread briefly at the end.

The latency of a file access operation might be very low under current conditions, but the latency may greatly increase in the future. For example, a file may be moved to a server that's across the world.

The added overhead of using the Async feature is small.

Asynchronous tasks can easily be run in parallel.

Running the Examples

To run the examples in this topic, you can create a WPF Application or a Windows Forms Application and then add a Button . In the button's Click event, add a call to the first method in each example.

In the following examples, include the following Imports statements.

Use of the FileStream Class

The examples in this topic use the FileStream class, which has an option that causes asynchronous I/O to occur at the operating system level. By using this option, you can avoid blocking a ThreadPool thread in many cases. To enable this option, you specify the useAsync=true or options=FileOptions.Asynchronous argument in the constructor call.

You can’t use this option with StreamReader and StreamWriter if you open them directly by specifying a file path. However, you can use this option if you provide them a Stream that the FileStream class opened. Note that asynchronous calls are faster in UI apps even if a ThreadPool thread is blocked, because the UI thread isn’t blocked during the wait.

Writing Text

The following example writes text to a file. At each await statement, the method immediately exits. When the file I/O is complete, the method resumes at the statement that follows the await statement. Note that the async modifier is in the definition of methods that use the await statement.

The original example has the statement Await sourceStream.WriteAsync(encodedText, 0, encodedText.Length) , which is a contraction of the following two statements:

The first statement returns a task and causes file processing to start. The second statement with the await causes the method to immediately exit and return a different task. When the file processing later completes, execution returns to the statement that follows the await. For more information, see Control Flow in Async Programs (Visual Basic) .

Reading Text

The following example reads text from a file. The text is buffered and, in this case, placed into a StringBuilder . Unlike in the previous example, the evaluation of the await produces a value. The ReadAsync method returns a Task < Int32 >, so the evaluation of the await produces an Int32 value ( numRead ) after the operation completes. For more information, see Async Return Types (Visual Basic) .

Parallel Asynchronous I/O

The following example demonstrates parallel processing by writing 10 text files. For each file, the WriteAsync method returns a task that is then added to a list of tasks. The Await Task.WhenAll(tasks) statement exits the method and resumes within the method when file processing is complete for all of the tasks.

The example closes all FileStream instances in a Finally block after the tasks are complete. If each FileStream was instead created in an Imports statement, the FileStream might be disposed of before the task was complete.

Note that any performance boost is almost entirely from the parallel processing and not the asynchronous processing. The advantages of asynchrony are that it doesn’t tie up multiple threads, and that it doesn’t tie up the user interface thread.

When using the WriteAsync and ReadAsync methods, you can specify a CancellationToken , which you can use to cancel the operation mid-stream. For more information, see Fine-Tuning Your Async Application (Visual Basic) and Cancellation in Managed Threads .

• Asynchronous Programming with Async and Await (Visual Basic)
• Async Return Types (Visual Basic)
• Control Flow in Async Programs (Visual Basic)

Coming soon: Throughout 2024 we will be phasing out GitHub Issues as the feedback mechanism for content and replacing it with a new feedback system. For more information see: https://aka.ms/ContentUserFeedback .

Submit and view feedback for

Additional resources

Blog Other Blogs McAfee Labs From Spam to AsyncRAT: Tracking the Surge in Non-PE Cyber Threats

McAfee Labs

From Spam to AsyncRAT: Tracking the Surge in Non-PE Cyber Threats

May 08, 2024

10 MIN READ

Authored by Yashvi Shah and Preksha Saxena

AsyncRAT, also known as “Asynchronous Remote Access Trojan,” represents a highly sophisticated malware variant meticulously crafted to breach computer systems security and steal confidential data. McAfee Labs has recently uncovered a novel infection chain, shedding light on its potent lethality and the various security bypass mechanisms it employs.

It utilizes a variety of file types, such as PowerShell, Windows Script File (WSF), VBScript (VBS), and others within a malicious HTML file. This multifaceted approach aims to circumvent antivirus detection methods and facilitate the distribution of infection.

Figure 1: AsyncRAT prevalence for the last one month

Infection Chain:

The infection initiates through a spam email containing an HTML page attachment. Upon unwittingly opening the HTML page, an automatic download of a Windows Script File (WSF) ensues. This WSF file is deliberately named in a manner suggestive of an Order ID, fostering the illusion of legitimacy and enticing the user to execute it. Subsequent to the execution of the WSF file, the infection progresses autonomously, necessitating no further user intervention. The subsequent stages of the infection chain encompass the deployment of Visual Basic Script (VBS), JavaScript (JS), Batch (BAT), Text (TXT), and PowerShell (PS1) files. Ultimately, the chain culminates in a process injection targeting aspnet_compiler.exe.

Figure 2: Infection Chain

Technical Analysis

Upon opening a spam email, the recipient unwittingly encounters a web link embedded within its contents. Upon clicking on the link, it triggers the opening of an HTML page. Simultaneously, the page initiates the download of a WSF (Windows Script File), setting into motion a potentially perilous sequence of events.

Figure 3:HTML page

The HTML file initiates the download of a WSF file. Disguised as an order-related document with numerous blank lines, the WSF file conceals malicious intent.  After its execution, no user interaction is required.

On executing wsf, we get the following process tree:

Figure 4: Process tree

Commandlines:

Figure 5:Content of wsf file

The downloaded text file, named “1.txt,” contains specific lines of code. These lines are programmed to download another file, referred to as “r.jpg,” but it is actually saved in the public folder under the name “ty.zip.” Subsequently, this zip file is extracted within the same public folder, resulting in the creation of multiple files.

Figure 6: Marked files are extracted in a public folder

Infection sequence:

a) The “ty.zip” file comprises 17 additional files. Among these, the file named “basta.js” is the first to be executed. The content of “basta.js” is as follows:

Figure 7: basta.js

b) “basta.js” invoked “node.bat ” file from the same folder.

Figure 8: node.js

Explaining the command present in node.bat:

• This creates a new instance of the Windows Task Scheduler COM object.
• This connects to the Task Scheduler service.
• This creates a new task object.
• This sets the description of the task.
• This enables the task.
• This allows the task to start even if the system is on battery power.
• This creates a trigger for the task. The value 1 corresponds to a trigger type of “Daily”.
• This sets the start time for the trigger to the current time.
• This sets the repetition interval for the trigger to 2 minutes.
• This creates an action for the task. The value 0 corresponds to an action type of “Execute”.
• This sets the path of the script to be executed by the task.
• This gets the root folder of the Task Scheduler.
• This registers the task definition with the Task Scheduler. The task is named “cafee”. The parameters 6 and 3 correspond to constants for updating an existing task and allowing the task to be run on demand, respectively.

To summarize, the command sets up a scheduled task called “cafee” which is designed to execute the “app.js” script found in the C:\Users\Public\ directory every 2 minutes. The primary purpose of this script is to maintain persistence on the system.

Figure 9: Schedule task entry

c) Now “ app.js ” is executed and it executes “ t.bat ” from the same folder.

Figure 10:app.js

d) “t.bat” has little obfuscated code which after concatenating becomes: “Powershell.exe -ExecutionPolicy Bypass -File “”C:\Users\Public\t.ps1”

Figure 11: Content of t.bat

e) Now the powershell script “t.ps1” is invoked. This is the main script that is responsible for injection.

Figure 12: Content of t.ps1

There are 2 functions defined in it:

A) function fun_alosh() This function is used in the last for decoding $tLx and $Uk

B) Function FH () This function is used only once to decode the content of “C:\\Users\\Public\\Framework.txt”. This function takes a binary string as input, converts it into a sequence of ASCII characters, and returns the resulting string.

Figure 13: Content of Framework.txt

After decoding the contents of “C:\Users\Public\Framework.txt” using CyberChef, we are able to reveal the name of the final binary file targeted for injection.

Figure 14: Binary to Hex, Hex to Ascii Conversion using CyberChef

This technique aims to evade detection by concealing suspicious keywords within the script. Same way other keywords are also stored in txt files, such as:

Content of other text files are:

Figure 15: Content of other files

After replacing all the names and reframing sentences. Below is the result.

Figure 16: Injection code

Now, the two variables left are decrypted by fun_alosh.

After decrypting and saving them, it was discovered that both files are PE files, with one being a DLL ($tLx) and the other an exe ($Uk).

Figure 17: Decoded binaries

Process injection in aspnet_compiler.exe.

Figure 18:  Process injection in aspnet_compiler.exe

Once all background tasks are finished, a deceptive Amazon page emerges solely to entice the user.

Figure 19: Fake Amazon page

Analysis of Binaries:

The Dll file is packed with confuserEX and as shown, the type is mentioned ‘NewPE2.PE’ and Method is mentioned ‘Execute’.

Figure 20: Confuser packed DLL

The second file is named AsyncClient123 which is highly obfuscated.

Figure 21: AsyncRat payload

To summarize the main execution flow of “AsyncRAT”, we can outline the following steps:

• Initialize its configuration (decrypts the strings).
• Verifies and creates a Mutex (to avoid running duplicated instances).
• If configured through the settings, the program will automatically exit upon detecting a virtualized or analysis environment.
• Establishes persistence in the system.
• Collect data from the victim’s machine.

Establish a connection with the server.

The decrypting function is used to decrypt strings.

Figure 22: Decrypting Function

The program creates a mutex to prevent multiple instances from running simultaneously.

Figure 23: Creating Mutex

Figure 24: Mutex in process explorer

Checking the presence of a debugger.

Figure 25: Anti analysis code

Collecting data from the system.

Figure 26: Code for collecting data from system

Figure 27: Code for C2 connection

Process injection in aspnet_compiler.exe:

Figure 28: C2 communication

Conclusion:

In this blog post, we dissect the entire attack sequence of AsyncRAT, beginning with an HTML file that triggers the download of a WSF file, and culminating in the injection of the final payload. Such tactics are frequently employed by attackers to gain an initial foothold. We anticipate a rise in the utilization of these file types following Microsoft’s implementation of protections against malicious Microsoft Office macros, which have also been widely exploited for malware delivery. McAfee labs consistently advise users to refrain from opening files from unknown sources, particularly those received via email. For organizations, we highly recommend conducting security training for employees and implementing a secure web gateway equipped with advanced threat protection. This setup enables real-time scanning and detection of malicious files, enhancing organizational security.

Mitigation:

Avoiding falling victim to email phishing involves adopting a vigilant and cautious approach. Here are some common practices to help prevent falling prey to email phishing:

• Verify Sender Information
• Think Before Clicking Links and Warnings
• Check for Spelling and Grammar Errors
• Be Cautious with Email Content
• Verify Unusual Requests
• Use Email Spam Filters
• Check for Secure HTTP Connections
• Delete Suspicious Emails
• Keep Windows and Security Software Up to date
• Use the latest and patched version of Acrobat reader

IOCs (Indicators of compromise):

Introducing McAfee+

Identity theft protection and privacy for your digital life

Stay Updated

Follow us to stay updated on all things McAfee and on top of the latest consumer and mobile security threats.

McAfee Labs is one of the leading sources for threat research, threat intelligence, and cybersecurity thought leadership. See our blog posts below for more information.

More from McAfee Labs

How Scammers Hijack Your Instagram

May 14, 2024   |   6 MIN READ

The Darkgate Menace: Leveraging Autohotkey & Attempt to Evade Smartscreen

Apr 29, 2024   |   13 MIN READ

Redline Stealer: A Novel Approach

Apr 17, 2024   |   10 MIN READ

Distinctive Campaign Evolution of Pikabot Malware

Apr 02, 2024   |   10 MIN READ

Android Phishing Scam Using Malware-as-a-Service on the Rise in India

Mar 14, 2024   |   7 MIN READ

Rise in Deceptive PDF: The Gateway to Malicious Payloads

Mar 01, 2024   |   17 MIN READ

GUloader Unmasked: Decrypting the Threat of Malicious SVG Files

Feb 28, 2024   |   5 MIN READ

MoqHao evolution: New variants start automatically right after installation

Feb 07, 2024   |   7 MIN READ

Generative AI: Cross the Stream Where it is Shallowest

Feb 07, 2024   |   5 MIN READ

From Email to RAT: Deciphering a VB Script-Driven Campaign

Jan 17, 2024   |   10 MIN READ

Stealth Backdoor “Android/Xamalicious” Actively Infecting Devices

Dec 22, 2023   |   14 MIN READ

Shielding Against Android Phishing in Indian Banking

Dec 20, 2023   |   8 MIN READ

Navigation Menu

Search code, repositories, users, issues, pull requests..., provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications

Open Source framework for voice and multimodal conversational AI

pipecat-ai/pipecat

Folders and files, repository files navigation.

pipecat is a framework for building voice (and multimodal) conversational agents. Things like personal coaches, meeting assistants, story-telling toys for kids , customer support bots, intake flows , and snarky social companions.

Take a look at some example apps:

Getting started with voice agents

You can get started with Pipecat running on your local machine, then move your agent processes to the cloud when you’re ready. You can also add a 📞 telephone number, 🖼️ image output, 📺 video input, use different LLMs, and more.

By default, in order to minimize dependencies, only the basic framework functionality is available. Some third-party AI services require additional dependencies that you can install with:

Your project may or may not need these, so they're made available as optional requirements. Here is a list:

• AI services : anthropic , azure , fal , moondream , openai , playht , silero , whisper
• Transports : local , websocket , daily

Code examples

• foundational — small snippets that build on each other, introducing one or two concepts at a time
• example apps — complete applications that you can use as starting points for development

A simple voice agent running locally

Here is a very basic Pipecat bot that greets a user when they join a real-time session. We'll use Daily for real-time media transport, and ElevenLabs for text-to-speech.

Run it with:

Daily provides a prebuilt WebRTC user interface. Whilst the app is running, you can visit at https://<yourdomain>.daily.co/<room_url> and listen to the bot say hello!

WebRTC for production use

WebSockets are fine for server-to-server communication or for initial development. But for production use, you’ll need client-server audio to use a protocol designed for real-time media transport. (For an explanation of the difference between WebSockets and WebRTC, see this post. )

One way to get up and running quickly with WebRTC is to sign up for a Daily developer account. Daily gives you SDKs and global infrastructure for audio (and video) routing. Every account gets 10,000 audio/video/transcription minutes free each month.

Sign up here and create a room in the developer Dashboard.

What is VAD?

Voice Activity Detection — very important for knowing when a user has finished speaking to your bot. If you are not using press-to-talk, and want Pipecat to detect when the user has finished talking, VAD is an essential component for a natural feeling conversation.

Pipecast makes use of WebRTC VAD by default when using a WebRTC transport layer. Optionally, you can use Silero VAD for improved accuracy at the cost of higher CPU usage.

The first time your run your bot with Silero, startup may take a while whilst it downloads and caches the model in the background. You can check the progress of this in the console.

Hacking on the framework itself

Note that you may need to set up a virtual environment before following the instructions below. For instance, you might need to run the following from the root of the repo:

From the root of this repo, run the following:

This builds the package. To use the package locally (eg to run sample files), run

If you want to use this package from another directory, you can run:

Running tests

From the root directory, run:

Setting up your editor

This project uses strict PEP 8 formatting.

You can use use-package to install py-autopep8 package and configure autopep8 arguments:

autopep8 was installed in the venv environment described before, so you should be able to use pyvenv-auto to automatically load that environment inside Emacs.

Visual Studio Code

Install the autopep8 extension. Then edit the user settings ( Ctrl-Shift-P Open User Settings (JSON) ) and set it as the default Python formatter, enable formatting on save and configure autopep8 arguments:

Getting help

➡️ Join our Discord

➡️ Reach us on X

Releases 15

Contributors 8.

• Python 99.3%
• Dockerfile 0.7%