After reading this you should know enough to write a pretty good socket server; and hopefully where to start looking when bad things happen. This post is written progressively, meaning I may use certain bad practices in the first few sections. Don’t just go and copy and paste – make sure you read the whole thing.

IOCP (I/O Completion Ports)

IOCP is probably the most important part of a socket server. If you have ever heard of the Berkely socket pattern; this is the exact opposite. Berkely relies on a tight loop that queries each socket asking it if it has any data ready; it doesn’t scale. Another often-used (and incorrect) pattern is the multi-threaded Berkely socket pattern. Instead of a single tight loop querying each socket, the server assigns a thread-per-client. While in theory this is a good idea; realise that spinning up 1000 tight loops is going to bring your server to a screeching halt very quickly.

So what is IOCP? Put simply; it’s a way for a program to say to the kernel “Hey, I am in charge of these streams. When data arrives on ANY of them please resume this thread I have created for you.” The .Net BCL team took IOCP a step further and shield developers from having to manage that thread. Using IOCP in .Net is as easy as implementing your server using the Begin/End async pattern. Using this pattern is quite simple:

1. Create your own Begin* method (as a bad example, BeginReceive).
2. Create a stub for the End* method. This method should accept a single IAsyncResult as a parameter.
3. In your Begin* method, call socket.Begin* passing your End* as a delegate parameter.
4. In your End* method, call socket.End* passing the IAsyncResult you got as a parameter.
5. Then call your Begin* method.

This sets up an async loop; there is a shorter form of this loop (designed for DRY error handling) – which looks like this:

Note that you should use the async pattern for everything: Accept, Receive, Send, Connect. As a side-note – using BeginSend with a null callback is fine (fire and forget); but it will play havoc with the socket performace counters for your process. You may also want to set UseOnlyOverlappedIO to true.

I also suggest you look at Reactive Extensions; as one of the things it deals with is the async pattern.

Use Streams

Don’t use the built-in Receive and Send methods, construct a NetworkStream over the socket. This is important because it allows you wrap your socket in a SslStream or DeflateStream (side note: always wrap the data in compression BEFORE encryption).

Side note: DeflateStream was implemented in a really strange way (the existence of the CompressionMode parameter). You are typically going to write a Stream that uses one DeflateStream (in CompressionMode.Compress) to write and another (in CompressionMode.Decompress) to read.

The Evils of Pinning

The Microsoft CLR uses P/Invoke to provision sockets. A side-effect of P/Invoke is that any reference types (and a Byte Array a.k.a buffer is a reference type) that you pass as parameters are pinned for the duration of the call. Pinning is a process whereby the Garbage Collector is informed that it should not move an object around (the garbage collector moves objects around to ensure that large continuous areas of free space are available). What this means is that if you pass a new buffer to each Send/Receive call you will wind up with a lot of pinned objects, which can lead to fragmentation. There have been stories of processes getting so fragmented that a process using 800MB of memory and 1.2GB of free memory throwing an OutOfMemoryException (because it could not find a large enough space to allocate an object). Remember that an OutOfMemoryException kills your .Net process without ever calling any catch blocks – not good. To further compound the problem, TCP has this problem where it can go into a black-hole state – this means that even though the connection was lost; the operating system (and your process) think it’s still there. A black-hole can last for as long as 15 minutes in certain worst-case scenarios.

The way to get around this is to pre-allocate large blocks of memory for buffers. ArraySegment is a good way to get handles on ‘sub-arrays’. Here is an effective buffer pool to get you started:

Note that you can also use BufferManager (which doesn’t support ArraySegment).

Unfortunately this one is actually really hard to get 100% right in the scenario where you do use SslStream and DeflateStream. These two streams allocate their own buffers; which means even if you do write to the “targetStream” using pooled buffers, unpooled buffers will still be sent to the underlying socket. There is no easy way to put this, if you do run into this scenario you are going to land up writing quite a bit of code (subclassing Stream; placed directly above your NetworkStream) that swaps out the buffers passed to it for pooled buffers (keeping in mind you need to do this async). I have some code that does this, but it is tied into some pretty proprietary stuff at the moment, so I have to isolate it before posting. If you go down this route just remember to use Buffer.BlockCopy and not ArrayCopy as Buffer.BlockCopy is blindingly fast compared to the former (IIRC it uses DMA).

