With the common approach, a DLL written in Managed C++ has a dependency from Microsoft Visual C++ Runtime, DLL files from which cannot be linked statically. The traditional solution is the inclusion of Microsoft Visual C++ Redistributable in the setup file.

With BoxedApp SDK, you can emulate the availability of Microsoft Visual C++ Runtime. Right after the application is launched, before using the components compiled in Managed C++, create the files, from which the Managed C++ DLL depends (how to find paths to dependencies):

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.IO;
using System.Runtime.InteropServices;
using System.Reflection;

namespace WindowsApplication1
{
    static class Program
    {
        /// 

        /// The main entry point for the application.
        /// 
        [STAThread]
        static void Main()
        {
            BoxedAppSDK.NativeMethods.BoxedAppSDK_Init();

            string PathOfWinSxS = 
                Directory.GetParent(Environment.SystemDirectory).FullName + 
                @"\WinSxS";

            if (!Directory.Exists(PathOfWinSxS))
                // Win2k
                PathOfWinSxS = Application.StartupPath;

            Stream fromStream =
                Assembly.
                GetExecutingAssembly().
                GetManifestResourceStream("WindowsApplication1.res.msvcm80d.dll");

            CreateDLLInMemory(
                PathOfWinSxS + 
                @"\x86_Microsoft.VC80.DebugCRT_1fc8b3b9a1e18e3b_8.0.50727.42_x-ww_f75eb16c\msvcm80d.dll",
                fromStream);

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());

            BoxedAppSDK.NativeMethods.BoxedAppSDK_Exit();
        }

        [DllImport("kernel32.dll", SetLastError = true)]
        static extern bool CloseHandle(IntPtr hObject);

        static void CreateDLLInMemory(string strVirtualPath, Stream stream)
        {
            const int BufferSize = 1024;
            byte[] buffer = new byte[BufferSize];

            IntPtr hHandle =
                BoxedAppSDK.NativeMethods.BoxedAppSDK_CreateVirtualFile(
                strVirtualPath,
                BoxedAppSDK.NativeMethods.EFileAccess.GenericWrite,
                BoxedAppSDK.NativeMethods.EFileShare.Read,
                IntPtr.Zero,
                BoxedAppSDK.NativeMethods.ECreationDisposition.New,
                BoxedAppSDK.NativeMethods.EFileAttributes.Normal,
                IntPtr.Zero);
            CloseHandle(hHandle);

            int nReadBytes;

            using (FileStream VirtualFileStream = new FileStream(strVirtualPath, FileMode.Open))
            {
                while ((nReadBytes = stream.Read(buffer, 0, BufferSize)) > 0)
                    VirtualFileStream.Write(buffer, 0, nReadBytes);
            }
        }
    }
}

To find out, which exact DLL files does your Managed C++ DLL has dependencies from, use the depends.exe application from Visual Studio setup. Open your Managed C++ DLL in depends.exe, and you will easily find, which VC++ Runtime components it depends from:

• registration in the registry requires admin rights
• sometimes registration influences to other applications
  for example, your application uses Flash 7, but another application requires Flash 9

• your application should register an ActiveX at startup and unregister it when ActiveX is not needed anymore
  for example, your application is so-called portable application

How to solve the task using BoxedApp?

BoxedApp provides a very interesting function BoxedAppSDK_RegisterCOMLibraryInVirtualRegistry. This function does the same things as regsvr32 does. BoxedAppSDK_RegisterCOMLibraryInVirtualRegistry loads a file (virtual or real) and calls DllRegisterServer. What’s important: all changes of the registry save in virtual registry, not real!

So, when an application creates an ActiveX, COM subsystem finds all what it needs in virtual registry.

As a result, the system registry remains unchanged, and COM subsystem “thinks” that the ActiveX is really registered in the system.

So, we’ve got a .net application WindowsApplication1.exe, which displays a simple form with a progress bar and a couple of links. Now we are to create the environment where WindowsApplication1.exe would successfully launch on systems that don’t have .net runtime.

BoxedApp SDK creates the infrastructure of a virtual file system and a virtual registry; so once the corresponding virtual kes and virtual files are created, the .NET application can be launched successfully.

It is known that the hive HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework contains the key InstallRoot that points to the folder with subfolders with different versions of.net runtime. For instance, on my computer the key contains the value содержит значение “C:\WINDOWS\Microsoft.NET\Framework”. That folder includes the following runtime versions:

v1.0.3705
v1.1.4322
v2.0.50727
v3.0
v3.5

In this example, we assume that our runtime version is 2.0.50727. For the folder for storing our runtime files, let’s choose some path; e.g., C:\DotNet. Next, let’s create the virtual files within that folder, and the application will see it as if .net runtime was actually installed on the computer.

So, let’s create our virtual key:

// Initialize BoxedAppSDK
BoxedAppSDK_Init();

tstring strDotNetRoot = _T("C:\\DotNet");

DWORD dwDisposition;
HKEY hKey__DotNet;
LONG lRes = 
BoxedAppSDK_CreateVirtualRegKey(
	HKEY_LOCAL_MACHINE, 
	_T("SOFTWARE\\Microsoft\\.NETFramework"), 
	0, 
	NULL, 
	REG_OPTION_NON_VOLATILE, 
	KEY_ALL_ACCESS, 
	NULL, 
	&hKey__DotNet, 
	&dwDisposition);

LPCTSTR szValue = _T("C:\\DotNet\\");
RegSetValueEx(hKey__DotNet, _T("InstallRoot"), 0, REG_SZ, (CONST BYTE*)szValue, (lstrlen(szValue) + 1) * sizeof(TCHAR));

We will need paths to the system folders:

TCHAR szWinDir[MAX_PATH] = { 0 };
GetWindowsDirectory(szWinDir, MAX_PATH);
tstring strWinDir = szWinDir;

TCHAR szSystemDir[MAX_PATH] = { 0 };
GetSystemDirectory(szSystemDir, MAX_PATH);
tstring strSystemDir = szSystemDir;

In the resource file, specify which files are to be embedded in the application. We are going to embed both .net runtime and the WindowsApplication1.exe files, plus the AppLauncher.dll assembly, which we’re going to cover a bit further:

WindowsApplication1.exe BIN "WindowsApplication1.exe"
AppLauncher.dll BIN "AppLauncher.dll"

mscoree.dll BIN "system32\\mscoree.dll"
mscorjit.dll BIN "v2.0.50727\\mscorjit.dll"
mscorwks.dll BIN "v2.0.50727\\mscorwks.dll"
comctl32.dll BIN "WinSxS\\x86_Microsoft.Windows.Common-Controls_6595b64144ccf1df_6.0.2600.2982_x-ww_ac3f9c03\\comctl32.dll"
msvcr80.dll BIN "WinSxS\\x86_Microsoft.VC80.CRT_1fc8b3b9a1e18e3b_8.0.50727.1433_x-ww_5cf844d2\\msvcr80.dll"
msvcr80d.dll BIN "WinSxS\\x86_Microsoft.VC80.DebugCRT_1fc8b3b9a1e18e3b_8.0.50727.42_x-ww_f75eb16c\\msvcr80d.dll"
System.Windows.Forms.dll BIN "assembly\\GAC_MSIL\\System.Windows.Forms\\2.0.0.0__b77a5c561934e089\\System.Windows.Forms.dll"
mscorlib.dll BIN "assembly\\GAC_32\\mscorlib\\2.0.0.0__b77a5c561934e089\\mscorlib.dll"
mscorrc.dll BIN "v2.0.50727\\mscorrc.dll"
sorttbls.nlp BIN "assembly\\GAC_32\\mscorlib\\2.0.0.0__b77a5c561934e089\\sorttbls.nlp"
sortkey.nlp BIN "assembly\\GAC_32\\mscorlib\\2.0.0.0__b77a5c561934e089\\sortkey.nlp"
System.dll BIN "v2.0.50727\\System.dll"
System.Data.dll BIN "v2.0.50727\\System.Data.dll"
System.Drawing.dll BIN "v2.0.50727\\System.Drawing.dll"
Culture.dll BIN "v2.0.50727\\Culture.dll"
Accessibility.dll BIN "v2.0.50727\\Accessibility.dll"
GdiPlus.dll BIN "system32\\GdiPlus.dll"

In the properties of the rc file (right-click on the rc file and then select Properties, Configuration Properties -> Resources -> General, Additional Include Directories), specify the additional folders to be searched for the files:


"$(FrameworkDir)";"$(SystemRoot)";"..\WindowsApplication1\bin\x86\$(ConfigurationName)";"..\AppLauncher\bin\x86\$(ConfigurationName)"


