Are you over 18 and want to see adult content?
More Annotations
![A complete backup of www.cbssports.com/soccer/news/chelsea-vs-tottenham-score-takeaways-giroud-alonso-lead-blues-to-pivotal-prem](https://www.archivebay.com/archive2/e7032adb-8091-48ba-a5f8-86737d865a7f.png)
A complete backup of www.cbssports.com/soccer/news/chelsea-vs-tottenham-score-takeaways-giroud-alonso-lead-blues-to-pivotal-prem
Are you over 18 and want to see adult content?
![A complete backup of aajtak.intoday.in/story/shilpa-shetty-become-mother-surrogacy-child-daughter-name-shamisha-shetty-kundra-me](https://www.archivebay.com/archive2/09ebcf2c-3372-4133-adb7-1e90f5ca539d.png)
A complete backup of aajtak.intoday.in/story/shilpa-shetty-become-mother-surrogacy-child-daughter-name-shamisha-shetty-kundra-me
Are you over 18 and want to see adult content?
Favourite Annotations
![A complete backup of lingerdenver.com](https://www.archivebay.com/archive5/images/d7a8efed-f933-4721-947c-81c57a0474ce.png)
A complete backup of lingerdenver.com
Are you over 18 and want to see adult content?
![A complete backup of fortecoaching.com](https://www.archivebay.com/archive5/images/f7a536c5-a111-4e0a-b43d-8ff0cd41ee97.png)
A complete backup of fortecoaching.com
Are you over 18 and want to see adult content?
![A complete backup of escapadarural.com](https://www.archivebay.com/archive5/images/652a895b-887c-4021-905c-fdd0cc7ac783.png)
A complete backup of escapadarural.com
Are you over 18 and want to see adult content?
![A complete backup of wedding-secret.com](https://www.archivebay.com/archive5/images/4aa28ff2-9d9a-4640-b880-bee6c1d76590.png)
A complete backup of wedding-secret.com
Are you over 18 and want to see adult content?
![A complete backup of bride-russian.com](https://www.archivebay.com/archive5/images/02f20270-2792-4cb3-80a3-0a37b78dd493.png)
A complete backup of bride-russian.com
Are you over 18 and want to see adult content?
![A complete backup of chinajerseysusa.com](https://www.archivebay.com/archive5/images/937b60d2-4fdb-4191-9496-dd6338486200.png)
A complete backup of chinajerseysusa.com
Are you over 18 and want to see adult content?
![A complete backup of weka-holzbau.com](https://www.archivebay.com/archive5/images/226460ed-f8d2-4b17-89ff-1862a607377a.png)
A complete backup of weka-holzbau.com
Are you over 18 and want to see adult content?
Text
stream.
A TOUR OF TASK, PART 6: RESULTS T result = task.GetAwaiter().GetResult(); The code above will synchronously block until the task completes. As such, it is subject to the same old deadlock problems as Wait and Result. However, it will not wrap the task exceptions in an AggregateException. The code above will retrieve the result value from a REPORTING PROGRESS FROM ASYNC TASKSASYNC AND AWAIT
ASYNCHRONOUS LAZY INITIALIZATION When you have a lazy-created value, it’s often useful to lazy-create it in an asynchronous fashion. A simple Lazy provides lazy initialization, but the initializationTHERE IS NO THREAD
This is an essential truth of async in its purest form: There is no thread. The objectors to this truth are legion. “No,” they cry, “if I am awaiting an operation, there must be a thread that is doing the wait! It’s probably a thread pool thread. A NEW PATTERN FOR EXCEPTION LOGGING If you’re following along at home, enable logging scopes for the Console logger by updating CreateHostBuilder in your Program.cs, adding a call to ConfigureLogging that removes the existing Console logger and adds a new one that sets IncludeScopes to true:. public static IHostBuilder CreateHostBuilder (string args) => Host. CreateDefaultBuilder (args) // (begin code changes). STEPHEN CLEARY (THE BLOG)ABOUT GODCONTACT Stephen Cleary's blog: async/await, programming, language design, and other sundry computer science topics. A TOUR OF TASK, PART 0: OVERVIEW Two Types of Task. There are two types of tasks. The first type is a Delegate Task; this is a task that has code to run. The second type is a Promise Task; this is a task that represents some kind of event or signal. Promise Tasks are often I/O-based signals (e.g., “the HTTP download has completed”), but they can actually represent anything MICROSOFT.EXTENSIONS.LOGGING, PART 1: INTRODUCTION Steven van Deursen, the creator of Simple Injector, has gone on record saying the whole Microsoft.Extensions.Logging design is a violation of the Dependency Injection Principle, with the ILogger specifically a violation of the Interface Segregation Principle. He strongly recommends option (3), but I have to counter that it’s hard for every library author in the world to get right. STREAMING ZIP ON ASP.NET CORE A few weeks ago, I wrote about using PushStreamContent on ASP.NET to build a zip file on-demand that was totally asynchronous and did not have to buffer any intermeditate files in memory.. Today, let’s take a look at doing the same thing on ASP.NET Core! Downloading a Simple Stream. First, let’s look at how we can download a single filestream.
A TOUR OF TASK, PART 6: RESULTS T result = task.GetAwaiter().GetResult(); The code above will synchronously block until the task completes. As such, it is subject to the same old deadlock problems as Wait and Result. However, it will not wrap the task exceptions in an AggregateException. The code above will retrieve the result value from a REPORTING PROGRESS FROM ASYNC TASKSASYNC AND AWAIT
ASYNCHRONOUS LAZY INITIALIZATION When you have a lazy-created value, it’s often useful to lazy-create it in an asynchronous fashion. A simple Lazy provides lazy initialization, but the initializationTHERE IS NO THREAD
This is an essential truth of async in its purest form: There is no thread. The objectors to this truth are legion. “No,” they cry, “if I am awaiting an operation, there must be a thread that is doing the wait! It’s probably a thread pool thread. BACKGROUNDSERVICE GOTCHA: STARTUP BackgroundService Gotcha: Synchronous Starts. This is some behavior that I’ve found surprising (and others have as well): ASP.NET Core background services are started with a synchronous call. Specifically, the host will invoke IHostedService.StartAsync for all its hosted services, and BackgroundService directly invokes ExecuteAsync before A TOUR OF TASK, PART 0: OVERVIEW Two Types of Task. There are two types of tasks. The first type is a Delegate Task; this is a task that has code to run. The second type is a Promise Task; this is a task that represents some kind of event or signal. Promise Tasks are often I/O-based signals (e.g., “the HTTP download has completed”), but they can actually represent anything A TOUR OF TASK, PART 9: DELEGATE TASKS TaskScheduler. The TaskScheduler is used to schedule the continuation. A TaskFactory may define its own TaskScheduler which it uses by default. Note that the default TaskScheduler of the static Task.Factory instance is not TaskScheduler.Default, but rather TaskScheduler.Current.This fact has caused quite a bit of confusion over the years, because the vast majority of the time, developers A TOUR OF TASK, PART 6: RESULTS T result = task.GetAwaiter().GetResult(); The code above will synchronously block until the task completes. As such, it is subject to the same old deadlock problems as Wait and Result. However, it will not wrap the task exceptions in an AggregateException. The code above will retrieve the result value from aASYNC AND AWAIT
The async keyword only enables the await keyword (and manages the method results). The beginning of an async method is executed just like any other method. That is, it runs synchronously until it hits an “await” (or throws an exception). The “await” keyword is where things can get asynchronous. Await is like a unary operator: it takesa
ASYNCHRONOUS MESSAGING, PART 5: MISCELLANEOUS CONSIDERATIONS And then there is the other side: some solutions are all-in-one, complete solutions for asynchronous messaging. Examples of all-in-one solutions are Hangfire (.NET) and Delayed Job (Ruby). Their all-in-one nature means they are easier to set up, but inevitably also means they are less flexible. There are also some very serious considerations FRAMEWORK PROFILES IN .NET The .NETPortable identifier is used for portable libraries.Each portable library may run on a number of different platforms, indicated by a profile named Profile_N_.For example, “.NETPortable,Version=v4.0,Profile=Profile1” refers to a portable library that can run on .NET 4.0, Silverlight 4, Windows Phone 7,Metro, or XBox 360.
SOCKET OPERATIONS
There are a few logical operations that may be performed on a TCP/IP socket, regardless of whether the socket is synchronous or asynchronous. Each of the operations below is marked “immediate” (meaning it is completed immediately) or “delayed” (meaning it depends on the network for completion). TASK.RUN ETIQUETTE EXAMPLES: DON'T USE TASK.RUN IN THE Last time we looked at using Task.Run for the wrong thing (code that is not CPU-bound). So let’s move on to the proper use case of Task.Run: CPU-bound code. We start off with some existing code, which synchronously does some heavy calculations. THE FIRST RULE OF IMPLEMENTING IDISPOSABLE AND FINALIZERS The correct IDisposable implementation for this class is to not implement IDisposable! When an ErrorList instance becomes unreachable, the garbage collector will automatically reclaim all of its memory and resources. Remember the two tests to determine if IDisposable is needed (owning unmanaged resources and owning managed resources). STEPHEN CLEARY (THE BLOG)ABOUT GODCONTACT Stephen Cleary's blog: async/await, programming, language design, and other sundry computer science topics. CONCURRENCY IN C# COOKBOOK This book focuses specifically on how code should be written, not how code could be written. This book does contain an introduction to concurrency (multithreading, asynchronous programming, etc). However, it is not an introduction to C# or .NET. I do expect my readers to understand delegates, lambda expressions, LINQ, OOP, etc. A NEW PATTERN FOR EXCEPTION LOGGING If you’re following along at home, enable logging scopes for the Console logger by updating CreateHostBuilder in your Program.cs, adding a call to ConfigureLogging that removes the existing Console logger and adds a new one that sets IncludeScopes to true:. public static IHostBuilder CreateHostBuilder (string args) => Host. CreateDefaultBuilder (args) // (begin code changes). A TOUR OF TASK, PART 0: OVERVIEW Two Types of Task. There are two types of tasks. The first type is a Delegate Task; this is a task that has code to run. The second type is a Promise Task; this is a task that represents some kind of event or signal. Promise Tasks are often I/O-based signals (e.g., “the HTTP download has completed”), but they can actually represent anything A TOUR OF TASK, PART 6: RESULTS T result = task.GetAwaiter().GetResult(); The code above will synchronously block until the task completes. As such, it is subject to the same old deadlock problems as Wait and Result. However, it will not wrap the task exceptions in an AggregateException. The code above will retrieve the result value from a STREAMING ZIP ON ASP.NET CORE A few weeks ago, I wrote about using PushStreamContent on ASP.NET to build a zip file on-demand that was totally asynchronous and did not have to buffer any intermeditate files in memory.. Today, let’s take a look at doing the same thing on ASP.NET Core! Downloading a Simple Stream. First, let’s look at how we can download a single filestream.
ASYNCHRONOUS PUSHSTREAMCONTENT First, we create the MemoryStream that the zip library will write to. Then, we download all the files asynchronously, and add them to the zip archive. Finally, we rewind the MemoryStream containing the zip file and send it to the browser using good ‘ol StreamContent. The problem with this approach is ASYNCHRONOUS LAZY INITIALIZATION When you have a lazy-created value, it’s often useful to lazy-create it in an asynchronous fashion. A simple Lazy provides lazy initialization, but the initialization TASK.RUN ETIQUETTE EXAMPLES: DON'T USE TASK.RUN IN THE Now the service API is clean (it exposes a synchronous API for a naturally-synchronous, CPU-bound method), it works for all consumers (e.g., ASP.NET), and the UI layer is responsible for not blocking the UI thread. Conclusion: do not use Task.Run in the implementation of the method; instead, use Task.Run to call the method. Task.RunEtiquette.
DETECTION OF HALF-OPEN (DROPPED) CONNECTIONSSEE MORE ON BLOG.STEPHENCLEARY.COM STEPHEN CLEARY (THE BLOG)ABOUT GODCONTACT Stephen Cleary's blog: async/await, programming, language design, and other sundry computer science topics. CONCURRENCY IN C# COOKBOOK This book focuses specifically on how code should be written, not how code could be written. This book does contain an introduction to concurrency (multithreading, asynchronous programming, etc). However, it is not an introduction to C# or .NET. I do expect my readers to understand delegates, lambda expressions, LINQ, OOP, etc. A NEW PATTERN FOR EXCEPTION LOGGING If you’re following along at home, enable logging scopes for the Console logger by updating CreateHostBuilder in your Program.cs, adding a call to ConfigureLogging that removes the existing Console logger and adds a new one that sets IncludeScopes to true:. public static IHostBuilder CreateHostBuilder (string args) => Host. CreateDefaultBuilder (args) // (begin code changes). A TOUR OF TASK, PART 0: OVERVIEW Two Types of Task. There are two types of tasks. The first type is a Delegate Task; this is a task that has code to run. The second type is a Promise Task; this is a task that represents some kind of event or signal. Promise Tasks are often I/O-based signals (e.g., “the HTTP download has completed”), but they can actually represent anything A TOUR OF TASK, PART 6: RESULTS T result = task.GetAwaiter().GetResult(); The code above will synchronously block until the task completes. As such, it is subject to the same old deadlock problems as Wait and Result. However, it will not wrap the task exceptions in an AggregateException. The code above will retrieve the result value from a STREAMING ZIP ON ASP.NET CORE A few weeks ago, I wrote about using PushStreamContent on ASP.NET to build a zip file on-demand that was totally asynchronous and did not have to buffer any intermeditate files in memory.. Today, let’s take a look at doing the same thing on ASP.NET Core! Downloading a Simple Stream. First, let’s look at how we can download a single filestream.
ASYNCHRONOUS PUSHSTREAMCONTENT First, we create the MemoryStream that the zip library will write to. Then, we download all the files asynchronously, and add them to the zip archive. Finally, we rewind the MemoryStream containing the zip file and send it to the browser using good ‘ol StreamContent. The problem with this approach is ASYNCHRONOUS LAZY INITIALIZATION When you have a lazy-created value, it’s often useful to lazy-create it in an asynchronous fashion. A simple Lazy provides lazy initialization, but the initialization TASK.RUN ETIQUETTE EXAMPLES: DON'T USE TASK.RUN IN THE Now the service API is clean (it exposes a synchronous API for a naturally-synchronous, CPU-bound method), it works for all consumers (e.g., ASP.NET), and the UI layer is responsible for not blocking the UI thread. Conclusion: do not use Task.Run in the implementation of the method; instead, use Task.Run to call the method. Task.RunEtiquette.
DETECTION OF HALF-OPEN (DROPPED) CONNECTIONSSEE MORE ON BLOG.STEPHENCLEARY.COM A NEW PATTERN FOR EXCEPTION LOGGING If you’re following along at home, enable logging scopes for the Console logger by updating CreateHostBuilder in your Program.cs, adding a call to ConfigureLogging that removes the existing Console logger and adds a new one that sets IncludeScopes to true:. public static IHostBuilder CreateHostBuilder (string args) => Host. CreateDefaultBuilder (args) // (begin code changes). MICROSOFT.EXTENSIONS.LOGGING, PART 2: TYPES Factory Provider Repository Builders. Yeah, naming is hard. In Microsoft.Extensions.Logging, there are two types in particular that I kept conflating: ILoggerProvider and ILoggerFactory.Even though they both can create instances of ILogger, they are actually completely different!. In this post, I’m going to cover the main types of Microsoft.Extensions.Logging and describe their intended use. MICROSOFT.EXTENSIONS.LOGGING, PART 1: INTRODUCTION Steven van Deursen, the creator of Simple Injector, has gone on record saying the whole Microsoft.Extensions.Logging design is a violation of the Dependency Injection Principle, with the ILogger specifically a violation of the Interface Segregation Principle. He strongly recommends option (3), but I have to counter that it’s hard for every library author in the world to get right. A TOUR OF TASK, PART 7: CONTINUATIONS Recent posts have considered several members that wait for tasks to complete (Wait, WaitAll, WaitAny, Result, and GetAwaiter().GetResult()).One common disadvantage that all of these have is that they synchronously block the calling thread while waiting for the task to complete.. Today’s post talks about continuations.A continuation is a delegate that you can attach to a task and tell the REPORTING PROGRESS FROM ASYNC TASKS An asynchronous method that wants to report progress just takes an IProgress parameter, with some appropriate type for T. There are two important things to keep in mind: The parameter can be null. This means that no progress reports are needed. IProgress.Report is thread-safe, but asynchronous. A TOUR OF TASK, PART 10: PROMISE TASKS YieldAwaitable Yield(); But it does kind of act kind of like a Promise Task. The YieldAwaitable type interacts with the async compiler transformation to force an asynchronous point within a method. By default, if await is used on an operation that has already completed, then the execution of the async method continues synchronously.THERE IS NO THREAD
This is an essential truth of async in its purest form: There is no thread. The objectors to this truth are legion. “No,” they cry, “if I am awaiting an operation, there must be a thread that is doing the wait! It’s probably a thread pool thread. TASK.RUN VS BACKGROUNDWORKER: CONCLUSION Round 1: Basics - how to run code on a background thread and receive a completion notification marshaled back to the UI thread. The Task.Run code is shorter and simpler with less “ceremony code”. Round 2: Errors - how to handle exceptions from the background thread code. The Task.Run code uses the more natural and less error-prone try/catch REVERSE COMPILING WINDOWS FORMS Today I had a fun task: the source code for an existing executable had been lost, and I got the job of getting it back. The good news is that Red Gate’s Reflector (formerly Lutz Roeder’s Reflector) is a standard tool for any serious .NET programmer, and it does quite a decent job of decompiling (nonobfuscated) .NET code. The bad news is that I had to also reverse-engineer the GUI. TASK.RUN ETIQUETTE EXAMPLES: DON'T USE TASK.RUN IN THE Last time we looked at using Task.Run for the wrong thing (code that is not CPU-bound). So let’s move on to the proper use case of Task.Run: CPU-bound code. We start off with some existing code, which synchronously does some heavy calculations. STEPHEN CLEARY (THE BLOG)ABOUT GODCONTACT Stephen Cleary's blog: async/await, programming, language design, and other sundry computer science topics. CONCURRENCY IN C# COOKBOOK This book focuses specifically on how code should be written, not how code could be written. This book does contain an introduction to concurrency (multithreading, asynchronous programming, etc). However, it is not an introduction to C# or .NET. I do expect my readers to understand delegates, lambda expressions, LINQ, OOP, etc. A NEW PATTERN FOR EXCEPTION LOGGING If you’re following along at home, enable logging scopes for the Console logger by updating CreateHostBuilder in your Program.cs, adding a call to ConfigureLogging that removes the existing Console logger and adds a new one that sets IncludeScopes to true:. public static IHostBuilder CreateHostBuilder (string args) => Host. CreateDefaultBuilder (args) // (begin code changes). A TOUR OF TASK, PART 0: OVERVIEW Two Types of Task. There are two types of tasks. The first type is a Delegate Task; this is a task that has code to run. The second type is a Promise Task; this is a task that represents some kind of event or signal. Promise Tasks are often I/O-based signals (e.g., “the HTTP download has completed”), but they can actually represent anything A TOUR OF TASK, PART 6: RESULTS T result = task.GetAwaiter().GetResult(); The code above will synchronously block until the task completes. As such, it is subject to the same old deadlock problems as Wait and Result. However, it will not wrap the task exceptions in an AggregateException. The code above will retrieve the result value from a STREAMING ZIP ON ASP.NET CORE A few weeks ago, I wrote about using PushStreamContent on ASP.NET to build a zip file on-demand that was totally asynchronous and did not have to buffer any intermeditate files in memory.. Today, let’s take a look at doing the same thing on ASP.NET Core! Downloading a Simple Stream. First, let’s look at how we can download a single filestream.
ASYNCHRONOUS PUSHSTREAMCONTENT First, we create the MemoryStream that the zip library will write to. Then, we download all the files asynchronously, and add them to the zip archive. Finally, we rewind the MemoryStream containing the zip file and send it to the browser using good ‘ol StreamContent. The problem with this approach is ASYNCHRONOUS LAZY INITIALIZATION When you have a lazy-created value, it’s often useful to lazy-create it in an asynchronous fashion. A simple Lazy provides lazy initialization, but the initialization TASK.RUN ETIQUETTE EXAMPLES: DON'T USE TASK.RUN IN THE Now the service API is clean (it exposes a synchronous API for a naturally-synchronous, CPU-bound method), it works for all consumers (e.g., ASP.NET), and the UI layer is responsible for not blocking the UI thread. Conclusion: do not use Task.Run in the implementation of the method; instead, use Task.Run to call the method. Task.RunEtiquette.
DETECTION OF HALF-OPEN (DROPPED) CONNECTIONSSEE MORE ON BLOG.STEPHENCLEARY.COM STEPHEN CLEARY (THE BLOG)ABOUT GODCONTACT Stephen Cleary's blog: async/await, programming, language design, and other sundry computer science topics. CONCURRENCY IN C# COOKBOOK This book focuses specifically on how code should be written, not how code could be written. This book does contain an introduction to concurrency (multithreading, asynchronous programming, etc). However, it is not an introduction to C# or .NET. I do expect my readers to understand delegates, lambda expressions, LINQ, OOP, etc. A NEW PATTERN FOR EXCEPTION LOGGING If you’re following along at home, enable logging scopes for the Console logger by updating CreateHostBuilder in your Program.cs, adding a call to ConfigureLogging that removes the existing Console logger and adds a new one that sets IncludeScopes to true:. public static IHostBuilder CreateHostBuilder (string args) => Host. CreateDefaultBuilder (args) // (begin code changes). A TOUR OF TASK, PART 0: OVERVIEW Two Types of Task. There are two types of tasks. The first type is a Delegate Task; this is a task that has code to run. The second type is a Promise Task; this is a task that represents some kind of event or signal. Promise Tasks are often I/O-based signals (e.g., “the HTTP download has completed”), but they can actually represent anything A TOUR OF TASK, PART 6: RESULTS T result = task.GetAwaiter().GetResult(); The code above will synchronously block until the task completes. As such, it is subject to the same old deadlock problems as Wait and Result. However, it will not wrap the task exceptions in an AggregateException. The code above will retrieve the result value from a STREAMING ZIP ON ASP.NET CORE A few weeks ago, I wrote about using PushStreamContent on ASP.NET to build a zip file on-demand that was totally asynchronous and did not have to buffer any intermeditate files in memory.. Today, let’s take a look at doing the same thing on ASP.NET Core! Downloading a Simple Stream. First, let’s look at how we can download a single filestream.
ASYNCHRONOUS PUSHSTREAMCONTENT First, we create the MemoryStream that the zip library will write to. Then, we download all the files asynchronously, and add them to the zip archive. Finally, we rewind the MemoryStream containing the zip file and send it to the browser using good ‘ol StreamContent. The problem with this approach is ASYNCHRONOUS LAZY INITIALIZATION When you have a lazy-created value, it’s often useful to lazy-create it in an asynchronous fashion. A simple Lazy provides lazy initialization, but the initialization TASK.RUN ETIQUETTE EXAMPLES: DON'T USE TASK.RUN IN THE Now the service API is clean (it exposes a synchronous API for a naturally-synchronous, CPU-bound method), it works for all consumers (e.g., ASP.NET), and the UI layer is responsible for not blocking the UI thread. Conclusion: do not use Task.Run in the implementation of the method; instead, use Task.Run to call the method. Task.RunEtiquette.
DETECTION OF HALF-OPEN (DROPPED) CONNECTIONSSEE MORE ON BLOG.STEPHENCLEARY.COM A NEW PATTERN FOR EXCEPTION LOGGING If you’re following along at home, enable logging scopes for the Console logger by updating CreateHostBuilder in your Program.cs, adding a call to ConfigureLogging that removes the existing Console logger and adds a new one that sets IncludeScopes to true:. public static IHostBuilder CreateHostBuilder (string args) => Host. CreateDefaultBuilder (args) // (begin code changes). MICROSOFT.EXTENSIONS.LOGGING, PART 2: TYPES Factory Provider Repository Builders. Yeah, naming is hard. In Microsoft.Extensions.Logging, there are two types in particular that I kept conflating: ILoggerProvider and ILoggerFactory.Even though they both can create instances of ILogger, they are actually completely different!. In this post, I’m going to cover the main types of Microsoft.Extensions.Logging and describe their intended use. MICROSOFT.EXTENSIONS.LOGGING, PART 1: INTRODUCTION Steven van Deursen, the creator of Simple Injector, has gone on record saying the whole Microsoft.Extensions.Logging design is a violation of the Dependency Injection Principle, with the ILogger specifically a violation of the Interface Segregation Principle. He strongly recommends option (3), but I have to counter that it’s hard for every library author in the world to get right. A TOUR OF TASK, PART 7: CONTINUATIONS Recent posts have considered several members that wait for tasks to complete (Wait, WaitAll, WaitAny, Result, and GetAwaiter().GetResult()).One common disadvantage that all of these have is that they synchronously block the calling thread while waiting for the task to complete.. Today’s post talks about continuations.A continuation is a delegate that you can attach to a task and tell the REPORTING PROGRESS FROM ASYNC TASKS An asynchronous method that wants to report progress just takes an IProgress parameter, with some appropriate type for T. There are two important things to keep in mind: The parameter can be null. This means that no progress reports are needed. IProgress.Report is thread-safe, but asynchronous. A TOUR OF TASK, PART 10: PROMISE TASKS YieldAwaitable Yield(); But it does kind of act kind of like a Promise Task. The YieldAwaitable type interacts with the async compiler transformation to force an asynchronous point within a method. By default, if await is used on an operation that has already completed, then the execution of the async method continues synchronously.THERE IS NO THREAD
This is an essential truth of async in its purest form: There is no thread. The objectors to this truth are legion. “No,” they cry, “if I am awaiting an operation, there must be a thread that is doing the wait! It’s probably a thread pool thread. TASK.RUN VS BACKGROUNDWORKER: CONCLUSION Round 1: Basics - how to run code on a background thread and receive a completion notification marshaled back to the UI thread. The Task.Run code is shorter and simpler with less “ceremony code”. Round 2: Errors - how to handle exceptions from the background thread code. The Task.Run code uses the more natural and less error-prone try/catch REVERSE COMPILING WINDOWS FORMS Today I had a fun task: the source code for an existing executable had been lost, and I got the job of getting it back. The good news is that Red Gate’s Reflector (formerly Lutz Roeder’s Reflector) is a standard tool for any serious .NET programmer, and it does quite a decent job of decompiling (nonobfuscated) .NET code. The bad news is that I had to also reverse-engineer the GUI. TASK.RUN ETIQUETTE EXAMPLES: DON'T USE TASK.RUN IN THE Last time we looked at using Task.Run for the wrong thing (code that is not CPU-bound). So let’s move on to the proper use case of Task.Run: CPU-bound code. We start off with some existing code, which synchronously does some heavy calculations. STEPHEN CLEARY (THE BLOG)ABOUT GODCONTACT Stephen Cleary's blog: async/await, programming, language design, and other sundry computer science topics. A TOUR OF TASK, PART 0: OVERVIEW Two Types of Task. There are two types of tasks. The first type is a Delegate Task; this is a task that has code to run. The second type is a Promise Task; this is a task that represents some kind of event or signal. Promise Tasks are often I/O-based signals (e.g., “the HTTP download has completed”), but they can actually represent anything ELIDING ASYNC AND AWAIT A TOUR OF TASK, PART 6: RESULTS T result = task.GetAwaiter().GetResult(); The code above will synchronously block until the task completes. As such, it is subject to the same old deadlock problems as Wait and Result. However, it will not wrap the task exceptions in an AggregateException. The code above will retrieve the result value from aTCP/IP RESOURCES
There are two books that any TCP/IP network programmer needs to have. Unfortunately, they were both written well before .NET, so they only deal with unmanaged code - specifically, the WinSock API. However, the .NET Socket class methods directly correspond to WinSock function calls, so knowledge can be gleaned from these books and directly applied to managed code. MICROSOFT.EXTENSIONS.LOGGING, PART 1: INTRODUCTION Steven van Deursen, the creator of Simple Injector, has gone on record saying the whole Microsoft.Extensions.Logging design is a violation of the Dependency Injection Principle, with the ILogger specifically a violation of the Interface Segregation Principle. He strongly recommends option (3), but I have to counter that it’s hard for every library author in the world to get right.THERE IS NO THREAD
This is an essential truth of async in its purest form: There is no thread. The objectors to this truth are legion. “No,” they cry, “if I am awaiting an operation, there must be a thread that is doing the wait! It’s probably a thread pool thread. ASYNCHRONOUS LAZY INITIALIZATION When you have a lazy-created value, it’s often useful to lazy-create it in an asynchronous fashion. A simple Lazy provides lazy initialization, but the initializationSOCKET OPERATIONS
There are a few logical operations that may be performed on a TCP/IP socket, regardless of whether the socket is synchronous or asynchronous. Each of the operations below is marked “immediate” (meaning it is completed immediately) or “delayed” (meaning it depends on the network for completion). REVERSE COMPILING WINDOWS FORMS Today I had a fun task: the source code for an existing executable had been lost, and I got the job of getting it back. The good news is that Red Gate’s Reflector (formerly Lutz Roeder’s Reflector) is a standard tool for any serious .NET programmer, and it does quite a decent job of decompiling (nonobfuscated) .NET code. The bad news is that I had to also reverse-engineer the GUI. STEPHEN CLEARY (THE BLOG)ABOUT GODCONTACT Stephen Cleary's blog: async/await, programming, language design, and other sundry computer science topics. A TOUR OF TASK, PART 0: OVERVIEW Two Types of Task. There are two types of tasks. The first type is a Delegate Task; this is a task that has code to run. The second type is a Promise Task; this is a task that represents some kind of event or signal. Promise Tasks are often I/O-based signals (e.g., “the HTTP download has completed”), but they can actually represent anything ELIDING ASYNC AND AWAIT A TOUR OF TASK, PART 6: RESULTS T result = task.GetAwaiter().GetResult(); The code above will synchronously block until the task completes. As such, it is subject to the same old deadlock problems as Wait and Result. However, it will not wrap the task exceptions in an AggregateException. The code above will retrieve the result value from aTCP/IP RESOURCES
There are two books that any TCP/IP network programmer needs to have. Unfortunately, they were both written well before .NET, so they only deal with unmanaged code - specifically, the WinSock API. However, the .NET Socket class methods directly correspond to WinSock function calls, so knowledge can be gleaned from these books and directly applied to managed code. MICROSOFT.EXTENSIONS.LOGGING, PART 1: INTRODUCTION Steven van Deursen, the creator of Simple Injector, has gone on record saying the whole Microsoft.Extensions.Logging design is a violation of the Dependency Injection Principle, with the ILogger specifically a violation of the Interface Segregation Principle. He strongly recommends option (3), but I have to counter that it’s hard for every library author in the world to get right.THERE IS NO THREAD
This is an essential truth of async in its purest form: There is no thread. The objectors to this truth are legion. “No,” they cry, “if I am awaiting an operation, there must be a thread that is doing the wait! It’s probably a thread pool thread. ASYNCHRONOUS LAZY INITIALIZATION When you have a lazy-created value, it’s often useful to lazy-create it in an asynchronous fashion. A simple Lazy provides lazy initialization, but the initializationSOCKET OPERATIONS
There are a few logical operations that may be performed on a TCP/IP socket, regardless of whether the socket is synchronous or asynchronous. Each of the operations below is marked “immediate” (meaning it is completed immediately) or “delayed” (meaning it depends on the network for completion). REVERSE COMPILING WINDOWS FORMS Today I had a fun task: the source code for an existing executable had been lost, and I got the job of getting it back. The good news is that Red Gate’s Reflector (formerly Lutz Roeder’s Reflector) is a standard tool for any serious .NET programmer, and it does quite a decent job of decompiling (nonobfuscated) .NET code. The bad news is that I had to also reverse-engineer the GUI. BACKGROUNDSERVICE GOTCHA: STARTUP BackgroundService Gotcha: Synchronous Starts. This is some behavior that I’ve found surprising (and others have as well): ASP.NET Core background services are started with a synchronous call. Specifically, the host will invoke IHostedService.StartAsync for all its hosted services, and BackgroundService directly invokes ExecuteAsync before A TOUR OF TASK, PART 0: OVERVIEW Two Types of Task. There are two types of tasks. The first type is a Delegate Task; this is a task that has code to run. The second type is a Promise Task; this is a task that represents some kind of event or signal. Promise Tasks are often I/O-based signals (e.g., “the HTTP download has completed”), but they can actually represent anything BACKGROUNDSERVICE GOTCHA: APPLICATION LIFETIME Hosted services (including BackgroundService s) have a lifetime that is independent from their host. This means that if a BackgroundService exits, its host will not exit. And a host will happily continue running even if all its services have exited. This mistake is most common when writing a kind of “subscriber” or “backend processor MICROSOFT.EXTENSIONS.LOGGING, PART 2: TYPES Factory Provider Repository Builders. Yeah, naming is hard. In Microsoft.Extensions.Logging, there are two types in particular that I kept conflating: ILoggerProvider and ILoggerFactory.Even though they both can create instances of ILogger, they are actually completely different!. In this post, I’m going to cover the main types of Microsoft.Extensions.Logging and describe their intended use. INTRODUCTION TO DATAFLOW, PART 3 So far in this series, we’ve covered an introduction to some Dataflow concepts and some of the Dataflow blocks that are available.Today we’ll look at some of the details to consider when building dataflow meshes. Completing Blocks. I mentioned in my first Dataflow post that completion can be handled by calling Complete, which will eventually cause the Completion task to complete. STREAMING ZIP ON ASP.NET CORE A few weeks ago, I wrote about using PushStreamContent on ASP.NET to build a zip file on-demand that was totally asynchronous and did not have to buffer any intermeditate files in memory.. Today, let’s take a look at doing the same thing on ASP.NET Core! Downloading a Simple Stream. First, let’s look at how we can download a single filestream.
A TOUR OF TASK, PART 10: PROMISE TASKS YieldAwaitable Yield(); But it does kind of act kind of like a Promise Task. The YieldAwaitable type interacts with the async compiler transformation to force an asynchronous point within a method. By default, if await is used on an operation that has already completed, then the execution of the async method continues synchronously. ASYNCHRONOUS LAZY INITIALIZATION When you have a lazy-created value, it’s often useful to lazy-create it in an asynchronous fashion. A simple Lazy provides lazy initialization, but the initialization ASP.NET CORE SYNCHRONIZATIONCONTEXT ASP.NET Core does not have a SynchronizationContext, so await defaults to the thread pool context. So, in the ASP.NET Core world, asynchronous continuations may run on any thread, and they may all run in parallel. As a contrived example, consider this code, which downloads two strings and places them into a TASK.RUN ETIQUETTE EXAMPLES: DON'T USE TASK.RUN IN THE Now the service API is clean (it exposes a synchronous API for a naturally-synchronous, CPU-bound method), it works for all consumers (e.g., ASP.NET), and the UI layer is responsible for not blocking the UI thread. Conclusion: do not use Task.Run in the implementation of the method; instead, use Task.Run to call the method. Task.RunEtiquette.
STEPHEN CLEARY (THE BLOG)ABOUT GODCONTACT Stephen Cleary's blog: async/await, programming, language design, and other sundry computer science topics. A TOUR OF TASK, PART 0: OVERVIEW Two Types of Task. There are two types of tasks. The first type is a Delegate Task; this is a task that has code to run. The second type is a Promise Task; this is a task that represents some kind of event or signal. Promise Tasks are often I/O-based signals (e.g., “the HTTP download has completed”), but they can actually represent anything ELIDING ASYNC AND AWAIT A TOUR OF TASK, PART 6: RESULTS T result = task.GetAwaiter().GetResult(); The code above will synchronously block until the task completes. As such, it is subject to the same old deadlock problems as Wait and Result. However, it will not wrap the task exceptions in an AggregateException. The code above will retrieve the result value from aTCP/IP RESOURCES
There are two books that any TCP/IP network programmer needs to have. Unfortunately, they were both written well before .NET, so they only deal with unmanaged code - specifically, the WinSock API. However, the .NET Socket class methods directly correspond to WinSock function calls, so knowledge can be gleaned from these books and directly applied to managed code. MICROSOFT.EXTENSIONS.LOGGING, PART 1: INTRODUCTION Steven van Deursen, the creator of Simple Injector, has gone on record saying the whole Microsoft.Extensions.Logging design is a violation of the Dependency Injection Principle, with the ILogger specifically a violation of the Interface Segregation Principle. He strongly recommends option (3), but I have to counter that it’s hard for every library author in the world to get right.THERE IS NO THREAD
This is an essential truth of async in its purest form: There is no thread. The objectors to this truth are legion. “No,” they cry, “if I am awaiting an operation, there must be a thread that is doing the wait! It’s probably a thread pool thread. ASYNCHRONOUS LAZY INITIALIZATION When you have a lazy-created value, it’s often useful to lazy-create it in an asynchronous fashion. A simple Lazy provides lazy initialization, but the initializationSOCKET OPERATIONS
There are a few logical operations that may be performed on a TCP/IP socket, regardless of whether the socket is synchronous or asynchronous. Each of the operations below is marked “immediate” (meaning it is completed immediately) or “delayed” (meaning it depends on the network for completion). REVERSE COMPILING WINDOWS FORMS Today I had a fun task: the source code for an existing executable had been lost, and I got the job of getting it back. The good news is that Red Gate’s Reflector (formerly Lutz Roeder’s Reflector) is a standard tool for any serious .NET programmer, and it does quite a decent job of decompiling (nonobfuscated) .NET code. The bad news is that I had to also reverse-engineer the GUI. STEPHEN CLEARY (THE BLOG)ABOUT GODCONTACT Stephen Cleary's blog: async/await, programming, language design, and other sundry computer science topics. A TOUR OF TASK, PART 0: OVERVIEW Two Types of Task. There are two types of tasks. The first type is a Delegate Task; this is a task that has code to run. The second type is a Promise Task; this is a task that represents some kind of event or signal. Promise Tasks are often I/O-based signals (e.g., “the HTTP download has completed”), but they can actually represent anything ELIDING ASYNC AND AWAIT A TOUR OF TASK, PART 6: RESULTS T result = task.GetAwaiter().GetResult(); The code above will synchronously block until the task completes. As such, it is subject to the same old deadlock problems as Wait and Result. However, it will not wrap the task exceptions in an AggregateException. The code above will retrieve the result value from aTCP/IP RESOURCES
There are two books that any TCP/IP network programmer needs to have. Unfortunately, they were both written well before .NET, so they only deal with unmanaged code - specifically, the WinSock API. However, the .NET Socket class methods directly correspond to WinSock function calls, so knowledge can be gleaned from these books and directly applied to managed code. MICROSOFT.EXTENSIONS.LOGGING, PART 1: INTRODUCTION Steven van Deursen, the creator of Simple Injector, has gone on record saying the whole Microsoft.Extensions.Logging design is a violation of the Dependency Injection Principle, with the ILogger specifically a violation of the Interface Segregation Principle. He strongly recommends option (3), but I have to counter that it’s hard for every library author in the world to get right.THERE IS NO THREAD
This is an essential truth of async in its purest form: There is no thread. The objectors to this truth are legion. “No,” they cry, “if I am awaiting an operation, there must be a thread that is doing the wait! It’s probably a thread pool thread. ASYNCHRONOUS LAZY INITIALIZATION When you have a lazy-created value, it’s often useful to lazy-create it in an asynchronous fashion. A simple Lazy provides lazy initialization, but the initializationSOCKET OPERATIONS
There are a few logical operations that may be performed on a TCP/IP socket, regardless of whether the socket is synchronous or asynchronous. Each of the operations below is marked “immediate” (meaning it is completed immediately) or “delayed” (meaning it depends on the network for completion). REVERSE COMPILING WINDOWS FORMS Today I had a fun task: the source code for an existing executable had been lost, and I got the job of getting it back. The good news is that Red Gate’s Reflector (formerly Lutz Roeder’s Reflector) is a standard tool for any serious .NET programmer, and it does quite a decent job of decompiling (nonobfuscated) .NET code. The bad news is that I had to also reverse-engineer the GUI. BACKGROUNDSERVICE GOTCHA: STARTUP BackgroundService Gotcha: Synchronous Starts. This is some behavior that I’ve found surprising (and others have as well): ASP.NET Core background services are started with a synchronous call. Specifically, the host will invoke IHostedService.StartAsync for all its hosted services, and BackgroundService directly invokes ExecuteAsync before A TOUR OF TASK, PART 0: OVERVIEW Two Types of Task. There are two types of tasks. The first type is a Delegate Task; this is a task that has code to run. The second type is a Promise Task; this is a task that represents some kind of event or signal. Promise Tasks are often I/O-based signals (e.g., “the HTTP download has completed”), but they can actually represent anything BACKGROUNDSERVICE GOTCHA: APPLICATION LIFETIME Hosted services (including BackgroundService s) have a lifetime that is independent from their host. This means that if a BackgroundService exits, its host will not exit. And a host will happily continue running even if all its services have exited. This mistake is most common when writing a kind of “subscriber” or “backend processor MICROSOFT.EXTENSIONS.LOGGING, PART 2: TYPES Factory Provider Repository Builders. Yeah, naming is hard. In Microsoft.Extensions.Logging, there are two types in particular that I kept conflating: ILoggerProvider and ILoggerFactory.Even though they both can create instances of ILogger, they are actually completely different!. In this post, I’m going to cover the main types of Microsoft.Extensions.Logging and describe their intended use. INTRODUCTION TO DATAFLOW, PART 3 So far in this series, we’ve covered an introduction to some Dataflow concepts and some of the Dataflow blocks that are available.Today we’ll look at some of the details to consider when building dataflow meshes. Completing Blocks. I mentioned in my first Dataflow post that completion can be handled by calling Complete, which will eventually cause the Completion task to complete. STREAMING ZIP ON ASP.NET CORE A few weeks ago, I wrote about using PushStreamContent on ASP.NET to build a zip file on-demand that was totally asynchronous and did not have to buffer any intermeditate files in memory.. Today, let’s take a look at doing the same thing on ASP.NET Core! Downloading a Simple Stream. First, let’s look at how we can download a single filestream.
A TOUR OF TASK, PART 10: PROMISE TASKS YieldAwaitable Yield(); But it does kind of act kind of like a Promise Task. The YieldAwaitable type interacts with the async compiler transformation to force an asynchronous point within a method. By default, if await is used on an operation that has already completed, then the execution of the async method continues synchronously. ASYNCHRONOUS LAZY INITIALIZATION When you have a lazy-created value, it’s often useful to lazy-create it in an asynchronous fashion. A simple Lazy provides lazy initialization, but the initialization ASP.NET CORE SYNCHRONIZATIONCONTEXT ASP.NET Core does not have a SynchronizationContext, so await defaults to the thread pool context. So, in the ASP.NET Core world, asynchronous continuations may run on any thread, and they may all run in parallel. As a contrived example, consider this code, which downloads two strings and places them into a TASK.RUN ETIQUETTE EXAMPLES: DON'T USE TASK.RUN IN THE Now the service API is clean (it exposes a synchronous API for a naturally-synchronous, CPU-bound method), it works for all consumers (e.g., ASP.NET), and the UI layer is responsible for not blocking the UI thread. Conclusion: do not use Task.Run in the implementation of the method; instead, use Task.Run to call the method. Task.RunEtiquette.
Toggle navigation
Stephen Cleary
* Blog
* Videos
* Projects
* Publications
* Book
* Contact
* __
* __
ALL BLOG POSTS
MAY 6, 2020
USING GITHUB ACTIONS FOR PULL REQUEST STAGING ENVIRONMENTS, PART 4: AUTOMATED DEPLOY AND TEARDOWNAPR 24, 2020
USING GITHUB ACTIONS FOR PULL REQUEST STAGING ENVIRONMENTS, PART 3: IMPLEMENTING DEPLOY AND TEARDOWNAPR 9, 2020
USING GITHUB ACTIONS FOR PULL REQUEST STAGING ENVIRONMENTS, PART 2:SLASH COMMANDS
APR 2, 2020
USING GITHUB ACTIONS FOR PULL REQUEST STAGING ENVIRONMENTS, PART 1:INTRODUCTION
MAR 28, 2020
VALUETASK RESTRICTIONSJUN 7, 2018
MICROSOFT.EXTENSIONS.LOGGING, PART 2: TYPESMAY 31, 2018
MICROSOFT.EXTENSIONS.LOGGING, PART 1: INTRODUCTIONMAY 24, 2018
DOCKER AS A TOOL PROVIDERMAY 18, 2018
USING VSCODE WITH PEGJSMAY 10, 2018
UNIT TESTING WITH ROSLYNAPR 12, 2018
SLIDES AVAILABLE: CODE PALOUSA 2018SEP 12, 2017
HAPPY BIRTHDAY ASYNCAUG 31, 2017
AZURE FUNCTIONS SPA
AUG 25, 2017
CONTINUOUSLY DEPLOY AZURE FUNCTIONS FROM A GITHUB SUBFOLDERJUL 14, 2017
ANNOUNCING ASYNCTIMEJUN 29, 2017
HAPPY BIRTHDAY, IPHONE!JUN 22, 2017
ASYNC JAVASCRIPT
MAR 30, 2017
ASP.NET CORE SYNCHRONIZATIONCONTEXTDEC 1, 2016
ELIDING ASYNC AND AWAITNOV 18, 2016
AZURE FUNCTIONS
NOV 11, 2016
STREAMING ZIP ON ASP.NET CORENOV 3, 2016
ZIPARCHIVE ON WRITE-ONLY STREAMSOCT 27, 2016
HISTORICAL ASYNCHRONOUS PUSHSTREAMCONTENTOCT 20, 2016
ASYNCHRONOUS PUSHSTREAMCONTENTOCT 13, 2016
ANNOUNCEMENT: SPEAKING AT MILWAUKEE .NETOCT 6, 2016
BRAZILIAN PORTUGUESE TRANSLATION OF ASYNC/AWAITJUN 28, 2016
DOTNET / NETCORE VERSIONSMAY 17, 2016
REACT/REDUX TODOMVC, PART 6: REFACTORINGAPR 12, 2016
REACT/REDUX TODOMVC, PART 5: DISPATCHINGMAR 8, 2016
REACT/REDUX TODOMVC, PART 4: DEBUGGINGMAR 1, 2016
REACT/REDUX TODOMVC, PART 3: STATEFEB 23, 2016
REACT/REDUX TODOMVC, PART 2: GETTING STARTEDFEB 17, 2016
REACT/REDUX TODOMVC, PART 1: LANGUAGE AND TOOLINGFEB 11, 2016
REACT/REDUX TODOMVC, PART 0B: WHY REACT? WHY REDUX?FEB 10, 2016
REACT/REDUX TODOMVC, PART 0: INTRODUCTIONJAN 21, 2016
DOTNETAPIS ENTERS BETAMAY 27, 2015
THATCONFERENCE 2015
MAY 1, 2015
MVP VIRTUAL CONFERENCEAPR 30, 2015
A TOUR OF TASK, PART 10: PROMISE TASKSMAR 28, 2015
CONTINUOUS INTEGRATION AND CODE COVERAGE FOR OPEN SOURCE .NET CORECLRPROJECTS
MAR 21, 2015
GRDEVDAY 2015
MAR 5, 2015
ASYNC CONSOLE APPS ON .NET CORECLRMAR 3, 2015
A TOUR OF TASK, PART 9: DELEGATE TASKSFEB 5, 2015
A TOUR OF TASK, PART 8: STARTINGJAN 29, 2015
A TOUR OF TASK, PART 7: CONTINUATIONSJAN 13, 2015
CODEMASH 2015
DEC 5, 2014
A TOUR OF TASK, PART 6: RESULTSOCT 10, 2014
A TOUR OF TASK, PART 5: WAITINGJUN 14, 2014
AWAIT IN CATCH AND FINALLYJUN 12, 2014
A TOUR OF TASK, PART 4: IDJUN 7, 2014
FIRE AND FORGET ON ASP.NETJUN 5, 2014
A TOUR OF TASK, PART 3: STATUSMAY 29, 2014
A TOUR OF TASK, PART 2: ASYNCSTATE AND CREATIONOPTIONSMAY 15, 2014
A TOUR OF TASK, PART 1: CONSTRUCTORSMAY 5, 2014
ANNOUNCEMENT: CONCURRENCY IN C# EARLY RELEASE EBOOK AVAILABLEMAY 1, 2014
ANNOUNCEMENT: MSDN ARTICLE ON ASYNC SERVICESAPR 28, 2014
ANNOUNCEMENT: CALCULATED PROPERTIESAPR 24, 2014
A TOUR OF TASK, PART 0: OVERVIEWAPR 17, 2014
ANNOUNCEMENT: BOOK
APR 8, 2014
ANNOUNCEMENT: MSDN "ASYNC MVVM" ARTICLESAPR 7, 2014
ANNOUNCEMENT: ASPNETBACKGROUNDTASKS NUGET LIBRARYAPR 4, 2014
ANNOUNCEMENT: GRDEVDAY 2014 SLIDES AVAILABLEMAR 13, 2014
A CROSS-DOMAIN SINGLETONFEB 27, 2014
GUIDELINES FOR LOCK-FREE PROGRAMMINGFEB 20, 2014
SYNCHRONOUS AND ASYNCHRONOUS DELEGATE TYPESJAN 9, 2014
ACHIEVEMENT UNLOCKED: SPEAK AT CODEMASHJAN 2, 2014
ANNOUNCEMENT: SPEAKING AT CODEMASH 2014DEC 12, 2013
AZURE CACHE SERIALIZATION (WITH JSON!)NOV 21, 2013
THERE IS NO THREAD
NOV 14, 2013
ANNOUNCEMENT: NITO.ASYNCEX 2.0.0NOV 11, 2013
ANNOUNCEMENT: ASYNCDIAGNOSTICS 1.0.1 PRERELEASENOV 8, 2013
TASK.RUN ETIQUETTE EXAMPLES: EVEN IN THE COMPLEX CASE, DON'T USE TASK.RUN IN THE IMPLEMENTATIONNOV 7, 2013
TASK.RUN ETIQUETTE EXAMPLES: DON'T USE TASK.RUN IN THE IMPLEMENTATIONNOV 6, 2013
TASK.RUN ETIQUETTE EXAMPLES: DON'T USE TASK.RUN FOR THE WRONG THINGOCT 17, 2013
TASK.RUN ETIQUETTE AND PROPER USAGEOCT 10, 2013
MANAGED SERVICES ROUNDUPOCT 3, 2013
CONTINUEWITH IS DANGEROUS, TOOSEP 26, 2013
TASK.RUN VS BACKGROUNDWORKER: CONCLUSIONSEP 19, 2013
TASK.RUN VS BACKGROUNDWORKER, ROUND 5: REPORTING PROGRESSSEP 12, 2013
TASK.RUN VS BACKGROUNDWORKER, ROUND 4: CANCELLATIONAUG 29, 2013
STARTNEW IS DANGEROUSAUG 13, 2013
SLIDES AVAILABLE: THATCONFERENCE 2013AUG 1, 2013
TASK.RUN VS BACKGROUNDWORKER, ROUND 3: RETURNING RESULTSJUL 26, 2013
TASK.RUN VS BACKGROUNDWORKER, ROUND 2: ERROR HANDLINGMAY 17, 2013
ANNOUNCEMENT: ASYNC DIAGNOSTICSMAY 16, 2013
ANNOUNCEMENT: C# MVPMAY 15, 2013
ANNOUNCEMENT: ASYNCEX STABLE RELEASEMAY 14, 2013
ANNOUNCEMENT: SPEAKING AT THATCONFERENCEMAY 13, 2013
ANNOUNCEMENT: OVER 200 POSTS!MAY 9, 2013
TASK.RUN VS BACKGROUNDWORKER, ROUND 1: THE BASIC PATTERNMAY 2, 2013
TASK.RUN VS BACKGROUNDWORKER: INTROAPR 25, 2013
RECURSIVE (RE-ENTRANT) LOCKSAPR 18, 2013
UI GUIDELINES FOR ASYNCAPR 11, 2013
CANCELLATIONTOKEN BEHAVIOR WITH ASYNCEX COORDINATION PRIMITIVESAPR 4, 2013
IMPLICIT ASYNC CONTEXT ("ASYNCLOCAL")MAR 28, 2013
TASK.CURRENTID IN ASYNC METHODSMAR 21, 2013
A FEW WORDS ON TASK.ID (AND TASKSCHEDULER.ID)MAR 14, 2013
ASYNC OOP 7: DESIGN
MAR 7, 2013
ASYNC OOP 6: DISPOSALMAR 2, 2013
GRDEVDAY SLIDES AND CODEMAR 1, 2013
MSDN ARTICLE AND GRDEVDAYFEB 28, 2013
ASYNC OOP 5: EVENTS
JAN 31, 2013
ASYNC OOP 4: STATE
JAN 24, 2013
ASYNC OOP 3: PROPERTIESJAN 17, 2013
ASYNC OOP 2: CONSTRUCTORSJAN 10, 2013
ASYNC OOP 1: INHERITANCE AND INTERFACESJAN 3, 2013
ASYNC OOP 0: INTRODUCTIONDEC 27, 2012
ASYNC PRODUCER-CONSUMER QUEUE 3: MORE FLEXIBILITYDEC 20, 2012
ASYNC PRODUCER-CONSUMER QUEUE 2: MORE PORTABILITYDEC 13, 2012
RETURNING EARLY FROM ASP.NET REQUESTSDEC 6, 2012
DON'T BLOCK IN ASYNCHRONOUS CODENOV 15, 2012
PORTABLE CLASS LIBRARY ENLIGHTENMENT / ADAPTATIONNOV 8, 2012
ASYNC PRODUCER/CONSUMER QUEUE USING DATAFLOWNOV 8, 2012
AND I'M BACK!
OCT 4, 2012
INTRODUCTION TO DATAFLOW, PART 3SEP 27, 2012
INTRODUCTION TO DATAFLOW, PART 2SEP 20, 2012
INTRODUCTION TO DATAFLOW, PART 1SEP 12, 2012
AN ASYNC HORROR STORYSEP 10, 2012
A NEW WEB SITE
AUG 30, 2012
ASYNC COROUTINES
AUG 23, 2012
ASYNC AND SCHEDULED CONCURRENCYAUG 16, 2012
WINDOWS 8 BOOT TO DIFFERENCING VHDAUG 16, 2012
ASYNCHRONOUS LAZY INITIALIZATIONAUG 9, 2012
ASYNC DOESN'T CHANGE THE HTTP PROTOCOLAUG 2, 2012
ASYNC WCF TODAY AND TOMORROWJUL 26, 2012
ASYNC INTEROP WITH IASYNCRESULTJUL 19, 2012
THREAD IS DEAD
JUL 12, 2012
DON'T BLOCK ON ASYNC CODEJUN 21, 2012
ARRAYSEGMENTS LIBRARY AVAILABLEMAY 17, 2012
FRAMEWORK PROFILES IN .NETFEB 23, 2012
THINKING ABOUT ASYNC TASKSFEB 16, 2012
REPORTING PROGRESS FROM ASYNC TASKSFEB 9, 2012
CREATING TASKS
FEB 7, 2012
ASYNC UNIT TESTS, PART 2: THE RIGHT WAYFEB 6, 2012
ASYNC UNIT TESTS, PART 1: THE WRONG WAYFEB 3, 2012
ASYNC CONSOLE PROGRAMSFEB 2, 2012
ASYNC AND AWAIT
DEC 1, 2011
OUT FOR A BIT
NOV 26, 2011
VIRTUALIZING TWO MACHINES OVER THANKSGIVINGOCT 13, 2011
OPTION PARSING: CASE SENSITIVITYOCT 6, 2011
OPTION PARSING: POSITIONAL ARGUMENTSSEP 9, 2011
NITO.ASYNCEX AVAILABLESEP 1, 2011
THE ASYNC CTP "WHY DO THE KEYWORDS WORK THAT WAY" UNOFFICIAL FAQAUG 25, 2011
OPTION PARSING: VALIDATIONAUG 18, 2011
OPTION PARSING: BOOLEAN OPTIONSAUG 11, 2011
OPTION PARSING: ARGUMENT PARSINGAUG 4, 2011
OPTION PARSING: PREVENTING MULTIPLE ARGUMENT VALUESJUL 28, 2011
OPTION PARSING: ALLOWING MULTIPLE ARGUMENT VALUESJUL 21, 2011
SYSTEM.THREADING.TIMER CONSTRUCTOR AND GARBAGE COLLECTIONJUL 14, 2011
OPTION PARSING: OPTIONS WITH OPTIONAL ARGUMENTSJUL 7, 2011
OPTION PARSING: DEFAULT AND NULLABLE ARGUMENT VALUESJUN 30, 2011
OPTION PARSING: OPTION NAMESJUN 23, 2011
OPTION PARSING: ERROR HANDLINGJUN 16, 2011
OPTION PARSING: LEXINGJUN 9, 2011
OPTION PARSING: THE OPTION PARSING PIPELINEJUN 2, 2011
HOW TO RUN PROCESSES REMOTELYMAY 26, 2011
GETTING THE OBJECTCONTEXT FROM AN ENTITYOBJECTMAY 19, 2011
SIGNED AND UNSIGNED COMPARISONS IN C, C#, AND T-SQLMAY 12, 2011
MANAGED SERVICES AND UISMAY 5, 2011
SIMPLE AND EASY ENTITY FRAMEWORK SQL TRACINGAPR 28, 2011
UNMANAGED BLOCKING
APR 26, 2011
NUGET NO LONGER SUPPORTS CODE CONTRACTSMAR 28, 2011
EXCEPTION TYPES
MAR 24, 2011
THE BORDER CASE OF ABSFEB 20, 2011
SYNCHRONIZATIONCONTEXT ODDS AND ENDSFEB 11, 2011
OPTION PARSING: INTRODUCTIONFEB 3, 2011
NUGET PACKAGES FOR NITO.KITCHENSINKFEB 1, 2011
MSDN ARTICLE ON SYNCHRONIZATIONCONTEXT PUBLISHEDJAN 21, 2011
NEW LIBRARY: CONNECTEDPROPERTIESJAN 19, 2011
SIMPLE AND EASY CODE CONTRACTSJAN 14, 2011
SHARP CORNER: REFERENCE TYPES, VALUE TYPES, AND WEIRDOSDEC 30, 2010
SIMPLE AND EASY TRACING IN .NETDEC 24, 2010
ON A LIGHTER NOTE: "WII ME"?DEC 21, 2010
CONDITIONALWEAKTABLENOV 20, 2010
IT'S A GIRL!
NOV 16, 2010
A FEW WORDS ON GUIDSOCT 23, 2010
GRAND RAPIDS DAY OF DOTNET SLIDES AVAILABLEOCT 18, 2010
IMPLEMENTING GCC'S BUILTIN FUNCTIONSOCT 15, 2010
FIRMWARE???
SEP 16, 2010
USING ILMERGE WITH .NET 4.0 AND/OR RXAUG 16, 2010
VARIOUS IMPLEMENTATIONS OF ASYNCHRONOUS BACKGROUND TASKSAUG 5, 2010
USING RX FOR STREAM ENCODING AND DECODINGAUG 2, 2010
A REMINDER ABOUT ASYNCHRONOUS FILESTREAMSJUL 31, 2010
ASYNCHRONOUS CONTEXTS IN RXJUL 16, 2010
RESHARPER AND THE OBSCURE CTS CORNER CASEJUN 25, 2010
ON A LIGHTER NOTE: SOCKETFLAGS.MAXIOVECTORLENGTHJUN 21, 2010
SQLITE AND ENTITY FRAMEWORK 4JUN 18, 2010
REPORTING PROGRESS FROM TASKSJUN 2, 2010
TRANSACTIONSCOPE HAS A DEFAULT TIMEOUTMAY 1, 2010
RUSSIAN TRANSLATION OF "IMPLEMENTING IDISPOSABLE AND FINALIZERS: 3SIMPLE RULES"
MAY 1, 2010
MS BUG: MVCBUILDVIEWS WITH ONE-CLICK PUBLISHAPR 30, 2010
DYNAMICALLY BINDING TO STATIC (CLASS-SCOPED) MEMBERSAPR 26, 2010
INNOVATIONS ARE GREAT, BUT CONTENT IS NECESSARYAPR 23, 2010
GENERIC METHODS WITH DYNAMIC IMPLEMENTATIONSAPR 19, 2010
SVN SOURCE INDEXING TO CODEPLEXAPR 15, 2010
DECLARATIVE PROGRAMMING LANGUAGESAPR 13, 2010
VS2010 WITHOUT WEB DEPLOYMENT PROJECTSAPR 13, 2010
VS2010 WEBDEPLOY AND VS2010 WEB DEPLOYMENT PROJECTS BETA 1APR 13, 2010
T4: ALMOST COMPLETE
APR 6, 2010
SHARP CORNERS: ILIST.ISREADONLY != ILIST.ISREADONLYMAR 27, 2010
XMLDOCS: LINKING TO THE OVERLOADS PAGEMAR 27, 2010
XML DOCUMENTATION: THE BASICSMAR 20, 2010
INHERITANCE IN GENERAL, AND DERIVING FROM HASHALGORITHM IN PARTICULARMAR 17, 2010
I/O LIMITATION IN WINDOWSMAR 14, 2010
SHARP CORNER: VALUE TYPES ARE NEVER REFERENCE-EQUALMAR 13, 2010
INTRODUCING SHARP CORNERSFEB 23, 2010
CRAZY SATURDAY
FEB 17, 2010
Q&A: SHOULD I SET VARIABLES TO NULL TO ASSIST GARBAGE COLLECTION?FEB 16, 2010
INTEROP: MULTIDIMENSIONAL ARRAYS OF CHARACTERS IN A STRUCTUREFEB 16, 2010
HOW TO IMPLEMENT IDISPOSABLE AND FINALIZERS: MATRIX AND FLOWCHARTFEB 15, 2010
EVOLUTION OF FRAMEWORK DESIGN GUIDELINES?FEB 15, 2010
ASP.NET SLIDES AVAILABLEFEB 6, 2010
NITO.ASSIMILATION - THE ASSEMBLY MANIPULATORFEB 1, 2010
JQUERY HOSTED ON GOOGLE'S CDN WITH INTELLISENSEFEB 1, 2010
CROSS-BROWSER SILVERLIGHTJAN 18, 2010
ASP.NET MVC FAKING WEB SERVICESJAN 5, 2010
EXTENSION-BASED TYPESJAN 2, 2010
VIEW OF 2010
JAN 2, 2010
BEST COMPUTER PROGRAMMING BOOK EVERDEC 18, 2009
(PRE)ANNOUNCEMENT OF NITO.LINQ!DEC 3, 2009
SLIDES FROM NMNUG AVAILABLENOV 28, 2009
RX RELEASE BRINGS NICE SURPRISES!NOV 18, 2009
UNIT TESTING WITHOUT DESIGN SUICIDENOV 18, 2009
GENERIC GENERICS AND METHOD OVERLOADSNOV 17, 2009
ICOLLECTION.ISREADONLY (AND ARRAYS)NOV 16, 2009
REVERSE COMPILING WINDOWS FORMSOCT 22, 2009
WINDOWS SERVICES AND THE NETWORKOCT 21, 2009
MANAGED WINDOWS SERVICES - THE BASICSOCT 20, 2009
SYNCHRONIZATIONCONTEXT PROPERTIES SUMMARYOCT 7, 2009
DYNAMICEXECUTE NOW OFFICIALOCT 1, 2009
THREADING IN THE BUSINESS LAYERSEP 26, 2009
MCPD ACHIEVED
SEP 22, 2009
NITO.ASYNC 1.4 RELEASEDSEP 22, 2009
ANOTHER SYNCHRONIZATIONCONTEXT GOTCHA: INVOKEREQUIRED?SEP 21, 2009
MINOR IMPROVEMENTS FOR LANGUAGE DESIGNSEP 18, 2009
IF PUSLEEVENT IS BROKEN, WHAT ABOUT MONITOR.PULSE?SEP 16, 2009
IASYNCRESULT.ASYNCWAITHANDLE AND THREADPOOL.REGISTERWAITFORSINGLEOBJECTSEP 14, 2009
PREVENTING UNDESIRED SIDE-EFFECTS IN ENUMERATORSSEP 14, 2009
ON A LIGHTER NOTE: INFINITE VISUAL STUDIO ERRORSEP 12, 2009
70-536 IN THE BAG
SEP 3, 2009
NOTES FROM THE RX TALKSEP 1, 2009
NAMING UNIT TESTS
AUG 28, 2009
Q&A: IS A CALL TO GC.KEEPALIVE(THIS) REQUIRED IN DISPOSE?AUG 28, 2009
Q&A: IF DISPOSE CALLS SUPPRESSFINALIZE, IS KEEPALIVE REQUIRED?AUG 28, 2009
Q&A: CAN GC.SUPPRESSFINALIZE(THIS) BE CALLED AT ANY TIME?AUG 27, 2009
THE THIRD RULE OF IMPLEMENTING IDISPOSABLE AND FINALIZERSAUG 27, 2009
THE SECOND RULE OF IMPLEMENTING IDISPOSABLE AND FINALIZERSAUG 27, 2009
HOW TO IMPLEMENT IDISPOSABLE AND FINALIZERS: 3 EASY RULESAUG 27, 2009
THE FIRST RULE OF IMPLEMENTING IDISPOSABLE AND FINALIZERSAUG 27, 2009
FINALIZERS AT PROCESS EXITAUG 20, 2009
WHERE HAS STEVE BEEN?AUG 20, 2009
BARCAMPGR4 SLIDES AVAILABLEAUG 17, 2009
ALTERNATIVE GUIDS FOR MOBILE DEVICES USING SQL SERVER COMPACTAUG 14, 2009
GOTCHAS FROM SYNCHRONIZATIONCONTEXT!JUL 28, 2009
SIMPLEPROPERTYPATH: A POOR MAN'S BINDINGJUL 21, 2009
FIRST CODEPROJECT ARTICLE ON NITO.MVVMJUL 16, 2009
INTERPRETING NOTIFYCOLLECTIONCHANGEDEVENTARGSJUL 10, 2009
NITO.WEAKREFERENCE AND NITO.WEAKCOLLECTIONJUL 1, 2009
XML OVER TCP/IP
JUN 30, 2009
APPLICATION PROTOCOL SPECIFICATIONSJUN 19, 2009
THREADSAFE EVENTS
JUN 13, 2009
USING SOCKET AS A CONNECTED SOCKETJUN 12, 2009
MSBUILD.EXTENSIONPACK ACCEPTS DYNAMICEXECUTE TASKJUN 2, 2009
MSBUILD: A REAL-WORLD RECURSIVE APPLICATIONMAY 28, 2009
MSBUILD: ITEMGROUP METADATA INVERSIONMAY 28, 2009
MSBUILD: FACTORIAL!
MAY 27, 2009
USING SOCKET AS A SERVER (LISTENING) SOCKETMAY 27, 2009
MSBUILD: FILTERING AN ITEMGROUP BASED ON A PROPERTYMAY 23, 2009
USING SOCKET AS A CLIENT SOCKETMAY 23, 2009
ON A LIGHTER NOTE: AIRPORT ERRORMAY 23, 2009
INI FILE READER IN C#MAY 18, 2009
WIX VERSION LYING, TAKE TWOMAY 18, 2009
ON A LIGHTER NOTE: INTERNET EXPLORER / MSDN FORUMS ERROR MESSAGEMAY 18, 2009
SAMPLE CODE: GETTING THE LOCAL IP ADDRESSESMAY 18, 2009
GETTING THE LOCAL IP ADDRESSMAY 16, 2009
ON A LIGHTER NOTE: INTERESTING MESSAGE IN AUTOCHKMAY 16, 2009
DETECTION OF HALF-OPEN (DROPPED) CONNECTIONSMAY 14, 2009
ERROR HANDLING
MAY 12, 2009
DEALING WITH WIX DATA FILESMAY 5, 2009
SOCKET OPERATIONS
MAY 4, 2009
TCP/IP RESOURCES
APR 30, 2009
TCP/IP .NET SOCKETS FAQAPR 30, 2009
SAMPLE CODE: LENGTH-PREFIX MESSAGE FRAMING FOR STREAMSAPR 30, 2009
MESSAGE FRAMING
APR 24, 2009
ASYNCHRONOUS CALLBACK CONTEXTSJAN 24, 2009
ANNOUNCING THE RELEASE OF NITO.ASYNCSEP 21, 2008
IDISPOSABLE ARTICLE PUBLISHEDSEP 16, 2008
OPENSSL 0.9.8I BINARIESJUL 24, 2008
INTEROP DOCUMENTATION POINTERSJUL 11, 2008
SOFTWARE-ONLY DEVICE DRIVERS: WHAT'S IN A NAME?JUL 8, 2008
SOYO WIDESCREEN MONITOR INF AVAILABLEJUL 3, 2008
FREE IOCTL DECODER
JUN 20, 2008
DYNAMICALLY LOADING 32-BIT OR 64-BIT CODE FROM A PLATFORM-AGNOSTICEXECUTABLE
About Stephen Cleary Stephen Cleary is a Christian , husband, father, and programmer living in Northern Michigan.My book
Available from O'Reilly (Safari),
Amazon (print/Kindle) , or eBooks.com(PDF/epub)
.
Advertisement
Don't like ads? Browse privately and ad-free with Brave!Popular Posts
* Async/await Intro
* There Is No Thread * Don't Block on Async CodeSeries
* React/Redux TodoMVC* A Tour of Task
* Task.Run Etiquette * Task.Run vs. BackgroundWorker* Async OOP
* TCP/IP .NET Sockets FAQ* Managed Services
* IDisposable and Finalizers* Option Parsing
Details
Copyright © 2024 ArchiveBay.com. All rights reserved. Terms of Use | Privacy Policy | DMCA | 2021 | Feedback | Advertising | RSS 2.0