ATL/COM 对象的方法：在 VBA 中为 excel 调用它与在 c# 中调用它

【问题标题】：Method of a ATL/COM object : calling it in VBA for excel versus calling it in c#ATL/COM 对象的方法：在 VBA 中为 excel 调用它与在 c# 中调用它
【发布时间】：2014-12-17 03:06:33
【问题描述】：

我创建了一个带有方法 (IDL) 的 ATL/COM 类：

[id(4)] HRESULT MULT3(double lCoeff, [in, out] VARIANT* pVarInOut);

它接受 pVarInOut，检查它是否是一个系数为实数的数组，并通过将它们全部乘以 lCoeff 来更新它的所有系数。

1) 当我以下列方式从 VBA for excel 调用此方法时：

Dim OneArrayIn As Variant
OneArrayIn = ws.Range("OneArrayIn")
Call Obj.MULT3(2#,OneArrayIn)
ws.Range("OneArrayOut").Offset(0, 0).Value2 = OneArrayOut

一切正常：OneArrayIn 确实已更新，其中包含预期值。

2) 当我以以下方式从 c# 调用此方法时：

MyVARIANT_TESTLib.TheATLObject TheATLObj = new MyVARIANT_TESTLib.TheATLObject();
double TheDouble = 2.0;
object[,] TheMatrix = { { -3.0, 3.0, 2.0, 1.0 } };
TheATLObj.MULT(TheDouble, TheMatrix);

有一个问题：TheMatrix 根本没有改变，好像 TheMatrix 没有像预期的那样通过“引用”传递......即使它在 MULT3 中被声明为 [in, out] IDL，带有指向 VARIANT* 的指针。

为了完整起见，我在这里给出 MULT3 的代码：

STDMETHODIMP CTheATLObject::MULT3(double lCoeff, /*[in, out]*/ VARIANT* pVarInOut)
{
    THEVARIANT pMyVarInOut = THEVARIANT(pVarInOut);
    long lNbLines = pMyVarInOut.GETNBLINES();
    long lNbColumns = pMyVarInOut.GETNBCOLS();
    ATL::CComVariant vTMPInOut;
    try
    {
        for (long i = 0; i < lNbLines; ++i)
        {
            for (long j = 0; j < lNbColumns; ++j)
            {
                pMyVarInOut.GET(i, j, vTMPInOut);
                if (vTMPInOut.vt != VT_R8)
                {
                    return E_FAIL;
                }
                else
                {
                    vTMPInOut.dblVal = vTMPInOut.dblVal * lCoeff;
                    pMyVarInOut.FILL(i, j, vTMPInOut, vTMPInOut.vt);
                }
            }
        }
        pMyVarInOut.ATTACH(pVarInOut);
        return S_OK;
    }
    catch (...) // for now
    {

    }
    return S_OK;
}

这是基于 VARIANT 包装类 THEVARIANT，在头文件 中定义如下（请注意，我已更新 FILL 方法以使其引用 ATL::CComVariant，因为此 ATL:: CComVariant 之前是按值传递的）：

#pragma once
#include <atlcomcli.h>
#include "atlsafe.h"
#include <vector>


class THEVARIANT
{
    private:

        ATL::CComVariant vTMP;
        ATL::CComSafeArray<VARIANT> *pSA;
        ATL::CComSafeArrayBound plDIM[2];
        long plINDEX[2];
        bool bIS_INIT;
        long lNBLINES;
        long lNBCOLUMNS;

