Using VS 2010 I created a small C# Console app that does nothing. I also created a managed C++ dll (called "steven") with a single method that just returns. I added a reference to the Managed dll into the C# Console app. No problem.

Now, when I type "using steven" in my C# app, it fails to compile. The error is:

The type or namespace name 'steven' could not be found (are you missing a using directive or an assembly reference?)

Code is attached. Any thoughts on this?

Steven

// steven.h
#pragma once
using namespace System;

namespace steven
{
	public ref class Class1
	{
	public:
		void DoSomething();
	};
}


// steven.cpp
// This is the main DLL file.

#include "stdafx.h"
#include "steven.h"

namespace steven
{
	void Class1::DoSomething()
	{
	}
}

// Program.cs
using System;
using System.Collections.Generic;
using System.Text;
using steven; // THIS LINE SHOWS THE ERROR MESSAGE

namespace ConsoleApplication1
{
	class Program
	{
		static void Main(string[] args)
		{
		}
	}
}

I want to find the most efficient way to access the CLR performance counters in-process (e.g. ".NET CLR Memory" or ".NET CLR Jit"). I use the CLR Profiling API, so I can do this natively (preferred), but also managed if necessary.

I do know, I can use PDH.dll to query perfcounters natively. However I am trying to avoid PDH.dll, since it has numerous drawbacks and quirks (instance-index handling, translation, permissions, ...).

My real question is, is there a way to get to the CLR metrics data-structures directly in-memory and read them as they are (without going through the perfcounter API)? When studying the Shared Source CLR, I found perfcounterdefs.h, which contains all of these data structures. Is there a way to get there directly? Should I even consider this direction, or will I drive straight to hell, when I get my hands on internal data structures?

Thanks,
-Christoph

I am calling a third-party unmanaged DLL from vb.net (framework 4.5) and on rare occasions the third party DLL thows an AccessViolationExcpetion ("Attempted to read or write protected memory. This is often an indication that other memory is corrupt."). 

I have added the <HandleProcessCorruptedStateExceptions> attribute to the method which calls the DLL as follows: -

    <Runtime.ExceptionServices.HandleProcessCorruptedStateExceptions> _
    <SecurityCritical> _
    Private Sub CallThirdParty()
            Try
                UnmanagedFunction(_outputFilename) ' this is the referenced with a DLLImport
            Catch ex As Exception
                ' example code to demonstrate handler
                Environment.Exit(0)
            End Try
    End Sub

When running in debug mode in VS2013 the exception is handled and the application quits as expected. However when I build and run the app outside of VS2013 it just hangs at this point and no exception is handled. The program doesn't even crash.

Is there anything I have missed here which makes debug vs build different?

Thanks for reading this...

Program crashes on startup with this strange error:

EventType clr20r3, P1 <app_name>.exe, P2 2.2.0.0, P3 527a0217, P4 system.configuration, P5 2.0.0.0, P6 4889de74, P7 9d, P8 48, P9 ioibmurhynrxkw0zxkyrvfn0boyyufow,

I have installed and can able to open the same application in other system(Windows Embedded, 7 and XP).

The .net framework 3.5 sp1 is installed in my machine.
pls help to sort the issue

After update to .NET Framework 4.5.1 (through Windows Update). Some of our customers have reported errors is our application, specifically when it comes to SQL Server access.
The error is: “A connection was successfully established with the server, but then an error occurred during the login process. (provider: SSL Provider, error: 0 - The message received was unexpected or badly formatted.)”

We found this problems occurs in some occasions, possibly in combination with SQL Server 2005 and Windows Server 2003.

Uninstalling .NET Framework 4 and reinstalling without update to 4.5.1 causes the problem to disappear, but this is not a permanent solution.

A search on internet revealed that the problem is happening more often and is known by Microsoft. Can anyone tell us if there is a more permanent fix for this issue, and if not when the permanent fix will be available.

Related threads mention the use of the command "netsh winsock reset". But this only seems to work for a few hours.

Thank you in advance for you assistance.

I posted this in the wrong forum. Sorry for a double post.

 

I am making an app using Visual Studio C++ express edition. When I change the forms icon in the editor, by clicking the form and selecting the icon property, it changes it properly in the editor and builds it fine. However if I run it I get an exception.

 

I get this message

An unhandled exception of type 'System.Resources.MissingManifestResourceException' occurred in mscorlib.dll

Additional information: Could not find any resources appropriate for the specified culture or the neutral culture.  Make sure "PHM.Form1.resources" was correctly embedded or linked into assembly "PHM" at compile time, or that all the satellite assemblies required are loadable and fully signed.

 

the only code pertaining to the icon is this

this

->Icon = (cli::safe_cast<System::Drawing::Icon^ >(resources->GetObject(L"$this.Icon")));

 

If I comment this out I get no errors but it uses the default form icon. How do I change the icon on a form, and why am I getting an error?

I'm on a Windows Vista system.
I download the microsoft sdk in order to be able to make certificates for this application I'm trying to get loaded.

based on the installation manual, I type the following command to create a certificate:

C:\Program Files\Microsoft SDKs\Windows\v6.0\Bin>makecert -n "CN=norcron-develop
" -pe -sr localMachine -ss My -a sha1 -sky exchange

I've had a number of people look at the command and everyone seems to think it is valid.
However, I get the following error:

Error: CryptCertStrToNameW failed => 0x80092023 (-2146885597)
Failed

There are no other certificates set up currently.
The makecert version is 6.0.6000.16384

Help ... I'm stuck.
Thanks
Eric 

Does anyone here know which combinations of SQLite DLLs and .Net Framework levels work?  I've been researching and flailing about and have yet to find the right combination.

In my naive first attempt I was getting an exception before any of my code even got control. 

Then I backed up the .Net level to 2.0 and the resulting .exe executed but there were many, many compile time warnings.

Now I am using .Net 4.5 and a SQLite DLL which is supposed to work with 4.5 but I am getting this run time error: Could not load file or assembly 'System.Data.SQLite, Version=1.0.91.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139' or one of its dependencies. An attempt was made to load a program with an incorrect format.

I've come across changes to app.config which apparently allow some combinations to work which would not work otherwise.  But since I don't really understand app.config files I don't to mess around there without complete instructions.

Does anyone know the answer or where I might find it?  (I've tried most of the likely places.)

Thanks,  Bob

Hi,

I am using float.parse to convert a number in string to float. Below is the code:

float fAmount = float.Parse("327652.11");

It is returning 327652.13.

This is happening for numbers that are greater than 100000.00. So, some invalid numbers are getting amended at the end.

Can anyone please advice?

Thanks & Regards,

   Hi,

   Is it possible to list all static objects in the application or AppDomain via the code or any sort of tools (the more simple the better)? The idea is to analyse the objects of the most top level which lives as long as the application is running or until they are explicitly disposed.

Thank you

---

Alex

Hi,

I'm trying to write a CLR host (.NET 4) to run an existing .NET product from C++.

I've implemented IHostAssemblyStore::ProvideAssembly and it works most of time.

However, I can't make it work in the following scenario:

Suppose there is an assembly called TestDep.

Running:

Assembly.Load("TestDep, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null");

from my hosted code works (TestDep.dll is resolved by my ProvideAssembly(..) implementation).

However, running:

Assembly.Load("TestDep, Culture=neutral");

does not. ProvideAssembly is not even called.

This is from the fusion log:

LOG: Fusion is hosted. Check host about this assembly.
LOG: Assembly is not in CLR Loaded list. Asking host assembly store.
LOG: Input is partial name. Skip host assembly store lookup.
ERR: Unrecoverable error occurred during pre-download check (hr = 0x80070002).

I tried to fix this by registering to AppDomain.AssemblyResolve event with this code:

if (args.name == "TestDep, Culture=neutral") {
	return Assembly.Load("TestDep, Version=1.0.0.0, Culture=neutral, PublicKeyToken=nulll");
}

But it still doesn't work. Now fusion log contains this:

LOG: The same bind was seen before, and was failed with hr = 0x80070002.
ERR: Unrecoverable error occurred during pre-download check (hr = 0x80070002).

I tried to disable binding caching by putting:

<runtime><disableCachingBindingFailures>1</disableCachingBindingFailures></runtime>

In my app.config but it had no affect.

Adding

<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1"><qualifyAssembly partialName="TestDep" fullName="TestDep, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/></assemblyBinding>

did not help either.

The only workaround I found was to call

Assembly.Load("TestDep, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null");

Before running the hosted code.

Is there a better solution? How am I supposed to support partial binding in my CLR host?
Is it possible to disable binding caching from code?
Of course I can't modify the application I'm trying to host (change partial to full bindings).

Thanks!

I am trying to implement basic debugging functionality. Mdbg is a great starting point. Though what I found out is that it does not analyse the properties of the object being inspected but fields only (e.g. TryExpandNode). It is understandable: properties are not fields-like members but just decorated methods under the hood.

Though it seems only logical to inspect both fields and properties. After all it is what Visual Studio does. I have managed to update the Mdbg Sample IMetadataImport  implementation and successfully call m_importer.GetPropertyProps(...

Though I can only make use the returned property name and don't see how to invoke the getter (returned by GetPropertyProps) to evaluate the property value. All my attempts just failed.

Any suggestion will be appreciated.

Regards,
Oleg

 

Please redirect if this is not the correct forum.

I am receiving the following exception during my processing:

Unable to find assembly 'MyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=xxxxxxxxxxxxxxxxSystem.Exception {System.Runtime.Serialization.SerializationException}

I've attempted to debug this issue without success.  The assembly shows up in the loaded modules while attached to the process using Visual Studio.  I tried usingProcmon.exe to determine if there were module load failures, however I am unable to determine where this error is coming from.  The interesting thing is that the method call that is failing is totally unrelated to the assembly load failure above.

I am using .Net 4.5, however my assemblies also reference .Net 2.0 and .Net 3.5 assemblies.

Any ideas on how to isolate this issue would be greatly appreciated.

---

David Downing... If this answers your question, please Mark as the Answer. If this post is helpful, please vote as helpful.

Hi everyone!

 

I have a very non-descript error message of "Bad Data" displayed for a CryptographicException when trying to import just the Modulus and Exponent (the Public Key) when using the RSACryptoServiceProvider class.

 

I am aware that the RSAParameters struct properties needs an object of type of byte[], however from some comments in some very complicated examples I have found it needs to be big-endian (ie, call Array.Reverse(byte[])). I tried this but still got the "Bad Data" error... strange how there's no mention of big-endian style arrays in any MSDN info, or any information on what format the RSACryptoServiceProvider expects to find RSAParameters.Modulus and .Exponent in, other than it being a byte array that is.

 

I have not found any simple examples of setting the RSAParameters.Modulus and RSAParameters.Exponent from something like a large integer, or a string of numerical characters that are representing a large integer? All the examples cheat by using the RSACryptoServiceProvider.ExportParameters() method right before calling the .ImportParameters() method, supposedly showing the usage of the two methods (albeit NOT A REAL WORLD example).

 

If anyone out there can give me an example of what kind of Converts to perform on the string or integer before putting the data in an array it would make my week!

 

Cheers for your time,

Voss.

Hello,

I'm trying to figure out why there are so many Gen2 collections? I assume normal situation where there 1:10:100 combinations of Gen0:Gen1:Gen2 collections. Collections are not induced either according to this PerfMon. There is no memory pressure and server has ample free memory.



Hi,

the issue arises in the following context:

MS Word -> .dot -> unmanaged library A (vb6) -> managed library B -> managed library C

The managed libraries are not strongly named and not signed.

Library B can resolve the reference to library C if the version of library C is the one it was at compile time of library B. However, if we produce a new version of library C only by increasing the assembly version number, assembly resolution fails.

Since there are hundreds of assemblies like library B that reference library C we would like to avoid recompilation and delivery of all of them for every new version of library C.

When using it in a context like

managed process -> managed library B -> managed library C

resolution of references to library C will always work, even if the version number of library C differs.

This leads to the conclusion that assembly resolution is different in the two contexts.

My question is, why assembly resolution is different in the first context and how it is exactly working then.

We used fuslogvw to see why resolution fails and it was obvious that in the first context with differing version numbers only the word-application path is being probed but with matching version number the assembly is found in its directory (the directory where library B resides, too).

Let's assume we cannot change library B to use dynamic loading an the likes.

Regards

Hi, I am calling a c++ function from a C# project by using a dll where it returns an IplImage. 

I have used this to export the function:

extern "C" __declspec(dllexport)IplImage * showNewImage(IplImage * input){...}

and this in C#

[DllImport("dllFile")]
public static extern MIplImage showNewImage(MIplImage input);

Is the way that I have used the dll import wrong? the function is supposed to return back an image, the c++ function is and dll both are working properly but I need help calling it from my C# project using the dll. 

Please Help.

Our .NET App crashed with the crash dump pointing to issue in CLR –

clr!CMiniMdTemplate<CMiniMd>::getMvidOfModule+0x49:

000007fe`f75d524d 0f1000          movups  xmm0,xmmword ptr [rax] ds:00000000`0e8b0678=daa33424cf4d1cb741e0f925862e35ed

The crash dump is attached.

We are doing a performance run using Automation (Silk4Net). This is executing UI test plans in a loop.

Here are the environment details:

OS: Windows 7 Enterprise service pack 1 64bit

.NET version runtime – 4.5

Here are the eestack from the crash dump -

0:000> !eestack
---------------------------------------------
Thread   0
Current frame: clr!CMiniMdTemplate<CMiniMd>::getMvidOfModule+0x49
Child-SP         RetAddr          Caller, Callee
00000000002f6350 000007fef75d51cf clr!MDInternalRO::GetScopeProps+0x3f, calling clr!CMiniMdTemplate<CMiniMd>::getMvidOfModule
00000000002f6380 000007fef75d6f2a clr!AssemblyMDInternalImport::GetScopeProps+0x56
00000000002f63a0 000007fef75d725b clr!AssemblyMDInternalImport::QueryInterface+0x87
00000000002f63d0 000007fef75d7593 clr!GetAssemblyNameDefFromMDImport+0x2f3
00000000002f64e0 000007fef75d4a9b clr!PEDecoder::GetMetaDataHelper+0x2f, calling clr!PEDecoder::HasNativeHeader
00000000002f6530 000007fef75ea911 clr!GetMetaDataInternalInterface+0x51, calling clr!GetMDInternalInterface
00000000002f65b0 000007fef761843a clr!PEImage::CheckILFormat+0x7f, calling clr!Wrapper<PEImageLayout * __ptr64,&DoNothing<PEImageLayout * __ptr64>,&DoTheRelease<PEImageLayout>,0,&CompareDefault<PEImageLayout * __ptr64>,2,1>::~Wrapper<PEImageLayout * __ptr64,&DoNothing<PEImageLayout * __ptr64>,&DoTheRelease<PEImageLayout>,0,&CompareDefault<PEImageLayout * __ptr64>,2,1>
00000000002f65e0 000007fef757ce86 clr!CExecutionEngine::ReleaseLock+0x47, calling ntdll!RtlLeaveCriticalSection
00000000002f6600 000007fef75a5959 clr!ClrLeaveCriticalSection+0xe, calling clr!GetExecutionEngine
00000000002f6630 000007fef75a5990 clr!Holder<void * __ptr64,&ClrEnterCriticalSection,&ClrLeaveCriticalSection,0,&CompareDefault<void * __ptr64>,2,1>::~Holder<void * __ptr64,&ClrEnterCriticalSection,&ClrLeaveCriticalSection,0,&CompareDefault<void * __ptr64>,2,1>+0x24, calling clr!ClrLeaveCriticalSection
00000000002f6670 000007fef7573051 clr!CrstBase::Enter+0x74, calling ntdll!RtlTryEnterCriticalSection
00000000002f6690 000007fef75736ba clr!EEHeapAllocInProcessHeap+0x46, calling ntdll!RtlAllocateHeap
00000000002f66a0 000007fef7572f7c clr!CrstBase::Leave+0x30, calling ntdll!RtlLeaveCriticalSection
00000000002f66d0 000007fef75d5e32 clr!PEImage::Release+0x3f, calling clr!CrstBase::Leave
00000000002f6710 000007fef75d7d2e clr!RuntimeReleaseHandle+0xe, calling clr!PEImage::Release
00000000002f6740 000007fef75d7d14 clr!BaseWrapper<_dummyCOR * __ptr64,FunctionBase<_dummyCOR * __ptr64,&DoNothing<_dummyCOR * __ptr64>,&ReleaseHCorModule,2>,0,&CompareDefault<_dummyCOR * __ptr64>,2>::~BaseWrapper<_dummyCOR * __ptr64,FunctionBase<_dummyCOR * __ptr64,&DoNothing<_dummyCOR * __ptr64>,&ReleaseHCorModule,2>,0,&CompareDefault<_dummyCOR * __ptr64>,2>+0x24, calling clr!RuntimeReleaseHandle
00000000002f6780 000007fef75d7cb6 clr!GetAssemblyMDInternalImportEx+0x124, calling clr!Wrapper<_dummyCOR * __ptr64,&DoNothing<_dummyCOR * __ptr64>,&ReleaseHCorModule,0,&CompareDefault<_dummyCOR * __ptr64>,2,1>::~Wrapper<_dummyCOR * __ptr64,&DoNothing<_dummyCOR * __ptr64>,&ReleaseHCorModule,0,&CompareDefault<_dummyCOR * __ptr64>,2,1>
00000000002f67c0 000007fef75d68d3 clr!CAssemblyManifestImport::CopyNameDef+0x43, calling clr!GetAssemblyNameDefFromMDImport
00000000002f67e0 000007fef726777f MSVCR110_CLR0400!wmemcpy_s+0x45, calling MSVCR110_CLR0400!memcpy
00000000002f6800 000007fef758a780 clr!BaseWrapper<unsigned char * __ptr64,FunctionBase<unsigned char * __ptr64,&DoNothing<unsigned char * __ptr64>,&DeleteArray<unsigned char>,2>,0,&CompareDefault<unsigned char * __ptr64>,2>::TypedAddressInitHolder::~TypedAddressInitHolder+0x20, calling clr!CompareDefault<char * __ptr64>
00000000002f6810 000007fef75d6ae9 clr!CAssemblyManifestImport::CopyMetaData+0x12, calling clr!CAssemblyManifestImport::CopyNameDef
00000000002f6840 000007fef762502c clr!CAssemblyManifestImport::InitAndLoadMetaData+0x88, calling clr!CAssemblyManifestImport::CopyMetaData
00000000002f6880 000007fef757b574 clr!SigPointer::GetTypeHandleThrowing+0x66b, calling clr!_chkstk
00000000002f6890 000007fef7624f69 clr!CreateAssemblyManifestImport+0x99, calling clr!CAssemblyManifestImport::InitAndLoadMetaData
00000000002f68e0 000007fef7627b7f clr!CAsmDownloadMgr::CreateAssembly+0x110, calling clr!CreateAssemblyManifestImport
00000000002f6910 000007fef76124fa clr!ClassLoader::CanAccessClass+0x2c2, calling clr!SecurityTransparent::IsMethodTransparent
00000000002f6a40 000007fef75aca3c clr!CEEInfo::getCallInfo+0x1544, calling clr!_security_check_cookie
00000000002f6b80 000007fef7588da5 clr!MemberLoader::GetDescFromMemberRef+0xde1, calling clr!MethodDesc::CheckRestore
00000000002f6bd0 00000000777a3448 ntdll!RtlAllocateHeap+0xe4, calling ntdll!RtlpLowFragHeapAllocFromContext
00000000002f6c20 000007fef7267403 MSVCR110_CLR0400!vsnwprintf_l+0x9c, calling MSVCR110_CLR0400!woutput_l
00000000002f6c80 000000007765300a kernel32!HeapFree+0xa, calling ntdll!RtlFreeHeap
00000000002f6cb0 000007fef757c13d clr!EEHeapFreeInProcessHeap+0x39, calling kernel32!HeapFree
00000000002f6ce0 000007fef757c0ec clr!operator delete+0x14, calling clr!EEHeapFreeInProcessHeap
00000000002f6d10 000007fef7629670 clr!CNodeFactory::GetCodebaseHint+0x18b, calling clr!operator delete
00000000002f6d40 000007fef760664a clr!StringCchPrintfW+0x4a, calling MSVCR110_CLR0400!vsnwprintf
00000000002f6d90 000007fef7626d79 clr!CAppCtxPolicyConfigs::GetAppCfgCodebaseHint+0x6a, calling clr!_security_check_cookie
00000000002f6ec0 00000000777a68c4 ntdll!RtlIsDosDeviceName_Ustr+0x24d, calling ntdll!RtlEqualUnicodeString
00000000002f6f00 00000000777a6219 ntdll!RtlGetFullPathName_Ustr+0xd4c, calling ntdll!_security_check_cookie
00000000002f7090 000007fef762862d clr!CAsmDownloadMgr::DoSetupRFS+0xc6, calling clr!CAsmDownloadMgr::CreateAssembly
00000000002f7170 00000000776455b8 kernel32!SortCompareString+0x200, calling kernel32!_security_check_cookie
00000000002f7260 000007fefd81234f KERNELBASE!CompareStringW+0x21f, calling KERNELBASE!_security_check_cookie
00000000002f7350 0000000077645a2b kernel32!CompareStringWStub+0x1b, calling kernel32!CompareStringW
00000000002f7390 000007feff8ad13e shlwapi!StrCmpW+0x22, calling kernel32!CompareStringWStub
00000000002f73d0 000007fef75c5247 clr!SimpleRWLock::EnterRead+0x70, calling clr!GetThread
00000000002f7420 000007fef75d4fb2 clr!CApplicationContext::Get+0x13d, calling clr!GetThread
00000000002f7440 000007fef75f306a clr!GetFileLastModified+0x46, calling clr!_security_check_cookie
00000000002f74a0 000007fef7628243 clr!CAsmDownloadMgr::DoSetup+0x1d0, calling clr!CAsmDownloadMgr::DoSetupRFS
00000000002f75d0 00000000777a3448 ntdll!RtlAllocateHeap+0xe4, calling ntdll!RtlpLowFragHeapAllocFromContext
00000000002f7680 000007fef757cc1e clr!CExecutionEngine::AcquireLock+0x9b, calling ntdll!RtlTryEnterCriticalSection
00000000002f7690 000007fef757ce86 clr!CExecutionEngine::ReleaseLock+0x47, calling ntdll!RtlLeaveCriticalSection
00000000002f76e0 000007fef75d59ed clr!CCriticalSection::Unlock+0x2d
00000000002f7700 000007fef757cc1e clr!CExecutionEngine::AcquireLock+0x9b, calling ntdll!RtlTryEnterCriticalSection
00000000002f7710 000007fef757ce86 clr!CExecutionEngine::ReleaseLock+0x47, calling ntdll!RtlLeaveCriticalSection
00000000002f7720 000007fef757cc1e clr!CExecutionEngine::AcquireLock+0x9b, calling ntdll!RtlTryEnterCriticalSection
00000000002f7730 000007fef757ce86 clr!CExecutionEngine::ReleaseLock+0x47, calling ntdll!RtlLeaveCriticalSection
00000000002f77b0 000007fef7627e1c clr!CAssemblyDownload::DoSetup+0xb8
00000000002f77d0 000007fef757ce86 clr!CExecutionEngine::ReleaseLock+0x47, calling ntdll!RtlLeaveCriticalSection
00000000002f7820 000007fef75d59ed clr!CCriticalSection::Unlock+0x2d
00000000002f7850 000007fef762672b clr!CAssemblyDownload::DownloadComplete+0xbb, calling clr!CAssemblyDownload::DoSetup
00000000002f78a0 000007fef7626615 clr!CAssemblyDownload::KickOffDownload+0x16d, calling clr!CAssemblyDownload::DownloadComplete
00000000002f7a10 00000000777a3448 ntdll!RtlAllocateHeap+0xe4, calling ntdll!RtlpLowFragHeapAllocFromContext
00000000002f7a40 000007fef76258ff clr!CClientBinding::QueryInterface+0x4f
00000000002f7a50 000007fef757cc1e clr!CExecutionEngine::AcquireLock+0x9b, calling ntdll!RtlTryEnterCriticalSection
00000000002f7a70 000007fef7627426 clr!FusionSink::OnProgress+0x89
00000000002f7aa0 000007fef76273d6 clr!CClientBinding::CallStartBinding+0x2e
00000000002f7af0 000007fef7627393 clr!CAssemblyDownload::AddClient+0xa3, calling clr!CCriticalSection::~CCriticalSection
00000000002f7b00 000007fef7625892 clr!CClientBinding::CClientBinding+0xb6
00000000002f7b50 000007fef76272ca clr!CAssemblyDownload::AddClient+0x56, calling clr!CAssemblyDownload::AddClient
00000000002f7b80 000007fef7625094 clr!CAssemblyName::BindToObject+0x543, calling clr!CAssemblyDownload::KickOffDownload
00000000002f7c70 000007fefd8118da KERNELBASE!ResetEvent+0xa, calling ntdll!NtClearEvent
00000000002f7c90 000007fef758a780 clr!BaseWrapper<unsigned char * __ptr64,FunctionBase<unsigned char * __ptr64,&DoNothing<unsigned char * __ptr64>,&DeleteArray<unsigned char>,2>,0,&CompareDefault<unsigned char * __ptr64>,2>::TypedAddressInitHolder::~TypedAddressInitHolder+0x20, calling clr!CompareDefault<char * __ptr64>
00000000002f7cd0 000007fef75dc5df clr!FusionBind::RemoteLoad+0x1cf
00000000002f7cf0 0000000077645a2b kernel32!CompareStringWStub+0x1b, calling kernel32!CompareStringW
00000000002f7d30 000007feff8ad13e shlwapi!StrCmpW+0x22, calling kernel32!CompareStringWStub
00000000002f7dc0 000007fef75d4fb2 clr!CApplicationContext::Get+0x13d, calling clr!GetThread
00000000002f7e00 000007fef75dc374 clr!FusionBind::LoadAssembly+0x1d4, calling clr!FusionBind::RemoteLoad
00000000002f7f20 000007fef75dc0ba clr!AssemblySpec::FindAssemblyFile+0x116, calling clr!FusionBind::LoadAssembly
00000000002f8040 000000007765300a kernel32!HeapFree+0xa, calling ntdll!RtlFreeHeap
00000000002f8070 000007fef757c13d clr!EEHeapFreeInProcessHeap+0x39, calling kernel32!HeapFree
00000000002f80a0 000007fef760f1a5 clr!EEJitManager::setBoundaries+0x8e6, calling clr!_security_check_cookie
00000000002f80d0 000007fef7601f4e clr!SString::CompareCaseInsensitive+0x23a, calling clr!_security_check_cookie
00000000002f80e0 000007fef7265a3a MSVCR110_CLR0400!qsort+0xb6, calling MSVCR110_CLR0400!qsort+0x2f0
00000000002f8170 000007fef7582061 clr!Assembly::GetDomainAssembly+0xe, calling clr!GetAppDomain
00000000002f81a0 000007fef75a9c4e clr!CEEInfo::canInline+0x3de, calling clr!Assembly::GetDomainAssembly
00000000002f8270 00000000777a3448 ntdll!RtlAllocateHeap+0xe4, calling ntdll!RtlpLowFragHeapAllocFromContext
00000000002f8350 000000007765300a kernel32!HeapFree+0xa, calling ntdll!RtlFreeHeap
00000000002f8380 000007fef75e44c2 clr!stricmpUTF8+0x302, calling clr!SString::~SString
00000000002f83d0 000007fef75e4500 clr!SString::_strnicmp+0x1c, calling clr!SString::CaseCompareHelperA
00000000002f8410 000007fef75da495 clr!AssemblySpec::IsMscorlib+0x89, calling clr!_security_check_cookie
00000000002f84e0 000007fef66e3ea1 clrjit!THX_makeEA+0x19d, calling clrjit!THX_immed
00000000002f8530 000007fef75ab4bb clr!CEEInfo::ConvToJitSig+0x268, calling clr!SigParser::SkipExactlyOne
00000000002f8580 000007fef75870d9 clr!ClassLoader::CanAccessClass+0x99, calling clr!MethodTable::GetAssembly
00000000002f8590 000007fef757db38 clr!HashMap::LookupValue+0x78, calling clr!GetThread
00000000002f8620 000007fef75cfb50 clr!PtrHashMap::LookupValue+0xc, calling clr!HashMap::LookupValue
00000000002f8650 000007fef75daa99 clr!AssemblySpecBindingCache::Contains+0x25, calling clr!PtrHashMap::LookupValue
00000000002f86b0 000007fef75db3bd clr!AppDomain::BindAssemblySpec+0x35e, calling clr!AssemblySpec::FindAssemblyFile
00000000002f88d0 000007fef7582061 clr!Assembly::GetDomainAssembly+0xe, calling clr!GetAppDomain
00000000002f8900 000007fef75a9c4e clr!CEEInfo::canInline+0x3de, calling clr!Assembly::GetDomainAssembly
00000000002f8a80 000007fef66db6e5 clrjit!GenIR::INLRecursivelyReadBuffers+0x9ac, calling clrjit!_security_check_cookie
00000000002f8b10 000007fef757b21b clr!SigPointer::GetTypeHandleThrowing+0x27a, calling clr!_security_check_cookie
00000000002f8c90 000007fef75ab4bb clr!CEEInfo::ConvToJitSig+0x268, calling clr!SigParser::SkipExactlyOne
00000000002f8ce0 000007fef75870d9 clr!ClassLoader::CanAccessClass+0x99, calling clr!MethodTable::GetAssembly
00000000002f8d70 000007fef75870d9 clr!ClassLoader::CanAccessClass+0x99, calling clr!MethodTable::GetAssembly
00000000002f8d80 000007fef75a85a6 clr!ClassLoader::CheckAccessMember+0x175
00000000002f8dc0 000007fef7573994 clr!MetaSig::Init+0xc4, calling clr!SigParser::SkipExactlyOne
00000000002f8e10 000007fef75aca3c clr!CEEInfo::getCallInfo+0x1544, calling clr!_security_check_cookie
00000000002f8fe0 000007fef757352b clr!DecCantAllocCount+0x3b, calling clr!ClrFlsGetBlock
00000000002f9010 000007fef757419a clr!ExecutionManager::FindCodeRangeWithLock+0xba, calling clr!DecCantAllocCount
00000000002f9030 000007fef7582061 clr!Assembly::GetDomainAssembly+0xe, calling clr!GetAppDomain
00000000002f9060 000007fef75b456c clr!CEEInfo::canInline+0x1072, calling clr!GetThread
00000000002f90b0 000007fef7600f67 clr!FusionBind::ParseEncodedName+0x57, calling clr!_security_check_cookie
00000000002f90d0 000007fef7600f67 clr!FusionBind::ParseEncodedName+0x57, calling clr!_security_check_cookie
00000000002f9270 000007fef757b21b clr!SigPointer::GetTypeHandleThrowing+0x27a, calling clr!_security_check_cookie
00000000002f93a0 000007fef757b21b clr!SigPointer::GetTypeHandleThrowing+0x27a, calling clr!_security_check_cookie
00000000002f93f0 000007fef75ab4bb clr!CEEInfo::ConvToJitSig+0x268, calling clr!SigParser::SkipExactlyOne
00000000002f9460 000007fef75f8210 clr!PEImage::Equals+0x254, calling clr!_security_check_cookie
00000000002f94e0 000007fef75a85a6 clr!ClassLoader::CheckAccessMember+0x175
00000000002f9610 00000000777a3448 ntdll!RtlAllocateHeap+0xe4, calling ntdll!RtlpLowFragHeapAllocFromContext
00000000002f9720 000007fef75736ba clr!EEHeapAllocInProcessHeap+0x46, calling ntdll!RtlAllocateHeap
00000000002f9750 000007fef760129d clr!FusionBind::CloneFields+0x129, calling MSVCR110_CLR0400!strcpy_s
00000000002f97c0 000007fef7601ab6 clr!AssemblySpec::InitializeSpecInternal+0x156, calling clr!CLRException::HandlerState::CleanupTry
00000000002f9820 000007fef757314b clr!CrstBase::Leave+0x63, calling clr!ClrFlsGetBlock
00000000002f98b0 000007fef75da1ba clr!AppDomain::BindAssemblySpec+0x1a, calling clr!_chkstk
00000000002f98f0 000007fef75e7ba4 clr!PEFile::LoadAssembly+0xe8
00000000002f9a20 000007fef75e79fa clr!Module::LoadAssembly+0x361, calling clr!PEFile::LoadAssembly
00000000002f9b10 000007fef757b574 clr!SigPointer::GetTypeHandleThrowing+0x66b, calling clr!_chkstk
00000000002f9b50 000007fef75ab4bb clr!CEEInfo::ConvToJitSig+0x268, calling clr!SigParser::SkipExactlyOne
00000000002f9be0 000007fef757e568 clr!EETypeHashTable::FindItem+0x2c0, calling clr!ClrFlsGetBlock
00000000002f9c00 000007fef757bf0f clr!MDInternalRO::GetAssemblyRefProps+0xad
00000000002f9c50 000007fef75bd13f clr!Module::GetAssemblyRefFlags+0x3f
00000000002f9cc0 000007fef761b8fe clr!Assembly::FindModuleByTypeRef+0x18f, calling clr!Module::LoadAssembly
00000000002f9d30 000007fef75b589f clr!MemberLoader::FindField+0x394, calling clr!MetaSig::CompareElementType
00000000002f9e10 000007fef75b5a1a clr!MemberLoader::GetDescFromMemberRef+0xeff, calling clr!MemberLoader::FindField
00000000002f9f20 000007fef66ffe72 clrjit!GenIR::INLIsPotentialCandidate+0x2f6
00000000002fa010 000007fef75bd17b clr!ClassLoader::LoadTypeDefOrRefThrowing+0x452, calling clr!Assembly::FindModuleByTypeRef
00000000002fa040 000007fef757b21b clr!SigPointer::GetTypeHandleThrowing+0x27a, calling clr!_security_check_cookie
00000000002fa050 000007fef75a83eb clr!FieldSecurityDescriptor::VerifyDataComputed+0x37e, calling clr!_security_check_cookie
00000000002fa150 000007fef7587855 clr!MemberLoader::GetDescFromMemberRef+0x255, calling clr!ClassLoader::LoadTypeDefOrRefThrowing
00000000002fa1e0 000007fef76124fa clr!ClassLoader::CanAccessClass+0x2c2, calling clr!SecurityTransparent::IsMethodTransparent
00000000002fa210 000007fef76124fa clr!ClassLoader::CanAccessClass+0x2c2, calling clr!SecurityTransparent::IsMethodTransparent
00000000002fa250 000007fef75a8419 clr!FieldSecurityDescriptor::IsTreatAsSafe+0xe, calling clr!FieldSecurityDescriptor::VerifyDataComputed
00000000002fa280 000007fef75a8419 clr!FieldSecurityDescriptor::IsTreatAsSafe+0xe, calling clr!FieldSecurityDescriptor::VerifyDataComputed
00000000002fa2b0 000007fef75a85a6 clr!ClassLoader::CheckAccessMember+0x175
00000000002fa2e0 000007fef769e8f9 clr!DuplicateString+0x7d, calling clr!CorTypeInfo::IsObjRef
00000000002fa340 000007fef75af4ba clr!CEEInfo::getFieldInfo+0xf6b, calling clr!ClassLoader::CanAccessClass
00000000002fa470 000007fef75af844 clr!CEEInfo::resolveToken+0x897, calling clr!MemberLoader::GetDescFromMemberRef
00000000002fa690 000007fef66c4df2 clrjit!THX_TupCopy+0xb2, calling clrjit!THX_TupCopyHelper
00000000002fa780 000007fef75afb0b clr!CEEInfo::embedGenericHandle+0x27e, calling clr!TypeHandle::IsSharedByGenericInstantiations
00000000002fa7d0 000007fef66c513f clrjit!THX_TupCopyHelper+0x3f, calling clrjit!memcpy
00000000002fa800 000007fef66c513f clrjit!THX_TupCopyHelper+0x3f, calling clrjit!memcpy
00000000002fa820 000007fef75baf6f clr!CEEInfo::initClass+0x480, calling clr!DomainLocalModule::GetClassFlags
00000000002fa860 000007fef75ab4bb clr!CEEInfo::ConvToJitSig+0x268, calling clr!SigParser::SkipExactlyOne
00000000002fa980 000007fef66f5124 clrjit!ReaderBase::rdrGetFieldAddress+0x8c
00000000002fa9e0 000007fef75aaa87 clr!CEEInfo::getMethodSig+0x367, calling clr!CEEInfo::ConvToJitSig
00000000002faa00 000007fef66f653b clrjit!GenIR::GenIR_LoadField+0x37a, calling clrjit!_security_check_cookie
00000000002faa90 000007fef66de910 clrjit!GenIR::GenIR_Return+0xc0
00000000002faae0 000007fef75ace6e clr!CEEInfo::getMethodAttribs+0x4b, calling clr!CEEInfo::getMethodAttribsInternal
00000000002faaf0 000007fef66d7e59 clrjit!GenIR::GenIR_RemoveStackInterference+0x29
00000000002fab40 000007fef6713c6f clrjit!ReaderBase::readBytesForFlowGraphNode_Helper+0xa85, calling clrjit!ReaderBase::resolveToken
00000000002fac50 000007fef66c3c33 clrjit!THX_TupReplaceSrc+0xb7, calling clrjit!THX_TupFreeKind
00000000002fac90 000007fef66fc08c clrjit!THX_GrAddEdge+0x28, calling clrjit!THX_getmem
00000000002facc0 000007fef6724b04 clrjit!GenIR::cloneInlinee+0x3de, calling clrjit!THX_TupHasFallThrough
00000000002fad50 000007fef66ee87a clrjit!GenIR::spliceFlowgraphs+0x25a, calling clrjit!THX_getmem
00000000002fad70 000007fef6724bf4 clrjit!GenIR::MSILToFG+0x117, calling clrjit!GenIR::inlinerClonePass
00000000002fada0 000007fef66ee5e4 clrjit!GenIR::INLInlineCandidate+0x110, calling clrjit!GenIR::spliceFlowgraphs
00000000002fade0 000007fef66c513f clrjit!THX_TupCopyHelper+0x3f, calling clrjit!memcpy
00000000002fadf0 000007fef66c513f clrjit!THX_TupCopyHelper+0x3f, calling clrjit!memcpy
00000000002fae10 000007fef66c513f clrjit!THX_TupCopyHelper+0x3f, calling clrjit!memcpy
00000000002fae30 000007fef67051f2 clrjit!GenIR::GenIR_AssignToSuccessorStackNode+0x62, calling clrjit!THX_TupCopyHelper
00000000002fae60 000007fef66da5d5 clrjit!GenStack::getIterator+0x16
00000000002fae90 000007fef670567e clrjit!ReaderBase::handleNonEmptyStack+0x286
00000000002faec0 000007fef66c513f clrjit!THX_TupCopyHelper+0x3f, calling clrjit!memcpy
00000000002faf10 000007fef66e0f05 clrjit!GenStack::copy+0x1c6, calling clrjit!THX_TupCopyHelper
00000000002faf60 000007fef66daac7 clrjit!ReaderBase::readBytesForFlowGraphNode+0x1a7, calling clrjit!ReaderBase::readBytesForFlowGraphNode_Helper
00000000002faf90 000007fef66e0013 clrjit!GenIR::INLExplodeFlowgraph+0x91, calling clrjit!GrInitDFOWalk
00000000002fafa0 000007fef66d707b clrjit!THX_JloFindBasicLoops+0x161, calling clrjit!CodeMarker
00000000002fb030 000007fef66df316 clrjit!ReaderBase::MSILToIR+0x186, calling clrjit!ReaderBase::readBytesForFlowGraphNode
00000000002fb090 000007fef66e0c65 clrjit!ReadProc+0x26, calling clrjit!ReaderBase::MSILToIR
00000000002fb260 000007fef66e0c06 clrjit!THX_dop2_ReadProc+0x36, calling clrjit!ReadProc
00000000002fb280 000007fef66f1aa4 clrjit!JitContext::GetContext+0xd3, calling clrjit!InitCompilerInstance
00000000002fb290 000007fef66c5d27 clrjit!THX_dop2+0x77, calling clrjit!THX_dop2_ReadProc
00000000002fb310 000007fef66d732b clrjit!PreJit::compileMethod+0x67, calling clrjit!PreJit::jitCompile
00000000002fb390 000007fef76907ee clr!invokeCompileMethodHelper+0x6a
00000000002fb3e0 000007fef769073f clr!invokeCompileMethod+0x8f, calling clr!invokeCompileMethodHelper
00000000002fb450 000007fef769062e clr!CallCompileMethodWithSEHWrapper+0x46, calling clr!invokeCompileMethod
00000000002fb4b0 00000000777ea64a ntdll! ?? ::FNODOBFM::`string'+0x17e6a, calling ntdll!ZwQueryPerformanceCounter
00000000002fb4e0 000007fef769050c clr!UnsafeJitFunction+0x23c, calling clr!CallCompileMethodWithSEHWrapper
00000000002fb850 000007fef7572f7c clr!CrstBase::Leave+0x30, calling ntdll!RtlLeaveCriticalSection
00000000002fb890 000007fef7583de6 clr!ClassLoader::ComputeLoaderModuleWorker+0x438, calling clr!MethodTable::GetDefiningModuleForOpenType
00000000002fb8e0 000007fef757e568 clr!EETypeHashTable::FindItem+0x2c0, calling clr!ClrFlsGetBlock
00000000002fb920 00000000777a3448 ntdll!RtlAllocateHeap+0xe4, calling ntdll!RtlpLowFragHeapAllocFromContext
00000000002fb960 000000007765300a kernel32!HeapFree+0xa, calling ntdll!RtlFreeHeap
00000000002fb990 000007fef760ead1 clr!ETW::MethodLog::MethodJitting+0x31, calling clr!GetThread
00000000002fb9b0 00000000777754a2 ntdll!RtlDeleteCriticalSection+0x121, calling ntdll!ExpInterlockedPushEntrySList
00000000002fb9f0 00000000777781f4 ntdll!RtlInitializeCriticalSection+0xf0, calling ntdll!RtlEnterCriticalSection
00000000002fba00 000007fef7573051 clr!CrstBase::Enter+0x74, calling ntdll!RtlTryEnterCriticalSection
00000000002fba60 000007fef760e88a clr!MethodDesc::MakeJitWorker+0x4ea, calling clr!UnsafeJitFunction
00000000002fba90 000007fef75d1e0d clr!StubLinker::EmitUnwindInfo+0x2b5, calling clr!CrstBase::Leave
00000000002fbb30 00000000776333ea kernel32!FlushInstructionCache+0xa, calling ntdll!NtFlushInstructionCache
00000000002fbb70 00000000777a3448 ntdll!RtlAllocateHeap+0xe4, calling ntdll!RtlpLowFragHeapAllocFromContext
00000000002fbbc0 000007fef75d2c6a clr!CTPMethodTable::CreateStubForNonVirtualMethod+0xbe0, calling clr!_security_check_cookie
00000000002fbbd0 000007fef75b0a8a clr!PEDecoder::CheckILMethod+0x1e1, calling clr!tagCOR_ILMETHOD_FAT::IsFat
00000000002fbbf0 000007fef75c07e9 clr!MethodDesc::DoBackpatch+0x1d5, calling clr!Precode::GetType
00000000002fbcb0 000007fef75c0971 clr!MethodDesc::DoPrestub+0xb1c, calling clr!MethodDesc::MakeJitWorker
00000000002fbdd0 000007fef757b574 clr!SigPointer::GetTypeHandleThrowing+0x66b, calling clr!_chkstk
00000000002fbe10 000007fef757b21b clr!SigPointer::GetTypeHandleThrowing+0x27a, calling clr!_security_check_cookie
00000000002fbe20 000007fef757b574 clr!SigPointer::GetTypeHandleThrowing+0x66b, calling clr!_chkstk
00000000002fbf50 000007fe98a40352 (MethodDesc 000007fe9845c510 +0x42 System.Windows.Forms.PropertyStore.GetInteger(Int32, Boolean ByRef)), calling (MethodDesc 000007fe9845c5d0 +0 System.Windows.Forms.PropertyStore.LocateIntegerEntry(Int16, Int32 ByRef))
00000000002fbfe0 000007fe98a3e7a2 (MethodDesc 000007fe9845c530 +0x42 System.Windows.Forms.PropertyStore.GetObject(Int32, Boolean ByRef)), calling (MethodDesc 000007fe9845c5e0 +0 System.Windows.Forms.PropertyStore.LocateObjectEntry(Int16, Int32 ByRef))
00000000002fc030 000007fef7582d0a clr!SigParser::SkipExactlyOne+0x1b7, calling clr!SigParser::SkipCustomModifiers
00000000002fc050 000007fe98a42221 (MethodDesc 000007fe987a5808 +0x161 System.Internal.HandleCollector.ResumeCollect()), calling clr!JIT_MonExit
00000000002fc080 000007fef75811d3 clr!SigParser::SkipExactlyOne+0x190, calling clr!SigParser::SkipExactlyOne
00000000002fc090 000007fef757be04 clr!ExecutionManager::FindZapModule+0x55, calling clr!DecCantAllocCount
00000000002fc0d0 000007fef75cb8ab clr!Dictionary::PopulateEntry+0x224, calling clr!_security_check_cookie
00000000002fc120 000007fef75cb8ab clr!Dictionary::PopulateEntry+0x224, calling clr!_security_check_cookie
00000000002fc190 000007fef75bfecb clr!PreStubWorker+0x3eb, calling clr!MethodDesc::DoPrestub
00000000002fc2c0 000007fef7574424 clr!HelperMethodFrame::Push+0x19, calling clr!GetThread
00000000002fc2f0 000007fef75c7bb1 clr!JIT_GenericHandle_Framed+0xd5, calling clr!HelperMethodFrameRestoreState
00000000002fc460 000007fef75c8f79 clr!JIT_GetGenericsGCStaticBase+0x99, calling clr!GetAppDomain
00000000002fc490 000007fef75724da clr!ThePreStub+0x5a, calling clr!PreStubWorker
00000000002fc560 000007fe9accf2a5 (MethodDesc 000007fe9aa67e80 +0x2295 Crd.Mwb.UI.MwbTreeCtl..ctor(Crd.Mwb.View.BaseView, Crd.Mwb.UI.MwbFrm, Crd.Mwb.UI.ViewModes, Crd.Mwb.UI.ExpandCollapseModes, Int32)), calling 000007fe9a99b9b0 (stub for Crd.Mwb.UI.MwbTreeCtl.InitializeSolveEnvironment())
00000000002fc700 000007fef75724da clr!ThePreStub+0x5a, calling clr!PreStubWorker
00000000002fc7d0 000007fe9acc15b9 (MethodDesc 000007fe99b9bd18 +0x14e9 Crd.Mwb.UI.MwbFrm.CreateView(Crd.Mwb.UI.ViewModes, System.String, System.Object, System.Object, Boolean, Crd.Mwb.Data.DataGroupCollection, CreateViewOptions, System.String, Boolean, System.Collections.Generic.Dictionary`2<System.String,Crd.Mwb.UI.CategoryItem>, Crd.Mwb.View.BaseView ByRef)), calling 000007fe9ab342c0
00000000002fc930 000007fe97fd365c (MethodDesc 000007fe97f795d0 +0x1c System.RuntimeType.get_IsEnum()), calling clr!JIT_GetSharedGCStaticBase_InlineGetAppDomain
00000000002fcb00 000007fe9acbf224 (MethodDesc 000007fe99b9c508 +0x1824 Crd.Mwb.UI.MwbFrm.tabbedGroups_PageLoading(Crownwood.DotNetMagic.Controls.TabbedGroups, Crownwood.DotNetMagic.Controls.TGPageLoadingEventArgs)), calling 000007fe9ab34100
00000000002fcd20 000007fe9853669d (MethodDesc 000007fe9858ae58 +0x6d System.Xml.NameTable.AddEntry(System.String, Int32)), calling clr!JIT_Stelem_Ref
00000000002fcf00 000007fe9acbb8f5 (MethodDesc 000007fe9a7408a0 +0x1c5 Crd.GuiCtl.CrdTabbedGroups.OnPageLoading(Crownwood.DotNetMagic.Controls.TGPageLoadingEventArgs)), calling 000007fe98bdfee0
00000000002fcf60 000007fe9acbb380 (MethodDesc 000007fe9a742a10 +0x440 Crownwood.DotNetMagic.Controls.TabGroupLeaf.LoadFromXml(System.Xml.XmlTextReader))
00000000002fd050 000007fe9acbaa39 (MethodDesc 000007fe9a74e038 +0x229 Crownwood.DotNetMagic.Controls.TabGroupSequence.LoadFromXml(System.Xml.XmlTextReader))
00000000002fd0e0 000007fe9acba1fd (MethodDesc 000007fe9a71e210 +0x3dd Crownwood.DotNetMagic.Controls.TabbedGroups.LoadConfigFromXml(System.Xml.XmlTextReader))
00000000002fd160 000007fe9acb960a (MethodDesc 000007fe99b9bf78 +0x25a Crd.Mwb.UI.MwbFrm.LoadMwbProfile()), calling 000007fe9ab33920
00000000002fd200 000007fe9a9ff5db (MethodDesc 000007fe99b9bbc8 +0x9ab Crd.Mwb.UI.MwbFrm.BuildMwbDesktopEnvironment()), calling 000007fe9ab33760
00000000002fd250 0000000058c63996 *** ERROR: Symbol file could not be found.  Defaulted to export symbols for syncSourceDll_amd64.dll - 
syncSourceDll_amd64!CreateTimerSyncBridge+0x1976, calling syncSourceDll_amd64!CreateTimerSyncBridge+0x19980
00000000002fd280 0000000058c63403 syncSourceDll_amd64!CreateTimerSyncBridge+0x13e3, calling syncSourceDll_amd64!CreateTimerSyncBridge+0x1960
00000000002fd2b0 0000000058c7b04f syncSourceDll_amd64!CreateTimerSyncBridge+0x1902f, calling syncSourceDll_amd64!CreateTimerSyncBridge+0x13d0
00000000002fd2d0 0000000058c5ec36 syncSourceDll_amd64+0x1ec36, calling kernel32!SetLastError
00000000002fd300 0000000065f60358 *** ERROR: Symbol file could not be found.  Defaulted to export symbols for synchronizationDll_amd64.dll - 
synchronizationDll_amd64!Synchronization_GetIdleCondition+0x2aaf8
00000000002fd310 0000000058c7aa6c syncSourceDll_amd64!CreateTimerSyncBridge+0x18a4c, calling syncSourceDll_amd64!CreateTimerSyncBridge+0x18f70
00000000002fd330 0000000065f43fe5 synchronizationDll_amd64!Synchronization_GetIdleCondition+0xe785, calling synchronizationDll_amd64!Synchronization_GetIdleCondition+0x1f4d0
00000000002fd350 0000000058c5de18 syncSourceDll_amd64+0x1de18, calling syncSourceDll_amd64!CreateTimerSyncBridge+0x18a30
00000000002fd370 000007fef75cf07c clr!VirtualCallStubManager::ResolveWorker+0x3e6, calling clr!CLRException::HandlerState::CleanupTry
00000000002fd380 0000000058c79ced syncSourceDll_amd64!CreateTimerSyncBridge+0x17ccd, calling syncSourceDll_amd64!CreateTimerSyncBridge+0x17e90
00000000002fd3a0 000007fef75cdd47 clr!Security::AllDomainsOnStackFullyTrusted+0x28
00000000002fd500 000007fe991220cb (MethodDesc 000007fe982e84d0 +0xdb System.Windows.Forms.Control.InvokeMarshaledCallbackHelper(System.Object)), calling (MethodDesc 000007fe982e84e0 +0 System.Windows.Forms.Control.InvokeMarshaledCallbackDo(ThreadMethodEntry))
00000000002fd540 000007fef7571019 clr!JIT_MemCpy+0x9, calling clr!JIT_memmove
00000000002fd570 000007fe987c14d5 (MethodDesc 000007fe984fe950 +0x285 System.Threading.ExecutionContext.RunInternal(System.Threading.ExecutionContext, System.Threading.ContextCallback, System.Object, Boolean))
00000000002fd6d0 000007fe987bf9c9 (MethodDesc 000007fe984fe940 +0x9 System.Threading.ExecutionContext.Run(System.Threading.ExecutionContext, System.Threading.ContextCallback, System.Object, Boolean)), calling (MethodDesc 000007fe984fe950 +0 System.Threading.ExecutionContext.RunInternal(System.Threading.ExecutionContext, System.Threading.ContextCallback, System.Object, Boolean))
00000000002fd6e0 000007fef7576e05 clr!ThreadNative::GetCurrentThread+0x9, calling clr!GetThread
00000000002fd700 000007fe987bf8ff (MethodDesc 000007fe984fe930 +0x4f System.Threading.ExecutionContext.Run(System.Threading.ExecutionContext, System.Threading.ContextCallback, System.Object)), calling (MethodDesc 000007fe984fe940 +0 System.Threading.ExecutionContext.Run(System.Threading.ExecutionContext, System.Threading.ContextCallback, System.Object, Boolean))
00000000002fd710 000007fe98a40c29 (MethodDesc 000007fe986a6b10 +0x19 System.Threading.SynchronizationContext.get_Current()), calling clr!ThreadNative::GetCurrentThread
00000000002fd720 000007fef7576e05 clr!ThreadNative::GetCurrentThread+0x9, calling clr!GetThread
00000000002fd730 000007fef765eb83 clr!JIT_GetSharedNonGCThreadStaticBase+0x33, calling clr!GetThread
00000000002fd750 000007fe9912198a (MethodDesc 000007fe982e84c0 +0x11a System.Windows.Forms.Control.InvokeMarshaledCallback(ThreadMethodEntry)), calling (MethodDesc 000007fe984fe930 +0 System.Threading.ExecutionContext.Run(System.Threading.ExecutionContext, System.Threading.ContextCallback, System.Object))
00000000002fd770 000007fe987b8b7b (MethodDesc 000007fe98344b00 +0x1b System.Windows.Forms.NativeWindow.get_WndProcFlags()), calling clr!JIT_GetSharedNonGCThreadStaticBase
00000000002fd7b0 000007fe9912153d (MethodDesc 000007fe982e84f0 +0x10d System.Windows.Forms.Control.InvokeMarshaledCallbacks()), calling 000007fe99104bc0
00000000002fd7d0 0000000065f3fa1d synchronizationDll_amd64!Synchronization_GetIdleCondition+0xa1bd, calling synchronizationDll_amd64!Synchronization_GetIdleCondition+0x1f4d0
00000000002fd840 000007fe98a446e9 (MethodDesc 000007fe982e7630 +0x969 System.Windows.Forms.Control.WndProc(System.Windows.Forms.Message ByRef)), calling 000007fe99104ae0
00000000002fd8b0 000007fef75cb1c3 clr!JIT_GetSharedGCStaticBaseDynamicClass+0x53, calling clr!GetAppDomain
00000000002fd8e0 000007fe9a067245 (MethodDesc 000007fe986a82f0 +0x75 System.Collections.Generic.List`1[[System.Int32, mscorlib]].Contains(Int32))
00000000002fd900 0000000058c426cf syncSourceDll_amd64+0x26cf, calling syncSourceDll_amd64+0x19980
00000000002fd930 000007fe9a0671af (MethodDesc 000007fe9845dc98 +0x1f Crd.Common.Diagnostics.Instrumentation.RecordActionForMessage(System.Windows.Forms.Message)), calling (MethodDesc 000007fe986a82f0 +0 System.Collections.Generic.List`1[[System.Int32, mscorlib]].Contains(Int32))
00000000002fd960 000007fe9a06714b (MethodDesc 000007fe99f897e8 +0x86b Crd.Gui.DataEditorControllerHelper.WindowsProc(System.Windows.Forms.Message ByRef, Crd.Gui.IDataEditorController, Boolean ByRef)), calling (MethodDesc 000007fe9845dc98 +0 Crd.Common.Diagnostics.Instrumentation.RecordActionForMessage(System.Windows.Forms.Message))
00000000002fd9e0 000007fe9a067ea7 (MethodDesc 000007fe99a21d90 +0x17 Crd.Windows.Forms.UserControl.WndProc(System.Windows.Forms.Message ByRef)), calling 000007fe98bd92c0
00000000002fda20 000007fe9a067e6c (MethodDesc 000007fe99a24f68 +0x3c Crd.Gui.CrdUserControl.WndProc(System.Windows.Forms.Message ByRef)), calling 000007fe98bd9270
00000000002fda70 000007fe987b955a (MethodDesc 000007fe98344b70 +0x15a System.Windows.Forms.NativeWindow.Callback(IntPtr, Int32, IntPtr, IntPtr))
00000000002fda90 0000000058c7f587 syncSourceDll_amd64!CreateTimerSyncBridge+0x1d567, calling syncSourceDll_amd64!CreateTimerSyncBridge+0x18850
00000000002fdb40 000007fe987b7ba7 (MethodDesc 000007fe987a6f10 +0x57 DomainBoundILStubClass.IL_STUB_ReversePInvoke(Int64, Int32, Int64, Int64))
00000000002fdbd0 000007fef766482e clr!UMThunkStub+0x6e
00000000002fdbf0 0000000058c7b5d8 syncSourceDll_amd64!CreateTimerSyncBridge+0x195b8, calling syncSourceDll_amd64+0x165f0
00000000002fdc00 0000000058c63996 syncSourceDll_amd64!CreateTimerSyncBridge+0x1976, calling syncSourceDll_amd64!CreateTimerSyncBridge+0x19980
00000000002fdc30 0000000058c63403 syncSourceDll_amd64!CreateTimerSyncBridge+0x13e3, calling syncSourceDll_amd64!CreateTimerSyncBridge+0x1960
00000000002fdc80 0000000058c5ec36 syncSourceDll_amd64+0x1ec36, calling kernel32!SetLastError
00000000002fdcb0 0000000058c7abd3 syncSourceDll_amd64!CreateTimerSyncBridge+0x18bb3, calling syncSourceDll_amd64+0x1ec20
00000000002fdcf0 0000000077549b43 user32!UserCallWinProcCheckWow+0x99, calling ntdll!RtlActivateActivationContextUnsafeFast
00000000002fdd20 00000000775498da user32!DispatchMessageWorker+0x3b5, calling user32!UserCallWinProcCheckWow
00000000002fdd70 0000000058c76e69 syncSourceDll_amd64!CreateTimerSyncBridge+0x14e49, calling syncSourceDll_amd64!CreateTimerSyncBridge+0x154a0
00000000002fdda0 0000000058c6bbb5 syncSourceDll_amd64!CreateTimerSyncBridge+0x9b95
00000000002fde70 0000000077549055 user32!PeekMessageW+0x105, calling user32!NtUserPeekMessage
00000000002fde90 0000000058c76e69 syncSourceDll_amd64!CreateTimerSyncBridge+0x14e49, calling syncSourceDll_amd64!CreateTimerSyncBridge+0x154a0
00000000002fdea0 000007fef75c1ba6 clr!VirtualCallStubManager::predictStubKind+0x66, calling clr!GetThread
00000000002fdeb8 000007fe98f9cd44 (MethodDesc 000007fe990f92d8 +0x94 DomainBoundILStubClass.IL_STUB_PInvoke(MSG ByRef, System.Runtime.InteropServices.HandleRef, Int32, Int32, Int32))
00000000002fdec0 0000000058c6c535 syncSourceDll_amd64!CreateTimerSyncBridge+0xa515, calling syncSourceDll_amd64!CreateTimerSyncBridge+0x33b90
00000000002fdee0 000007fef75be581 clr!JIT_GetSharedGCThreadStaticBase+0x31, calling clr!GetThread
00000000002fdf20 000007fe99a6979f (MethodDesc 000007fe98b3dfe0 +0xcf System.Windows.Forms.ToolStripManager+ModalMenuFilter.GetActiveToolStrip()), calling (MethodDesc 000007fe98b3dff0 +0 System.Windows.Forms.ToolStripManager+ModalMenuFilter.GetActiveToolStripInternal())
00000000002fdf90 000007fe99a68ecf (MethodDesc 000007fe98b3e100 +0xdf System.Windows.Forms.ToolStripManager+ModalMenuFilter.PreFilterMessage(System.Windows.Forms.Message ByRef)), calling (MethodDesc 000007fe98b3dfe0 +0 System.Windows.Forms.ToolStripManager+ModalMenuFilter.GetActiveToolStrip())
00000000002fe170 000007fef75c1e28 clr!ResolveWorkerAsmStub+0x68, calling clr!VirtualCallStubManager::ResolveWorkerStatic
00000000002fe180 000007fef75724da clr!ThePreStub+0x5a, calling clr!PreStubWorker
00000000002fe250 000007fe98f9daa4 (MethodDesc 000007fe983461b8 +0x224 System.Windows.Forms.Application+ThreadContext.ProcessFilters(MSG ByRef, Boolean ByRef)), calling clr!JIT_IsInstanceOfInterface
00000000002fe340 000007fe98f9d555 (MethodDesc 000007fe983461c8 +0xc5 System.Windows.Forms.Application+ThreadContext.PreTranslateMessage(MSG ByRef)), calling 000007fe99104760
00000000002fe350 000007fe98f9ce1b (MethodDesc 000007fe983462b0 +0x4b System.Windows.Forms.Application+ThreadContext.System.Windows.Forms.UnsafeNativeMethods.IMsoComponent.FContinueMessageLoop(Int32, Int32, MSG[])), calling 000007fe98d61820
00000000002fe360 0000000077549aa6 user32!ValidateHwnd+0x2b, calling user32!HMValidateHandle
00000000002fe380 000007fef7572625 clr!JIT_InitPInvokeFrame+0x15, calling clr!GetThread
00000000002fe3b0 000007fe98f9e010 (MethodDesc 000007fe990fa940 +0x70 DomainBoundILStubClass.IL_STUB_PInvoke(MSG ByRef))
00000000002fe408 000007fe98f9e010 (MethodDesc 000007fe990fa940 +0x70 DomainBoundILStubClass.IL_STUB_PInvoke(MSG ByRef))
00000000002fe480 000007fe98f9c894 (MethodDesc 000007fe98d4c8e8 +0x684 System.Windows.Forms.Application+ComponentManager.System.Windows.Forms.UnsafeNativeMethods.IMsoComponentManager.FPushMessageLoop(IntPtr, Int32, Int32)), calling 000007fe982f7948 (stub for System.Windows.Forms.UnsafeNativeMethods.DispatchMessageW(MSG ByRef))
00000000002fe4a0 000007fe984a6a13 (MethodDesc 000007fe981e2c78 +0x43 System.Runtime.InteropServices.Marshal.SizeOf(System.Type))
00000000002fe680 000007fe98f81ad2 (MethodDesc 000007fe98346198 +0x562 System.Windows.Forms.Application+ThreadContext.RunMessageLoopInner(Int32, System.Windows.Forms.ApplicationContext))
00000000002fe7d0 000007fe98f8139e (MethodDesc 000007fe98346188 +0x5e System.Windows.Forms.Application+ThreadContext.RunMessageLoop(Int32, System.Windows.Forms.ApplicationContext)), calling 000007fe98d6bdb0
00000000002fe830 000007fe98f812fd (MethodDesc 000007fe982e67a8 +0xd System.Windows.Forms.Control.add_HandleDestroyed(System.EventHandler)), calling 000007fe98803160
00000000002fe860 000007fe984a546d (MethodDesc 000007fe980bc710 +0x16d Crd.AppCommon.IMS.AppManagerIms.Main(System.String[])), calling 000007fe98d6bcd0
00000000002fe940 000007fe97fd4d8c (MethodDesc 000007fe97e03918 +0x6c Crd.Ctm.CrdStartup.Main(System.String[])), calling 000007fe97e0cbc0 (stub for Crd.AppCommon.IMS.AppManagerIms.Main(System.String[]))
00000000002fe9a0 000007fef75bf713 clr!CallDescrWorkerInternal+0x83
00000000002fe9b8 000007fef7688cf5 clr!MetaSig::IsReturnTypeVoid+0x9, calling clr!MetaSig::GetReturnType
00000000002fe9e0 000007fef75bf242 clr!CallDescrWorkerWithHandler+0x4a, calling clr!CallDescrWorkerInternal
00000000002fea20 000007fef75bf30b clr!MethodDescCallSite::CallTargetWorker+0x2e6, calling clr!CallDescrWorkerWithHandler
00000000002feab0 000007fef75c385e clr!MethodDescCallSite::CallTargetWorker+0xa1, calling clr!_chkstk
00000000002feac0 000007fef75d0a5c clr!HndDestroyHandle+0x50, calling clr!CORProfilerTrackGC
00000000002feaf0 000007fef7688cf5 clr!MetaSig::IsReturnTypeVoid+0x9, calling clr!MetaSig::GetReturnType
00000000002febd0 000007fef775721c clr!RunMain+0x1e7, calling clr!MethodDescCallSite::CallTargetWorker
00000000002fec50 000007fe97fd4989 (MethodDesc 000007fe98054d38 +0x99 System.Security.Policy.AssemblyEvidenceFactory.UpgradeSecurityIdentity(System.Security.Policy.Evidence, System.Reflection.RuntimeAssembly))
00000000002fed60 000007fef76f693d clr!Thread::SetBackground+0x9f, calling clr!ThreadStore::UnlockThreadStore
00000000002feda0 000007fef7757976 clr!Assembly::ExecuteMainMethod+0xb6, calling clr!RunMain
00000000002fee30 000007fef75c3d32 clr!REGUTIL::EnvGetString+0x92, calling clr!_security_check_cookie
00000000002fee50 00000000777a3448 ntdll!RtlAllocateHeap+0xe4, calling ntdll!RtlpLowFragHeapAllocFromContext
00000000002feea0 000007fef7573051 clr!CrstBase::Enter+0x74, calling ntdll!RtlTryEnterCriticalSection
00000000002feec0 000007fef75c3c6f clr!REGUTIL::RegCacheValueNameSeenPerhaps+0x28, calling clr!HashiStringKnownLower80
00000000002feed0 000007fef7572f7c clr!CrstBase::Leave+0x30, calling ntdll!RtlLeaveCriticalSection
00000000002feef0 000007fef76fe2d5 clr!REGUTIL::GetConfigString_DontUse_+0x13d, 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>
00000000002fef20 000007fef75c3fd6 clr!EEConfig::GetConfiguration_DontUse_+0x36, calling clr!GetThread
00000000002fef30 000000007765300a kernel32!HeapFree+0xa, calling ntdll!RtlFreeHeap
00000000002fefb0 000007fef76fe3d6 clr!CLRConfig::GetConfigValue+0xd6, calling clr!CLRConfig::CheckLookupOption
00000000002ff010 000007fef76fe420 clr!CLRConfig::GetConfigValue+0x14, calling clr!CLRConfig::GetConfigValue
00000000002ff040 000007fef7705db8 clr!MulticoreJitManager::AutoStartProfile+0x69, 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>
00000000002ff060 000007fef757bb45 clr!GCPreemp::GCPreemp+0xe, calling clr!GetThread
00000000002ff090 000007fef7757870 clr!SystemDomain::ExecuteMainMethod+0x45e, calling clr!Assembly::ExecuteMainMethod
00000000002ff290 000007fef7587afc clr!MethodTable::MethodData::Release+0x2a
00000000002ff2c0 000007fef76563d4 clr!MemberLoader::FindMethod+0x157, calling clr!SString::~SString
00000000002ff380 000007fef7656683 clr!MemberLoader::FindMethod+0x53, calling clr!MemberLoader::FindMethod
00000000002ff3e0 000007fef76564f2 clr!MscorlibBinder::LookupMethod+0x4e, calling clr!MemberLoader::FindMethod
00000000002ff440 000007fef774c6f2 clr!EEStartupHelper+0x64e, calling clr!ConfigDWORD::val
00000000002ff470 00000000777a40fd ntdll!RtlFreeHeap+0x1a6, calling ntdll!RtlpFreeHeap
00000000002ff610 000007fef774c081 clr!EEStartup+0x15, calling clr!EEStartupHelper
00000000002ff650 000007fef77573e6 clr!ExecuteEXE+0x3f, calling clr!SystemDomain::ExecuteMainMethod
00000000002ff6c0 000007fef775733e clr!CorExeMainInternal+0xae, calling clr!ExecuteEXE
00000000002ff750 000007fef7753ed4 clr!CorExeMain+0x14, calling clr!CorExeMainInternal
00000000002ff790 000007fef7f574e5 mscoreei!CorExeMain+0xe0
00000000002ff7e0 000007fef8085b21 mscoree!CorExeMain_Exported+0x57
00000000002ff810 000000007764652d kernel32!BaseThreadInitThunk+0xd
00000000002ff840 000000007777c541 ntdll!RtlUserThreadStart+0x1d

Hello everyone,

 I'm developing an OPC client (in C#) and an OPC server (in C++ COM). The client is tested with Martrikon's and Iconics' free OPC server(both COM) and works fine (functionally as well as the interoperability).

 However, I found some troublesome bug, I try to explain with some steps:
 - server starts (all the COM components are registered in the registry)
 - client starts and connects to server
 (
 I used

        Type srv = Type.GetTypeFromProgID(ProgID);
        myServer = (IOPCServer)Activator.CreateInstance(srv, false);

and it returns a valid server object
 )
 -client tries to call a method (AddGroup) on the server and this is where the exception occurs
 Details:
 server method

HRESULT CServer::AddGroup(LPCWSTR szName, BOOL bActive, DWORD dwRequestedUpdateRate, OPCHANDLE hClientGroup, LONG *pTimeBias, FLOAT *pPercentDeadband, DWORD dwLCID, OPCHANDLE *phServerGroup, DWORD *pRevisedUpdateRate, REFIID riid, LPUNKNOWN *ppUnk)
{
	...

	*phServerGroup = ServerGroupHandle++;

	...

	HRESULT hr;
	if(dwRequestedUpdateRate >= 100){
		*pRevisedUpdateRate = dwRequestedUpdateRate;
		hr = 0; // S_OK
	}
	else{
		*pRevisedUpdateRate = 100;
		hr = 0x0004000DL; // OPC_S_UNSUPPORTEDRATE
	}

	COPCGroup* g = new COPCGroup(szName, bActive, dwRequestedUpdateRate, hClientGroup, pTimeBias, pPercentDeadband, dwLCID, phServerGroup, pRevisedUpdateRate);

	...
	
	if (riid == IID_IOPCGroupStateMgt) 
		*ppUnk = (LPUNKNOWN)((IOPCGroupStateMgt*)g);
        return hr;
}

