Developer Support

Advocacy and Innovation

andarno - Developer Support

Limiting concurrency for faster and more responsive apps

May 11, 2017 May 11, 2017 05/11/17
Andrew Arnott
When you have a set of highly parallelizeable work, executing it concurrently can be easy: Of course you'd probably want to track the work at least so you know when it's done: Calling Task.Run schedules the work to run on the .NET ThreadPool which is highly tuned and can likely get the work done as fast as you have CPUs to do the...

TaskSchedulers and semaphores

February 6, 2016 Feb 6, 2016 02/6/16
Andrew Arnott
When you write multi-threaded code, it's important to be aware of whether the code in other libraries you call into is also thread-safe. By my observation, most code written is not thread-safe. So if you're writing thread-safe code, kudos to you. But as you'll sometimes need to call non-thread-safe code from your multi-threaded code, this post...

When TPL Task continuations are inlined

December 31, 2015 Dec 31, 2015 12/31/15
Andrew Arnott
Task and Task in .NET 4.0 are absolutely awesome types and they provide the basis for async support that came in .NET 4.5. One somewhat unexpected behavior they have that can occasionally cause bugs in your code is that when a Task completes, it can execute continuations inline. In this post, I explain this and what you can do to avoid it when...

Install Android SDKs using Powershell

October 12, 2015 Oct 12, 2015 10/12/15
Andrew Arnott
The Android SDK Manager requires a GUI and tedious searching for the SDKs that you want to install. There is a command line android.bat script that lets you install and uninstall these without the GUI but it's based on an ordinal index for each SDK so you have to run the script once, note the index(es) of the SDKs you want to install, then ...

ImmutableObjectGraph has some big updates now, and more coming soon

November 19, 2014 Nov 19, 2014 11/19/14
Andrew Arnott
I was able to work out a model for continued open source development of ImmutableObjectGraph -- at least in a limited way. This means that the 16 month silence on the public repo is over, and I was able to push a bunch of the commits I had been keeping internal to the public. For those of you not already familiar with the library/tool, you ...

So many exceptions… but only one can throw

May 13, 2014 May 13, 2014 05/13/14
Andrew Arnott
When a method may throw for more than one reason, the thoughtful programmer might ask “which exception should be thrown?”Consider a method which performs argument validation, is cancelable, and also might throw based on the state of the object. What order should these validations occur so that the best exception is thrown? Here is ...

Asynchronous and multithreaded programming within VS using the JoinableTaskFactory

May 7, 2014 May 7, 2014 05/7/14
Andrew Arnott
Everyone appreciates a fast and responsive UI, and Visual Studio is no exception. Extensions that run in Visual Studio play a significant role in how responsive the IDE will be for its users. Visual Studio has been evolving over the past few cycles to not only improve performance, but also responsiveness during operations that may take a while...

Recommended patterns for CancellationToken

March 19, 2014 Mar 19, 2014 03/19/14
Andrew Arnott
Whether you're doing async work or not, accepting a CancellationToken as a parameter to your method is a great pattern for allowing your caller to express lost interest in the result. Supporting cancelable operations comes with a little bit of extra responsibility on your part. Optional CancellationToken ...

Immutable Object Graph updates

May 7, 2013 May 7, 2013 05/7/13
Andrew Arnott
In my last post, I introduced a T4 template that constructs efficient and quite capable immutable objects based on the simplest mutable type definition. I also mentioned that the published sample is (necessarily, ala T4 style) open source and hosted online. Two outsiders have already submitted pull requests that have been accepted. Some ...

Simple immutable objects

January 8, 2013 Jan 8, 2013 01/8/13
Andrew Arnott
We’re all familiar with immutable collections now. But immutability is only as immutable as it is deep. And an immutable collection of mutable objects may not provide the depth you’re looking for. So how can one create an immutable object? Suppose you would define the mutable version like this: An immutable version might be ...