    public:
        THEVARIANT(void);
        THEVARIANT(VARIANT * pVARIANT_IN);
        THEVARIANT(double * pdARRAY_IN, long NBLINES, long NBCOLUMNS);
        THEVARIANT(std::vector<double>& pdARRAY_IN, long NBLINES, long NBCOLUMNS);
        THEVARIANT(std::vector<int>& pdARRAY_IN, long NBLINES, long NBCOLUMNS);
        THEVARIANT(const THEVARIANT& MyV_COPY);
        ~THEVARIANT(void);
        void SET_LDIMENSIONS(long NBLINES, long NBCOLUMNS);
        void FILL(long lLINE, long lCOL, ATL::CComVariant & VARIANT_IN, VARTYPE VARIANT_TYPE);
        void ATTACH(VARIANT * pVARIANT_OUT);
        void GET(long lLINE, long lCOL, ATL::CComVariant& VARIANT_OUT);
        long GETNBCOLS( void ) const;
        long GETNBLINES( void ) const;
};

并在cpp文件中实现如下：

#include "StdAfx.h"
#include "THEVARIANT.h"
#include <comutil.h>
#include <atlconv.h>
#include <comdef.h>

#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>

#ifdef _DEBUG
#define DEBUG_NEW new(_NORMAL_BLOCK,__FILE__,__LINE__)
#define new DEBUG_NEW
#endif

THEVARIANT::THEVARIANT(void)
{
    pSA = NULL;
    bIS_INIT = false;
}

THEVARIANT::THEVARIANT(VARIANT * pVARIANT_IN)
{
    pSA = NULL;
    if ( V_VT(pVARIANT_IN) == VT_DISPATCH )
    {
        unsigned int uiArgErr;
        DISPID dispidValue;
        LPOLESTR XName = L"Value";
        pVARIANT_IN->pdispVal->GetIDsOfNames(IID_NULL, &XName, 1, LOCALE_SYSTEM_DEFAULT, &dispidValue);
        VARIANT * pVARIANT_IN_EXTENSION = new VARIANT();
        VariantInit(pVARIANT_IN_EXTENSION);
        DISPPARAMS dispparams;
        dispparams.cArgs = 0;
        dispparams.cNamedArgs = 0;
        EXCEPINFO exception;
        pVARIANT_IN->pdispVal->Invoke(dispidValue, IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYGET, &dispparams, pVARIANT_IN_EXTENSION, &exception, &uiArgErr);
        if( V_VT(pVARIANT_IN_EXTENSION) & VT_ARRAY )
        {
            if(pVARIANT_IN_EXTENSION->parray->cDims == 2)
            {
                plDIM[0].SetLowerBound(pVARIANT_IN_EXTENSION->parray->rgsabound[0].lLbound);
                plDIM[0].SetCount(pVARIANT_IN_EXTENSION->parray->rgsabound[0].cElements);
                plDIM[1].SetLowerBound(pVARIANT_IN_EXTENSION->parray->rgsabound[1].lLbound);
                plDIM[1].SetCount(pVARIANT_IN_EXTENSION->parray->rgsabound[1].cElements);
                pSA = new ATL::CComSafeArray<VARIANT>(plDIM,2);
                pSA->CopyFrom(pVARIANT_IN_EXTENSION->parray);
                lNBLINES = plDIM[1].cElements;
                lNBCOLUMNS = plDIM[0].cElements;
                bIS_INIT = true;
            }
            else if(pVARIANT_IN_EXTENSION->parray->cDims == 1)
            {
                plDIM[0].SetLowerBound(pVARIANT_IN_EXTENSION->parray->rgsabound[0].lLbound);
                plDIM[0].SetCount(pVARIANT_IN_EXTENSION->parray->rgsabound[0].cElements);
                plDIM[1].SetLowerBound(pVARIANT_IN_EXTENSION->parray->rgsabound[0].lLbound);
                plDIM[1].SetCount(1);
                pSA = new ATL::CComSafeArray<VARIANT>(plDIM,2);
                pSA->CopyFrom(pVARIANT_IN_EXTENSION->parray);
                lNBLINES = plDIM[1].cElements;
                lNBCOLUMNS = plDIM[0].cElements;
                bIS_INIT = true;
            }
        }
        else
        {
            plDIM[0].SetLowerBound(0);
            plDIM[0].SetCount(1);
            plDIM[1].SetLowerBound(0);
            plDIM[1].SetCount(1);
            pSA = new ATL::CComSafeArray<VARIANT>(plDIM,2);
            ATL::CComVariant varArrayWrapper(*pVARIANT_IN_EXTENSION);
            plINDEX[0]=0;
            plINDEX[1]=0;
            HRESULT hr = pSA->MultiDimSetAt(plINDEX,varArrayWrapper);
            ATLASSERT(hr == S_OK);
            lNBLINES = plDIM[1].cElements;
            lNBCOLUMNS = plDIM[0].cElements;
            bIS_INIT = true;
        }
    }
    else if( V_VT(pVARIANT_IN) & VT_ARRAY ) // this case
    {
        if(pVARIANT_IN->parray->cDims == 2)
        {
            plDIM[0].SetLowerBound(pVARIANT_IN->parray->rgsabound[0].lLbound);
            plDIM[0].SetCount(pVARIANT_IN->parray->rgsabound[0].cElements);
            plDIM[1].SetLowerBound(pVARIANT_IN->parray->rgsabound[1].lLbound);
            plDIM[1].SetCount(pVARIANT_IN->parray->rgsabound[1].cElements);
            pSA = new ATL::CComSafeArray<VARIANT>(plDIM,2);
            pSA->CopyFrom(pVARIANT_IN->parray);
            lNBLINES = plDIM[1].cElements;
            lNBCOLUMNS = plDIM[0].cElements;
            bIS_INIT = true;
        }
        else if(pVARIANT_IN->parray->cDims == 1)
        {
            plDIM[0].SetLowerBound(pVARIANT_IN->parray->rgsabound[0].lLbound);
            plDIM[0].SetCount(pVARIANT_IN->parray->rgsabound[0].cElements);
            plDIM[1].SetLowerBound(pVARIANT_IN->parray->rgsabound[0].lLbound);
            plDIM[1].SetCount(1);
            pSA = new ATL::CComSafeArray<VARIANT>(plDIM,2);
            pSA->CopyFrom(pVARIANT_IN->parray);
            lNBLINES = plDIM[1].cElements;
            lNBCOLUMNS = plDIM[0].cElements;
            bIS_INIT = true;
        }
    }
    else
    {
        plDIM[0].SetLowerBound(0);
        plDIM[0].SetCount(1);
        plDIM[1].SetLowerBound(0);
        plDIM[1].SetCount(1);
        pSA = new ATL::CComSafeArray<VARIANT>(plDIM,2);
        ATL::CComVariant varArrayWrapper(*pVARIANT_IN);
        plINDEX[0]=0;
        plINDEX[1]=0;
        HRESULT hr = pSA->MultiDimSetAt(plINDEX,varArrayWrapper);
        ATLASSERT(hr == S_OK);
        lNBLINES = plDIM[1].cElements;
        lNBCOLUMNS = plDIM[0].cElements;
        bIS_INIT = true;
    }
}

