Linux-Fedora25下Unity3D外部C++插件调用C#方法问询

Hey there, let's get this sorted properly! Your current delegate approach has a couple critical issues—like not protecting against garbage collection and ignoring Unity's thread restrictions for its API. Since OnRenderEventThreadSafe runs on Unity's render thread, we need to handle both the cross-language callback and thread safety carefully.

What Was Wrong With Your Original Approach? #

• You didn't pin the delegate in memory: Mono's garbage collector could clean up your delegate at any time, leading to a crash when C++ tries to call it.
• You tried to call Unity API (like Debug.Log) directly from the render thread: Most Unity APIs are only safe to use on the main thread.
• No proper mechanism to persist the callback pointer across threads.

Step-by-Step Correct Implementation #

1. Update Your C++ Plugin Code #

First, we'll add a way to register and store the C# callback pointer, then call it from your render thread function:

#include <Unity/IUnityInterface.h>
#include <Unity/IUnityGraphics.h>

// Define the function pointer type that matches your C# delegate
typedef void (*CSharpRenderCallback)(int);
static CSharpRenderCallback g_Callback = nullptr;

// Export a function for C# to register its callback
extern "C" void UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API RegisterRenderCallback(CSharpRenderCallback callback) {
    g_Callback = callback;
}

static void UNITY_INTERFACE_API OnRenderEventThreadSafe(int eventID) {
    // Your existing C++ logic here
    [...]

    // Safely call the C# callback if it's been registered
    if (g_Callback != nullptr) {
        // Pass any data you need—here we're using eventID as an example
        g_Callback(eventID);
    }
}

2. C# Side Implementation #

On the C# side, we'll pin the delegate to avoid GC collection, handle thread marshaling to the main thread, and register the callback with the plugin:

using UnityEngine;
using System;
using System.Runtime.InteropServices;

public class PluginCallbackManager : MonoBehaviour
{
    // Delegate that matches the C++ function pointer type
    private delegate void CSharpRenderCallback(int eventId);

    // Import the C++ registration function
#if UNITY_EDITOR || UNITY_STANDALONE_LINUX
    [DllImport("lib")]
#else
    [DllImport("lib")]
#endif
    private static extern void RegisterRenderCallback(CSharpRenderCallback callback);

    // GCHandle to pin the delegate in memory (prevents GC from collecting it)
    private static GCHandle _pinnedCallback;

    // Mark this method as the callback target for Mono's interop layer
    [MonoPInvokeCallback(typeof(CSharpRenderCallback))]
    private static void OnRenderThreadCallback(int eventId)
    {
        // WARNING: This runs on the RENDER THREAD—do NOT call Unity API directly here!
        // We need to send the message to the main thread first
        UnityMainThreadDispatcher.Instance.Enqueue(() =>
        {
            Debug.Log($"Received render thread event: {eventId}");
            // Call your actual C# business logic methods here
        });
    }

    void Start()
    {
        // Create and pin the delegate to keep it alive
        var callback = new CSharpRenderCallback(OnRenderThreadCallback);
        _pinnedCallback = GCHandle.Alloc(callback);

        // Register the callback with the C++ plugin
        RegisterRenderCallback(callback);
    }

    void OnDestroy()
    {
        // Clean up to avoid memory leaks and dangling pointers
        if (_pinnedCallback.IsAllocated)
        {
            _pinnedCallback.Free();
            // Tell C++ to clear the callback pointer
            RegisterRenderCallback(null);
        }
    }
}

3. Main Thread Dispatcher (Critical for Thread Safety) #

Since Unity's API can't be called from the render thread, we need a simple dispatcher to run code on the main thread. Add this script to a persistent GameObject in your scene:

using UnityEngine;
using System.Collections.Generic;

public class UnityMainThreadDispatcher : MonoBehaviour
{
    public static UnityMainThreadDispatcher Instance { get; private set; }
    private readonly Queue<Action> _mainThreadActions = new Queue<Action>();

    void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }

    void Update()
    {
        lock (_mainThreadActions)
        {
            while (_mainThreadActions.Count > 0)
            {
                _mainThreadActions.Dequeue().Invoke();
            }
        }
    }

    public void Enqueue(Action action)
    {
        lock (_mainThreadActions)
        {
            _mainThreadActions.Enqueue(action);
        }
    }
}

Key Things to Remember #

• Pin Your Delegate: Always use GCHandle.Alloc to pin the callback delegate—without this, Mono's GC will eventually collect it, causing a crash.
• Respect Thread Boundaries: Never call Unity APIs (like Debug.Log, GameObject.GetComponent, etc.) from the render thread. Use the dispatcher to forward calls to the main thread.
• Clean Up Resources: In OnDestroy, free the GCHandle and tell C++ to clear the callback pointer to avoid memory leaks and dangling pointers.
• Fedora Compilation: When building your C++ plugin on Fedora 25, make sure to use a compiler compatible with your Unity version (GCC 4.8+ is usually safe) and compile for the correct architecture (64-bit, since modern Unity uses 64-bit on Linux).

内容的提问来源于stack exchange，提问作者Aze