Implementieren callback-C# - Funktionen für C++ - DLL

Als von Visual Studio 2013 mindestens, ist ein sicherer Weg, um pass Rückrufe von C# zu C++ und C++ speichern Sie Sie und rufen Sie asynchron später aus nicht verwaltetem code. Was Sie tun können, ist, erstellen Sie eine verwaltete C++/CX-Klasse (z.B. mit dem Namen "CallbackManager") zu halten, die callback-Delegaten Referenzen in einer Karte kodiert, aus einer enum-Wert für jeden. Dann Ihre nicht verwalteten code abrufen kann ein managed delegate-Referenz von managed C++/CX CallbackManager Klasse über die Delegierten der zugehörigen enum-Wert. So dass Sie nicht haben, zu speichern raw-Funktion Zeiger und so müssen Sie nicht sorgen zu machen über die Stellvertretung, die verschoben oder garbage Collection: es bleibt in der verwalteten Heaps über den gesamten Lebenszyklus.

Auf der C++ Seite in CallbacksManager.h:

#include <unordered_map>
#include <mutex>

using namespace Platform;

namespace CPPCallbacks
{
    //define callback IDs; this is what unmanaged C++ code will pass to the managed CallbacksManager class to retrieve a delegate instance
    public enum class CXCallbackType
    {
        cbtLogMessage,
        cbtGetValueForSetting
        //TODO: add additional enum values as you add more callbacks
    }

    //defines the delegate signatures for our callbacks; these are visible to the C# side as well
    public delegate void LogMessageDelegate(int level, String^ message);
    public delegate bool GetValueForSettingDelegate(String^ settingName, String^* settingValueOut);
    //TODO: define additional callbacks here as you need them

     //Singleton WinRT class to manage C# callbacks; since this class is marked 'public' it is consumable from C# as well
    public ref class CXCallbacksManager sealed
    {
    private:
        CXCallbacksManager() { }  //this is private to prevent incorrect instantiation

    public:
        //public methods and properties are all consumable by C# as well
        virtual ~CXCallbacksManager() { }

        static property CXCallbacksManager^ Instance
        {
            CXCallbacksManager^ get();
        }

        bool UnregisterCallback(CXCallbackType cbType);
        void UnregisterAllCallbacks();
        Delegate^ GetCallback(CXCallbackType cbType);

        //define callback registration methods
        RegisterLogMessageCallback(LogMessageDelegate^ cb) { RegisterCallback(CXCallbackType::cbtLogMessage, cb); }
        RegisterGetValueForSettingCallback(GetValueForSettingDelegate^ cb) { RegisterCallback(CXCallbackType::GetValueForSetting, cb); }
        //TODO: define additional callback registration methods as you add more callbacks

    private:
        void RegisterCallback(CXCallbackType cbType, Delegate^ rCallbackFunc);

        typedef unordered_map<CXCallbackType, Delegate^> CALLBACK_MAP;
        typedef pair<CXCallbackType, Delegate^> CBType_Delegate_Pair;

        //Note: IntelliSense errors shown for static data is a Visual Studio IntellSense bug; the code below builds fine
        //See http://social.msdn.microsoft.com/Forums/windowsapps/en-US/b5d43215-459a-41d6-a85e-99e3c30a162e/about-static-member-of-ref-class?forum=winappswithnativecode
        static mutex s_singletonMutex;
        static CXCallbacksManager^ s_rInstance;

        mutex m_callbackMapMutex;
        CALLBACK_MAP m_callbacksMap;   //key=CallbackType, value = C# delegate (function) pointer
    };
}  

In CallbacksManager.cpp wir implementieren von managed C++/CX Klasse zugreifen, die von C# und unsere unmanaged C++ - code:

#include <assert.h>
#include "CXCallbacksManager.h"

using namespace Platform;

namespace CPPCallbacks
{
    //define static class data
    CXCallbacksManager^ CXCallbacksManager::s_rInstance;
    mutex CXCallbacksManager::s_singletonMutex;

    //Returns our singleton instance; this method is thread-safe
    CXCallbacksManager^ CXCallbacksManager::Instance::get()
    {
        s_singletonMutex.lock();

        if (s_rInstance == nullptr)
            s_rInstance = ref new CXCallbacksManager();  //this lives until the application terminates

        s_singletonMutex.unlock();
        return s_rInstance;
    }

    //Register a C# callback; this method is thread-safe
    void CXCallbacksManager::RegisterCallback(const CXCallbackType cbType, Delegate^ rCallbackFunc)
    {
        _ASSERTE(rCallbackFunc);

        m_callbackMapMutex.lock();
        m_callbacksMap.insert(CBType_Delegate_Pair(cbType, rCallbackFunc)); 
        m_callbackMapMutex.unlock();
    }

    //Unregister a C# callback; this method is thread-safe
    //Returns: true on success, false if no callback was registered for callbackType
    bool CXCallbacksManager::UnregisterCallback(const CXCallbackType cbType)
    {
        m_callbackMapMutex.lock();
        const bool bRemoved = (m_callbacksMap.erase(cbType) > 0);
        m_callbackMapMutex.unlock();

        return bRemoved;
    }

    //Unregister all callbacks; this method is thread-safe
    void CXCallbacksManager::UnregisterAllCallbacks()
    {
        //must lock the map before iterating across it
        //Also, we can't change the contents of the map as we iterate across it, so we have to build a vector of all callback types in the map first.
        vector<CXCallbackType> allCallbacksList;
        m_callbackMapMutex.lock();

        for (CALLBACK_MAP::const_iterator it = m_callbacksMap.begin(); it != m_callbacksMap.end(); it++)
            allCallbacksList.push_back(it->first);

        for (unsigned int i = 0; i < allCallbacksList.size(); i++)
        {
            CALLBACK_MAP::const_iterator it = m_callbacksMap.find(allCallbacksList[i]);
            if (it != m_callbacksMap.end())     //sanity check; should always succeed
                UnregisterCallback(it->first);
        }
        m_callbackMapMutex.unlock();
    }

    //Retrieve a registered C# callback; returns NULL if no callback registered for type
    Delegate^ CXCallbacksManager::GetCallback(const CXCallbackType cbType)
    {
        Delegate^ rCallbackFunc = nullptr;
        m_callbackMapMutex.lock();

        CALLBACK_MAP::const_iterator it = m_callbacksMap.find(cbType);
        if (it != m_callbacksMap.end())
            rCallbackFunc = it->second;
        else
            _ASSERTE(false);    //should never happen! This means the caller either forgot to register a callback for this cbType or already unregistered the callback for this cbType.

        m_callbackMapMutex.unlock();
        return rCallbackFunc;
    }
}

Die Delegaten-Instanzen gespeichert bleiben, in dem verwalteten heap durch unsere CXCallbacksManager Klasse, so, jetzt ist es einfach und sicher zu speichern callbacks an die C++ Seite für nicht verwalteten code aufrufen, später asynchron. Hier ist der C# - Seite registrieren zwei Rückrufe:

using CPPCallbacks;

namespace SomeAppName
{
    internal static class Callbacks
    {
        //invoked during app startup to register callbacks for unmanaged C++ code to invoke asynchronously
        internal static void RegisterCallbacks()
        {
            CPPCallbacks.CXCallbacksManager.Instance.RegisterLogMessageCallback(new LogMessageDelegate(LogMessageDelegateImpl));
            CPPCallbacks.CXCallbacksManager.Instance.RegisterGetValueForSettingCallback(new GetValueForSettingDelegate(GetValueForSettingDelegateImpl));
            //TODO: register additional callbacks as you add them
        }

        //-----------------------------------------------------------------
        //Callback delegate implementation methods are below; these are invoked by C++
        //Although these example implementations are in a static class, you could also pass delegate instances created 
        //from inside a non-static class, which would maintain their state just like any other instance method (i.e., they have a 'this' object).
        //-----------------------------------------------------------------

        private static void LogMessageDelegateImpl(int level, string message)
        {
            //This next line is shown for example purposes, but at this point you can do whatever you want because 
            //you are running in a normal C# delegate context.
            Logger.WriteLine(level, message);
        }

        private static bool GetValueForSettingDelegateImpl(String settingName, out String settingValueOut)
        {
            //This next line is shown for example purposes, but at this point you can do whatever you want because 
            //you are running in a normal C# delegate context.
            return Utils.RetrieveEncryptedSetting(settingName, out settingValueOut);   
        }
    };
}

Schließlich, hier ist gewusst wie: aufrufen von Ihr registrierten C# Rückrufe von nicht verwaltetem C++ - code:

#include <assert.h>
#include <atlstr.h>   //for CStringW
#include "CXCallbacksManager.h"

using namespace CPPCallbacks;

//this is an unmanaged C++ function in the same project as our CXCallbacksManager class
void LogMessage(LogLevel level, const wchar_t *pMsg)
{
    _ASSERTE(msg);

    auto rCallback = static_cast<LogMessageDelegate^>(CXCallbacksManager::Instance->GetCallback(CXCallbackType::cbtLogMessage));
    _ASSERTE(rCallback);
    rCallback(level, ref new String(pMsg));   //invokes C# method
}

//this is an unmanaged C++ function in the same project as our CXCallbacksManager class
//Sets settingValue to the value retrieved from C# for pSettingName
//Returns: true if the value existed and was set, false otherwise
bool GetValueForSetting(const wchar_t *pSettingName, CStringW &settingValue)
{
    bool bRetCode = false;

    auto rCallback = static_cast<GetValueForSettingDelegate^>(CXCallbacksManager::Instance->GetCallback(CXCallbackType::cbtGetValueForSetting));
    _ASSERTE(rCallback);
    if (rCallback)    //sanity check; should never be null
    {
        String^ settingValueOut;
        bRetCode = rCallback(ref new String(pSettingName), &settingValueOut);

        //store the retrieved setting value to our unmanaged C++ CStringW output parameter
        settingValue = settingValueOut->Data(); 
    }
    return bRetCode;
}

Es funktioniert, weil, obwohl Sie nicht speichern kann ein managed delegate-Referenz als member-variable innerhalb einer unmanaged Klasse, können Sie immer noch abrufen und aufrufen einer verwalteten delegieren von nicht verwaltetem code, die, was die beiden oben genannten native C++ - Methoden zu tun.

Gibt es keinen Punkt, um mit C++/cli.

Und hier ist ein reales Beispiel von meinem Projekt.

public ImageSurface(byte[] pngData)
    : base(ConstructImageSurfaceFromPngData(pngData), true)
{
    offset = 0;
}

private static int offset;

private static IntPtr ConstructImageSurfaceFromPngData(byte[] pngData)
{
    NativeMethods.cairo_read_func_t func = delegate(IntPtr closure, IntPtr out_data, int length)
    {
        Marshal.Copy(pngData, offset, out_data, length);
        offset += length;
        return Status.Success;
    };
    return NativeMethods.cairo_image_surface_create_from_png_stream(func, IntPtr.Zero);
}

Für die übertragung von PNG-Daten von C# auf die native cairo-API.

Können Sie sehen, wie die C-Funktion einen Zeiger cairo_read_func_t ist in C# implementiert und dann verwendet als callback für cairo_image_surface_create_from_png_stream.

Hier ist ein ähnliches Beispiel.