Лямбда-выражения в виде делегатов / обработчиков событий CLR (.NET) в Visual C ++ 2010

Ниже представлено мое решение, позволяющее обернуть лямбды (а также любые объекты функций - т.е. все, на чем можно вызвать operator()) в делегаты. Он имеет некоторые ограничения - в частности, он не поддерживает делегаты с параметрами отслеживания ссылок (% в C++/CLI, ref/out в C#); и он имеет верхний предел на количество параметров, которые может принимать делегат (поскольку VC++2010 не поддерживает шаблоны vararg) - хотя код может быть тривиально скорректирован для поддержки любого количества параметров.

#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);
}

Пример использования:

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

Хотя технически это делает то, что вы хотите, практическое применение несколько ограничено из-за того, что ламбды C++0x расширяются в простые классы, а не ref или value. Поскольку в C++/CLI простые классы не могут содержать управляемые типы (т.е. нет членов типа object handle, нет членов типа tracking reference и нет членов типа value class), это означает, что лямбды также не могут захватывать переменные этих типов. Для отслеживающих ссылок нет никакого обходного пути, о котором я знаю. Для value class вы можете взять неуправляемый указатель на него (pin_ptr, если нужно) и захватить его.

Для объектных дескрипторов можно хранить их в gcroot и перехватывать - но это сильно сказывается на производительности - в моих тестах доступ к члену через gcroot примерно в 40 раз медленнее, чем при использовании обычного объектного дескриптора. В абсолютном выражении это не так много для одного вызова, но для чего-то, что вызывается многократно в цикле - скажем, для большинства алгоритмов LINQ - это было бы убийственно. Но обратите внимание, что это применимо только тогда, когда вам нужно перехватить хэндл в лямбде! Если вы просто используете ее для написания предиката в строке или для обновления счетчика, она будет работать отлично.

На этой странице есть несколько примеров лямбда-выражения для C ++:

http://msdn.microsoft.com/en-us/library/dd293608%28v=VS.100%29.aspx

Усовершенствования Microsoft VS2010 C ++ выглядят так, как будто они действительно реализуют C Спецификация лямбда ++ 0x . Как таковые, они являются полностью неуправляемыми и относятся к типу лямбда .

В документации Microsoft нет ничего, что намекало бы на возможность использования лямбда-выражений C ++ в качестве лямбда-выражений CLR. На этом этапе я должен сказать, что вы не можете использовать лямбды C ++ в качестве обработчиков для управляемых делегатов.