THEVARIANT::THEVARIANT(double * pdARRAY_IN, long NBLINES, long NBCOLUMNS)
{
    plDIM[0].SetLowerBound(0);
    plDIM[0].SetCount(NBLINES);
    plDIM[1].SetLowerBound(0);
    plDIM[1].SetCount(NBCOLUMNS);
    pSA = new ATL::CComSafeArray<VARIANT>(plDIM,2);
    for(int j=0; j<NBCOLUMNS; j++)
    {
        for(int i=0; i<NBLINES; i++)
        {
            vTMP = pdARRAY_IN[i+j*NBLINES];
            vTMP.vt = VT_R8;
            plINDEX[0] = i;
            plINDEX[1] = j;
            HRESULT hr = pSA->MultiDimSetAt(plINDEX,vTMP);
            ATLASSERT(hr == S_OK);
        }
    }
    lNBLINES = NBLINES;
    lNBCOLUMNS = NBCOLUMNS;
    bIS_INIT = true;
}

THEVARIANT::THEVARIANT(std::vector<double>& pdARRAY_IN, long NBLINES, long NBCOLUMNS)
{
    plDIM[0].SetLowerBound(0);
    plDIM[0].SetCount(NBLINES);
    plDIM[1].SetLowerBound(0);
    plDIM[1].SetCount(NBCOLUMNS);
    pSA = new ATL::CComSafeArray<VARIANT>(plDIM,2);
    for(int j=0; j<NBCOLUMNS; j++)
    {
        for(int i=0; i<NBLINES; i++)
        {
            vTMP = pdARRAY_IN[i+j*NBLINES];
            vTMP.vt = VT_R8;
            plINDEX[0] = i;
            plINDEX[1] = j;
            HRESULT hr = pSA->MultiDimSetAt(plINDEX,vTMP);
            ATLASSERT(hr == S_OK);
        }
    }       
    lNBLINES = NBLINES;
    lNBCOLUMNS = NBCOLUMNS;
    bIS_INIT = true;
}

