Piszę oprogramowanie w języku c #, które musi wywoływać wiele razy, a przez wiele wątków funkcję w niezarządzanej bibliotece c ++.

Mam taki plik C ++:

// "variables" which consist in some simple variables (int, double) 
//  and in some complex variables (structs containing arrays of structs)


extern "C"
{
     __declspec(dllexport) int function1()
    {
        // some work depending on random and on the "variables"
    }
}

i taka klasa C #

public class class1
{
    //  "variables" <--- the "same" as the C++ file's ones 
    //  Dll import <--- ok

    public void method1()
    {
        int [] result;

        for(int i=0; i<many_times; i++)
        {
            result = new int[number_of_parallel_tasks];                

            Parallel.For(0, number_of_parallel_tasks, delegate(int j)
            { 
                 // I would like to do  result[j] = function1()  
            });

            //  choose best result
            //  then update "variables" 
        }
    }

}

Napisałem „Chciałbym zrobić ...”, ponieważ funkcja c ++ potrzebuje w każdej rundzie aktualizacji „zmiennych”.

Moje pytanie brzmi:

Czy możliwe jest współdzielenie pamięci między C ++ i C #, aby za każdym razem uniknąć przekazywania referencji? Czy to tylko strata czasu?

Czytałem o plikach mapowanych w pamięci. Czy mogą mi pomóc? Czy znasz jednak bardziej odpowiednie rozwiązania?
Dziękuję Ci bardzo.