Here’s a light helper function for handling resources:

void LoadResourceHelper( /* in */ LPCTSTR lpszName, 
                         /* in */ LPCTSTR lpszType, 
                         /* out */ LPVOID& lpData, 
                         /* out */ DWORD& dwSize)
{
    HMODULE hModule = GetModuleHandle(NULL);
    HRSRC hResInfo = FindResource(hModule, lpszName, lpszType);
    HGLOBAL hResData = LoadResource(hModule, hResInfo);
    lpData = LockResource(hResData);
    dwSize = SizeofResource(hModule, hResInfo);
}

And here’s the function for creating a virtual file; the content will be taken from the specified resource:

void CreateVirtualFileFromResource(LPCTSTR szVirtualPath, LPCTSTR szResName, LPCTSTR szResType)
{
	DWORD temp;

	LPVOID pData;
	DWORD dwSize;

	LoadResourceHelper(szResName, szResType, pData, dwSize);

	HANDLE hFile = BoxedAppSDK_CreateVirtualFile(szVirtualPath, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_NEW, 0, NULL);
	WriteFile(hFile, pData, dwSize, &temp, NULL);
	CloseHandle(hFile);
}

Now we can create the virtual files, required for the successful performance of the .net runtime:

struct SFileResInfo
{
	tstring strVirtualPath;
	LPCTSTR szResName;
};

const SFileResInfo ResInfo[] = 
{
		{ strSystemDir + _T("\\mscoree.dll"), _T("mscoree.dll") }, 

		{ strDotNetRoot + _T("\\v2.0.50727\\mscorjit.dll"), _T("mscorjit.dll") }, 

		{ strDotNetRoot + _T("\\v2.0.50727\\mscorwks.dll"), _T("mscorwks.dll") }, 

		{ strWinDir + _T("\\WinSxS\\x86_Microsoft.Windows.Common-Controls_6595b64144ccf1df_6.0.2600.2982_x-ww_ac3f9c03\\comctl32.dll"), _T("comctl32.dll") }, 
		{ strSystemDir + _T("\\comctl32.dll"), _T("comctl32.dll") }, 

		{ strWinDir + _T("\\WinSxS\\x86_Microsoft.VC80.CRT_1fc8b3b9a1e18e3b_8.0.50727.1433_x-ww_5cf844d2\\msvcr80.dll"), _T("msvcr80.dll") }, 
		{ strSystemDir + _T("\\msvcr80.dll"), _T("msvcr80.dll") }, 

		{ strWinDir + _T("\\assembly\\GAC_MSIL\\System.Windows.Forms\\2.0.0.0__b77a5c561934e089\\System.Windows.Forms.dll"), _T("System.Windows.Forms.dll") }, 

		{ strWinDir + _T("\\assembly\\GAC_32\\mscorlib\\2.0.0.0__b77a5c561934e089\\mscorlib.dll"), _T("mscorlib.dll") }, 

		{ strDotNetRoot + _T("\\v2.0.50727\\mscorrc.dll"), _T("mscorrc.dll") }, 

		{ strWinDir + _T("\\assembly\\GAC_32\\mscorlib\\2.0.0.0__b77a5c561934e089\\sorttbls.nlp"), _T("sorttbls.nlp") }, 
		{ strWinDir + _T("\\assembly\\GAC_32\\mscorlib\\2.0.0.0__b77a5c561934e089\\sortkey.nlp"), _T("sortkey.nlp") }, 

		{ strDotNetRoot + _T("\\v2.0.50727\\System.dll"), _T("System.dll") }, 

		{ strDotNetRoot + _T("\\v2.0.50727\\System.Data.dll"), _T("System.Data.dll") }, 
		{ strDotNetRoot + _T("\\v2.0.50727\\System.Drawing.dll"), _T("System.Drawing.dll") }, 

		{ strDotNetRoot + _T("\\v2.0.50727\\Culture.dll"), _T("Culture.dll") }, 

		{ strWinDir + _T("\\assembly\\GAC_MSIL\\System\\2.0.0.0__b77a5c561934e089\\System.dll"), _T("System.dll") }, 
		{ strWinDir + _T("\\assembly\\GAC_MSIL\\System.Drawing\\2.0.0.0__b03f5f7f11d50a3a\\System.Drawing.dll"), _T("System.Drawing.dll") }, 

		{ strWinDir + _T("\\Microsoft.NET\\Framework\\v2.0.50727\\Accessibility.dll"), _T("Accessibility.dll") }, 
		{ strWinDir + _T("\\assembly\\GAC_MSIL\\Accessibility\\2.0.0.0__b03f5f7f11d50a3a\\Accessibility.dll"), _T("Accessibility.dll") }, 

		{ strSystemDir + _T("\\GdiPlus.dll"), _T("GdiPlus.dll") }, 


		{ _T("C:\\AppLauncher.dll"), _T("AppLauncher.dll") }, 
		{ _T("C:\\WindowsApplication1.exe"), _T("WindowsApplication1.exe") }
};