There are also two ways to manage these pooled buffers. If your server behaves in a streaming fashion (which is probably the case) you will want to experiment with allocating a buffer to each client; instead of a buffer to each Read/Write call. Whether this will work out better or not depends on the nature of your server.

DOS

Denial-Of-Service (not that I didn’t mention DDOS; pretty-much the only way to deal with that is horizontal scaling) is one you need to look out for. DOS is really simple to pull off if you don’t protect yourself against it. It merely comes down to asking “why is this client connected to me?”, “can I handle this much data?” and for the love of God staying away from byte arrays (except for, obviously, at the socket level). For instance, what is a client doing connected to you if it has not authenticated itself in 30 seconds? Why is this client sending you 200MB of data? Can the data be written to disk instead?

PUSH Parsing

Make sure that your server can PUSH parse. One form of DOS is to send a really big (but valid) packet. Naive servers will build up a large buffer in memory to attempt to store this packet before parsing it. Don’t do this, instead parse the bytes as you get them. For instance instead of using a StreamReader look at the following:

If you need to build up the packet before parsing it (say it’s XML and you don’t want to write/test your own PUSH parser) rather write it to a temporary file.

Hope This Helps

If you can think of anything I should add or correct please let me know in the comments.

TLDR; Part

I recently started a game (that I plan to finish for once) that requires distortion effects. I read up about a few implementations on how to do distortions, all of them pretty much handled one type of distortion: radial (i.e explosions/ripple). I needed distortions for heat haze etc.

The usual post-processing stuff is pretty static. Apply a threshold, apply a Gaussian blur, multiply. Notice that this stuff happens against one image. Versatile distortions require 2 images. Firstly you need the entire game as a render target (i.e. Texture2D) as well as the distortion render target. Typically you would use a particle system to fill the distortion render target. I will come back to how I did this a bit later (as it is TLDR; ).

Now here is the crunch. Each color component in the distortion target represents the following:

• R: dx: X offset – f(x)=2x-1 mapping ([0.0f, 1.0f] to [-1.0f, 1.0f]).
• G: dy: Y offset – f(x)=2x-1 mapping.
• B: m: Z strength – f(x)=x mapping.

The B component is not entirely necessary but it does make creating the textures simpler (because if you use pure black it means no distortion, as R/G only needs grey as 0-offset). The next elegant bit: to determine the final outcome of a wave you simply need to add all of its vector components (in our case dx, dy, m). So if you have two waves you can determine the final outcome as follows:

where dx(x, y, i), dy(x, y, i), m(x, y, i) are the sizes of the vector components in the wave at position x,y for wave i.
where fdx(x, y), fdy(x, y), fm(x, y) are the sizes of the vector components in the final wave at position x,y.
fdx(x, y) = dx(x, y, 0) + dx(x, y, 1) + ... + dx(x, y, n)
fdy(x, y) = dy(x, y, 0) + dy(x, y, 1) + ... + dy(x, y, n)
fm(x, y) = m(x, y, 0) + m(x, y, 1) + ... + m(x, y, n)

In other words. Render a particle system to a render target using additive blending. The particles themselves are quite interesting. For example to get the typical ripple effect you would use the following image:

I used to a console program to generate that. Basically it pushes out the offset from the center (remember the R/G mapping) into the pixels using the R and G components. The B component is a simple radial gradient. What you would do with this is render it in a particle system where the particle size grows as it gets older; as well as fading (through grey) to black.

As a further example here is an (untested) heat haze particle. Because of the B scaling it is simple to create these in an image editor (black means no distortion):

Finally this render target needs to be composed with the actual render target. I used the following shader:

Texture InputTexture;
Texture LastTexture;

sampler inputTexture = sampler_state
{
texture = <InputTexture>;
magFilter = POINT;
minFilter = POINT;
mipFilter = POINT;
};

sampler lastTexture = sampler_state
{
texture = <LastTexture>;
magFilter = LINEAR;
minFilter = LINEAR;
mipFilter = LINEAR;
addressU = CLAMP;
addressV = CLAMP;
};

struct VS_OUTPUT
{
float4 Position : POSITION;
float2 TexCoords : TEXCOORD0;
};

float4 Distort (VS_OUTPUT Input)
{
float4 color1;
float4 color2;
float2 coords;
float mul;

coords = Input.TexCoords;
color1 = tex2D(inputTexture, coords);

// 0.1 seems to work nicely.
mul = (color1.b * 0.1);

coords.x += (color1.r * mul) - mul / 2;
coords.y += (color1.g * mul) - mul / 2;

color2 = tex2D(lastTexture, coords);

return color2;
}

float4 RunEffects (VS_OUTPUT Input) : COLOR0
{
float4 color;

color = Distort(Input);

return color;
}

technique Main
{
pass P0
{
PixelShader = compile ps_2_0 RunEffects();
}
}

Pretty simple shader, but it has a great effect:

The Required Render System

In order for this to work you need a slightly more advanced render system. You basically need to be able to:

• Render a scene/layer/whatever to a temporary render target.
• Compose this render target with an underlying render target using a pixel shader (basically provide a ‘last composition’ texture to the shader).

My layers (I call them RenderContexts) are DrawableGameComponents. Each one contains a RenderTarget2D member that it uses when it renders it’s children; once a RenderContext has finished rendering it informs the containing game. The Game contains a final RenderTarget (remember changing RenderTargets clears the back buffer) that is used for the final scene. The crunch of the code is:

/// <summary>
/// Called when a context has been rendered.
/// </summary>
/// <param name="context">The context.</param>
internal void ContextRendered(RenderingContext context)
{
var renderTarget = CompositingRenderTarget;
var effect = context.CompositingEffect;

if (effect != null)
{
// See if the effect needs the last context rendered.
var param = effect.Parameters["LastTexture"];
if (param != null)
{
// Store the last render target in a new render target.
// You can't render to- and read from- a render target in
// the same shader.
GraphicsDevice.SetRenderTarget(EffectRenderTarget);
_compositingSpriteBatch.Begin(SpriteSortMode.Deferred, BlendState.Opaque);
_compositingSpriteBatch.Draw(CompositingRenderTarget, new Vector2(0, 0), Color.White);
_compositingSpriteBatch.End();
}
}

GraphicsDevice.SetRenderTarget(CompositingRenderTarget);

if (effect == null)
{
_compositingSpriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend);
}
else
{
// Now we can send the shader the composed image.
var param = effect.Parameters["LastTexture"];
if (param != null)
{
param.SetValue(EffectRenderTarget);
}
_compositingSpriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, null, null, null, effect);
}

// Notice I am using a sprite batch, not the best way to do things
// but better during the prototyping phase.
_compositingSpriteBatch.Draw(context.RenderTarget, new Vector2(0, 0), Color.White);
_compositingSpriteBatch.End();
}

Hope that helps you all do some seriously sweet distortions in your game. If there are any obvious omissions feel free to complain.

Parts

• Visual Studio theme editor.
• Visual Studio theme.
• Visual Studio syntax theme (not 100% Expression Blend; but fits in nicer than Metroline).
• My Command-line Console color set. (rename to .reg)

Command-line Theme

Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\Console]
"ColorTable00"=dword:00333333
"ColorTable01"=dword:00ff8080
"ColorTable02"=dword:0080ff80
"ColorTable03"=dword:00ffff80
"ColorTable04"=dword:008080ff
"ColorTable05"=dword:00ff80ff
"ColorTable06"=dword:0080ffff
"ColorTable07"=dword:00c0c0c0
"ColorTable08"=dword:00808080
"ColorTable09"=dword:00ff8000
"ColorTable10"=dword:0000ff80
"ColorTable11"=dword:00dcff00
"ColorTable12"=dword:008000ff
"ColorTable13"=dword:00dc00ff
"ColorTable14"=dword:0000dcff
"ColorTable15"=dword:00dddddd
"FontFamily"=dword:00000036
"FontSize"=dword:00100000
"FontWeight"=dword:00000190
"PopupColors"=dword:00000001
"ScreenColors"=dword:0000000f
"FaceName"="Consolas"

Preview

Even though the console is blurred it should give you the general idea of the colors (they are pretty much identitical to the Selenitic ones).

I have a logging system that contains one or more loggers. These logger should NOT be initialized (or ever constructed) for child domains; this is a problem because each AppDomain in .Net recieves it’s own static instances.

Typical Solution

Most people resort to the MSCOREE library and enumerate all the current AppDomains to find the primary AppDomain. After that they can retrieve the singleton instance from within the primary AppDomain.

This has it’s problems, most notably interop ties you to an architecture and requires certain CAS policies. Furthermore, I just don’t like too much interop.

My Solution

My solution involves creating a custom AppDomainManager that is aware of the primary AppDomain. The principle is that the AppDomainManager creates a new AppDomain for primary execution. This new domain uses the custom AppDomainManager (which can then control the creation of child domains; and therefore wire itself into them). The code is self-explanatory (hopefully):

    /// <summary>
    /// Represents a <see cref="AppDomainManager"/> that is
    /// aware of the primary application AppDomain.
    /// </summary>
    public class PrimaryAppDomainManager : AppDomainManager
    {
        private static AppDomain _primaryDomain;

        /// <summary>
        /// Gets the primary domain.
        /// </summary>
        /// <value>The primary domain.</value>
        public static AppDomain PrimaryDomain
        {
            get
            {
                return _primaryDomain;
            }
        }

        /// <summary>
        /// Sets the primary domain.
        /// </summary>
        /// <param name="primaryDomain">The primary domain.</param>
        private void SetPrimaryDomain(AppDomain primaryDomain)
        {
            _primaryDomain = primaryDomain;
        }

        /// <summary>
        /// Sets the primary domain to self.
        /// </summary>
        private void SetPrimaryDomainToSelf()
        {
            _primaryDomain = AppDomain.CurrentDomain;
        }

        /// <summary>
        /// Determines whether this is the primary domain.
        /// </summary>
        /// <value>
        /// 	<see langword="true"/> if this instance is the primary domain; otherwise, <see langword="false"/>.
        /// </value>
        public static bool IsPrimaryDomain
        {
            get
            {
                return _primaryDomain == AppDomain.CurrentDomain;
            }
        }

        /// <summary>
        /// Creates the initial domain.
        /// </summary>
        /// <param name="friendlyName">Name of the friendly.</param>
        /// <param name="securityInfo">The security info.</param>
        /// <param name="appDomainInfo">The AppDomain setup info.</param>
        /// <returns></returns>
        public static AppDomain CreateInitialDomain(string friendlyName, Evidence securityInfo, AppDomainSetup appDomainInfo)
        {
            if (AppDomain.CurrentDomain.DomainManager is PrimaryAppDomainManager)
                return null;

            appDomainInfo = appDomainInfo ?? new AppDomainSetup();
            appDomainInfo.AppDomainManagerAssembly = typeof(PrimaryAppDomainManager).Assembly.FullName;
            appDomainInfo.AppDomainManagerType = typeof(PrimaryAppDomainManager).FullName;

            var appDomain = AppDomainManager.CreateDomainHelper(friendlyName, securityInfo, appDomainInfo);
            ((PrimaryAppDomainManager)appDomain.DomainManager).SetPrimaryDomainToSelf();
            _primaryDomain = appDomain;
            return appDomain;
        }

        /// <summary>
        /// Returns a new or existing application domain.
        /// </summary>
        /// <param name="friendlyName">The friendly name of the domain.</param>
        /// <param name="securityInfo">An object that contains evidence mapped through the security policy to establish a top-of-stack permission set.</param>
        /// <param name="appDomainInfo">An object that contains application domain initialization information.</param>
        /// <returns>A new or existing application domain.</returns>
        /// <PermissionSet>
        /// 	<IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="ControlEvidence, ControlAppDomain, Infrastructure"/>
        /// </PermissionSet>
        public override AppDomain CreateDomain(string friendlyName, Evidence securityInfo, AppDomainSetup appDomainInfo)
        {
            appDomainInfo = appDomainInfo ?? new AppDomainSetup();
            appDomainInfo.AppDomainManagerAssembly = typeof(PrimaryAppDomainManager).Assembly.FullName;
            appDomainInfo.AppDomainManagerType = typeof(PrimaryAppDomainManager).FullName;

            var appDomain = base.CreateDomain(friendlyName, securityInfo, appDomainInfo);
            ((PrimaryAppDomainManager)appDomain.DomainManager).SetPrimaryDomain(_primaryDomain);

            return appDomain;
        }
    }

Note that it isn’t possible to use the ‘real’ primary domain for anything; otherwise any domains created by it would be outside of the control of PrimaryAppDomainManager. Using this we can implement cross-domain thread-safe singleton class:

    /// <summary>
    /// Represents a cross-domain singleton.
    /// </summary>
    /// <remarks>
    /// The singleton always lives in the primary domain.
    /// </remarks>
    public abstract class CrossDomainSingleton<TSelf> : MarshalByRefObject
        where TSelf : CrossDomainSingleton<TSelf>, new()
    {
        // Used to alter the primary domain
        // in a thread safe-manner.
        private class Locker : MarshalByRefObject
        {
            private static object _lock = new object();
            public void Lock()
            {
                Monitor.Enter(_lock);
            }

            public void Exit()
            {
                Monitor.Exit(_lock);
            }

            public TSelf GetSelf()
            {
                // At this point we always have a lock;
                // just check that the instance is still null.
                if (_instance == null)
                {
                    _instance = new TSelf();
                }
                return _instance;
            }
        }

        private static TSelf _instance;
        /// <summary>
        /// Gets the instance.
        /// </summary>
        /// <value>The instance.</value>
        public static TSelf Instance
        {
            get
            {
                Contract.Ensures(Contract.Result<TSelf>() != null);
                if (_instance == null)
                {
                    SetInstance();
                }
                return _instance;
            }
        }

        private static void SetInstance()
        {
            Locker locker;
            if (PrimaryAppDomainManager.IsPrimaryDomain)
            {
                // No need for the remoting.
                locker = new Locker();
            }
            else
            {
                // Get the primary domain locker.
                locker = PrimaryAppDomainManager.PrimaryDomain.CreateInstanceAndUnwrap<Locker>();
            }

            try
            {
                locker.Lock();
                _instance = locker.GetSelf();
            }
            finally
            {
                locker.Exit();
            }
        }
    }

You will need the following extension method somewhere:

/// <summary>
/// Creates a new instance of the specified type.
/// </summary>
/// <typeparam name="T">The type of object to create.</typeparam>
/// <param name="appDomain">The app domain.</param>
/// <returns>A proxy for the new object.</returns>
public static T CreateInstanceAndUnwrap<T>(this AppDomain appDomain)
{
    Contract.Requires<ArgumentNullException>(appDomain != null);
    Contract.Ensures(Contract.Result<T>() != null);

    var res = (T)appDomain.CreateInstanceAndUnwrap(typeof(T));
    return res;
}

In order for all of this to work you need to make sure that your ‘real’ primary domain is never used:

    class Program : MarshalByRefObject
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        static void Main(string[] args)
        {
            new Program().Run(args);
        }

        void Run(string[] args)
        {
            var domain = PrimaryAppDomainManager.CreateInitialDomain("PrimaryDomain", null, null);
            if (domain == null)
            {
                // Original Main() code here.
            }
            else
            {
                domain.CreateInstanceAndUnwrap<Program>().Run(args);
            }
        }
    }

And the singleton classes are simple (thanks to the generic-TSelf trick; which I need to do a post on some time):

    class Foo : CrossDomainSingleton<Foo>
    {
        public Foo()
        {
            // Singleton initializer.
        }
    }

Initially the custom module would prevent Windows credentials from being accepted. The browser would enter the login dialog loop with valid credentials. This is because the basic module was eagerly checking the Authorization header. I had to make the following fix:

protected bool IsHeaderPresent
{
    get
    {
        HttpContext context = HttpContext.Current;
        string authHeader = context.Request.Headers["Authorization"];
        return (!string.IsNullOrEmpty(authHeader))
                 && authHeader.StartsWith("Basic"); // Added this line.
    }
}

This property is used in the AuthenticateRequest event handler. What you need to do is short-circuit your entire method, as such:

void context_AuthenticateRequest(object sender, EventArgs e)
{
    if (IsHeaderPresent)
    {
        // Previous method body
    }
}

Next you need to enable Windows Authentication in IIS. How you do this depends on which version of IIS you are using; and is trivial. You then need to add it to your web.config:

<system.web>
   <authentication mode="Windows" />
</system.web>

The custom authentication module I read indicated that the following needed to be added to the web.config; if you have something like it remove it:

<serviceAuthorization principalPermissionMode="Custom">
  <authorizationPolicies>
    <add policyType="X.Services.Authentication.HttpContextIdentityPolicy, X.Services.Runtime" />
    <add policyType="X.Services.Authentication.HttpContextPrincipalPolicy, X.Services.Runtime" />
  </authorizationPolicies>
</serviceAuthorization>

Now you just need to look for your custom Identity/Principal; versus the Windows one and react accordingly. Good luck!

0:019> !pe
PDB symbol for mscorwks.dll not loaded
Exception object: 029e87f4
Exception type: System.ArgumentNullException
Message: Value cannot be null.
InnerException:
StackTrace (generated):
    SP       IP       Function

StackTraceString:
HResult: 80004003
There are nested exceptions on this thread. Run with -nested for details

As has the output of !clrstack:

0:019> !clrstack
OS Thread Id: 0x5d0 (19)
ESP       EIP
0f31f340 7c80bef7 [HelperMethodFrame_1OBJ: 0f31f340]
0f31f398 1449167a
0f31f3c4 144915e6
0f31f3f4 10d81b48
0f31f4b4 793e25cf
0f31f4bc 79366b3d
0f31f4d4 793e2734
0f31f4e8 793e26ac
0f31f678 79e7c0e3 [GCFrame: 0f31f678]

This invariably leads to me closing WinDBG and start manually trying to determine what is going wrong without it. The reason? Microsoft needs to rethink documentation around WinDBG, SOS, and MSCORDACWKS. According to them all you need is the correct version of MSCORDACWKS; that will get you as far as the above.

Getting a Memory Dump From Your Customer

After using whichever method you suggest (e.g. ADPlus) they will also need to do this:

1. Navigate to %WINDIR%\Microsoft.NET\Framework\v2.0.50727
   1. Copy SOS.DLL
   2. Copy MSCORDACWKS.DLL
2. If 64bit Navigate to %WINDIR%\Microsoft.NET\Framework64\v2.0.50727
   1. Copy SOS.DLL
   2. Copy MSCORDACWKS.DLL
3. If they you are optionally or additionally using .Net 4.0 they will need to do steps 1 and 2 for \v4.0.30319.

You will need those files individually; and keep them along-side the memory dump.

Setting Up Your Environment

You are going to need a local symbols directory (we have a file share on a server). WinDBG is rather unforgiving when it comes to the MSCORDACWKS search (e.g. having MSCORDACWKS in the same directory as the memory dump doesn’t work); so you have to put their MSCORDACWKS in your symbol store.

Determining where to store MSCORDACWKS

FYI: I have been able to get this DLL from the Microsoft Symbol Servers; so you should probably try this first:

.sympath srv*http://msdl.microsoft.com/download/symbols;cache*D:\symbols
.reload

Otherwise, there is a way to determine this; but using WinDBG to figure out the path is more reliable:

0:019> !sym noisy
noisy mode - symbol prompts on
0:019> .sympath+ D:\symbols
DBGHELP: Symbol Search Path: d:\symbols
DBGHELP: Symbol Search Path: d:\symbols
Symbol search path is: D:\symbols
Expanded Symbol search path is: d:\symbols
0:019> !loadby sos mscorwks
0:019> .cordll -ve -u -l
CLR DLL status: No load attempts
0:019> !threads
PDB symbol for mscorwks.dll not loaded
...
SYMSRV:  d:\symbols\mscordacwks_x86_x86_2.0.50727.1873.dll\4A7D131D59b000\mscordacwks_x86_x86_2.0.50727.1873.dll not found
...

That SYMSRV line is your answer. Create the directory, rename the file and copy the file there.

Loading up SOS.DLL

First we should undo the noisy symbol prompts:

0:019> !sym quiet
quiet mode - symbol prompts on

We can then load up the correct version of SOS:

0:019> !load D:\Dump Files\2010-01-01\x86\v2.0\SOS.dll

And now we can get stack traces:

0:019> !clrstack
OS Thread Id: 0x5d0 (19)
ESP       EIP
0f31f340 7c80bef7 [HelperMethodFrame_1OBJ: 0f31f340] System.Threading.Monitor.Enter(System.Object)
0f31f398 1449167a SourceCode.**
0f31f3c4 144915e6 SourceCode.**
0f31f3f4 10d81b48 K2Worker.**
0f31f4b4 793e25cf System.Threading._ThreadPoolWaitCallback.WaitCallback_Context(System.Object)
0f31f4bc 79366b3d System.Threading.ExecutionContext.Run(System.Threading.ExecutionContext, System.Threading.ContextCallback, System.Object)
0f31f4d4 793e2734 System.Threading._ThreadPoolWaitCallback.PerformWaitCallbackInternal(System.Threading._ThreadPoolWaitCallback)
0f31f4e8 793e26ac System.Threading._ThreadPoolWaitCallback.PerformWaitCallback(System.Object)
0f31f678 79e7c0e3 [GCFrame: 0f31f678]

Good luck and happy debugging!

Update: According to Tess Ferrandez of WinDBG fame the new SOS (called PSSCOR2.DLL) used by the employees at Microsoft will also fix this. Read about it more over at her blog.

emulator: ERROR: unknown virtual device name: 'xxx'
emulator: could not find virtual device named 'xxx'

It’s because the Android emulator works a little differently from the rest of the SDK (the rest of the SDK is Java, emulator.exe is C/++). The rest of the SDK behaves correctly in terms of user home folder (I move mine to a different hard disk) and emulator.exe has it hardcoded (depending on your OS). In Windows 7 and Vista that means it ALWAYS looks in “C:\Users\<username>\.android”. The fix for this is simple (in a command prompt under Vista/Win7):

C:
cd C:\Users\<user name>
mklink /j .android <new home directory>\.android

Worked for me. Source: XDA Developers.

1. Install guest.
2. Create descriptive wallpaper (root chain).
3. Install guest tools.
4. Change WSUS server.
5. Update Windows.
6. Bootstrap Internet Explorer.
7. Install Clamwin.
8. Update Clamwin.
9. Change registered company to my company. Remember WOW64 node.
10. Disable netlogon machine password change.

    HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1

11. Disable shutdown event tracker.
12. (Snapshot)
13. Create descriptive wallpaper (development chain).
14. Join domain.
15. Install .Net Framework 3.51.
16. Install IIS.
17. Install MSMQ AD Integration.
18. Install Visual Studio.
19. Install TFS Client.
20. Install Visual Studio SP1.
21. Install SQL Server.
22. Install SQL Server SP1.
23. Configure SQL Firewall Ports.
24. Enable SQL Server TCP/IP.
25. Install GhostDoc.
26. Install CodeRush.
27. Install Coco/R.
28. Install Tytan.
29. Update Windows.
30. Bootstrap VS.
31. Apply VS customizations.
    1. Import settings.
    2. Set up TFS working folder.
    3. Set up GhostDoc to use langword.
32. Bootstrap SMS.
33. Create link to K2 keygen.
34. (Snapshot)
35. Justice.

• If you are migrating existing code and worrying only about contracts, switch off background checking. Firstly, this means that the results you get are comprehensive and secondly because of the build time you will think twice about hitting that build key again. Long builds == fewer builds == more time thinking == better code.
• Use code snippets. The ones provided by Microsoft are great! Think about creating your own or changing them. For example cren and cresn no longer throw ArgumentExceptions for me; they are both ArgumentNullExceptions. I also have snippets like create contract class for (cc – scaffolding for ContractClassFor) and contract class implementation (cci – ContractClass attributation).
• Invariants are your friend. Figure out what state a class should really be in and depend on that rather than Contract.Requires everywhere.
• A well placed Contract.Ensures will save you a lot of grief.
• Don’t loose hope. It may seem like it’s daunting at first – but as you start thinking in terms of contracts things become a lot faster. A single well-thought out Contract call will often clear off 5 warnings (for the bigger projects).
• Some classes can be skipped ([ContractVerification(false)]) – especially if they are internal. Don’t gung-ho and try and get everything in contracts; because sometimes they may be ill-suited for the task (and you would by ‘lying’ just to get the stuff to pass). These situations are few and far between; but they are there.
• New development = contracts. Full stop.

Overall I am finding fewer and fewer Contract failures during each build. This is mainly because CodeContracts is getting me into a better and more disciplined mindset. It’s a great tool and I highly recommend it.

It has a few notable features – it gives a reason for the flip, it wraps it in a region, it has a auto-task FLIP: prefix and it explains how it’s used.

            #region Flip - This new behaviour is experimental. -
            // FLIP: This new behaviour is experimental.
            //*/// Two proceding slashes will activate the first block, one will activate the second.
            Console.ReadLine();
            /*/
            Console.ReadLine();
            //*/
            #endregion Flip - This new behaviour is experimental. -

Drop it in your My Code Snippets folder. In VS select the code you want to flip-comment, Hold CTRL, Press K, Press S, Release CTRL, Press M, Press Enter, Press F, Press Enter (I wish you could assign hot keys to snippets!).

Code Block Flipper (WordPress won’t let me upload .snippet – so you will need to rename it)