Added example of writing to a C# ILogger from Rust

Author: gregyjames

CSharpDemo/CSharpDemo.csproj

@@ -8,4 +8,11 @@
         <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     </PropertyGroup>
 
+    <ItemGroup>
+      <PackageReference Include="Microsoft.Extensions.Logging" Version="9.0.3" />
+      <PackageReference Include="Serilog" Version="4.2.0" />
+      <PackageReference Include="Serilog.Extensions.Logging" Version="9.0.0" />
+      <PackageReference Include="Serilog.Sinks.Console" Version="6.0.0" />
+    </ItemGroup>
+
 </Project>

CSharpDemo/Program.cs

@@ -1,5 +1,8 @@
 using System.IO.MemoryMappedFiles;
 using System.Runtime.InteropServices;
+using Microsoft.Extensions.Logging;
+using Serilog;
+using ILogger = Serilog.ILogger;
 
 class Program
 {
@@ -18,18 +21,63 @@ public class MyClass
         public float value;
     }
 
-    [DllImport("librust_test.dylib")]
+    private const string LIB_NAME = "librust_test.dylib";
+    
+    [DllImport(LIB_NAME)]
     private static extern void write_to_memory(IntPtr ptr, int size);
 
-    [DllImport("librust_test.dylib", CallingConvention = CallingConvention.Cdecl)]
+    [DllImport(LIB_NAME, CallingConvention = CallingConvention.Cdecl)]
     private static extern void read_structs(IntPtr ptr, int count);
 
 
-    [DllImport("librust_test.dylib", CallingConvention = CallingConvention.Cdecl)]
+    [DllImport(LIB_NAME, CallingConvention = CallingConvention.Cdecl)]
     private static extern void read_class(IntPtr ptr);
 
+    // Delegate that matches Rust's function signature
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void LogCallback(IntPtr message);
+
+    // Import Rust functions
+    [DllImport(LIB_NAME, CallingConvention = CallingConvention.Cdecl)]
+    private static extern void set_info_logger(LogCallback callback);
+
+    // Import Rust functions
+    [DllImport(LIB_NAME, CallingConvention = CallingConvention.Cdecl)]
+    private static extern void set_err_logger(LogCallback callback);
+    
     static unsafe void Main()
     {
+        Log.Logger = new LoggerConfiguration()
+            .WriteTo.Console()  // Output logs to console
+            .MinimumLevel.Debug() // Set minimum log level
+            .CreateLogger();
+        
+        using var loggerFactory = LoggerFactory.Create(builder =>
+        {
+            builder.AddSerilog(); // Use Serilog
+        });
+
+        var logger = loggerFactory.CreateLogger<Program>();
+        
+        logger.LogInformation("[{ctx}]: Program starting...", "CSharp");
+        
+        // Define the C# function that will be called from Rust
+        void LogInfoCallback(IntPtr messagePtr)
+        {
+            var message = Marshal.PtrToStringAnsi(messagePtr);
+            logger.LogInformation("[{ctx}]: {msg}", "RUST", message);
+        }
+        
+        void LogErrorCallback(IntPtr messagePtr)
+        {
+            var message = Marshal.PtrToStringAnsi(messagePtr);
+            logger.LogError("[{ctx}]: {msg}", "RUST", message);
+        }
+        
+        // Pass the delegate function pointer to Rust
+        set_info_logger(LogInfoCallback);
+        set_err_logger(LogErrorCallback);
+        
         var size = 1024; // 1 KB memory-mapped file
         using var mmf = MemoryMappedFile.CreateFromFile("file.txt", FileMode.OpenOrCreate, null, size);
         using var accessor = mmf.CreateViewAccessor();
@@ -39,11 +87,12 @@ static unsafe void Main()
 
         try
         {
-            Console.WriteLine("Passing pointer to Rust...");
+            logger.LogInformation("[{ctx}]: Passing pointer of ViewAccessor to Rust...", "CSharp");
             write_to_memory((IntPtr)ptr, size);
         }
         finally
         {
+            logger.LogInformation("[{ctx}]: Releasing ViewAccessor pointer.", "CSharp");
             accessor.SafeMemoryMappedViewHandle.ReleasePointer();
         }
 
@@ -57,6 +106,7 @@ static unsafe void Main()
         var span = CollectionsMarshal.AsSpan(structs);
         ref var searchSpace = ref MemoryMarshal.GetReference(span);
 
+        logger.LogInformation("[{ctx}]: Passing pointer of first span element to Rust...", "CSharp");
         fixed (MyStruct* readPtr = &searchSpace)
         {
             read_structs((IntPtr)readPtr, structs.Count);
@@ -70,11 +120,15 @@ static unsafe void Main()
 
         try
         {
+            logger.LogInformation("[{ctx}]: Passing pointer of Pinned Heap object to Rust...", "CSharp");
             read_class(ptr3);
         }
         finally
         {
+            logger.LogInformation("[{ctx}]: Freed pinned handle.", "CSharp");
             handle.Free(); // Release the handle after Rust is done
         }
+        
+        logger.LogInformation("[{ctx}]: Program ending...", "CSharp");
     }
 }

