¿Es posible calcular la referencia parámetros árbitro en SAFEARRAY

Question

Este es mi método # servidor de C:

public void Exec(out int status, string output) 
{ 
    status = 3; 
    Console.WriteLine("Exec({0}, ...)", status); 

    output = string.Format("Hello from .NET {0}", DateTime.Now); 
    Console.WriteLine("Exec(..., {0})", output);   
} 

Mi C++ cliente es la creación y llamar a este método. Esto funciona bien, pero las variables de estado y salida no parecen estar encadenadas. Es como si les pasaran valor en lugar de referencia.

Aquí está mi código de cliente:

InitCLR(); 

LONG index = 0; 

LONG i1 = 12; // just some number for testing 
BSTR s1 = SysAllocString(L"Hello world"); 

SAFEARRAY* args = NULL; 
CHECK_HRESULT(SafeArrayAllocDescriptor(1, &args)); 

args->cbElements = sizeof(VARIANT); 
args->rgsabound[0].lLbound = 0; 
args->rgsabound[0].cElements = 2; 

CHECK_HRESULT(SafeArrayAllocData(args)); 

// byref not working for in/out param 
VARIANT arg1; 
VariantInit(&arg1); 
V_I4REF(&arg1) = &i1; 
V_VT(&arg1) = VT_I4 | VT_BYREF; 

// byref not working 
VARIANT arg2; 
VariantInit(&arg2); 
V_BSTR(&arg2) = SysAllocString(L"Hello world"); 
V_VT(&arg2) = VT_BSTR; 

index = 0; 
CHECK_HRESULT(SafeArrayPutElement(args, &index, &arg1)); 

index = 1; 
CHECK_HRESULT(SafeArrayPutElement(args, &index, &arg2)); 

int bindingFlags = mscorlib::BindingFlags_InvokeMethod | 
    mscorlib::BindingFlags_Instance | 
    mscorlib::BindingFlags_Public; 

VARIANT retval; 
VariantInit(&retval); 

bstr_t methodName("Exec"); 
HRESULT hRes = Type->InvokeMember_3(
    methodName, 
    static_cast<mscorlib::BindingFlags>(bindingFlags), 
    NULL, // binder * 
    Instance, 
    args, 
    &retval); 

_tprintf(TEXT("Exec() == 0x%x\n"), hRes); 

_tprintf(TEXT("i1=%d\n"), i1); 

Puede alguien proporcionar asistencia en el establecimiento de los argumentos SAFEARRAY de manera que los parametros 'ref' se copian a salir?

Answer 1

que puede no saber la respuesta completa, pero detectar dos cosas en el código:

cadena no se pasa correctamente por referencia

cadenas en C# son objetos de referencia inmutables. Esto significa que las referencias a ellos se pasan (por valor), y una vez que se crea una cadena, no puede modificarla. Si modifica el valor de cadena, realmente crea una nueva cadena y cambia la referencia local a ella.

Hay una gran explicación al respecto here

Por lo tanto, es necesario cambiar la definición de su función en C# para algo como esto:

public void Exec(out int status, out string output) 
{ 
    ... 
} 

que puedes usar ref lugar de salir

Parece que inicializar los valores de argumento antes de La función C# no llama a la función misma.

Por lo tanto, debería utilizar ref en lugar de out palabra clave;

public void Exec(ref int status, ref string output) 
{ 
    ... 
}