embedded_dotnet_runtime_examples

KO | EN

gitlite — search

#hacktoberfest #llm #golang #deep-learning #linux #docker #nodejs #java #cli #awesome-list #vue #mcp #ios #open-source

embedded_dotnet_runtime_examples

(★ 16)

Example project for embedding and interfacing with a .NET 6 runtime with C++ using https://github.com/KevinGliewe/dotnet_runtime

embedded_dotnet_runtime_examples Latest Version Download

Download Latest Version (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

<div align="center">
 <h1>Embedded .NET 6 Runtime</h1>
 <a href="https://github.com/KevinGliewe/embedded_dotnet_runtime_examples/actions"><img alt="Build and Test" src="https://github.com/KevinGliewe/embedded_dotnet_runtime_examples/workflows/Build%20and%20Test/badge.svg?branch=master"/></a>
</div>

This repo contains a project with examples for using a embedded .NET 6 runtime in a C++ application using [dotnet_runtime](https://github.com/KevinGliewe/dotnet_runtime).

* [Embedded .NET 6 Runtime](#embedded-net-6-runtime)
* [Build and Run](#build-and-run)
 * [Windows](#windows)
 * [Requirements](#requirements)
 * [Steps](#steps)
 * [What happens during the build?](#what-happens-during-the-build)
 * [Linux &amp; MacOS](#linux--macos)
 * [Requirements](#requirements-1)
 * [Steps](#steps-1)
 * [What happens during the build?](#what-happens-during-the-build-1)
* [Examples](#examples)
 * [Load and initialize .NET runtime](#load-and-initialize-net-runtime)
 * [Managed Entrypoint](#managed-entrypoint)
 * [Managed component-entrypoint](#managed-component-entrypoint)
 * [Managed custom-entrypoint](#managed-custom-entrypoint)
 * [Managed Strings](#managed-strings)
 * [Return managed ASCII string](#return-managed-ascii-string)
 * [Return managed wide string](#return-managed-wide-string)
 * [Native Strings](#native-strings)
 * [Native ASCII string](#native-ascii-string)
 * [Native Wide string](#native-wide-string)
 * [Native string to managed function pointer](#native-string-to-managed-function-pointer)
 * [Managed function-pointer](#managed-function-pointer)
 * [Managed function-pointer to instance method](#managed-function-pointer-to-instance-method)
 * [Managed function-pointer to static function](#managed-function-pointer-to-static-function)
 * [Native function-pointer](#native-function-pointer)
 * [Calling checked native function pointer](#calling-checked-native-function-pointer)
 * [Calling unchecked native function pointer](#calling-unchecked-native-function-pointer)
 * [Usage of unsafe managed code to access native objects](#usage-of-unsafe-managed-code-to-access-native-objects)
 * [Native Arrays](#native-arrays)
 * [Native arrays using fixed struct member](#native-arrays-using-fixed-struct-member)
 * [Native arrays using pointer](#native-arrays-using-pointer)
 * [Native arrays using ArrPointerX on function-pointer](#native-arrays-using-arrpointerx-on-function-pointer)
 * [Native Symbols](#native-symbols)
 * [Calling native exported symbols using DllImport](#calling-native-exported-symbols-using-dllimport)
 * [Calling native exported symbols using GetProcAddress/dlsym](#calling-native-exported-symbols-using-getprocaddressdlsym)
 * [Native VTable](#native-vtable)
 * [Calling native VTable from managed code](#calling-native-vtable-from-managed-code)
 * [Overwriting native VTable with managed code](#overwriting-native-vtable-with-managed-code)
* [LICENSE](#license)

# Build and Run

## Windows

### Requirements

* Visual Studio 2019
 * .NET 6 SDK

### Steps

1. Clone this repository recursively using
    `git clone --recursive git@github.com:KevinGliewe/embedded_dotnet_runtime_examples.git`
 2. Run `build_run.bat`

### What happens during the build?
 
 * Imports `VsDevCmd.bat`
 * Installs dotnet tool [`runtimedl`](https://github.com/KevinGliewe/dotnet_runtime/tree/runtimedl-tool)
 * Downloads the propper .NET 6 runtime for your system using [`runtimedl`](https://github.com/KevinGliewe/dotnet_runtime/tree/runtimedl-tool)
 * Builds `Lib` and `Host` using MSBuild
 * Runs `Host`

## Linux & MacOS

### Requirements

* CMake 3.16 or newer
 * .NET 6 SDK
 * C++ compiler

### Steps

1. Clone this repository recursively using
    `git clone --recursive git@github.com:KevinGliewe/embedded_dotnet_runtime_examples.git`
 2. Run `sh build_run.sh`

### What happens during the build?

* Installs dotnet tool [`runtimedl`](https://github.com/KevinGliewe/dotnet_runtime/tree/runtimedl-tool)
 * Downloads the propper .NET 6 runtime for your system using [`runtimedl`](https://github.com/KevinGliewe/dotnet_runtime/tree/runtimedl-tool)
 * Builds `Lib` using .NET 6 SDK
 * Creates makefile using CMake
 * Builds `Host` using make
 * Runs `Host`

# Examples

## Load and initialize .NET runtime

<a id='snippet-initruntimeandlib'></a>
```cpp
// Init runtime and lib

auto runtime = dotnet_runtime::Runtime(hostfxr_path, libRuntimeconfig_path);

auto lib = dotnet_runtime::Library(&runtime, libDll_path, STR("Lib"));
```
<a href='/Host/Host.cpp#L87-L93' title='Snippet source file'>snippet source</a> | <a href='#snippet-initruntimeandlib' title='Start of snippet'>anchor</a>

---

## Managed Entrypoint

> Entrypoints can only use [blittable types](https://en.wikipedia.org/wiki/Blittable_types)

### Managed component-entrypoint

<details><summary>Native</summary>

<a id='snippet-test_managedentrypoint_args_cpp'></a>
```h
struct args
{
	int number1;
	int number2;
};
```
<a href='/Host/Test_ManagedEntryPoint.h#L7-L13' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_managedentrypoint_args_cpp' title='Start of snippet'>anchor</a>

<a id='snippet-test_managedentrypoint_componententrypoint_cpp'></a>
```h
auto fpTest_ComponentEntryPoint = a_lib.GetComponentEntrypoint(
	STR("LibNamespace.Test_ManagedEntryPoint"),
	STR("Test_ComponentEntryPoint")
);

bool success = fpTest_ComponentEntryPoint(&_args, sizeof(_args)) == 3;
LogTest(success, L"Test_ComponentEntryPoint");
```
<a href='/Host/Test_ManagedEntryPoint.h#L24-L34' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_managedentrypoint_componententrypoint_cpp' title='Start of snippet'>anchor</a>


</details>

<details><summary>Managed</summary>

<a id='snippet-test_managedentrypoint_args_cs'></a>
```cs
[StructLayout(LayoutKind.Sequential)]
public unsafe struct Args
{
 public int Number1;
 public int Number2;
}
```
<a href='/Lib/Test_ManagedEntryPoint.cs#L9-L16' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_managedentrypoint_args_cs' title='Start of snippet'>anchor</a>

<a id='snippet-test_managedentrypoint_componententrypoint_cs'></a>
```cs
public static int Test_ComponentEntryPoint(IntPtr arg, int argLength)
{
 if (argLength < Marshal.SizeOf(typeof(Args)))
 {
 return 1;
 }

Args args = Marshal.PtrToStructure<Args>(arg);

return args.Number1 + args.Number2;
}
```
<a href='/Lib/Test_ManagedEntryPoint.cs#L18-L30' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_managedentrypoint_componententrypoint_cs' title='Start of snippet'>anchor</a>


</details>

### Managed custom-entrypoint

> Entrypoints can only use [blittable types](https://en.wikipedia.org/wiki/Blittable_types)

<details><summary>Native</summary>

<a id='snippet-test_managedentrypoint_customentrypoint_cpp'></a>
```h
typedef int (CORECLR_DELEGATE_CALLTYPE* custom_entry_point_fn)(args);

auto fpTest_CustomEntryPoint = (custom_entry_point_fn)a_lib.GetCustomEntrypoint(
	STR("LibNamespace.Test_ManagedEntryPoint"),
	STR("Test_CustomEntryPoint")
);

bool success = fpTest_CustomEntryPoint(_args) == 3;
LogTest(success, L"Test_CustomEntryPoint");
```
<a href='/Host/Test_ManagedEntryPoint.h#L40-L52' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_managedentrypoint_customentrypoint_cpp' title='Start of snippet'>anchor</a>


</details>

<details><summary>Managed</summary>

<a id='snippet-test_managedentrypoint_customentrypoint_cs'></a>
```cs
[UnmanagedCallersOnly]
public static int Test_CustomEntryPoint(Args args)
{
 return args.Number1 + args.Number2;
}
```
<a href='/Lib/Test_ManagedEntryPoint.cs#L32-L38' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_managedentrypoint_customentrypoint_cs' title='Start of snippet'>anchor</a>


</details>

---

## Managed Strings

### Return managed ASCII string

<details><summary>Native</summary>

<a id='snippet-test_managedstring_ansi_cpp'></a>
```h
auto fpTest_ManagedString_Ansi = (custom_entry_point_fn)a_lib.GetCustomEntrypoint(
	STR("LibNamespace.Test_ManagedString"),
	STR("Test_ManagedString_Ansi")
);

char* str = (char*)fpTest_ManagedString_Ansi();

// Compare the ASCII strings
bool success = cmp(str, (char*)"Hello Ansi");

LogTest(success, L"Test_ManagedString_Ansi");
```
<a href='/Host/Test_ManagedString.h#L17-L31' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_managedstring_ansi_cpp' title='Start of snippet'>anchor</a>


</details>

<details><summary>Managed</summary>

<a id='snippet-test_managedstring_ansi_cs'></a>
```cs
public static readonly CString HelloAnsi = new CString("Hello Ansi");

[UnmanagedCallersOnly]
public static IntPtr Test_ManagedString_Ansi()
{
 return HelloAnsi.Ptr;
}
```
<a href='/Lib/Test_ManagedString.cs#L9-L17' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_managedstring_ansi_cs' title='Start of snippet'>anchor</a>


</details>

What does CString do?
 1. Apends a `\0` character on the end of the string.
 2. Converts the string into ANSI encoding.
 3. Allocate memory for native access using [`Marshal.AllocHGlobal`](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.marshal.allochglobal?view=net-6.0).
 4. Copy the encoded string into the allocated memory.

### Return managed wide string

> The encoding depends on the platform. For windows systems it is UTF16 and for posix systems it is UTF32.

<details><summary>Native</summary>

<a id='snippet-test_managedstring_wide_cpp'></a>
```h
auto fpTest_ManagedString_Wide = (custom_entry_point_fn)a_lib.GetCustomEntrypoint(
	STR("LibNamespace.Test_ManagedString"),
	STR("Test_ManagedString_Wide")
);

wchar_t* str = (wchar_t*)fpTest_ManagedString_Wide();

// Compare the wide strings
bool success = cmp(str, (wchar_t*)L"Hello ❤");

LogTest(success, L"Test_ManagedString_Wide");
```
<a href='/Host/Test_ManagedString.h#L36-L50' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_managedstring_wide_cpp' title='Start of snippet'>anchor</a>


</details>

<details><summary>Managed</summary>

What does CString do?
 1. Determins the correct encoding for the current platform. (UTF16 or UTF32)
 2. Apends a `\0` character on the end of the string.
 3. Converts the string into the propper encoding.
 4. Allocate memory for native access using [`Marshal.AllocHGlobal`](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.marshal.allochglobal?view=net-6.0).
 5. Copy the encoded string into the allocated memory.

<a id='snippet-test_managedstring_wide_cs'></a>
```cs
public static readonly CString HelloWide = new CString("Hello ❤", CEncoding.Wide);

[UnmanagedCallersOnly]
public static IntPtr Test_ManagedString_Wide()
{
 return HelloWide.Ptr;
}
```
<a href='/Lib/Test_ManagedString.cs#L19-L27' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_managedstring_wide_cs' title='Start of snippet'>anchor</a>


</details>

---

## Native Strings

### Native ASCII string

<details><summary>Native</summary>

<a id='snippet-test_nativestring_ansi_cpp'></a>
```h
auto fpTest_NativeString_Ansi = (custom_entry_point_fn)a_lib.GetCustomEntrypoint(
	STR("LibNamespace.Test_NativeString"),
	STR("Test_NativeString_Ansi")
);

bool success = fpTest_NativeString_Ansi((void*)"Hello Ansi");
LogTest(success, L"Test_NativeString_Ansi");
```
<a href='/Host/Test_NativeString.h#L22-L32' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativestring_ansi_cpp' title='Start of snippet'>anchor</a>


</details>

<details><summary>Managed</summary>

<a id='snippet-test_nativestring_ansi_cs'></a>
```cs
[UnmanagedCallersOnly]
public static int Test_NativeString_Ansi(IntPtr stringPtr)
{
 return CEncoding.Ascii.GetString(stringPtr) == "Hello Ansi" ? 1 : 0;
}
```
<a href='/Lib/Test_NativeString.cs#L12-L18' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativestring_ansi_cs' title='Start of snippet'>anchor</a>


</details>

### Native Wide string

<details><summary>Native</summary>

<a id='snippet-test_nativestring_wide_cpp'></a>
```h
auto fpTest_NativeString_Wide = (custom_entry_point_fn)a_lib.GetCustomEntrypoint(
	STR("LibNamespace.Test_NativeString"),
	STR("Test_NativeString_Wide")
);

bool success = fpTest_NativeString_Wide((void*)L"Hello ❤");
LogTest(success, L"Test_NativeString_Wide");
```
<a href='/Host/Test_NativeString.h#L37-L47' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativestring_wide_cpp' title='Start of snippet'>anchor</a>


</details>

<details><summary>Managed</summary>

<a id='snippet-test_nativestring_wide_cs'></a>
```cs
[UnmanagedCallersOnly]
public static int Test_NativeString_Wide(IntPtr stringPtr)
{
 return CEncoding.Wide.GetString(stringPtr) == "Hello ❤" ? 1 : 0;
}
```
<a href='/Lib/Test_NativeString.cs#L20-L26' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativestring_wide_cs' title='Start of snippet'>anchor</a>


</details>

### Native string to managed function pointer

<details><summary>Native</summary>

<a id='snippet-test_nativestring_retargs_cpp'></a>
```h
struct RetArgs
{
	bool (*CallbackAnsi)(const char*);
	bool (*CallbackWide)(const wchar_t*);
};
```
<a href='/Host/Test_NativeString.h#L7-L13' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativestring_retargs_cpp' title='Start of snippet'>anchor</a>

<a id='snippet-test_nativestring_functionpointer_cpp'></a>
```h
typedef void (CORECLR_DELEGATE_CALLTYPE* custom_entry_point_fn2)(void*);

auto fpTest_NativeString_FunctionPointer = (custom_entry_point_fn2)a_lib.GetCustomEntrypoint(
	STR("LibNamespace.Test_NativeString"),
	STR("Test_NativeString_FunctionPointer")
);

RetArgs retArgs;
fpTest_NativeString_FunctionPointer(&retArgs);

{ // Ansi
	bool success = retArgs.CallbackAnsi("Hello Ansi");
	LogTest(success, L"Test_NativeString_FunctionPointer.CallbackAnsi");

ret &= success;
}

{ // Wide
	bool success = retArgs.CallbackWide(L"Hello ❤");
	LogTest(success, L"Test_NativeString_FunctionPointer.CallbackWide");

ret &= success;
}
```
<a href='/Host/Test_NativeString.h#L52-L78' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativestring_functionpointer_cpp' title='Start of snippet'>anchor</a>


</details>

<details><summary>Managed</summary>

<a id='snippet-test_nativestring_functionpointer_cs'></a>
```cs
public delegate bool FunctionPointerCallbackAnsiDelegate(NativeString nstr);
public delegate bool FunctionPointerCallbackWideDelegate(NativeWString nstr);

public static FunctionPointerCallbackAnsiDelegate FunctionPointerCallbackAnsiDelegateInstance =
    new FunctionPointerCallbackAnsiDelegate(CallbackAnsi);

public static FunctionPointerCallbackWideDelegate FunctionPointerCallbackWideDelegateInstance =
    new FunctionPointerCallbackWideDelegate(CallbackWide);

public static bool CallbackAnsi(NativeString nstr) => nstr.ToString() == "Hello Ansi";
public static bool CallbackWide(NativeWString nstr) => nstr.ToString() == "Hello ❤";

[StructLayout(LayoutKind.Sequential)]
public struct RetArgs
{
    public IntPtr CallbackAnsi;
    public IntPtr CallbackWide;
}

[UnmanagedCallersOnly]
public static void Test_NativeString_FunctionPointer(IntPtr retArgsPtr)
{
 unsafe
 {
 RetArgs* retArgs = (RetArgs*)retArgsPtr;
 retArgs->CallbackAnsi =
 Marshal.GetFunctionPointerForDelegate(FunctionPointerCallbackAnsiDelegateInstance);
 retArgs->CallbackWide =
 Marshal.GetFunctionPointerForDelegate(FunctionPointerCallbackWideDelegateInstance);
 }
}
```
<a href='/Lib/Test_NativeString.cs#L29-L62' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativestring_functionpointer_cs' title='Start of snippet'>anchor</a>


</details>

---

## Managed function-pointer

### Managed function-pointer to instance method

<details><summary>Native</summary>

<a id='snippet-test_managedfunctionpointer_typedef_managed_callback_fn_cpp'></a>
```h
typedef int (*managed_callback_fn)(int);
```
<a href='/Host/Test_ManagedFunctionPointer.h#L11-L13' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_managedfunctionpointer_typedef_managed_callback_fn_cpp' title='Start of snippet'>anchor</a>

<a id='snippet-test_managedfunctionpointer_instance_cpp'></a>
```h
typedef void* (CORECLR_DELEGATE_CALLTYPE* custom_entry_point_fn)(int);

// Get the managed entry point
auto fpTest_ManagedFunctionPointer_Instance = (custom_entry_point_fn)a_lib.GetCustomEntrypoint(
	STR("LibNamespace.Test_ManagedFunctionPointer"),
	STR("Test_ManagedFunctionPointer_Instance")
);

// Get the function pointer to the managed method
managed_callback_fn managedCallback = (managed_callback_fn)fpTest_ManagedFunctionPointer_Instance(2);

bool success = managedCallback(6) == 8;

LogTest(success, L"Test_ManagedFunctionPointer_Instance");
```
<a href='/Host/Test_ManagedFunctionPointer.h#L16-L33' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_managedfunctionpointer_instance_cpp' title='Start of snippet'>anchor</a>


</details>

<details><summary>Managed</summary>

<a id='snippet-test_managedfunctionpointer_functionpointercallbackdelegate_cs'></a>
```cs
public delegate int FunctionPointerCallbackDelegate(int a);
```
<a href='/Lib/Test_ManagedFunctionPointer.cs#L8-L10' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_managedfunctionpointer_functionpointercallbackdelegate_cs' title='Start of snippet'>anchor</a>

<a id='snippet-test_managedfunctionpointer_instance_cs'></a>
```cs
public class CallableObject
{
 public FunctionPointerCallbackDelegate CallbackDelegate;
 public IntPtr CallbackFunctionPointer;

private int Member;

public int Callback(int i) => i + Member;

public CallableObject(int member)
    {
        Member = member;
        CallbackDelegate = new FunctionPointerCallbackDelegate(Callback);
        CallbackFunctionPointer = Marshal.GetFunctionPointerForDelegate(CallbackDelegate);
    }

}

public static CallableObject CallableObjectInstance;

// Enty point for unmanaged code
[UnmanagedCallersOnly]
public static IntPtr Test_ManagedFunctionPointer_Instance(int member)
{
 CallableObjectInstance = new CallableObject(member);
 return CallableObjectInstance.CallbackFunctionPointer;
}
```
<a href='/Lib/Test_ManagedFunctionPointer.cs#L13-L44' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_managedfunctionpointer_instance_cs' title='Start of snippet'>anchor</a>


</details>

### Managed function-pointer to static function

<details><summary>Native</summary>

<a id='snippet-test_managedfunctionpointer_static_cpp'></a>
```h
typedef void* (CORECLR_DELEGATE_CALLTYPE* custom_entry_point_fn)();

// Get the managed entry point
auto fpTest_ManagedFunctionPointer_Static = (custom_entry_point_fn)a_lib.GetCustomEntrypoint(
	STR("LibNamespace.Test_ManagedFunctionPointer"),
	STR("Test_ManagedFunctionPointer_Static")
);

// Get the function pointer to the managed function
managed_callback_fn managedCallback = (managed_callback_fn)fpTest_ManagedFunctionPointer_Static();

bool success = managedCallback(5) == 8;

LogTest(success, L"Test_ManagedFunctionPointer_Static");
```
<a href='/Host/Test_ManagedFunctionPointer.h#L38-L55' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_managedfunctionpointer_static_cpp' title='Start of snippet'>anchor</a>


</details>

<details><summary>Managed</summary>

<a id='snippet-test_managedfunctionpointer_static_cs'></a>
```cs
public static FunctionPointerCallbackDelegate FunctionPointerCallbackDelegateStatic = new FunctionPointerCallbackDelegate(Callback);

public static int Callback(int i) => i + 3;

// Enty point for unmanaged code
[UnmanagedCallersOnly]
public static IntPtr Test_ManagedFunctionPointer_Static()
{
 return Marshal.GetFunctionPointerForDelegate(FunctionPointerCallbackDelegateStatic);
}
```
<a href='/Lib/Test_ManagedFunctionPointer.cs#L46-L60' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_managedfunctionpointer_static_cs' title='Start of snippet'>anchor</a>


</details>

---

## Native function-pointer

### Calling checked native function pointer

<details><summary>Native</summary>

<a id='snippet-test_nativefunctionpointer_callbackfunc_cpp'></a>
```h
int FEXPORT CallbackFunc(int i)
{
	return i * 2;
}
```
<a href='/Host/Test_NativeFunctionPointer.h#L8-L13' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativefunctionpointer_callbackfunc_cpp' title='Start of snippet'>anchor</a>

<a id='snippet-test_nativefunctionpointer_callbackpointer_cpp'></a>
```h
void* fpNativeCallback = (void*)&CallbackFunc;
```
<a href='/Host/Test_NativeFunctionPointer.h#L21-L23' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativefunctionpointer_callbackpointer_cpp' title='Start of snippet'>anchor</a>

<a id='snippet-test_nativefunctionpointer_callbackfunc_checked_cpp'></a>
```h
auto fpTest_NativeFunctionPointer_Checked = (custom_entry_point_fn)a_lib.GetCustomEntrypoint(
	STR("LibNamespace.Test_NativeFunctionPointer"),
	STR("Test_NativeFunctionPointer_Checked")
);

bool success = fpTest_NativeFunctionPointer_Checked(fpNativeCallback, 4) == 8;
LogTest(success, L"Test_NativeFunctionPointer_Checked");
```
<a href='/Host/Test_NativeFunctionPointer.h#L26-L36' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativefunctionpointer_callbackfunc_checked_cpp' title='Start of snippet'>anchor</a>


</details>

<details><summary>Managed</summary>

<a id='snippet-test_nativefunctionpointer_checked_cs'></a>
```cs
public delegate int FunctionPointerCallbackDelegate(int a);

[UnmanagedCallersOnly]
public static int Test_NativeFunctionPointer_Checked(IntPtr nativeFunctionPtr, int number)
{
 var callbackFuncDelegate =
 (FunctionPointerCallbackDelegate)Marshal.GetDelegateForFunctionPointer(nativeFunctionPtr,
 typeof(FunctionPointerCallbackDelegate));
 return callbackFuncDelegate(number);
}
```
<a href='/Lib/Test_NativeFunctionPointer.cs#L8-L19' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativefunctionpointer_checked_cs' title='Start of snippet'>anchor</a>


</details>

### Calling unchecked native function pointer

<details><summary>Native</summary>

<a id='snippet-test_nativefunctionpointer_callbackfunc_unchecked_cpp'></a>
```h
auto fpTest_NativeFunctionPointer_Unchecked = (custom_entry_point_fn)a_lib.GetCustomEntrypoint(
	STR("LibNamespace.Test_NativeFunctionPointer"),
	STR("Test_NativeFunctionPointer_Unchecked")
);

bool success = fpTest_NativeFunctionPointer_Unchecked(fpNativeCallback, 4) == 8;
LogTest(success, L"Test_NativeFunctionPointer_Unchecked");
```
<a href='/Host/Test_NativeFunctionPointer.h#L41-L51' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativefunctionpointer_callbackfunc_unchecked_cpp' title='Start of snippet'>anchor</a>


</details>

<details><summary>Managed</summary>

<a id='snippet-test_nativefunctionpointer_unchecked_cs'></a>
```cs
[UnmanagedCallersOnly]
public static int Test_NativeFunctionPointer_Unchecked(IntPtr nativeFunctionPtr, int number)
{
 unsafe
 {
 unchecked
 {
 var callbackFuncPtr = (delegate* unmanaged[Cdecl]<int, int>)nativeFunctionPtr;
 return callbackFuncPtr(number);
 }
 }
}
```
<a href='/Lib/Test_NativeFunctionPointer.cs#L21-L34' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativefunctionpointer_unchecked_cs' title='Start of snippet'>anchor</a>


</details>

---

## Usage of unsafe managed code to access native objects

<details><summary>Native</summary>

<a id='snippet-test_managedunsafe_cpp'></a>
```h
struct Args
{
	int number1;
	int number2;
	int sum;
	char returnMsg[128];
};

bool Run(dotnet_runtime::Library& a_lib)
{
	bool ret = true;

typedef void (CORECLR_DELEGATE_CALLTYPE* custom_entry_point_fn)(void*);

auto fpTest_ManagedUnsafe_Struct = (custom_entry_point_fn)a_lib.GetCustomEntrypoint(
		STR("LibNamespace.Test_ManagedUnsafe"),
		STR("Test_ManagedUnsafe_Struct")
	);

Args args;
	args.number1 = 1;
	args.number2 = 2;

fpTest_ManagedUnsafe_Struct(&args);

{ //sum
		bool success = args.sum == 3;
		LogTest(success, L"Test_ManagedUnsafe_Struct.Sum");
		ret &= success;
	}

{ // ReturnMsg
		bool success = cmp(args.returnMsg, (char*)"Hello Ansi");
		LogTest(success, L"Test_ManagedUnsafe_Struct.ReturnMsg");
		ret &= success;
	}
	return ret;
}
```
<a href='/Host/Test_ManagedUnsafe.h#L7-L47' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_managedunsafe_cpp' title='Start of snippet'>anchor</a>


</details>

<details><summary>Managed</summary>

<a id='snippet-test_managedunsafe_cs'></a>
```cs
[StructLayout(LayoutKind.Sequential)]
public unsafe struct Args
{
 public int Number1;
 public int number2;
 public int Sum;
 public fixed byte ReturnMsg[128];
}

[UnmanagedCallersOnly]
public static void Test_ManagedUnsafe_Struct(IntPtr ptr)
{
    unsafe
    {
        Args* args = (Args*) ptr;

args->Sum = args->Number1 + args->number2;

// Get the memory offset of Args.ReturnMsg
        var destReturnMsg = IntPtr.Add(ptr, (int)Marshal.OffsetOf(typeof(Args), nameof(Args.ReturnMsg)));

var data = CEncoding.Ascii.GetBytes("Hello Ansi");

// Copy the data to the unmanaged memory
 Marshal.Copy(data, 0, (IntPtr)destReturnMsg, data.Length);
 }
}
```
<a href='/Lib/Test_ManagedUnsafe.cs#L9-L37' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_managedunsafe_cs' title='Start of snippet'>anchor</a>


</details>

---

## Native Arrays

### Native arrays using fixed struct member

<details><summary>Native</summary>

<a id='snippet-test_nativearray_args_cpp'></a>
```h
struct args
{
	int Arr[8];
	int Multiplier;
};
```
<a href='/Host/Test_NativeArray.h#L7-L13' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativearray_args_cpp' title='Start of snippet'>anchor</a>

<a id='snippet-test_nativearray_args_data_cpp'></a>
```h
args _args{
	1, 2, 3, 4, 5, 6, 7, 8, // Arr[8]
	2 // Multiplier
};
```
<a href='/Host/Test_NativeArray.h#L19-L24' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativearray_args_data_cpp' title='Start of snippet'>anchor</a>

<a id='snippet-test_nativearray_structfixed_cpp'></a>
```h
typedef int (CORECLR_DELEGATE_CALLTYPE* custom_entry_point_fn)(args);

auto fpTest_NativeArray_StructFixed = (custom_entry_point_fn)a_lib.GetCustomEntrypoint(
	STR("LibNamespace.Test_NativeArray"),
	STR("Test_NativeArray_StructFixed")
);

bool success = fpTest_NativeArray_StructFixed(_args) == 72;
LogTest(success, L"Test_NativeArray_StructFixed");
```
<a href='/Host/Test_NativeArray.h#L27-L39' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativearray_structfixed_cpp' title='Start of snippet'>anchor</a>


</details>

<details><summary>Managed</summary>

<a id='snippet-test_nativearray_structfixed_cs'></a>
```cs
[StructLayout(LayoutKind.Sequential)]
public unsafe struct Args
{
 public fixed int Arr[8];
 public int Multiplier;
}

[UnmanagedCallersOnly]
public static unsafe int Test_NativeArray_StructFixed(Args args)
{
    int ret = 0;

for(int i = 0; i < 8; i++)
 {
 ret += args.Arr[i] * args.Multiplier;
 }

return ret;
}
```
<a href='/Lib/Test_NativeArray.cs#L10-L31' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativearray_structfixed_cs' title='Start of snippet'>anchor</a>


</details>

### Native arrays using pointer

<details><summary>Native</summary>

<a id='snippet-test_nativearray_argumentfixed_cpp'></a>
```h
typedef int (CORECLR_DELEGATE_CALLTYPE* custom_entry_point_fn)(int[], int);

auto fpTest_NativeArray_ArgumentFixed = (custom_entry_point_fn)a_lib.GetCustomEntrypoint(
	STR("LibNamespace.Test_NativeArray"),
	STR("Test_NativeArray_ArgumentFixed")
);

bool success = fpTest_NativeArray_ArgumentFixed(_args.Arr, _args.Multiplier) == 72;
LogTest(success, L"Test_NativeArray_ArgumentFixed");
```
<a href='/Host/Test_NativeArray.h#L45-L57' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativearray_argumentfixed_cpp' title='Start of snippet'>anchor</a>


</details>

<details><summary>Managed</summary>

<a id='snippet-test_nativearray_argumentfixed_cs'></a>
```cs
[UnmanagedCallersOnly]
public static int Test_NativeArray_ArgumentFixed(IntPtr arrPtr, int multiplier)
{
 // ArrPointer as argument does not work here!

ArrPointer8<int> arr = new ArrPointer8<int>(arrPtr);

return arr.Sum(el => el * multiplier); ;
}
```
<a href='/Lib/Test_NativeArray.cs#L33-L44' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativearray_argumentfixed_cs' title='Start of snippet'>anchor</a>


</details>

### Native arrays using ArrPointerX on function-pointer

<details><summary>Native</summary>

<a id='snippet-test_nativearray_argumentfixed_functionpointer_cpp'></a>
```h
typedef void* (CORECLR_DELEGATE_CALLTYPE* custom_entry_point_fn)();
typedef int (*managed_callback_fn)(int[], int);

auto fpTest_NativeArray_ArgumentFixed_FunctionPointer = (custom_entry_point_fn)a_lib.GetCustomEntrypoint(
	STR("LibNamespace.Test_NativeArray"),
	STR("Test_NativeArray_ArgumentFixed_FunctionPointer")
);

managed_callback_fn callback = (managed_callback_fn)fpTest_NativeArray_ArgumentFixed_FunctionPointer();

bool success = callback(_args.Arr, _args.Multiplier) == 72;
LogTest(success, L"Test_NativeArray_ArgumentFixed_FunctionPointer");
```
<a href='/Host/Test_NativeArray.h#L62-L77' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativearray_argumentfixed_functionpointer_cpp' title='Start of snippet'>anchor</a>


</details>

<details><summary>Managed</summary>

<a id='snippet-test_nativearray_argumentfixed_functionpointer_cs'></a>
```cs
public delegate int FunctionPointerCallbackDelegate(ArrPointer8<int> arr, int multiplier);

public static FunctionPointerCallbackDelegate FunctionPointerCallbackDelegateInstance =
    new FunctionPointerCallbackDelegate(Callback);

public static int Callback(ArrPointer8<int> arr, int multiplier) => arr.Sum(el => el * multiplier);

[UnmanagedCallersOnly]
public static IntPtr Test_NativeArray_ArgumentFixed_FunctionPointer()
{
 return Marshal.GetFunctionPointerForDelegate(FunctionPointerCallbackDelegateInstance);
}
```
<a href='/Lib/Test_NativeArray.cs#L46-L59' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativearray_argumentfixed_functionpointer_cs' title='Start of snippet'>anchor</a>


</details>

---

## Native Symbols

### Calling native exported symbols using `DllImport`

<details><summary>Native</summary>

<a id='snippet-test_dllimport_export_cpp'></a>
```h
extern "C"
{
	int FEXPORT Test_DllImport_ExternC(int number)
	{
		return number * 2;
	}
}
```
<a href='/Host/Test_DllImport.h#L5-L13' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_dllimport_export_cpp' title='Start of snippet'>anchor</a>

<a id='snippet-test_dllimport_call_cpp'></a>
```h
void* host_handle = dotnet_runtime::get_host_handle();
return fpTest_DllImport_Call(host_handle, 4) == 8;
```
<a href='/Host/Test_DllImport.h#L28-L31' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_dllimport_call_cpp' title='Start of snippet'>anchor</a>

> For posix systems, use the `-export-dynamic` flag for the linker.

</details>

<details><summary>Managed</summary>

<a id='snippet-test_dllimport_cs'></a>
```cs
private static IntPtr s_moduleHandle = IntPtr.Zero;

private static IntPtr ImportResolver(string libraryName, Assembly assembly, DllImportSearchPath? searchPath)
{
    IntPtr ret = libraryName == "Test_DllImport_LibName" ? s_moduleHandle : NativeLibrary.Load(libraryName, assembly, searchPath);
    //Console.WriteLine($"ImportResolver s_moduleHandle={s_moduleHandle} ret={ret}");
    return ret;
}

[DllImport("Test_DllImport_LibName")]
public static extern int Test_DllImport_ExternC(int number);

[UnmanagedCallersOnly]
public static int Test_DllImport_Call(IntPtr moduleHandle, int number)
{
    s_moduleHandle = moduleHandle;
    NativeLibrary.SetDllImportResolver(typeof(Test_DllImport).Assembly, ImportResolver);

return Test_DllImport_ExternC(number);
}
```
<a href='/Lib/Test_DllImport.cs#L10-L31' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_dllimport_cs' title='Start of snippet'>anchor</a>


</details>

### Calling native exported symbols using `GetProcAddress`/`dlsym`

<details><summary>Native</summary>

<a id='snippet-test_nativeexport_export_cpp'></a>
```h
extern "C"
{
	int FEXPORT Test_NativeExport_ExternC(int number)
	{
		return number * 4;
	}
}
```
<a href='/Host/Test_NativeExport.h#L5-L13' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativeexport_export_cpp' title='Start of snippet'>anchor</a>

<a id='snippet-test_nativeexport_call_cpp'></a>
```h
void* host_handle = dotnet_runtime::get_host_handle();
return fpTest_NativeExport_Call(host_handle, 4) == 16;
```
<a href='/Host/Test_NativeExport.h#L28-L31' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativeexport_call_cpp' title='Start of snippet'>anchor</a>

> For posix systems, use the `-export-dynamic` flag for the linker.

</details>

<details><summary>Managed</summary>

<a id='snippet-test_nativeexport_cs'></a>
```cs
public delegate int FunctionPointerCallbackDelegate(int a);

[UnmanagedCallersOnly]
public static int Test_NativeExport_Call(IntPtr moduleHandle, int number)
{
 var exportedDelegate = ModuleLoader.GetExport<FunctionPointerCallbackDelegate>(moduleHandle, "Test_NativeExport_ExternC");
 int result = exportedDelegate(number);

unsafe
 {
 unchecked
 {
 var callbackFuncPtr = (delegate* unmanaged[Cdecl]<int, int>)ModuleLoader.GetExport(moduleHandle, "Test_NativeExport_ExternC");
 result += callbackFuncPtr(number);
 }
 }

return result / 2;
}
```
<a href='/Lib/Test_NativeExport.cs#L10-L30' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativeexport_cs' title='Start of snippet'>anchor</a>


</details>

---

## Native VTable

[VTable](https://en.wikipedia.org/wiki/Virtual_method_table)

### Calling native VTable from managed code

<details><summary>Native</summary>

<a id='snippet-test_nativevtable_class_cpp'></a>
```h
class ClassLayout
{
private:
	int m_iTest = 0;
public:
	virtual void AddOne() { this->m_iTest += 1; }
	virtual void AddTwo() { this->m_iTest += 2; }

int GetTest() { return m_iTest; }
};
```
<a href='/Host/Test_NativeVTable.h#L8-L19' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativevtable_class_cpp' title='Start of snippet'>anchor</a>

<a id='snippet-test_nativevtable_call_cpp'></a>
```h
ClassLayout* instance = new ClassLayout();

// Calls AddOne and AddTwo, then overwrites VTable
fpTest_NativeVTable_Call((void*)instance);
```
<a href='/Host/Test_NativeVTable.h#L34-L39' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativevtable_call_cpp' title='Start of snippet'>anchor</a>

</details>

<details><summary>Managed</summary>

<a id='snippet-test_nativevtable_class_cs'></a>
```cs
[StructLayout(LayoutKind.Sequential)]
private struct ClassLayout
{
 public IntPtr VTable;
 public int test;
}

[StructLayout(LayoutKind.Sequential)]
private struct ClassVTable
{
    public IntPtr Method_AddOne;
    public IntPtr Method_AddTwo;
}

delegate void MethodDelegate(IntPtr thisPtr);
```
<a href='/Lib/Test_NativeVTable.cs#L9-L25' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativevtable_class_cs' title='Start of snippet'>anchor</a>

<a id='snippet-test_nativevtable_managedcall_cs'></a>
```cs
ClassLayout instance = Marshal.PtrToStructure<ClassLayout>(classInstance);

ClassVTable vTable = Marshal.PtrToStructure<ClassVTable>(instance.VTable);

MethodDelegate method_AddOne =
 Marshal.GetDelegateForFunctionPointer<MethodDelegate>(vTable.Method_AddOne);
MethodDelegate method_AddTwo =
 Marshal.GetDelegateForFunctionPointer<MethodDelegate>(vTable.Method_AddTwo);

method_AddOne(classInstance);
method_AddTwo(classInstance);
```
<a href='/Lib/Test_NativeVTable.cs#L44-L57' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativevtable_managedcall_cs' title='Start of snippet'>anchor</a>

</details>

### Overwriting native VTable with managed code

<details><summary>Native</summary>

<a id='snippet-test_nativevtable_call_cpp'></a>
```h
ClassLayout* instance = new ClassLayout();

</details>

<details><summary>Managed</summary>

[StructLayout(LayoutKind.Sequential)]
private struct ClassVTable
{
    public IntPtr Method_AddOne;
    public IntPtr Method_AddTwo;
}

<a id='snippet-test_nativevtable_overwrite_cs'></a>
```cs
// This delegate will be the new virtual method
private static readonly unsafe MethodDelegate delegate_SubOne = new MethodDelegate(thisPtr =>
{
 var instance = (ClassLayout*)thisPtr;
 instance->test -= 1;
});

// Create new unmanaged VTable instance
private static readonly UnmanagedMemory<ClassVTable> OverwrittenVTable = new();
```
<a href='/Lib/Test_NativeVTable.cs#L27-L37' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativevtable_overwrite_cs' title='Start of snippet'>anchor</a>

<a id='snippet-test_nativevtable_managedoverwrite_cs'></a>
```cs
unsafe
{
 // Get the new VTable
 var vTable = OverwrittenVTable.PtrElem;

// Set the virtual methods with the new managed function pointer (Both the same for simplicity)
    vTable->Method_AddTwo = vTable->Method_AddOne =
        Marshal.GetFunctionPointerForDelegate(delegate_SubOne);

// Overwrite the VTable reference of the instance
 var instance = (ClassLayout*) classInstance;
 instance->VTable = (IntPtr) vTable;
}
```
<a href='/Lib/Test_NativeVTable.cs#L60-L74' title='Snippet source file'>snippet source</a> | <a href='#snippet-test_nativevtable_managedoverwrite_cs' title='Start of snippet'>anchor</a>

</details>

# LICENSE

dotnet_runtime_test is licensed under MIT license. See [LICENSE](./LICENSE) for more details.

embedded_dotnet_runtime_examples

embedded_dotnet_runtime_examples Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

embedded_dotnet_runtime_examples

embedded_dotnet_runtime_examples Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

Download README