Method InvokeMethod

Source/Engine/Scripting/BinaryModule.cpp:1225–1370

}

bool ManagedBinaryModule::InvokeMethod(void* method, const Variant& instance, Span<Variant> paramValues, Variant& result)
{
#if USE_CSHARP
    const auto mMethod = (MMethod*)method;
    const int32 parametersCount = mMethod->GetParametersCount();;
    if (paramValues.Length() != parametersCount)
    {
        LOG(Error, "Failed to call method '{0}.{1}' (args count: {2}) with invalid parameters amount ({3})", String(mMethod->GetParentClass()->GetFullName()), String(mMethod->GetName()), parametersCount, paramValues.Length());
        return true;
    }

    // Get instance object
    void* mInstance = nullptr;
    const bool withInterfaces = !mMethod->IsStatic() && mMethod->GetParentClass()->IsInterface();
    if (!mMethod->IsStatic())
    {
        // Box instance into C# object (and validate the type)
        MObject* instanceObject = MUtils::BoxVariant(instance);
        if (!instanceObject)
        {
            LOG(Error, "Failed to call method '{0}.{1}' (args count: {2}) without object instance", String(mMethod->GetParentClass()->GetFullName()), String(mMethod->GetName()), parametersCount);
            return true;
        }
        const MClass* instanceObjectClass = MCore::Object::GetClass(instanceObject);
        if (!instanceObjectClass->IsSubClassOf(mMethod->GetParentClass(), withInterfaces))
        {
            LOG(Error, "Failed to call method '{0}.{1}' (args count: {2}) with invalid object instance of type '{3}'", String(mMethod->GetParentClass()->GetFullName()), String(mMethod->GetName()), parametersCount, String(MUtils::GetClassFullname(instanceObject)));
            return true;
        }

#if USE_NETCORE
        mInstance = instanceObject;
#else
        // For value-types instance is the actual boxed object data, not te object itself
        mInstance = instanceObjectClass->IsValueType() ? MCore::Object::Unbox(instanceObject) : instanceObject;
#endif
    }

    // Marshal parameters
    void** params = (void**)alloca(parametersCount * sizeof(void*));
    void** outParams = nullptr;
    bool failed = false;
    bool hasOutParams = false;
    for (int32 paramIdx = 0; paramIdx < parametersCount; paramIdx++)
    {
        Variant& paramValue = paramValues[paramIdx];
        const bool isOut = mMethod->GetParameterIsOut(paramIdx);
        hasOutParams |= isOut;

        // Marshal parameter for managed method
        MType* paramType = mMethod->GetParameterType(paramIdx);
        params[paramIdx] = MUtils::VariantToManagedArgPtr(paramValue, paramType, failed);
        if (failed)
        {
            LOG(Error, "Failed to marshal parameter {5}:{4} of method '{0}.{1}' (args count: {2}), value type: {6}, value: {3}", String(mMethod->GetParentClass()->GetFullName()), String(mMethod->GetName()), parametersCount, paramValue, MCore::Type::ToString(paramType), paramIdx, paramValue.Type);
            return true;
        }
        if (isOut && MCore::Type::IsReference(paramType) && MCore::Type::GetType(paramType) == MTypes::Object)