THEVARIANT::THEVARIANT(std::vector<int>& pdARRAY_IN, long NBLINES, long NBCOLUMNS)
{
    plDIM[0].SetLowerBound(0);
    plDIM[0].SetCount(NBLINES);
    plDIM[1].SetLowerBound(0);
    plDIM[1].SetCount(NBCOLUMNS);
    pSA = new ATL::CComSafeArray<VARIANT>(plDIM,2);
    for(int j=0; j<NBCOLUMNS; j++)
    {
        for(int i=0; i<NBLINES; i++)
        {
            vTMP = pdARRAY_IN[i+j*NBLINES];
            vTMP.vt = VT_I4;
            plINDEX[0] = i;
            plINDEX[1] = j;
            HRESULT hr = pSA->MultiDimSetAt(plINDEX,vTMP);
            ATLASSERT(hr == S_OK);
        }
    }       
    lNBLINES = NBLINES;
    lNBCOLUMNS = NBCOLUMNS;
    bIS_INIT = true;
}

THEVARIANT::THEVARIANT(const THEVARIANT& MyV_COPY)
{
    pSA = NULL; 
    if( MyV_COPY.pSA != NULL && MyV_COPY.bIS_INIT )
    {
        plDIM[0].SetLowerBound(0);
        plDIM[0].SetCount(MyV_COPY.plDIM[0].GetLowerBound());
        plDIM[1].SetLowerBound(0);
        plDIM[1].SetCount(MyV_COPY.plDIM[1].GetLowerBound());
        pSA = new ATL::CComSafeArray<VARIANT>(plDIM,2);
        pSA->CopyFrom(*MyV_COPY.pSA);
        lNBLINES = MyV_COPY.lNBLINES;
        lNBCOLUMNS = MyV_COPY.lNBCOLUMNS;
        bIS_INIT = true;
    }
}

THEVARIANT::~THEVARIANT(void)
{
    delete pSA;
    pSA = NULL;
    bIS_INIT = false;
}

void THEVARIANT::SET_LDIMENSIONS(long NBLINES, long NBCOLUMNS)
{
    if(!bIS_INIT)
    {
        plDIM[0].SetLowerBound(0);
        plDIM[0].SetCount(NBLINES);
        plDIM[1].SetLowerBound(0);
        plDIM[1].SetCount(NBCOLUMNS);
        pSA = new ATL::CComSafeArray<VARIANT>(plDIM,2);
        lNBLINES = NBLINES;
        lNBCOLUMNS = NBCOLUMNS;
        bIS_INIT=true;
    }
}

void THEVARIANT::FILL(long lLINE, long lCOL, ATL::CComVariant & VARIANT_IN, VARTYPE VARIANT_TYPE)
{
    if(bIS_INIT)
    {
        vTMP = VARIANT_IN;
        vTMP.vt = VARIANT_TYPE;
        plINDEX[0] = lLINE;
        plINDEX[1] = lCOL;
        HRESULT hr = pSA->MultiDimSetAt(plINDEX,vTMP);
        ATLASSERT(hr == S_OK);
    }
}

