"The symbolic link cannot be followed because its type is disabled"

This is because by default remote to remote symbolic links are disabled. You can enable it with fsutil.

C:\Windows\system32>fsutil behavior query SymlinkEvaluation

Local to local symbolic links are enabled.
Local to remote symbolic links are enabled.
Remote to local symbolic links are disabled.
Remote to remote symbolic links are disabled.

C:\Windows\system32>fsutil behavior set SymlinkEvaluation R2R:1

C:\Windows\system32>fsutil behavior query SymlinkEvaluation

Local to local symbolic links are enabled.
Local to remote symbolic links are enabled.
Remote to local symbolic links are disabled.
Remote to remote symbolic links are enabled.

Be sure to run fsutil from elevated command prompt.

Subject: RE: How to investigate Windows Error Report from managed app?

FYI

I actually found that there is way to find what method caused this error and where without the dump. See below:

Problem signature

Problem Event Name:             CLR20r3

Problem Signature 01:            consoleapplication35.exe

Problem Signature 02:            1.0.0.0

Problem Signature 03:            48ed4a20

Problem Signature 04:            ConsoleApplication35

Problem Signature 05:            1.0.0.0

Problem Signature 06:            48ed4a20

Problem Signature 07:            1

Problem Signature 08:            2e

Problem Signature 09:            System.InvalidOperationException

OS Version:                              6.0.6001.2.1.0.272.7

Locale ID:                                1033

The Problem Signature 07 is MethodDef token. And SOS provides !Token2EE command to find the token. The trick here is that it trimmed “06” from the top, so its original value should be 0600000 + the value you see from Problem Signature 07 which is 06000001 in this example.

Now use !Token2EE to figure out the method:

0:003> !Token2EE ConsoleApplication35 06000001

Module: 00112c5c (ConsoleApplication35.exe)

Token: 0x06000001

MethodDesc: 00112ff0

Name: ConsoleApplication35.Program.Main(System.String[])

JITTED Code Address: 001b0070

Now you use !dumpil to list all IL for the method and check the IL offset to find which line actually failed.

0:003> !dumpil 00112ff0

ilAddr = 00ee2050

IL_0000: nop

IL_0001: ldstr "notepad.exe"

IL_0006: ldnull

IL_0007: call System.Diagnostics.Process::Start

IL_000c: stloc.0

.try

{

  IL_000d: nop

  IL_000e: ldloc.0

  IL_000f: callvirt System.Diagnostics.Process::WaitForExit

  IL_0014: nop

  IL_0015: nop

  IL_0016: leave.s IL_0028

} // end .try

.finally

{

  IL_0018: ldloc.0

  IL_0019: ldnull

  IL_001a: ceq

  IL_001c: stloc.1

  IL_001d: ldloc.1

  IL_001e: brtrue.s IL_0027

  IL_0020: ldloc.0

  IL_0021: callvirt System.IDisposable::Dispose

  IL_0026: nop

  IL_0027: endfinally

} // end .finally

IL_0028: nop

IL_0029: newobj System.InvalidOperationException::.ctor

IL_002e: throw

That’s it.

External manifest is App.exe.manifest.

In Windows XP, Sxs searches external manifest before internal manifest. If an external manifest is found, the internal manifest is ignored.

 In Windows Server 2003 and later, the order is reversed.  Internal manifest is preferred over external manifest.

If you use external manifest, and your scenario works in Windows XP, but not Windows Server 2003 and later, please double check the executable does not have an internal manifest

All CLR errors are defined in CorError.h. You can find CorError.h in your Visual Studio install (or Microsoft Platform SDK).

C:\Program Files\Microsoft SDKs\Windows\v6.0A\Include\CorError.h

For example,

#define FUSION_E_REF_DEF_MISMATCH       EMAKEHR(0x1040)     // The located assembly's manifest definition does not match the assembly reference.

That is, 0x80131040 is FUSION_E_REF_DEF_MISMATCH.

        Resource resource = GetResource();

        DoWork();           

        return resource;

If DoWork() throws exception, the resource will be leaked. We need to guard against this.

For example

        bool success = false;

        Resource resource = GetResource();

        try

        {

            DoWork();

            success = true;

            return resource;

        }

        finally

        {

            if (!success)

            {

                DisposeResource(resource);

            }

        }

The example below is one way we may implement the function to support exception filter. It asks the caller to provide four delegates, and call them at the right places.

Imports Microsoft.VisualBasic

Namespace Utility

    Public Delegate Sub TryDelegate()

    Public Delegate Function FilterDelegate(ByVal exception As System.Exception) As Boolean

    Public Delegate Sub CatchDelegate(ByVal exception As System.Exception)

    Public Delegate Sub FinallyDelegate()

    Public Class ExceptionFilter

        Inherits System.Object

        Public Shared Sub TryFilterCatch(ByVal tryDelegate As TryDelegate, ByVal filterDelegate As FilterDelegate, ByVal catchDelegate As CatchDelegate, ByVal finallyDelegate As FinallyDelegate)

            Try

                tryDelegate()

            Catch ex As System.Exception When catchDelegate <> Nothing And filterDelegate(ex)

                catchDelegate(ex)

            Finally

                If (finallyDelegate <> Nothing) Then

                    finallyDelegate()

                End If

            End Try

        End Sub

    End Class

End Namespace

In C# we can call Utility.TryFilterCatch as the following:

using System;

namespace ExceptionFilterUsage

{

    class Program

    {

        static void Main(string[] args)

        {

            TryDelegate tryDelegate = delegate()

            {

                Console.WriteLine("In try.");

                throw new ApplicationException();

            };

            FilterDelegate filterDelegate = delegate(Exception e)

            {

                Console.WriteLine("In exception filter.");

                if (e is ApplicationException)

                {

                    Console.WriteLine("ApplicationException is thrown, which should never happen.");

                    return false;

                }

                return true;

            };

            CatchDelegate catchDelegate = delegate(Exception e)

            {

                Console.WriteLine("In Catch: Exception: {0}", e);

            };

            FinallyDelegate finallyDelegate = delegate()

            {

                Console.WriteLine("In finally.");

            };

            ExceptionFilter.TryFilterCatch(tryDelegate, filterDelegate, catchDelegate, finallyDelegate);

        }

    }

}

1.       Create an overlapped file handle

            SafeFileHandle handle = CreateFile(

                                filename,

                                Win32.GENERIC_READ_ACCESS,

                                Win32.FILE_SHARE_READ | Win32.FILE_SHARE_WRITE | Win32.FILE_SHARE_DELETE,

                                (IntPtr)null,

                                Win32.OPEN_EXISTING,

                                Win32.FILE_FLAG_OVERLAPPED,

                                new SafeFileHandle(IntPtr.Zero, false));

        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]

        private static extern SafeFileHandle CreateFile(

           string lpFileName,

           uint dwDesiredAccess,

           uint dwShareMode,

            //SECURITY_ATTRIBUTES lpSecurityAttributes,

           IntPtr lpSecurityAttributes,

           uint dwCreationDisposition,

           int dwFlagsAndAttributes,

           SafeFileHandle hTemplateFile);

2.       Bind the handle to thread pool.

            if (!ThreadPool.BindHandle(handle))

            {

                Console.WriteLine("Fail to BindHandle to threadpool.");

                return;

        }

3.       Prepare your asynchronous IO callback.

                byte[] bytes = new byte[0x8000];

                IOCompletionCallback iocomplete = delegate(uint errorCode, uint numBytes, NativeOverlapped* _overlapped)

                {

                    unsafe

                    {

                        try

                        {

                            if (errorCode == Win32.ERROR_HANDLE_EOF)

                                Console.WriteLine("End of file in callback.");

                            if (errorCode != 0 && numBytes != 0)

                            {

                                Console.WriteLine("Error {0} when reading file.", errorCode);

                            }

                            Console.WriteLine("Read {0} bytes.", numBytes);

                        }

                        finally

                        {

                            Overlapped.Free(pOverlapped);

                        }

                    }

                };   

4.       Create a NativeOverlapped* pointer.

                    Overlapped overlapped = new Overlapped();

                    NativeOverlapped* pOverlapped = overlapped.Pack(iocomplete, bytes);

                pOverlapped->OffsetLow = (int)offset;

5.       Call the asynchronous IO API and pass the NativeOverlapped * to it.

                    fixed (byte* p = bytes)

                    {

                        r = ReadFile(handle, p, bytes.Length, IntPtr.Zero, pOverlapped);

                        if (r == 0)

                        {

                            r = Marshal.GetLastWin32Error();

                            if (r == Win32.ERROR_HANDLE_EOF)

                            {

                                Console.WriteLine("Done.");

                                break;

                            }

                            if (r != Win32.ERROR_IO_PENDING)

                            {

                                Console.WriteLine("Failed to read file. LastError is {0}", Marshal.GetLastWin32Error());

                                Overlapped.Free(pOverlapped);

                                return;

                            }

                        }

                    }

        [DllImport("KERNEL32.dll", SetLastError = true)]

        unsafe internal static extern int ReadFile(

            SafeFileHandle handle,

            byte* bytes,

            int numBytesToRead,

            IntPtr numBytesRead_mustBeZero,

            NativeOverlapped* overlapped);

Your IO callback will be invoked by CLR thread when the IO completed.

So when should you use ThreadPool.BindHandle? The answer is almost *Never*. .Net Framework's FileStream class internally uses ThreadPool.BindHandle to implement the async IO. You should always use FileStream if possible.

CLR’s thread pool has two pools of threads. The first pool is used by ThreadPool.QueueUserWorkItem. The second pool is an IoCompletionPort thread pool used by ThreadPool.BindHandle and ThreadPool.UnsafeQueueNativeOverlapped.

ThreadPool.BindHandle is used by CLR to implement asynchronous IO. For example, FileStream uses it to implement BeginRead/BeginWrite. Developers can take advantage of it too. We will talk about that in a separate article.

ThreadPool.UnsafeQueueNativeOverlapped can be used to queue a non IO work item to the IoCompletionPort thread pool, just like ThreadPool.QueueUserWorkItem.

Why will you want to use ThreadPool.UnsafeQueueNativeOverlapped instead of ThreadPool.QueueUserWorkItem?

In our development, we discover an inefficiency of ThreadPool.QueueUserWorkItem. If we have some alternate high and low number of work items, some of the threads may do busy waiting, artificially increase the CPU usage of our application.

If you have the same pattern, and you have observed high CPU usage when it should not, you can try ThreadPool.UnsafeQueueNativeOverlapped.

The following is an example how to ThreadPool.UnsafeQueueNativeOverlapped.

using System;

using System.Runtime.InteropServices;

using System.Threading;

namespace UQNO

{

    internal class AsyncHelper

    {

        WaitCallback callback;

        object state;

        internal AsyncHelper(WaitCallback callback, object state)

        {

            this.callback = callback;

            this.state = state;

        }

        unsafe internal void Callback(uint errorCode, uint numBytes, NativeOverlapped* _overlapped)

        {

            try

            {

                this.callback(this.state);

            }

            finally

            {

                Overlapped.Free(_overlapped);

            }

        }

    }

    class Program

    {

        static void Main(string[] args)

        {

            ManualResetEvent wait = new ManualResetEvent(false);

            WaitCallback callback = delegate(object state)

            {

                Console.WriteLine("callback is executed in thread id {0} name {1}", Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.Name);

                ManualResetEvent _wait = (ManualResetEvent)state;

                _wait.Set();

            };

            AsyncHelper ah = new AsyncHelper(callback, wait);

            unsafe

            {

                Overlapped overlapped = new Overlapped();

                NativeOverlapped* pOverlapped = overlapped.Pack(ah.Callback, null);

                ThreadPool.UnsafeQueueNativeOverlapped(pOverlapped);

                wait.WaitOne();

            }

        }

    }

}

string str = new string((char*)p);

And for the reverse:

fixed(char *p = str){}

Why do we care about conversion between System.String and char *?

From this article, this is the fastest way to marshal strings between managed and native boundary.

If you do experience this problem, you can install hotfix KB952709.

https://support.microsoft.com/kb/952709/