README.md

@@ -14,6 +14,7 @@ Some examples I found useful calling Rust from CSharp
  1. Writing to a memory mapped file by getting a `SafeMemoryMappedViewHandle` and passing its pointer to Rust.
  2. Passing a List of structs to Rust by using `CollectionMarshall` to read as a span and pinning the reference to the first element using `MemoryMarshal.GetReference`
  3. Passing a heap allocated class to Rust by using `GCHandle.Alloc(obj, GCHandleType.Pinned)` to acquire a handler to a fixed handler and using `AddrOfPinnedObject()` to retrieve the pointer to that object's memory location.
+ 4. Writing to a C# ILogger using delegate function stored as global function pointer in Rust
 
 
 # License

rust_test/src/lib.rs

@@ -1,9 +1,55 @@
+use std::ffi::{c_char, CString};
+
+// Define a type for the logging function pointer
+type LogCallback = extern "C" fn(*const c_char);
+
+// Store the logging function globally (Unsafe, must be set before use)
+static mut INFOLOGGER: Option<LogCallback> = None;
+static mut ERRLOGGER: Option<LogCallback> = None;
+
+// Function to set the logger from C#
+#[unsafe(no_mangle)]
+pub extern "C" fn set_info_logger(callback: LogCallback) {
+    unsafe {
+        INFOLOGGER = Some(callback);
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn set_err_logger(callback: LogCallback) {
+    unsafe {
+        ERRLOGGER = Some(callback);
+    }
+}
+
+pub fn log_info_to_csharp(message: &str) {
+    let c_message = CString::new(message).unwrap();
+    
+    unsafe {
+        if let Some(logger) = INFOLOGGER {
+            logger(c_message.as_ptr());
+        }
+    }
+}
+
+pub fn log_err_to_csharp(message: &str) {
+    let c_message = CString::new(message).unwrap();
+    
+    unsafe {
+        if let Some(logger) = ERRLOGGER {
+            logger(c_message.as_ptr());
+        }
+    }
+}
+
 #[unsafe(no_mangle)]
 pub extern "C" fn write_to_memory(ptr: *mut u8, size: i32) {
     if ptr.is_null() {
+        log_err_to_csharp("Null ptr recieved from C#");
         return;
     }
 
+    log_info_to_csharp("Getting slice to memory mapped file...");
     let slice = unsafe { std::slice::from_raw_parts_mut(ptr, size as usize) };
     slice.fill(b' ');
 
@@ -14,9 +60,10 @@ pub extern "C" fn write_to_memory(ptr: *mut u8, size: i32) {
         slice[i] = 0;
     }
 
+    log_info_to_csharp("Copying message to slice...");
     slice[..len].copy_from_slice(&message[..len]);
 
-    println!("Rust wrote to memory-mapped file!");
+    log_info_to_csharp("Rust wrote to memory-mapped file!");
 }
 
 #[repr(C)]
@@ -29,14 +76,15 @@ pub struct MyStruct {
 #[unsafe(no_mangle)]
 pub extern "C" fn read_structs(ptr: *const MyStruct, count: i32) {
     if ptr.is_null() || count <= 0 {
+        log_err_to_csharp("Null ptr recieved from C#");
         return;
     }
 
     // Convert raw pointer into a slice
     let structs = unsafe { std::slice::from_raw_parts(ptr, count as usize) };
 
     for s in structs {
-        println!("Rust received: id = {}, value = {}", s.id, s.value);
+        log_info_to_csharp(&format!("Rust received: id = {}, value = {}", s.id, s.value))
     }
 }
 
@@ -50,12 +98,11 @@ pub struct MyClass {
 #[unsafe(no_mangle)]
 pub extern "C" fn read_class(ptr: *const MyClass) {
     if ptr.is_null() {
-        println!("Received null pointer!");
+        log_err_to_csharp("Null ptr recieved from C#");
         return;
     }
 
     // Dereference the pointer to read the class data
     let obj = unsafe { &*ptr };
-
-    println!("Rust received: id = {}, value = {}", obj.id, obj.value);
+    log_info_to_csharp(&format!("Rust received: id = {}, value = {} from the C# class.", obj.id, obj.value));
 }