Lambda-Ausdrücke als CLR (.NET) die Delegierten / event-Handler in Visual C++ 2010

Folgende ist meine Lösung, die es uns ermöglicht zu wickeln lambdas (wie auch alle Funktions-Objekte - also alles, was auf die operator() genannt werden kann) in die Delegiertenversammlung. Es hat einige Grenzen - genauer gesagt, Sie unterstützt jedoch nicht die Delegierten mit der tracking-Referenz Parameter (% in C++/CLI, ref/out in C#); und es gibt eine Obergrenze für die Anzahl der Parameter kann die Stellvertretung nehmen (weil VC++2010 bietet keine Unterstützung vararg-Vorlagen), obwohl der code trivial angepasst zu unterstützen, um so viele wie Sie möchten.

#pragma once

#include <new>
#include <type_traits>

namespace detail
{
    struct return_type_helper
    {
    private:

        template<class D>
        struct dependent_false { enum { value = false }; };

        template <class D>
        struct illegal_delegate_type
        {
            static_assert(dependent_false<D>::value, "Delegates with more than 2 parameters, or with parameters of tracking reference types (T%), are not supported.");
        };

        struct anything
        {
            template<class T>
            operator T() const;
        };

    public:

        template<class D>
        static decltype(static_cast<D^>(nullptr)()) dummy(int(*)[1]);

        template<class D>
        static decltype(static_cast<D^>(nullptr)(anything())) dummy(int(*)[2]);

        template<class D>
        static decltype(static_cast<D^>(nullptr)(anything(), anything())) dummy(int(*)[3]);

        template <class D>
        static illegal_delegate_type<D> dummy(...);
    };


    template<class Func, class Aligner = char, bool Match = (std::tr1::alignment_of<Func>::value == std::tr1::alignment_of<Aligner>::value)>
    struct aligner
    {
        static_assert(Match, "Function object has unsupported alignment");
    };

    template<class Func, class Aligner>
    struct aligner<Func, Aligner, true>
    {
        typedef Aligner type;
    };

    template<class Func>
    struct aligner<Func, char, false> : aligner<Func, short>
    {
    };

    template<class Func>
    struct aligner<Func, short, false> : aligner<Func, int>
    {
    };

    template<class Func>
    struct aligner<Func, int, false> : aligner<Func, long>
    {
    };

    template<class Func>
    struct aligner<Func, long, false> : aligner<Func, long long>
    {
    };

    template<class Func>
    struct aligner<Func, long long, false> : aligner<Func, double>
    {
    };

    template<class Func>
    struct aligner<Func, double, false> : aligner<Func, void*>
    {
    };


    template<class F>
    ref class lambda_wrapper
    {
    public:

        lambda_wrapper(const F& f)
        {
            pin_ptr<F> pf = (interior_ptr<F>)&f_storage;
            new(pf) F(f);
        }

        ~lambda_wrapper()
        {
            pin_ptr<F> pf = (interior_ptr<F>)&f_storage;
            pf->~F();
        }

        template <class D>
        operator D^ ()
        {
            D^ d = nullptr;
            return gcnew D(this, &lambda_wrapper<F>::invoke<decltype(return_type_helper::dummy<D>(0))>);
        }

    private:

        template<class T>
        [System::Runtime::InteropServices::StructLayout(System::Runtime::InteropServices::LayoutKind::Sequential, Size = sizeof(T))]
        value struct embedded_storage
        {
        private:
            typename aligner<T>::type dummy;
        };


        embedded_storage<F> f_storage;

        template<class R>
        R invoke()
        {
            pin_ptr<F> pf = (interior_ptr<F>)&f_storage;
            return (*pf)();
        }

        template<class R, class A1>
        R invoke(A1 a1)
        {
            pin_ptr<F> pf = (interior_ptr<F>)&f_storage;
            return (*pf)(a1);
        }

        template<class R, class A1, class A2>
        R invoke(A1 a1, A2 a2)
        {
            pin_ptr<F> pf = (interior_ptr<F>)&f_storage;
            return (*pf)(a1, a2);
        }
    };
}

template<class F>
detail::lambda_wrapper<F>^ make_delegate(F f)
{
    return gcnew detail::lambda_wrapper<F>(f);
}

Beispiel für die Nutzung:

Func<int, String^, int>^ f2 = make_delegate([&](int x, String^ y) -> int {
    Console::WriteLine("Func {0} {1}", x, y);
    return 2;
});

Während dies technisch funktioniert, was Sie wollen, die praktische Anwendungen sind etwas begrenzt aufgrund der Tatsache, dass C++0x-Lambda-Ausdrücke erweitert werden, in einfachen Klassen, nicht ref oder value lieben. Da plain Klassen enthalten, nicht verwalteten Typen in C++/CLI (also keine Mitglieder von Objekt-handle-Typ, keine Mitglieder der tracking-Referenz-Typ, und die keine Mitglieder der value class geben), das bedeutet, dass Lambda-Ausdrücke können nicht erfassen alle Variablen dieser Typen, entweder. Es gibt keine Problemumgehung, ich bin mir bewusst, der für die Verfolgung von Referenzen. Für value class Sie können einen nicht verwalteten Zeiger darauf (pin_ptr falls erforderlich), und erfassen, dass.

Für die Objekt-handles, Sie können speichern Sie in gcroot<T> festhalten, dass - aber es gibt schwerwiegende Auswirkungen auf die Leistung - in meinen tests, die Zugriff auf ein Mitglied über gcroot<T> ist etwa 40 mal langsamer als wenn man es mit einem einfachen Objekt-handle. Es ist eigentlich nicht viel in absoluten Maßnahme für einen einzelnen Anruf, aber für etwas, das nennt sich wiederholt in einer Schleife, die sagen, die meisten LINQ-algorithmen - es wäre ein killer. Beachten Sie aber, dass dies nur gilt, wenn Sie brauchen, um zu erfassen, ein Griff in die lambda! Wenn Sie einfach verwenden, um schreiben Sie ein Prädikat, das inline oder zu aktualisieren, einen Zähler, dann funktioniert es einwandfrei.