void THEVARIANT::ATTACH(VARIANT * pVARIANT_OUT)
{
    if(bIS_INIT)
    {
        ATL::CComVariant varArrayWrapper(*pSA);
        varArrayWrapper.Detach(pVARIANT_OUT);

    }
}

void THEVARIANT::GET(long lLINE, long lCOL, ATL::CComVariant& VARIANT_OUT)
{
    plINDEX[0] = lLINE+plDIM[1].lLbound;            //be careful with the order
    plINDEX[1] = lCOL+plDIM[0].lLbound;
    HRESULT hr = pSA->MultiDimGetAt(plINDEX,VARIANT_OUT);
    ATLASSERT(hr == S_OK);
}

long THEVARIANT::GETNBCOLS( void ) const
{
    return lNBCOLUMNS ;
}

long THEVARIANT::GETNBLINES( void ) const
{
    return lNBLINES ;
}

也许这个变体包装类 THEVARIANT 有错误，但我测试过，我不这么认为。

【问题讨论】：

  • 不确定，但我认为您可能需要TheATLObj.MULT(TheDouble, ref TheMatrix);。 ref 是 [in, out] 的 c# 等价物。
  • 这是一个错误：“'MyVARIANT_TESTLib.ITheATLObject.MULT3(double, ref object)' 的最佳重载方法匹配有一些无效参数”。实际上，如果你进入 c# idl，你会看到函数签名中的所有 [in, out] variant * 元素都被标记为 ref 对象。
  • 您违反了 [out]，您从未在 C++ 代码中真正更新调用者的 VARIANT。在 VBA 案例中不明显，因为它通过了 IRange* 并且您没有任何理由生成新的 IRange。但是在 C# 案例中失败了。您必须创建一个包装安全数组的新 VARIANT 并将其分配给 *pVarInOut。需要进行重大更改。
  • 当你说我从不在你的 C++ 代码中更新调用者的 VARIANT 时，你的意思是 pVarInOut，对吧？我不明白，因为我从中构造了一个 THEVARIANT pMyVarInOut，通过 FILL 方法修改了这个（现在正确编码，通过引用传递 ATL::CComVariant VARIANT_IN 而不是通过值），然后我更新pVarInOut 感谢 ATTACH 方法。这样 C++ 确实会修改调用者的 VARIANT，不是吗？
  • （在 ATL/COM 对象的 MULT3 方法的return S_OK; 行，pVarInOut 填充了正确的值。）

标签： c# c++ vba com variant


【解决方案1】：

错误出现在 c# 代码中。对 ATL/COM 方法的良好调用是：

MyVARIANT_TESTLib.TheATLObject TheATLObj = new MyVARIANT_TESTLib.TheATLObject();
double TheDouble = 2.0;
object[,] TheMatrix = { { -3.0, 3.0, 2.0, 1.0 } };
object thevariant = new object();
thevariant = TheMatrix ;
TheATLObj.MULT(TheDouble, ref thevariant); // ref is crucial here

然后，变量确实被更新了，它的所有系数都乘以 2.0。

【讨论】：

  • 还有一个问题：声明object[,] TheMatrix = { { -3.0, 3.0, 2.0, 1.0 } }; 然后object thevariant = new object(); thevariant = TheMatrix ; 真的很难看。我们怎样做才能避免这种情况，并且能够直接通过 TheMatrix ？
  • 好的，object TheMatrix = new object[,] { { -3.0, 3.0, 2.0, 1.0 } }; ; ;使它起作用。我根本不是 c# 方面的专家，但我认为 object 是通用类型是 c#，所以当我将 object[,] 传递给 toto 时，即使 toto 期望一个对象，“c#”也可以“将它正确地投射/看到”到正确的对象，然后完成这项工作。
猜你喜欢
  • 2012-03-10
  • 2017-09-10
  • 1970-01-01
  • 2014-09-20
  • 1970-01-01
  • 2013-05-16
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode