I am not sure if this is the right forum to ask my question, if not please anyone let me know the better one.

I am developing an application which allows a user to enter c# code and it is built at runtime.

I also want to provide the user a simplified intelli-sense like feature. So when the mouse is moved over an identifier in the code text I want to display the details like type, value and parameters if it is a method name.

Currently I am facing with the following problem : assume the code is error-free and I can compile it. Let's say there is an identifier in the code named Foo.Whatewer.Something. The compiler obviously understands this. How can I get some information about an identifier if I only know its name "Foo.Whatever.Something" ?

There is well-defined object model in the built runtime code and I have the type and instance of the referring class (the class containing the code with the identifier "Foo.Whatewer.Something" ). Currently I am making assumptions that Foo is a variable in the referring object and I can use reflection this way to get the information I want.

But this is too specific and does not work if the user code refers to a class outside of my defined object model, for instance to a File class.

I want to have a more general approach, the way the compiler can resolve the reference.

What is the correct way ? Any ideas please ?

I have built a VB.NET application, two instances of which talk (only) to each other via a single named pipe.

One instance is configured as named pipe Server, and the other as Client.

Works fine, except that once I break the pipe (such as by stopping either the Client or the Server), I am unable to re-establish it.

I have tried everything I can find to "destroy" the pipe and associated objects, but keep getting "All pipe instances are busy" when trying to re-create it, so I am missing something.

Is there a way to destroy the pipe so that the application can re-create it as if it was just starting up?

Thanks in advance for any help/insight!

Hey Hello .net Experts, I have a question regarding the implicit casting of enum. If we are having same type of enums should we cast both before we are comparing these?

It is something like if there are two enums of type int then should we cast implicitly before we are comparing both for robust programming?

What are your thoughts? Please suggest.

I need to build some classes dynamically and save the assembly
to disk,however when I examine a dynamically built class
using ildasm, and compare it with a statically built class
with the same member structure, I realized that the 
manifest of dynamically built ones seem to be cut off,
I mean that its manifest is much simpler, besides when
statically referencing the dynamically generated dll from
another program class members don't show. Here is a snippet
with 2 very simple and identical classes one built
statically and the other dynamically to compare their manifest.
I cant figure out what is wrong, please can someone help me?


      public class SimpleClass
      {
       public string Name;
       public int Age;

      }

    class Program
   {
      static void Main(string[] args)
      {
        AppDomain appDomain = AppDomain.CurrentDomain;
        AssemblyName aName = new AssemblyName();
            aName.Name = "SimpleReflection";
        AssemblyBuilder assemBuilder = appDomain.DefineDynamicAssembly(aName,
           AssemblyBuilderAccess.Save);
        ModuleBuilder modBuilder = assemBuilder.DefineDynamicModule(aName.Name,"SimpleDyn.dll");


        TypeBuilder tb = modBuilder.DefineType("SimpleDyn.SimpleClass1",
            TypeAttributes.Public | TypeAttributes.BeforeFieldInit, typeof(object));

        FieldBuilder field1 = tb.DefineField("Name", typeof(string), FieldAttributes.Public);
         FieldBuilder field2 = tb.DefineField("Age", typeof(int), FieldAttributes.Public);

         tb.CreateType();
         assemBuilder.Save("SimpleDyn.dll");


        }
    }

    

At one of our customers, our application, that was build with the .Net Framework 2.0, always gets started with .Net Framework 4.0.

This causes a crash in a 3rd party assembly (Telerik).

We already created a CLR Load Log:

5568,1726707.515,CLR Loading log for C:\Program Files (x86)\windream GmbH\windream\Windream.Find.WinForms.exe
5568,1726707.515,Log started at 09:26:15 on 07.01.2016
5568,1726707.515,-----------------------------------
5568,1726707.515,FunctionCall: _CorExeMain
5568,1726707.515,FunctionCall: ClrCreateInstance, Clsid: {2EBCD49A-1B47-4A61-B13A-4A03701E594B}, Iid: {E2190695-77B2-492E-8E14-C4B3A7FDD593}
5568,1726707.515,MethodCall: ICLRMetaHostPolicy::GetRequestedRuntime.  Version: (null),  Metahost Policy Flags: 0x1168, Binary: (null), Iid: {BD39D1D2-BA2F-486A-89B0-B4B0CB466891}
5568,1726707.515,Installed Runtime: v2.0.50727.  VERSION_ARCHITECTURE: 0
5568,1726707.515,Installed Runtime: v4.0.30319.  VERSION_ARCHITECTURE: 0
5568,1726707.515,Input values for ComputeVersionString follow this line
5568,1726707.515,-----------------------------------
5568,1726707.515,Default Application Name: C:\Program Files (x86)\windream GmbH\windream\Windream.Find.WinForms.exe
5568,1726707.515,IsLegacyBind is: 0
5568,1726707.515,IsCapped is 0
5568,1726707.515,SkuCheckFlags are 0
5568,1726707.515,ShouldEmulateExeLaunch is 0
5568,1726707.515,LegacyBindRequired is 0
5568,1726707.515,-----------------------------------
5568,1726707.515,Parsing config file: C:\Program Files (x86)\windream GmbH\windream\Windream.Find.WinForms.exe.config
5568,1726707.515,Config File (Open). Result:00000000
5568,1726707.515,Config File (Read). Result:00000000
5568,1726707.515,Found config file: C:\Program Files (x86)\windream GmbH\windream\Windream.Find.WinForms.exe.config
5568,1726707.515,UseLegacyV2RuntimeActivationPolicy is set to 0
5568,1726707.515,FindLatestVersion is returning the following version: v4.0.30319 Input VERSION_ARCHITECTURE: 0, V2.0 Capped: 0
5568,1726707.515,Default version of the runtime on the machine: v4.0.30319
5568,1726707.515,Decided on runtime: v4.0.30319

...

As you can see, the Version, the application was build with, is not taken into account.

Why ? Is there any Setting, that may cause this ?

We than decided to put a define the Framework Version to use in a config file, using supportedRuntime.

The result is the following CLR Load Log:

312,1810559.703,CLR Loading log for C:\Program Files (x86)\windream GmbH\windream\Windream.Find.WinForms.exe
312,1810559.703,Log started at 08:43:49 on 08.01.2016
312,1810559.703,-----------------------------------
312,1810559.703,FunctionCall: _CorExeMain
312,1810559.703,FunctionCall: ClrCreateInstance, Clsid: {2EBCD49A-1B47-4A61-B13A-4A03701E594B}, Iid: {E2190695-77B2-492E-8E14-C4B3A7FDD593}
312,1810559.718,MethodCall: ICLRMetaHostPolicy::GetRequestedRuntime.  Version: (null),  Metahost Policy Flags: 0x1168, Binary: (null), Iid: {BD39D1D2-BA2F-486A-89B0-B4B0CB466891}
312,1810559.718,Installed Runtime: v2.0.50727.  VERSION_ARCHITECTURE: 0
312,1810559.718,Installed Runtime: v4.0.30319.  VERSION_ARCHITECTURE: 0
312,1810559.718,Input values for ComputeVersionString follow this line
312,1810559.718,-----------------------------------
312,1810559.718,Default Application Name: C:\Program Files (x86)\windream GmbH\windream\Windream.Find.WinForms.exe
312,1810559.718,IsLegacyBind is: 0
312,1810559.718,IsCapped is 0
312,1810559.718,SkuCheckFlags are 0
312,1810559.718,ShouldEmulateExeLaunch is 0
312,1810559.718,LegacyBindRequired is 0
312,1810559.718,-----------------------------------
312,1810559.718,Parsing config file: C:\Program Files (x86)\windream GmbH\windream\Windream.Find.WinForms.exe.config
312,1810559.718,Config File (Open). Result:00000000
312,1810559.718,Config File (Read). Result:00000000
312,1810559.718,Found config file: C:\Program Files (x86)\windream GmbH\windream\Windream.Find.WinForms.exe.config
312,1810559.718,UseLegacyV2RuntimeActivationPolicy is set to 0
312,1810559.718,Config file includes SupportedRuntime entry.  Version: v2.0.50727, SKU: (null)
312,1810559.718,FindLatestVersion is returning the following version: v4.0.30319 Input VERSION_ARCHITECTURE: 0, V2.0 Capped: 0
312,1810559.718,Default version of the runtime on the machine: v4.0.30319
312,1810559.718,Decided on runtime: v4.0.30319

It even sees the SupportedRuntime in the config file, but still decides to use the wrong runtime Version.

Does anybody know a possible reason for this strange behaviour ?

Additional info: the machine is running Server 2012 R2 with Citrix XenApp 6.5

Regards,

  Uwe Honermann

  windream GmbH

Hi

I generate and sign my app using makecert & signtool commands. After signing the executable file, the checksum field of optional header changed from 0 to some value, Then I changed some bytes of the executable file using a binary editor program then I run the executable file but it runs normally and Windows does NOT alert that file is changed!

Why code signing not works? What is it for digitally signature?

Hi

I generate a certificate using makecert.exe and using signtool.exe to sign my app. But in the file properties dialog box on digital signatures details the email field is "Not available". How can i add an email address to it (or and other extra information)? is it depend on certificate file (makecert) or signtool?

Also what is "Countersignatures" sectiton?

Another question:

When generating the certificate for code signing is it necessary to use passwords (requested by makecert & pvk2pfx tools)? or can i set them to none?

Thanks

I'm trying to list the alternate streams of a file hosted on an SMB server using the NtQueryInformationFile function. The code I've written so far works correctly with most servers but fails sometimes when run against non-samba Mac OS X SMB server.

I've reduced the code form my application to the following bit of code that reproduces the issue reliably:

using Microsoft.Win32.SafeHandles;

namespace Streams
{
    class Program
    {
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
        public class NETRESOURCE
        {
            public uint dwScope;
            public uint dwType;
            public uint dwDisplayType;
            public uint dwUsage;

            public string lpLocalName;
            public string lpRemoteName;
            public string lpComment;
            public string lpProvider;
        }

        [DllImport("ntdll.dll", SetLastError = false, CharSet = CharSet.Unicode)]
        public static extern uint NtQueryInformationFile(
            SafeFileHandle handle,
            IntPtr IoStatusBlock,
            IntPtr pInfoBlock,
            uint length,
            uint fileInformationClass);


        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
        public static extern SafeFileHandle CreateFile(
            string fileName,
            uint desiredAccessMask,
            uint shareMode,
            IntPtr lpSecurityAttributes,
            uint creationDisposition,
            uint flagsAndAttributes,
            IntPtr hTemplateFile);

        [DllImport("mpr.dll", SetLastError = true, CharSet = CharSet.Unicode)]
        public static extern uint WNetAddConnection2(NETRESOURCE netResource, [MarshalAs(UnmanagedType.LPTStr)] string password, [MarshalAs(UnmanagedType.LPTStr)] string username, uint flags);

        static void Main(string[] args)
        {
            var server = args[0];
            var username = args[1];
            var password = args[2];
            var uncPath = args[3];

            NETRESOURCE netResource = new NETRESOURCE();
            netResource.dwType = 0x1 /* DISK */;
            netResource.lpRemoteName = server;
            WNetAddConnection2(netResource, password, username, 0x00000004 /* CONNECT_TEMPORARY */);

            var fh = CreateFile(
                uncPath,
                0x80000000 /* GENERIC_READ */,
                (uint)(FileShare.Read | FileShare.Write | FileShare.Delete),
                IntPtr.Zero,
                3 /* OPEN_EXISTING */,
                0x08000000 /* SequentialScan */ | 0x02000000 /* BackupSemantics */,
                IntPtr.Zero
                );

            IntPtr status = Marshal.AllocHGlobal(1024);
            uint bufferSize = 64*1024;
            IntPtr buffer = Marshal.AllocHGlobal((int)bufferSize);

            uint ntStatus = NtQueryInformationFile(fh, status, buffer, bufferSize, 22 /* FileStreamInformation */);

            Console.WriteLine($"NtQueryFileInformation returned {ntStatus}");
            Console.ReadKey();
        }
    }
}

In most cases the value of ntStatus is STATUS_OK as is expected. When I try to use this on a file that has alternate data streams with a Mac OS X SMB server I get STATUS_INVALID_NETWORK_RESPONSE instead. That error code seems to indicate that the response from the server is incorrect, but when I inspect this with Wireshark there are no differences compared to when STATUS_OK is returned.

To make things even stranger, this code works when I run it in 32-bit mode (set the 'Prefer 32-bit' in the Visual Studio project settings). When run in 64-bit mode I always get the error code. The obvious error then would be that the code in question is not 64-bit clean, but AFAICT the code above is.

I've also tried replacing the NtQueryInformationFile call with the call to GetFileInformationByHandleEx, but that gives me the same result (with a Win32 error code instead of an NT status code of course).

What could explain this difference in behaviour between 32-bit and 64-bit mode?

When I try to go to the following link I get an error page.

https://www.microsoft.com/en-us/download/details.aspx?id=42637

Is there another link where I could download the .NET 4.5.2 Developer Pack?

Foolishly, I was in a hurry and didn't backup my box before allowing this update, which I always do. A good lesson here for everyone. My app was stable, but now it will not run compiled with .NET native. Debug build is OK, although I'm annoyed that the command bar theme has changed. .NET Native states it compiles OK, but it crashes every time. This is a UWP app based on Template 10. Will not run within or outside of the IDE. When run within the IDE, I get...

Unhandled exception at 0x00007FFE5CC5B199 (twinapi.appcore.dll) in MyApp.exe: 0xC000027B: An application-internal exception has occurred (parameters: 0x00000069E14FE960, 0x0000000000000001).

I'm trying to use PInvoke to call ReadEx, but I haven't been able to figure out exactly how to do it.

The signature for ReadFileEx contains a callback delegate, which is provided as System.Threading.IOCompletionCallback. However, ALL the pack routines also require a completion callback. I've tried every combination, and nothing works.

I have an old program that was written and is running under .net 2.0 with SP2. It worked with no problems on Windows 7, but on Windows 8 and Windows 10 the program crashes when changing the keyboard layout with ALT+Shift. I created a minidump and analyzed this, and according to the debugger, the faulting module is msftedit.dll, but it doesn't really make any sense that it is a Windows component failing, as all other programs on my machine work just fine and I can change keyboards as I please.

Strangely enough if I assign shortcuts to the keyboards as CTRL+1 and CTRL+3 I can change using those, however CTRL+2 as a shortcut for change of keyboard will cause the application to crash -- and so will ALT+Shift and WIN+Space. Using the language bar and the mouse also causes a crash.

I don't know enough about the inner workings of Windows to debug this and have my application work without a problem, but really need some help with this. I have tried running the application in compatibility mode and that does not change the behavior.

Hi,

 Target "ValidateRoleFiles64bitAssemblies" in file "C:\Program Files (x86)\MSBuild\Microsoft\VisualStudio\v11.0\Windows Azure Tools\2.4\Microsoft.WindowsAzure.targets" from project "C:\Builds\1\product\testWebApi\src\test.WebApi.Azure\test.WebApi.Azure.ccproj" (target "ValidateRoleFiles" depends on it):
Using "ProvideAssemblyProcessorArchitecture" task from assembly "C:\Program Files (x86)\MSBuild\Microsoft\VisualStudio\v11.0\Windows Azure Tools\2.4\Microsoft.VisualStudio.WindowsAzure.Tasks.2.4.dll".
Task "ProvideAssemblyProcessorArchitecture"
C:\Program Files (x86)\MSBuild\Microsoft\VisualStudio\v11.0\Windows Azure Tools\2.4\Microsoft.WindowsAzure.targets(2331,5): error MSB4018: The "ProvideAssemblyProcessorArchitecture" task failed unexpectedly. [C:\Builds\1\product\testWebApi\src\test.WebApi.Azure\test.WebApi.Azure.ccproj]
C:\Program Files (x86)\MSBuild\Microsoft\VisualStudio\v11.0\Windows Azure Tools\2.4\Microsoft.WindowsAzure.targets(2331,5): error MSB4018: System.BadImageFormatException: The module was expected to contain an assembly manifest. (Exception from HRESULT: 0x80131018) [C:\Builds\1\product\testWebApi\src\test.WebApi.Azure\test.WebApi.Azure.ccproj]
C:\Program Files (x86)\MSBuild\Microsoft\VisualStudio\v11.0\Windows Azure Tools\2.4\Microsoft.WindowsAzure.targets(2331,5): error MSB4018:    at Microsoft.Build.Tasks.Deployment.ManifestUtilities.NativeMethods.GetAssemblyIdentityFromFile(String filePath, Guid& riid) [C:\Builds\1\product\testWebApi\src\test.WebApi.Azure\test.WebApi.Azure.ccproj]
C:\Program Files (x86)\MSBuild\Microsoft\VisualStudio\v11.0\Windows Azure Tools\2.4\Microsoft.WindowsAzure.targets(2331,5): error MSB4018:    at Microsoft.Build.Tasks.Deployment.ManifestUtilities.MetadataReader.ImportAttributes() [C:\Builds\1\product\testWebApi\src\test.WebApi.Azure\test.WebApi.Azure.ccproj]
C:\Program Files (x86)\MSBuild\Microsoft\VisualStudio\v11.0\Windows Azure Tools\2.4\Microsoft.WindowsAzure.targets(2331,5): error MSB4018:    at Microsoft.Build.Tasks.Deployment.ManifestUtilities.MetadataReader.get_Attributes() [C:\Builds\1\product\testWebApi\src\test.WebApi.Azure\test.WebApi.Azure.ccproj]
C:\Program Files (x86)\MSBuild\Microsoft\VisualStudio\v11.0\Windows Azure Tools\2.4\Microsoft.WindowsAzure.targets(2331,5): error MSB4018:    at Microsoft.Build.Tasks.Deployment.ManifestUtilities.AssemblyIdentity.FromManagedAssembly(String path) [C:\Builds\1\product\testWebApi\src\test.WebApi.Azure\test.WebApi.Azure.ccproj]
C:\Program Files (x86)\MSBuild\Microsoft\VisualStudio\v11.0\Windows Azure Tools\2.4\Microsoft.WindowsAzure.targets(2331,5): error MSB4018:    at Microsoft.CloudExtensions.MSBuildTasks.ProvideAssemblyProcessorArchitecture.RetreiveProcessorArcitectureFromFusionName(String assemblyFileName) [C:\Builds\1\product\testWebApi\src\test.WebApi.Azure\test.WebApi.Azure.ccproj]
C:\Program Files (x86)\MSBuild\Microsoft\VisualStudio\v11.0\Windows Azure Tools\2.4\Microsoft.WindowsAzure.targets(2331,5): error MSB4018:    at Microsoft.CloudExtensions.MSBuildTasks.ProvideAssemblyProcessorArchitecture.ExecuteImpl(GetProcessorArchitectureFromAssemblyFileName getProcessorArchitectureFromAssemblyFileName) [C:\Builds\1\product\testWebApi\src\test.WebApi.Azure\test.WebApi.Azure.ccproj]
C:\Program Files (x86)\MSBuild\Microsoft\VisualStudio\v11.0\Windows Azure Tools\2.4\Microsoft.WindowsAzure.targets(2331,5): error MSB4018:    at Microsoft.Build.BackEnd.TaskExecutionHost.Microsoft.Build.BackEnd.ITaskExecutionHost.Execute() [C:\Builds\1\product\testWebApi\src\test.WebApi.Azure\test.WebApi.Azure.ccproj]
C:\Program Files (x86)\MSBuild\Microsoft\VisualStudio\v11.0\Windows Azure Tools\2.4\Microsoft.WindowsAzure.targets(2331,5): error MSB4018:    at Microsoft.Build.BackEnd.TaskBuilder.<ExecuteInstantiatedTask>d__20.MoveNext() [C:\Builds\1\product\testWebApi\src\test.WebApi.Azure\test.WebApi.Azure.ccproj]
Done executing task "ProvideAssemblyProcessorArchitecture" -- FAILED.
Done building target "ValidateRoleFiles64bitAssemblies" in project "test.WebApi.Azure.ccproj" -- FAILED.

How and which application is JIT Compiler in windows 10 Latest version of .Net Framework? 

C#, VB.Net or Compiled to MSCIL  then when app runs JIT ( JUST IN TIME ) Compiler compiles and Convert that MSCIL to Native Code ( APP ). What is JIT PE Executable and what it's location in windows 10 .Net Framework. When an IL App runs how JIT Works is this API or SYS OR EXE ?? 

Thanks 

hey im having problems with my vb output thing. im using vb 2015 for a vb 2013 project and i keep getting this thing about something in my threads in my output it looks like this

'Bradley's Game Room.vshost.exe' (CLR v4.0.30319: Bradley's Game Room.vshost.exe): Loaded 'C:\WINDOWS\Microsoft.Net\assembly\GAC_MSIL\System.Drawing\v4.0_4.0.0.0__b03f5f7f11d50a3a\System.Drawing.dll'. Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
'Bradley's Game Room.vshost.exe' (CLR v4.0.30319: Bradley's Game Room.vshost.exe): Loaded 'C:\WINDOWS\assembly\GAC_MSIL\Microsoft.VisualStudio.HostingProcess.Utilities.Sync\14.0.0.0__b03f5f7f11d50a3a\Microsoft.VisualStudio.HostingProcess.Utilities.Sync.dll'. Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
'Bradley's Game Room.vshost.exe' (CLR v4.0.30319: Bradley's Game Room.vshost.exe): Loaded 'C:\WINDOWS\assembly\GAC_MSIL\Microsoft.VisualStudio.Debugger.Runtime\14.0.0.0__b03f5f7f11d50a3a\Microsoft.VisualStudio.Debugger.Runtime.dll'. Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
'Bradley's Game Room.vshost.exe' (CLR v4.0.30319: Bradley's Game Room.vshost.exe): Loaded 'F:\Bradley's Game Room\Bradley's Game Room\bin\Debug\Bradley's Game Room.vshost.exe'. Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
'Bradley's Game Room.vshost.exe' (CLR v4.0.30319: Bradley's Game Room.vshost.exe): Loaded 'C:\WINDOWS\Microsoft.Net\assembly\GAC_32\System.Data\v4.0_4.0.0.0__b77a5c561934e089\System.Data.dll'. Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
'Bradley's Game Room.vshost.exe' (CLR v4.0.30319: Bradley's Game Room.vshost.exe): Loaded 'C:\WINDOWS\Microsoft.Net\assembly\GAC_MSIL\System.Deployment\v4.0_4.0.0.0__b03f5f7f11d50a3a\System.Deployment.dll'. Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
'Bradley's Game Room.vshost.exe' (CLR v4.0.30319: Bradley's Game Room.vshost.exe): Loaded 'C:\WINDOWS\Microsoft.Net\assembly\GAC_MSIL\System.Xml\v4.0_4.0.0.0__b77a5c561934e089\System.Xml.dll'. Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
'Bradley's Game Room.vshost.exe' (CLR v4.0.30319: Bradley's Game Room.vshost.exe): Loaded 'C:\WINDOWS\Microsoft.Net\assembly\GAC_MSIL\System.Core\v4.0_4.0.0.0__b77a5c561934e089\System.Core.dll'. Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
'Bradley's Game Room.vshost.exe' (CLR v4.0.30319: Bradley's Game Room.vshost.exe): Loaded 'C:\WINDOWS\Microsoft.Net\assembly\GAC_MSIL\System.Xml.Linq\v4.0_4.0.0.0__b77a5c561934e089\System.Xml.Linq.dll'. Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
'Bradley's Game Room.vshost.exe' (CLR v4.0.30319: Bradley's Game Room.vshost.exe): Loaded 'C:\WINDOWS\Microsoft.Net\assembly\GAC_MSIL\System.Data.DataSetExtensions\v4.0_4.0.0.0__b77a5c561934e089\System.Data.DataSetExtensions.dll'. Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
'Bradley's Game Room.vshost.exe' (CLR v4.0.30319: Bradley's Game Room.vshost.exe): Loaded 'C:\WINDOWS\Microsoft.Net\assembly\GAC_MSIL\System.Net.Http\v4.0_4.0.0.0__b03f5f7f11d50a3a\System.Net.Http.dll'. Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
'Bradley's Game Room.vshost.exe' (CLR v4.0.30319: Bradley's Game Room.vshost.exe): Loaded 'C:\WINDOWS\Microsoft.Net\assembly\GAC_MSIL\Microsoft.VisualBasic\v4.0_10.0.0.0__b03f5f7f11d50a3a\Microsoft.VisualBasic.dll'. Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.
The thread 0x1654 has exited with code 0 (0x0).
The thread 0x820 has exited with code 0 (0x0).

I have enabled the FIPS algorithm policy on our windows server2008 machine. Now, any page that has a viewstate is abending with the following error: 

This implementation is not part of the Windows Platform FIPS validated cryptographic algorithms.


This is used in a web farm so we have a machine key defined in our machine.config. If I add decryption="3DES" to the end of that key everything works again. My guess is the default is AES which isn't FIPS compliant. I also noticed this is not an issue on my iis 6.0 servers running server 2003. Very similar setup.

Is there a better way to handle this situation? I read some articles about doing something similar in the app web config. The web.config worked fine. However, the machine.config change seems better because I won't have to change every application.

Hi,

I found this msdn article showing how to strong name sign an assembly with SHA-2 (Enhanced Strong Naming), but it uses the command line and delayed signing. This is not what i want to do.

I would like to know how to use the Enhanced Strong Naming out of the box like the usual strong name signatures.

Can anybody tell me how to do this?

Hi there,

we've a C# WPF 4.5 application, that crashes on a Terminal Server on the second startup with an internal error in the Framework:

Ereignis-ID 1023
Application: Windream.Find.Wpf.exe
Framework Version: v4.0.30319
Description: The process was terminated due to an internal error in the .NET Runtime at IP 000007FEDC0771B4 (000007FEDBE70000) with exit code 80131506.
Ereignis-ID 1000
Name der fehlerhaften Anwendung: Windream.Find.Wpf.exe, Version: 6.0.4.6015, Zeitstempel: 0x54e36082
Name des fehlerhaften Moduls: clr.dll, Version: 4.0.30319.34209, Zeitstempel: 0x5348a1ef
Ausnahmecode: 0xc0000005
Fehleroffset: 0x00000000002071b4
ID des fehlerhaften Prozesses: 0x46ac
Startzeit der fehlerhaften Anwendung: 0x01d14966395f0ba1
Pfad der fehlerhaften Anwendung: C:\Program Files\windream GmbH\windream\Windream.Find.Wpf.exe
Pfad des fehlerhaften Moduls: C:\Windows\Microsoft.NET\Framework64\v4.0.30319\clr.dll
Berichtskennung: 77ad748b-b559-11e5-b82e-0050568f6244

This happens on every subsequent starts.
After some time (about 5 - 15 minutes), it works again.

The process from the first, working startup is not running anymore, at that time.

In a dump, I can see, that the .Net CLR startup is still in progress, when the exception occurs.
Also, I can see, that no dependent assembly has been loaded, and none of our code has been running, so far.

Here's the whole CLR Stack from the Dump:

0:000> !DumpStack
OS Thread Id: 0x38b4 (0)
Current frame: clr!ClassLoader::AddAvailableClassHaveLock+0x234
Child-SP         RetAddr          Caller, Callee
000000000015be00 000007feea894fcc clr!LoaderAllocator::AllocateHandle_Unlocked+0xfc, calling clr!ErectWriteBarrier_ASM
000000000015bf00 000000007787f9b8 ntdll!RtlAllocateHeap+0xe4, calling ntdll!RtlpLowFragHeapAllocFromContext
000000000015bf10 000007feea8ee5fe clr!CExecutionEngine::AcquireLock+0x9b, calling ntdll!RtlTryEnterCriticalSection
000000000015bf80 000007feea8ba4a2 clr!Assembly::GetManifestWinMDImport+0x5e
000000000015bfd0 000007feea8ba429 clr!Assembly::GetWinMDStatus+0x23, calling clr!Assembly::GetManifestWinMDImport
000000000015c030 000007feea8bb8d3 clr!ClassLoader::PopulateAvailableClassHashTable+0xd4, calling clr!ClassLoader::AddAvailableClassHaveLock
000000000015c0f0 000007feea8df590 clr!Module::DoInit+0x70, calling clr!CLRException::HandlerState::CleanupTry
000000000015c120 000007feea89995a clr!SimpleRWLock::SimpleRWLock+0x17, calling clr!GetCurrentProcessCpuCount
000000000015c190 000007feea8df3df clr!Module::Module+0xab
000000000015c1a0 000007feea9f273d clr!PEDecoder::GetPersistedModuleImage+0xe, calling clr!PEDecoder::GetNativeHeader
000000000015c1c0 0000000077857534 ntdll!RtlInitializeCriticalSection+0xf0, calling ntdll!RtlEnterCriticalSection
000000000015c1d0 000007feea8e03e6 clr!Module::Create+0xd3, calling clr!Module::DoInit
000000000015c230 000007feea8bb7f2 clr!Assembly::PrepareModuleForAssembly+0x7f, calling clr!ClassLoader::PopulateAvailableClassHashTable
000000000015c260 000007feea8df8b4 clr!Assembly::Init+0x1a5, calling clr!Assembly::PrepareModuleForAssembly
000000000015c290 000007feea883b6f clr!operator new+0xf, calling clr!EEHeapAllocInProcessHeap
000000000015c2c0 000007feea8df6ca clr!Assembly::Create+0xda, calling clr!Assembly::Init
000000000015c2f0 000000007787f9b8 ntdll!RtlAllocateHeap+0xe4, calling ntdll!RtlpLowFragHeapAllocFromContext
000000000015c340 000007feea8c7ad3 clr!AssemblySecurityDescriptor::Resolve+0x1c
000000000015c360 000007feea8d631e clr!BaseAssemblySpec::ConvertPublicKeyToToken+0xa6, calling clr!StrongNameFreeBuffer
000000000015c390 000007feea883735 clr!GCPreemp::GCPreemp+0xe, calling clr!GetThread
000000000015c3c0 000007feea8dac98 clr!DomainAssembly::Allocate+0x17e, calling clr!Assembly::Create
000000000015c400 000007feea883a6a clr!EEHeapAllocInProcessHeap+0x46, calling ntdll!RtlAllocateHeap
000000000015c430 000007feea883b6f clr!operator new+0xf, calling clr!EEHeapAllocInProcessHeap
000000000015c460 000007feea8c8023 clr!BaseAssemblySpec::CloneFields+0x103, calling MSVCR120_CLR0400!strcpy_s
000000000015c4d0 000007feea8c7e4c clr!AssemblySpec::InitializeSpecInternal+0x118, calling clr!CLRException::HandlerState::CleanupTry
000000000015c520 000007feea882b2c clr!CrstBase::Enter+0x74, calling ntdll!RtlTryEnterCriticalSection
000000000015c548 000007fe8b150278 000007fe8b150278, calling 000007fe8b150a76
000000000015c580 000007feea8cc472 clr!PEImage::Release+0x3f, calling clr!CrstBase::Leave
000000000015c5c0 000007feeac41136 clr!DomainFile::VerifyNativeImageDependencies+0x366266, calling clr!PEImage::Release
000000000015c760 000007feea8daafb clr!DomainFile::DoIncrementalLoad+0x117
000000000015c790 000007feea8d9805 clr!AppDomain::TryIncrementalLoad+0x136, calling clr!DomainFile::DoIncrementalLoad
000000000015c7b0 000007feea8a38ef clr!PEImage::Equals+0x257, calling clr!_security_check_cookie
000000000015c7d0 000007feea93b9bd clr!SimpleRWLock::EnterRead+0x6a, calling clr!GetThread
000000000015c7e0 000007feea882b2c clr!CrstBase::Enter+0x74, calling ntdll!RtlTryEnterCriticalSection
000000000015c840 000007feea8cc472 clr!PEImage::Release+0x3f, calling clr!CrstBase::Leave
000000000015c9c0 000000007787f9b8 ntdll!RtlAllocateHeap+0xe4, calling ntdll!RtlpLowFragHeapAllocFromContext
000000000015ca40 000007feea8d8915 clr!BaseAssemblySpec::IsMscorlib+0x89, calling clr!_security_check_cookie
000000000015ca80 000000007787f9b8 ntdll!RtlAllocateHeap+0xe4, calling ntdll!RtlpLowFragHeapAllocFromContext
000000000015cab0 000007feea882b2c clr!CrstBase::Enter+0x74, calling ntdll!RtlTryEnterCriticalSection
000000000015cad0 0000000077857534 ntdll!RtlInitializeCriticalSection+0xf0, calling ntdll!RtlEnterCriticalSection
000000000015cae0 000007feea882a90 clr!CrstBase::Leave+0x30, calling ntdll!RtlLeaveCriticalSection
000000000015cb10 000007feea8904bd clr!DeadlockAwareLock::TryBeginEnterLock+0x65, calling clr!CrstBase::Leave
000000000015cb20 000007feea882b2c clr!CrstBase::Enter+0x74, calling ntdll!RtlTryEnterCriticalSection
000000000015cb30 000007feea882f21 clr!ClrFlsGetValue+0xe, calling clr!ClrFlsGetBlock
000000000015cb40 000007feea89039d clr!CrstBase::InitWorker+0x35, calling ntdll!RtlInitializeCriticalSection
000000000015cb50 000007feea8d96a5 clr!ListLockEntry::DeadlockAwareEnter+0x52, calling clr!GetThread
000000000015cb90 000007feea8d9492 clr!AppDomain::LoadDomainFile+0x107, calling clr!AppDomain::TryIncrementalLoad
000000000015cbb0 000007feea8db266 clr!FileLoadLock::FileLoadLock+0x66
000000000015cc10 000007feea882a90 clr!CrstBase::Leave+0x30, calling ntdll!RtlLeaveCriticalSection
000000000015cc40 000007feea8d85c7 clr!AppDomain::LoadDomainAssemblyInternal+0x177, calling clr!AppDomain::LoadDomainFile
000000000015ccb0 000007feea8d8a2b clr!AppDomain::FindCachedFile+0x3b, calling clr!AssemblySpecBindingCache::LookupFile
000000000015cd30 000007feea8d840f clr!AppDomain::LoadDomainAssembly+0x8c, calling clr!AppDomain::LoadDomainAssemblyInternal
000000000015cdc0 000007feef0753fd MSVCR120_CLR0400!getptd_noexit+0x74, calling kernel32!SetLastError
000000000015cde0 0000000077631a7a kernel32!HeapFree+0xa, calling ntdll!RtlFreeHeap
000000000015cdf0 000007feef0754ea MSVCR120_CLR0400!getptd+0xb, calling MSVCR120_CLR0400!getptd_noexit
000000000015ce10 000007feef0753fd MSVCR120_CLR0400!getptd_noexit+0x74, calling kernel32!SetLastError
000000000015ce20 000007feea8a3fe4 clr!AssemblySpec::ParseEncodedName+0x5c, calling clr!_security_check_cookie
000000000015ce60 000007feea8d8948 clr!SString::_strnicmp+0x1c, calling clr!SString::CaseCompareHelperA
000000000015ce70 000007feef076512 MSVCR120_CLR0400!_LocaleUpdate::_LocaleUpdate+0x1b, calling MSVCR120_CLR0400!getptd
000000000015ce80 000007feea93c410 clr!BaseAssemblySpec::CompareEx+0x16d, calling MSVCR120_CLR0400!strcmp
000000000015ced0 000007feea93c410 clr!BaseAssemblySpec::CompareEx+0x16d, calling MSVCR120_CLR0400!strcmp
000000000015cee0 000007feea93bfb9 clr!ComparePtr::CompareHelper+0x15
000000000015cf00 000007feea93c47b clr!DomainAssemblyCache::CompareBindingSpec+0x37, calling clr!BaseAssemblySpec::CompareEx
000000000015cf30 000007feea93bfb9 clr!ComparePtr::CompareHelper+0x15
000000000015cf50 000007feea883735 clr!GCPreemp::GCPreemp+0xe, calling clr!GetThread
000000000015cf60 000007feea93bfc5 clr!HashMap::CompareValues+0x15
000000000015cf90 000007feea90bd5c clr!HashMap::LookupValue+0x78, calling clr!GetThread
000000000015d010 000007feea8d896a clr!AppDomain::BindAssemblySpec+0x1a, calling clr!_chkstk
000000000015d050 000007feea8d8fde clr!AssemblySpec::LoadDomainAssembly+0x224, calling clr!AppDomain::LoadDomainAssembly
000000000015d1d0 000007feea8eebbf clr!MethodDesc::GetOrCreatePrecode+0x257, calling clr!_security_check_cookie
000000000015d240 000007feea882b2c clr!CrstBase::Enter+0x74, calling ntdll!RtlTryEnterCriticalSection
000000000015d250 0000000077855ed4 ntdll!RtlpLowFragHeapAllocFromContext+0x68f, calling ntdll!ExpInterlockedPopEntrySList
000000000015d260 000007feea883b2d clr!EEHeapFreeInProcessHeap+0x39, calling kernel32!HeapFree
000000000015d270 000007feea8a3fe4 clr!AssemblySpec::ParseEncodedName+0x5c, calling clr!_security_check_cookie
000000000015d2a0 000007feea8d8b35 clr!AppDomain::AddAssemblyToCache+0x69, calling clr!CrstBase::Leave
000000000015d2e0 000007feea8ee5fe clr!CExecutionEngine::AcquireLock+0x9b, calling ntdll!RtlTryEnterCriticalSection
000000000015d330 000000007787f9b8 ntdll!RtlAllocateHeap+0xe4, calling ntdll!RtlpLowFragHeapAllocFromContext
000000000015d360 000007feea882b2c clr!CrstBase::Enter+0x74, calling ntdll!RtlTryEnterCriticalSection
000000000015d3b0 000007feea93b9bd clr!SimpleRWLock::EnterRead+0x6a, calling clr!GetThread
000000000015d3c0 000007feea93ba37 clr!Holder<SimpleRWLock * __ptr64,&SimpleRWLock::AcquireReadLock,&SimpleRWLock::ReleaseReadLock,0,&CompareDefault<SimpleRWLock * __ptr64>,2,1>::~Holder<SimpleRWLock * __ptr64,&SimpleRWLock::AcquireReadLock,&SimpleRWLock::ReleaseReadLock,0,&CompareDefault<SimpleRWLock * __ptr64>,2,1>+0x27, calling clr!GetThread
000000000015d3d0 000007feea883735 clr!GCPreemp::GCPreemp+0xe, calling clr!GetThread
000000000015d3f0 000007feea88f385 clr!ClassLoader::LoadConstructedTypeThrowing+0x436, calling clr!Module::LookupFullyCanonicalInstantiation
000000000015d400 000007feea8dc1f9 clr!PEFile::GetMDImportWithRef+0x5a, calling clr!Holder<SimpleRWLock * __ptr64,&SimpleRWLock::AcquireReadLock,&SimpleRWLock::ReleaseReadLock,0,&CompareDefault<SimpleRWLock * __ptr64>,2,1>::~Holder<SimpleRWLock * __ptr64,&SimpleRWLock::AcquireReadLock,&SimpleRWLock::ReleaseReadLock,0,&CompareDefault<SimpleRWLock * __ptr64>,2,1>
000000000015d440 000007feea883a6a clr!EEHeapAllocInProcessHeap+0x46, calling ntdll!RtlAllocateHeap
000000000015d460 000007feea8dc16e clr!Wrapper<IBindResult * __ptr64,&DoNothing<IBindResult * __ptr64>,&DoTheRelease<IBindResult>,0,&CompareDefault<IBindResult * __ptr64>,2,1>::~Wrapper<IBindResult * __ptr64,&DoNothing<IBindResult * __ptr64>,&DoTheRelease<IBindResult>,0,&CompareDefault<IBindResult * __ptr64>,2,1>+0x30
000000000015d470 000007feea883b6f clr!operator new+0xf, calling clr!EEHeapAllocInProcessHeap
000000000015d4a0 000007feea8c8023 clr!BaseAssemblySpec::CloneFields+0x103, calling MSVCR120_CLR0400!strcpy_s
000000000015d510 000007feea8c7e4c clr!AssemblySpec::InitializeSpecInternal+0x118, calling clr!CLRException::HandlerState::CleanupTry
000000000015d560 0000000077631a7a kernel32!HeapFree+0xa, calling ntdll!RtlFreeHeap
000000000015d590 000007feea883b2d clr!EEHeapFreeInProcessHeap+0x39, calling kernel32!HeapFree
000000000015d600 000007feea9f2e6e clr!DomainFile::VerifyNativeImageDependencies+0x1a8, calling clr!AssemblySpec::LoadDomainAssembly
000000000015d7a0 000007feea8daec9 clr!DomainFile::DoIncrementalLoad+0x123, calling clr!DomainFile::VerifyNativeImageDependencies
000000000015d7d0 000007feea8d9805 clr!AppDomain::TryIncrementalLoad+0x136, calling clr!DomainFile::DoIncrementalLoad
000000000015d7f0 000007feea8a38ef clr!PEImage::Equals+0x257, calling clr!_security_check_cookie
000000000015d810 000007feea93b9bd clr!SimpleRWLock::EnterRead+0x6a, calling clr!GetThread
000000000015d820 000007feea882b2c clr!CrstBase::Enter+0x74, calling ntdll!RtlTryEnterCriticalSection
000000000015d880 000007feea8cc472 clr!PEImage::Release+0x3f, calling clr!CrstBase::Leave
000000000015d9e0 000007feea8edbab clr!MetaSig::NextArg+0x7f, calling clr!SigParser::SkipExactlyOne
000000000015da30 000007feea969215 clr!PEImage::IsNativeILILOnly+0x35, calling clr!PEDecoder::GetNativeHeader
000000000015da80 000007feea9cf09c clr!PEFile::IsILOnly+0x59, calling clr!PEImage::IsNativeILILOnly
000000000015dac0 000000007787f9b8 ntdll!RtlAllocateHeap+0xe4, calling ntdll!RtlpLowFragHeapAllocFromContext
000000000015daf0 000007feea882b2c clr!CrstBase::Enter+0x74, calling ntdll!RtlTryEnterCriticalSection
000000000015db10 0000000077857534 ntdll!RtlInitializeCriticalSection+0xf0, calling ntdll!RtlEnterCriticalSection
000000000015db20 000007feea882a90 clr!CrstBase::Leave+0x30, calling ntdll!RtlLeaveCriticalSection
000000000015db50 000007feea8904bd clr!DeadlockAwareLock::TryBeginEnterLock+0x65, calling clr!CrstBase::Leave
000000000015db60 000007feea882b2c clr!CrstBase::Enter+0x74, calling ntdll!RtlTryEnterCriticalSection
000000000015db70 000007feea882f21 clr!ClrFlsGetValue+0xe, calling clr!ClrFlsGetBlock
000000000015db80 000007feea89039d clr!CrstBase::InitWorker+0x35, calling ntdll!RtlInitializeCriticalSection
000000000015db90 000007feea8d96a5 clr!ListLockEntry::DeadlockAwareEnter+0x52, calling clr!GetThread
000000000015dbd0 000007feea8d9492 clr!AppDomain::LoadDomainFile+0x107, calling clr!AppDomain::TryIncrementalLoad
000000000015dbf0 000007feea8db266 clr!FileLoadLock::FileLoadLock+0x66
000000000015dc50 000007feea882a90 clr!CrstBase::Leave+0x30, calling ntdll!RtlLeaveCriticalSection
000000000015dc80 000007feea8d85c7 clr!AppDomain::LoadDomainAssemblyInternal+0x177, calling clr!AppDomain::LoadDomainFile
000000000015dd70 000007feea8d840f clr!AppDomain::LoadDomainAssembly+0x8c, calling clr!AppDomain::LoadDomainAssemblyInternal
000000000015de00 000007feea8c8023 clr!BaseAssemblySpec::CloneFields+0x103, calling MSVCR120_CLR0400!strcpy_s
000000000015de70 000007feea8c7e4c clr!AssemblySpec::InitializeSpecInternal+0x118, calling clr!CLRException::HandlerState::CleanupTry
000000000015ded0 000007feea883a6a clr!EEHeapAllocInProcessHeap+0x46, calling ntdll!RtlAllocateHeap
000000000015def0 000007feea8a405b clr!MDInternalRO::GetAssemblyRefProps+0x1bd, calling clr!CMiniMdTemplate<CMiniMd>::getLocaleOfAssemblyRef
000000000015df00 000007feea883b6f clr!operator new+0xf, calling clr!EEHeapAllocInProcessHeap
000000000015df30 000007feea8c8023 clr!BaseAssemblySpec::CloneFields+0x103, calling MSVCR120_CLR0400!strcpy_s
000000000015dfa0 000007feea8c7e4c clr!AssemblySpec::InitializeSpecInternal+0x118, calling clr!CLRException::HandlerState::CleanupTry
000000000015e050 000007feea8c80ad clr!AssemblySpec::InitializeSpec+0x1e, calling clr!AssemblySpec::InitializeSpecInternal
000000000015e090 000007feea8b9c88 clr!Module::LoadAssembly+0x2bb, calling clr!AppDomain::LoadDomainAssembly
000000000015e150 000000007787fa8b ntdll!RtlpAllocateHeap+0xf8c, calling ntdll!RtlLeaveCriticalSection
000000000015e2d0 000007feea968235 clr!CEECompileInfo::DecodeModuleFromIndexes+0x69, calling clr!Module::LoadAssembly
000000000015e310 000007feea882b2c clr!CrstBase::Enter+0x74, calling ntdll!RtlTryEnterCriticalSection
000000000015e320 000007feea90ce20 clr!CExecutionEngine::ClrVirtualQuery+0x2d, calling kernel32!VirtualQueryStub
000000000015e370 000007feea896df3 clr!StubLinker::EmitUnwindInfo+0x2be, calling clr!CrstBase::Leave
000000000015e3e0 000007feea96816f clr!Module::GetModuleFromIndex+0x6f, calling clr!CEECompileInfo::DecodeModuleFromIndexes
000000000015e410 000007feea9eea25 clr!Module::GetEncodedSig+0x55, calling clr!Module::GetModuleFromIndex
000000000015e440 000007feea9eea95 clr!Module::RestoreMethodTablePointerRaw+0x3a, calling clr!Module::GetEncodedSig
000000000015e470 000007feea9d7795 clr!MethodTable::DoRestoreTypeKey+0x95, calling clr!MethodTable::GetWriteableDataForWrite
000000000015e490 000007feea9eeb66 clr!MethodTable::Restore+0x72, calling clr!Module::RestoreMethodTablePointerRaw
000000000015e4b0 000007feea9d76ef clr!TypeHandle::DoRestoreTypeKey+0x27, calling clr!MethodTable::DoRestoreTypeKey
000000000015e4e0 000007feea9d76b0 clr!ClassLoader::DoIncrementalLoad+0x104, calling clr!MethodTable::Restore
000000000015e520 000007feea893aa7 clr!Precode::SetTargetInterlocked+0x202, calling kernel32!FlushInstructionCache
000000000015e600 000000007787f9b8 ntdll!RtlAllocateHeap+0xe4, calling ntdll!RtlpLowFragHeapAllocFromContext
000000000015e6a0 000007feea90c78c clr!MethodTable::FindDispatchImpl+0x7a, calling clr!MethodTable::GetRestoredSlot
000000000015e6d0 0000000077857534 ntdll!RtlInitializeCriticalSection+0xf0, calling ntdll!RtlEnterCriticalSection
000000000015e710 000007feea883a6a clr!EEHeapAllocInProcessHeap+0x46, calling ntdll!RtlAllocateHeap
000000000015e740 000007feea8f4e4c clr!ClassLoader::LoadTypeHandleForTypeKey_Body+0x378, calling clr!ClassLoader::DoIncrementalLoad
000000000015e800 000007feea8eeb1c clr!LoaderHeap::RealAllocAlignedMem+0x121
000000000015e830 000007feea8946ac clr!LockedRangeList::IsInRangeWorker+0x118, calling clr!GetThread
000000000015e8b0 000007feea895821 clr!VirtualCallStubManager::BackPatchSite+0x6d
000000000015e990 000007feea8f4c83 clr!ClassLoader::LoadTypeHandleForTypeKey+0xf5, calling clr!ClassLoader::LoadTypeHandleForTypeKey_Body
000000000015ea30 000007feea9cf297 clr!ClassLoader::LoadTypeDefThrowing+0x23b, calling clr!ClassLoader::LoadTypeHandleForTypeKey
000000000015eb90 000007feea92377c clr!ClassLoader::LoadTypeDefOrRefThrowing+0x39b, calling clr!ClassLoader::LoadTypeDefThrowing
000000000015ec00 000007feea88fd96 clr!CMiniMd::Impl_GetEndRidForColumn+0x6a, calling clr!CMiniMdBase::getIX
000000000015ec10 000007feea8e793e clr!CRWLock::StaticReleaseWriterLockPublic+0x106, calling clr!HelperMethodFrameRestoreState
000000000015ec40 000007feeaa15ed9 clr!CMiniMdTemplate<CMiniMd>::getEndParamListOfMethod+0x29, calling clr!CMiniMd::Impl_GetEndRidForColumn
000000000015ec60 000007feea8845f1 clr!Frame::Push+0xe, calling clr!GetThread
000000000015ec80 000007feeaa15e40 clr!MDInternalRO::FindParamOfMethod+0x60, calling clr!CMiniMdTemplate<CMiniMd>::getEndParamListOfMethod
000000000015ecc0 000007feea97ca52 clr!Assembly::GetEntryPoint+0x126, calling clr!ClassLoader::LoadTypeDefOrRefThrowing
000000000015ed50 000007feea88225a clr!ThePreStub+0x5a, calling clr!PreStubWorker
000000000015edb0 000007feeabc71d0 clr!REGUTIL::EnvCacheValueNameSeenPerhaps+0x15, calling clr!HashiStringKnownLower80
000000000015edc0 000007feea93d1c9 clr!ThreadNative::FastGetDomain+0x9, calling clr!GetAppDomain
000000000015ede0 000007feea88bbd6 clr!REGUTIL::EnvGetString+0x83, calling clr!_security_check_cookie
000000000015edf0 000007fee97852a0 (MethodDesc 000007fee92e6988 +0x50 System.AppDomain.get_HostSecurityManager()), calling clr!JIT_TrialAllocSFastMP_InlineGetThread
000000000015ee20 000007fee9784a3b (MethodDesc 000007fee93c1b60 +0x9b System.Security.Policy.AssemblyEvidenceFactory.UpgradeSecurityIdentity(System.Security.Policy.Evidence, System.Reflection.RuntimeAssembly))
000000000015ee70 000007feea88babb clr!REGUTIL::RegCacheValueNameSeenPerhaps+0x28, calling clr!HashiStringKnownLower80
000000000015eea0 000007feea998bc7 clr!REGUTIL::GetConfigString_DontUse_+0x967, calling clr!Wrapper<HKEY__ * __ptr64,&DoNothing<HKEY__ * __ptr64>,&RegKeyRelease,0,&CompareDefault<HKEY__ * __ptr64>,2,1>::~Wrapper<HKEY__ * __ptr64,&DoNothing<HKEY__ * __ptr64>,&RegKeyRelease,0,&CompareDefault<HKEY__ * __ptr64>,2,1>
000000000015eeb0 000007feea882ba4 clr!ClrFlsIncrementValue+0x18, calling clr!ClrFlsGetBlock
000000000015eed0 000007feea882a90 clr!CrstBase::Leave+0x30, calling ntdll!RtlLeaveCriticalSection
000000000015eee0 000007feea882ba4 clr!ClrFlsIncrementValue+0x18, calling clr!ClrFlsGetBlock
000000000015ef00 000007feea88bc5a clr!EEConfig::GetConfiguration_DontUse_+0x36, calling clr!GetThread
000000000015ef10 000007feea888f13 clr!ThreadStore::UnlockThreadStore+0x53, calling clr!ClrFlsIncrementValue
000000000015ef40 000007feea9cfb59 clr!Thread::SetBackground+0x9f, calling clr!ThreadStore::UnlockThreadStore
000000000015ef50 000007feea8836f9 clr!GCCoop::GCCoop+0xe, calling clr!GetThread
000000000015ef60 000007feea998241 clr!CLRConfig::GetConfigValue+0xed, calling clr!_security_check_cookie
000000000015ef80 000007feeaa17a62 clr!Assembly::ExecuteMainMethod+0x8a, calling clr!Assembly::GetEntryPoint
000000000015efd0 000007feea882b2c clr!CrstBase::Enter+0x74, calling ntdll!RtlTryEnterCriticalSection
000000000015f030 000000007787f9b8 ntdll!RtlAllocateHeap+0xe4, calling ntdll!RtlpLowFragHeapAllocFromContext
000000000015f080 000007feea882b2c clr!CrstBase::Enter+0x74, calling ntdll!RtlTryEnterCriticalSection
000000000015f0b0 000007feea882a90 clr!CrstBase::Leave+0x30, calling ntdll!RtlLeaveCriticalSection
000000000015f100 000007fefd8e10dc KERNELBASE!WaitForSingleObjectEx+0x79, calling ntdll!ZwWaitForSingleObject
000000000015f110 0000000077631a7a kernel32!HeapFree+0xa, calling ntdll!RtlFreeHeap
000000000015f130 000007feea997de4 clr!AppDomain::GetFriendlyNameForDebugger+0x48, calling clr!SString::GetUnicode
000000000015f1a0 0000000077631a7a kernel32!HeapFree+0xa, calling ntdll!RtlFreeHeap
000000000015f1f0 000007feea998144 clr!CLRConfig::GetConfigValue+0x14, calling clr!CLRConfig::GetConfigValue
000000000015f200 000007feea883b54 clr!operator delete+0x14, calling clr!EEHeapFreeInProcessHeap
000000000015f220 000007feea998eff clr!MulticoreJitManager::AutoStartProfile+0x60, calling clr!Wrapper<unsigned short * __ptr64,&DoNothing<unsigned short * __ptr64>,&CLRConfig::FreeConfigString,0,&CompareDefault<unsigned short * __ptr64>,2,1>::~Wrapper<unsigned short * __ptr64,&DoNothing<unsigned short * __ptr64>,&CLRConfig::FreeConfigString,0,&CompareDefault<unsigned short * __ptr64>,2,1>
000000000015f240 000007feea883735 clr!GCPreemp::GCPreemp+0xe, calling clr!GetThread
000000000015f270 000007feeaa17987 clr!SystemDomain::ExecuteMainMethod+0x506, calling clr!Assembly::ExecuteMainMethod
000000000015f2a0 000007feea9cd85a clr!HndCreateHandle+0x112, calling clr!StressLog::LogOn
000000000015f4f0 000007feea8843fa clr!Alloc+0x54, calling clr!GetThread
000000000015f520 000007feea8855a0 clr!AllocateObject+0x68, calling clr!Alloc
000000000015f550 000007feea9cd85a clr!HndCreateHandle+0x112, calling clr!StressLog::LogOn
000000000015f580 000007feea9d0385 clr!CreateGlobalHandle+0xe, calling clr!GetCurrentThreadHomeHeapNumber
000000000015f5b0 000007feea9a28cb clr!AppDomain::SetupSharedStatics+0xf0, calling clr!ErectWriteBarrier_ASM
000000000015f5d0 000007feeaa05d99 clr!SafeHandle::Init+0x41, calling clr!MethodDesc::GetSlot
000000000015f600 000007feeaa0e979 clr!EEStartupHelper+0xcb0, calling clr!ConfigDWORD::val
000000000015f830 000007feeaa0451d clr!EEStartup+0x15, calling clr!EEStartupHelper
000000000015f840 000007feeaa07aaf clr!ClrAllocInProcessHeapBootstrap+0x33
000000000015f880 000007feeaa1790a clr!ExecuteEXE+0x3f, calling clr!SystemDomain::ExecuteMainMethod
000000000015f8f0 000007feeaa17862 clr!_CorExeMainInternal+0xae, calling clr!ExecuteEXE
000000000015f980 000007feeaa14174 clr!CorExeMain+0x14, calling clr!_CorExeMainInternal
000000000015f9c0 000007feef1572fd mscoreei!CorExeMain+0xe0
000000000015fa10 000007fef0495b21 mscoree!CorExeMain_Exported+0x57
000000000015fa40 0000000077625a4d kernel32!BaseThreadInitThunk+0xd
000000000015fa70 000000007785b831 ntdll!RtlUserThreadStart+0x1d