for (int i = 0; i < sizeof(ResInfo) / sizeof(ResInfo[0]); i++)
	CreateVirtualFileFromResource(ResInfo[i].strVirtualPath.c_str(), ResInfo[i].szResName, _T("BIN"));

To get along with .net runtime, we’re going to use the mscoree.dll library (please note that mscoree.dll is embedded in the application). mscoree.dll exports the function CorBindToRuntimeEx, which will give us the interface ICLRRuntimeHost. The method ICLRRuntimeHost::ExecuteInDefaultAppDomain loads the assembly and calls the specified method. However, that method is to have a very specific signature; you cannot call just any method, but we’re going to cover this later. So, here’s our ICLRRuntimeHost:

HMODULE hMSCoree = LoadLibrary((strSystemDir + _T("\\mscoree.dll")).c_str());

typedef HRESULT (__stdcall *P_CorBindToRuntimeEx)(LPCWSTR pwszVersion, LPCWSTR pwszBuildFlavor, DWORD startupFlags, REFCLSID rclsid, REFIID riid, LPVOID FAR *ppv);
P_CorBindToRuntimeEx pCorBindToRuntimeEx = (P_CorBindToRuntimeEx)GetProcAddress(hMCoree, "CorBindToRuntimeEx");

ICLRRuntimeHost* pCLRRuntimeHost = NULL;
pCorBindToRuntimeEx(L"v2.0.50727", NULL, 0, CLSID_CLRRuntimeHost, IID_ICLRRuntimeHost, (void**)&pCLRRuntimeHost);

ICLRRuntimeHost::ExecuteInDefaultAppDomain can be called only by a method with the following signature:

int SomeMethod (string Argument);

Now, our job is to load the assembly of the .net application and call its point of entry. However, the point of entry has a different signature:

static void Main();

Therefore, we’re going to create another assembly, which will be a class with a static method, which in its turn will load the assembly of the main application and call its point of entry:

using System;
using System.Reflection;
using System.Text;

namespace AppLauncher
{
    public class Launcher
    {
        public static int Launch(string strPath)
        {
            Assembly assembly = Assembly.LoadFile(strPath);
            assembly.EntryPoint.Invoke(null, null);

            return 0;
        }
    }
}

Now we’ve got everything ready for running the application:

pCLRRuntimeHost->Start();

DWORD nRetValue;
pCLRRuntimeHost->ExecuteInDefaultAppDomain(
	L"C:\\AppLauncher.dll", 
	L"AppLauncher.Launcher", 
	L"Launch", 
	L"C:\\WindowsApplication1.exe", 
	&nRetValue);

pCLRRuntimeHost->Stop();

pCLRRuntimeHost->Release();

FreeLibrary(hMSCoree);

Related links:

• Download example; see the folder samples\Misc\DotNetEmbedding
• Description of CorBindToRuntimeEx
• BoxedAppSDK_CreateVirtualRegKey
• BoxedAppSDK_CreateVirtualFile

At the first, decide how to store an assembly. In this example, I keep an assembly in static array. To create C# code with such array, I use the following code:

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace ConvertBinToSharpCode
{
    class Program
    {
        static void Main(string[] args)
        {
            byte[] data = File.ReadAllBytes(args[0]);

            Console.Write("namespace BinData\n{\n\tpublic class Data1\n\t\t{\n\n\t\tpublic static byte[] data = \n{\n");

            foreach (byte b in data)
            {
                Console.Write(b.ToString() + ",");
            }

            Console.Write("};\n}\n}\n");
        }
    }
}

It takes one argument (path to an assembly) and outputs C# code, save it as data.cs, for example:

namespace BinData
{
	public class Data1
		{