client method

    public void AddGroup(string name, int bActive, uint dwUpdateRate, float fDeadband, ref uint phGroup) { 
      Guid IID_IOPCGroupStateMgt = new Guid ("39C13A50-011E-11D0-9675-0020AFD8ADB3");
      uint hServerGroup;
      uint dwRevUpdateRate = 0;
      int pTimeBias = 0;
      object pUnk;

      try
      { 
        myServer.AddGroup(name, bActive, dwUpdateRate, ++hClientGroup, ref pTimeBias, ref fDeadband, 0, out hServerGroup, out dwRevUpdateRate, ref IID_IOPCGroupStateMgt, out pUnk);

        phGroup = hServerGroup;
        myGroups.Insert(/*(int)hServerGroup*/numGrps++ , new OPC_Group(pUnk, name, mydwFlags, phGroup));
      }
      catch (Exception e) {
        Console.WriteLine(e.ToString());
      }
    }

The clients calls the server correctly, the server executes the method without errors, and returns all out and ref parameters correctly except the ppUnk which is set to NULL when it arrives to the client, although the server generated the value.

 The client throws the exception:
 BadImageFormatException "Invalid access to memory location. (Exception from HRESULT: 0x800703E6)" at AddGroup(...).
 While the server states in the Immediate Window the following at that moment:
 First-chance exception at 0x7c80980f in OPCDAServerCOM.exe: 0xC0000005: Access violation writing location 0xcdcdcdcd.
 First-chance exception at 0x7c809823 in OPCDAServerCOM.exe: 0xC0000005: Access violation writing location 0xcdcdcdcd.

 I experimented around and found a peculiar circumstance, namely if I modify the assignment of ppUnk in the server AddGroup to

ppUnk = new LPUNKNOWN((IOPCGroupStateMgt*)g);

no exception occurs, but in the client the pUnk is still NULL.

 At last I find it important to mention that during the debugging of the server, the method is completed successfully but after that, when using step by step debugging, I'm redirected to the disassembly of the server, and there the exception is thrown somewhere, but I wasn't able to track down where.

 What do you think the problem is? Any suggestions in what direction I should look will help, because I'm pretty much out of idea. The only thing that goes through my mind is that the error lies somewhere in the ptr-to-ptr assignment. I doubt there are any interoperability issues, given that the client was tested on other COM server and that the method's signature is defined by the OPC specification.

 Thank you

 PS:
 A few words to the semantics of the method:
 As you might guess, the client calls this method to add a group to the server, and expects, among the other parameters, to get the COPCGroup object back (via pUnk). The interface cast is necessary, because it is required that the client specifies the interface which is to be returned by the server.

I want to register a .dll in gac.plz help me to solve out.

 

plz tell me what is process to register a .dll in vb.net through programming.