In this article, we are going to learn about the various patterns to implement asynchronous programming in .NET.<\/p>\n
.NET has had in-built support for asynchronous programming since the release of .NET Framework 1.1. It has been through various improvements over the years, and today it’s a powerful mainstream programming paradigm.<\/p>\n
Let’s start by understanding what asynchronous programming is.<\/p>\n
Asynchronous programming enables multiple operations to run concurrently without waiting for any other operations to complete. Besides, it has a non-blocking nature where the program continues to execute other tasks while executing long-running operations.<\/p>\n
Check out our article on Asynchronous Programming Using TAP<\/a> to know more.<\/p>\n Currently, TAP is the recommended pattern for implementing asynchronous programming in .NET<\/strong>. Although APM and EAP are now legacy models, it’s important to understand them when dealing with legacy projects or libraries.<\/p>\n There are 3 patterns for implementing asynchronous programming in .NET:<\/p>\n So, let’s now dive into each of these.<\/p>\n .NET Framework 1.1 introduced asynchronous programming with APM. This model uses the For example, to implement an asynchronous operation named The The main building blocks for creating an APM implementation are:<\/p>\n A typical example of the APM model is the The For this purpose, we define the The callback method also receives a reference to an Now, we define the As the name implies, with EAP, we use events to implement asynchronous operations.<\/strong> The operations execute in separate threads, and we use events to notify the completion status.<\/p>\n Check out our article on Events in C#<\/a> if you are new to this topic.<\/p>\n Applications with UI components mainly use EAP for implementations. This model keeps the UI components responsive while running time-consuming operations as the components don’t need to wait for the operations to complete.<\/p>\n A long-running operation executes in a separate thread making the UI thread free. The UI thread subscribes to the event that notifies the completion of the long-running operation by registering a callback method. Thus, the UI doesn’t need to wait till the operation is complete.<\/p>\n EAP is not just limited to UI components, we can use it to implement various operations asynchronously. For instance, downloading a file, web service calls, etc.<\/p>\n .NET Framework 2.0 introduced EAP. Similar to APM, even EAP is a legacy model as Microsoft recommends using TAP.<\/p>\n To implement an asynchronous operation with EAP, we first need an event, Next, we need a custom event argument Finally, we create the asynchronous operation using Let’s see this in practice by implementing an asynchronous operation that fetches user information.<\/p>\n First, let’s create a simple Secondly, we create a Now, we define the event argument:<\/p>\n The event argument class derives from the After that, we create the The We assign The Then, we add the The First, we create an Next, let’s create a We register for the Finally, let’s call the TAP is the recommended pattern of implementing asynchronous operations in .NET for new development. This pattern emerged from the Task Parallel Library<\/a> introduced in .NET Framework 4.0. <\/p>\n TAP uses Meanwhile, the To know more about task-based async programming, check out our article on executing multiple tasks asynchronously<\/a>.<\/p>\n We can implement TAP with or without the \n
Asynchronous Programming Model (APM)<\/h2>\n
IAsyncResult<\/code><\/a> design pattern to perform asynchronous programming.<\/strong><\/p>\nIAsyncResult<\/code> interface is the return type of a method that initiates an asynchronous operation while a method that concludes an asynchronous operation receives this as a parameter.<\/p>\nOperationName<\/code> using IAsyncResult<\/code> pattern, we use two methods named BeginOperationName()<\/code> and EndOperationName()<\/code>. These methods denote the beginning and end of the asynchronous operation.<\/strong><\/p>\nBeginOperationName()<\/code> method starts the asynchronous operation and returns an output type that implements the IAsyncResult<\/code> interface. In addition to operation parameters, it can accept a callback method that fires on operation completion. We can also pass an operation context state where we normally pass any dependencies.<\/p>\nAsynchronous Programming Implementation<\/h3>\n
\n
delegate<\/code> of AsyncCallback<\/code> type that fires on operation completion<\/li>\nstate<\/code> property that holds dependencies<\/li>\n<\/ul>\nFileStream<\/code><\/a> class in System.IO<\/code> namespace. It defines BeginRead()<\/code> and EndRead()<\/code> methods to asynchronously read bytes from a file. Let’s see how to use them:<\/p>\npublic class ApmFileReader\r\n{\r\n private byte[]? _buffer;\r\n private const int InputReportLength = 1024;\r\n private FileStream? _fileStream;\r\n\r\n public void BeginReadAsync()\r\n {\r\n _buffer = new byte[InputReportLength];\r\n _fileStream = File.OpenRead(\"User.txt\");\r\n _fileStream.BeginRead(_buffer, 0, InputReportLength, ReadCallbackAsync, _buffer);\r\n }\r\n\r\n public void ReadCallbackAsync(IAsyncResult iResult)\r\n {\r\n _fileStream?.EndRead(iResult);\r\n var buffer = iResult.AsyncState as byte[];\r\n }\r\n}<\/pre>\nBeginRead()<\/code> method of the FileStream<\/code> class accepts an optional state parameter and a callback of AsyncCallback<\/code> delegate type:<\/p>\ndelegate void AsyncCallback(IAsyncResult ar);<\/code><\/p>\nReadCallbackAsync()<\/code> method. Within this method, we call the EndRead()<\/code> method of FileStream<\/code> class to wait for the pending asynchronous read operation to complete.\u00a0<\/p>\nIAsyncResult<\/code> object. Hence, it can query the AsyncState<\/code> property of the IAsyncResult<\/code> interface to obtain the reference of the state object.\u00a0<\/p>\nBeginReadAsync()<\/code> method to read the file asynchronously. We start the asynchronous operation by invoking the BeginRead()<\/code> method of the FileStream<\/code> class.\u00a0<\/p>\nEvent-Based Asynchronous Pattern (EAP)<\/h2>\n
Asynchronous Programming Implementation<\/h3>\n
OperationNameCompleted<\/code> that fires on operation completion.\u00a0<\/p>\nOperationNameEventArgs<\/code> where we can define custom properties to store any operations results and event statuses.<\/p>\nOperationNameAsync()<\/code> method and pass any required parameters to run the asynchronous operation.<\/p>\nEAP Code Example<\/h3>\n
User<\/code> class that holds user attributes:<\/p>\npublic class User\r\n{\r\n public int Id { get; set; }\r\n\r\n public string? Name { get; set; }\r\n}<\/pre>\nUserService<\/code> that emulates a long-running operation:<\/p>\npublic class UserService\r\n{\r\n private readonly List<User> _users = new List<User>\r\n {\r\n new User { Id = 100, Name = \"Adam\"},\r\n new User { Id = 101, Name = \"Eve\"}\r\n };\r\n\r\n public User GetUser(int userId)\r\n {\r\n \/\/ Long-running operation\r\n return _users.FirstOrDefault(x => x.Id == userId);\r\n }\r\n}<\/pre>\npublic class GetUserCompletedEventArgs : AsyncCompletedEventArgs\r\n{\r\n private User _result;\r\n\r\n public User Result\r\n {\r\n get\r\n {\r\n RaiseExceptionIfNecessary();\r\n return _result;\r\n }\r\n }\r\n\r\n public GetUserCompletedEventArgs(Exception error, bool cancelled, User user)\r\n : base(error, cancelled, user)\r\n {\r\n _result = user;\r\n }\r\n}<\/pre>\nGetUserCompletedEventArgs<\/code> class and holds event-related information. We use this to identify the operation status and retrieve the results. In addition to that, we use the RaiseExceptionIfNecessary()<\/code> method of AsyncCompletedEventArgs<\/code> class to raise an exception if the operation failed or was canceled.<\/p>\nEapUserProvider<\/code> class with EAP implementation:<\/p>\npublic class EapUserProvider\r\n{\r\n private readonly SendOrPostCallback _operationFinished;\r\n private readonly UserService _userService;\r\n\r\n public EapUserProvider()\r\n {\r\n _operationFinished = ProcessOperationFinished;\r\n _userService = new UserService();\r\n }\r\n\r\n public User GetUser(int userId) => _userService.GetUser(userId);\r\n\r\n public event EventHandler<GetUserCompletedEventArgs> GetUserCompleted;\r\n\r\n public void GetUserAsync(int userId) => GetUserAsync(userId, null);\r\n\r\n private void ProcessOperationFinished(object state)\r\n {\r\n var args = (GetUserCompletedEventArgs)state;\r\n\r\n GetUserCompleted?.Invoke(this, args);\r\n }\r\n}<\/pre>\n_operationFinished<\/code> field is a SendOrPostCallback<\/code> delegate that represents a callback method that we want to execute when a message dispatches to a synchronization context.<\/p>\nProcessOperationFinished()<\/code> the\u00a0 _operationFinished<\/code> delegate. So, ProcessOperationFinished()<\/code> fires once the task finishes and the call returns to the current synchronization context.<\/p>\nGetUserCompleted<\/code> property represents the event that fires on operation completion. This provides the option for consumers to subscribe to this operation.<\/p>\nGetUserAsync()<\/code> method to the EapUserProvider<\/code> class and fetch the user asynchronously:<\/p>\npublic void GetUserAsync(int userId, object userState)\r\n{\r\n AsyncOperation operation = AsyncOperationManager.CreateOperation(userState);\r\n\r\n ThreadPool.QueueUserWorkItem(state =>\r\n {\r\n GetUserCompletedEventArgs args;\r\n try\r\n {\r\n var user = GetUser(userId);\r\n args = new GetUserCompletedEventArgs(null, false, user);\r\n }\r\n catch (Exception e)\r\n {\r\n Console.WriteLine(e.Message);\r\n args = new GetUserCompletedEventArgs(e, false, null);\r\n }\r\n\r\n operation.PostOperationCompleted(_operationFinished, args);\r\n\r\n }, userState);\r\n}<\/pre>\nGetUserAsync()<\/code> method encapsulates the EAP implementation logic.<\/p>\nAsyncOperation<\/code> object to track and report the progress of the asynchronous task. Thereupon, we run the operation asynchronously on a thread pool using the ThreadPool.QueueWorkItem()<\/code> method. Then we notify about the operation completion by invoking the PostOperationCompleted()<\/code> method from the AsyncOperation<\/code> object. This in turn fires the GetUserCompleted<\/code> event.<\/p>\nEventBasedAsyncPatternHelper<\/code> class and add the FetchAndPrintUser()<\/code> method to perform the asynchronous operation using EAP:<\/p>\npublic static class EventBasedAsyncPatternHelper\r\n{\r\n public static void FetchAndPrintUser(int userId)\r\n {\r\n var eapUserProvider = new EapUserProvider();\r\n\r\n eapUserProvider.GetUserCompleted += (sender, args) =>\r\n {\r\n var result = args.Result;\r\n Console.WriteLine($\"Id: {result.Id}\\nName: {result.Name}\");\r\n };\r\n\r\n eapUserProvider.GetUserAsync(userId);\r\n }\r\n}<\/pre>\nGetUserCompleted<\/code> event by defining our callback method that prints user information. Then, we start the asynchronous operation by invoking the GetUserAsync()<\/code> method.<\/p>\nFetchAndPrintUser()<\/code> method to retrieve and print the user information asynchronously:<\/p>\nEventBasedAsyncPatternHelper.FetchAndPrintUser(100);<\/code><\/p>\nTask-Based Asynchronous Pattern (TAP)<\/h2>\n
async<\/code> and await<\/code> keywords to implement the pattern. The compiler creates a state machine for methods with async<\/code> keywords to handle the asynchronous execution.<\/p>\nawait<\/code> keyword pauses the execution and asynchronously waits for the awaited Task<\/code> to complete. At this point, the current thread releases to the thread pool as it unblocks and picks up another task.<\/p>\nAsynchronous Programming Implementation<\/h3>\n
async<\/code> keyword:<\/p>\npublic Task<int> OperationName1Async(int param)\r\n{\r\n \/\/ more code\r\n return Task.FromResult(1);\r\n}\r\n\r\npublic async Task<int> OperationName2Async(int\u00a0param)\r\n{\r\n \/\/ more code with await\r\n return 1;\r\n}<\/pre>\n