		public static byte[] data = 
{
77,90,144,0,3,0 .......
}
}

Include it to the main solution.

Now, how to create a virtual file with assembly and fill it from the BinData.Data1.data:

static void CreateAssemblyInMemory(
   string strVirtualPath, 
   byte[] data)
{
   IntPtr hHandle =
      BoxedAppSDK.NativeMethods.BoxedAppSDK_CreateVirtualFile(
         strVirtualPath,
         BoxedAppSDK.NativeMethods.EFileAccess.GenericWrite,
         BoxedAppSDK.NativeMethods.EFileShare.Read,
         IntPtr.Zero,
         BoxedAppSDK.NativeMethods.ECreationDisposition.New,
         BoxedAppSDK.NativeMethods.EFileAttributes.Normal,
         IntPtr.Zero);
   CloseHandle(hHandle);

   using (FileStream VirtualFileStream = 
            new FileStream(strVirtualPath, FileMode.Open))
   {
      VirtualFileStream.Write(data, 0, (int)data.Length);
   }
}

Now how to create an assembly into memory:

CreateAssemblyInMemory(@"Z:\myclass.dll", BinData.Data1.data);

Assembly assembly = Assembly.LoadFrom(@"Z:\myclass.dll");
object o = assembly.CreateInstance("myclass.Class1");
o.GetType().GetMethod("SomeMethod").Invoke(o, null);

Another option, when your application uses some assembly and you would like to keep this assembly in memory. In this case, you write:

static class Program
{
    /// 

    /// The main entry point for the application.
    /// 
    [STAThread]
    static void Main()
    {
        BoxedAppSDK.NativeMethods.BoxedAppSDK_Init();

        // Creates a virtual file with assembly
        // before using the assembly, in 
        // other words, the assembly is not 
        // loaded yet
        CreateAssemblyInMemory(
           Application.StartupPath + @"\\Assembly1.dll", 
           BinData.Data1.data);

        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);

        // The Form1 will be created, 
        // Form1 loads the assembly Assembly1.dll, 
        // BoxedApp SDK provides it from memory
        Application.Run(new Form1());

        BoxedAppSDK.NativeMethods.BoxedAppSDK_Exit();
   }
...
}

One of the most important features is embedding ActiveX into an application. BoxedAppSDK_RegisterCOMLibraryInVirtualRegistry registers a virtual file in a virtual registry. In detail, it loads a specified file (LoadLibrary) and calls DllRegisterServer (exported from the DLL). All changes made by DllRegisterServer are saved in the virtual registry; the system registry remains unchanged.

After that, CoCreateInstance (and the related functions) will receive the correct information from the “registry”.

Embedding Flash step-by-step:

1. Get started with BoxedApp SDK:

BoxedAppSDK_Init();

2. Create a virtual file with Flash.ocx:

LPVOID pBuffer;
DWORD dwSize;

// LoadResourceHelper gets resource pointer and size
LoadResourceHelper(
   MAKEINTRESOURCE(IDR_BIN_FLASH_OCX), 
   _T("BIN"), 
   pBuffer, 
   dwSize);

HANDLE hVirtualFile1 = 
   BoxedAppSDK_CreateVirtualFile(
      _T("C:\\Flash9e.ocx"), 
      GENERIC_READ, 
      FILE_SHARE_READ, 
      NULL, 
      CREATE_NEW, 
      0, 
      NULL);  

DWORD dwTemp; 
WriteFile(hVirtualFile1, pBuffer, dwSize, &dwTemp, NULL);

CloseHandle(hVirtualFile1);

3. Register the COM library in the virtual registry:

BoxedAppSDK_RegisterCOMLibraryInVirtualRegistry(_T("C:\\Flash9e.ocx"));

Further on, when you have created a Flash ActiveX instance, the COM subsystem (CoCreateInstance) will read information from the virtual registry and create an ActiveX object from the virtual DLL.

In particular, using this method you can create applications that are ready to work without installation (so-called “portable applications”) even if they use ActiveX or others COM-objects. Simply create a virtual file with an appropriate DLL and call BoxedAppSDK_RegisterCOMLibraryInVirtualRegistry.

Related links:

1. Download BoxedApp SDK samples
2. The best solution to work with Flash ActiveX (embedding is also supported)
3. Function BoxedAppSDK_RegisterCOMLibraryInVirtualRegistry