FatalExecutionEngineError

[skluge]

Hallo zusammen,

ich habe das Problem, dass ich um eine (unmanaged) DLL einen C# Wrapper bauen möchte, mit dessen Hilfe ich für spätere C# Anwendungen einfach den Wrapper einbinden kann und die Funktionen der älteren DLL nutzen kann.

Ich hole mir die (mit LabWindows und ANSI-C entwickelten) Funktionen über [DllImport] in mein C# Projekt und leite die Aufrufe an diese weiter. Nun hab ich das Problem, dass in manchen dieser Funktionen mit dem Speicher der Parameter rumgespielt wird, die ich der Funktion mit z.B. ref übergebe. Ich möchte so zusage, dass nach dem Funktionsaufruf die Ergebnisse in dem mit ref übergebenen Parametern gespeichert sind. Das klappt auch gut, bis ich nach dem Funktionsaufruf einen Schritt weiter steppe. Danach tritt immer ein "FatalExecutionEngineError" auf, der besagt:

The runtime has encountered a fatal error. The address of the error was at 0x63f2eaf5, on thread 0x2b8c. The error code is 0xc0000005. This error may be a bug in the CLR or in the unsafe or non-verifiable portions of user code. Common sources of this bug include user marshaling errors for COM-interop or PInvoke, which may corrupt the stack.

Ich denke, dass es was damit zu tun hat, dass die unmanaged Funktion mir den managed Heap so manipuliert, dass die CLR bei ihrer Überprüfung einen korrupten Speicher entdeckt und deshalb den Fehler wirft. Kann das sein?

Wie kann ich diesem Problem entgegenwirken? Hab ansatzweise mit "unsafe" und "fixed" versucht zu arbeiten, jedoch bisher ohne Erfolg. Ich möchte euch hier auch den Code anzeigen, um das Problem vll. besser erkennen zu können. Vielen Dank euch schon mal im Voraus für die Hilfe!!

Unmanaged Funktionen

//Funktionsdefinition
int __stdcall EDM_RC_GetIndexTable(int hApp, char *name, int *indizes, int *icount);
...
...
DLLEXPORT_IMPORT int __stdcall EDM_RC_GetIndexTable(CAObjHandle hApp, char *name, int *indizes, int *icount)
{
	...
        ...
		memset(indizes, 0x0, EDM_RC_MAX_INDEX_TABLE_ENTRIES*sizeof(int));
		memset(name_without_minus, 0x0, 260);
		memset(name_without_ext, 0x0, 260);
		memset(name_ext, 0x0, 260);		

        ...

	return(iret);
}

Managed Funktion

[DllImport("EDM_RC.dll", EntryPoint = "EDM_RC_GetIndexTable", CallingConvention = CallingConvention.StdCall)]
            private static extern int edm_GetIndexTable(IntPtr hEDMHandle, string sName, ref IntPtr iIndizes, ref IntPtr iCount);

...
...

public bool GetIndexTable(string name, ref int iIndizes, ref int iCount)
            {
                bool retVal = false;
                iIndizes = -1;
                iCount = -1;

                try
                {
                    int val;

                    if (m_iEDMHandle != IntPtr.Zero)
                    {
                        unsafe
                        {
                            IntPtr ptrIndizes = IntPtr.Zero;
                            IntPtr ptrCount = IntPtr.Zero;

                            val = edm_GetIndexTable(m_iEDMHandle, name, ref ptrIndizes, ref ptrCount);

                            iIndizes = ptrIndizes.ToInt32(); // Hier tritt der Fehler auf
                            iCount = ptrCount.ToInt32();

                        }

                        //int val = edm_GetIndexTable(m_iEDMHandle, name, out iIndizes, out iCount);

                        if (val == 0)
                        {
                            retVal = true;
                            //iIndizes = ptrIndizes.ToInt32();
                            //iCount = ptrCount.ToInt32();
                        }
                        else
                        {
                            retVal = false;
                        }
                    }
                }
                catch (System.Exception ex)
                {
                    MessageBox.Show(ex.Message);
                    return false;
                }
                finally
                {
                }

                return retVal;
            }

[asc]

skluge schrieb:

Ich denke, dass es was damit zu tun hat, dass die unmanaged Funktion mir den managed Heap so manipuliert, dass die CLR bei ihrer Überprüfung einen korrupten Speicher entdeckt und deshalb den Fehler wirft. Kann das sein?

Du kannst keine managed-Objekte nicht zum Ändern an eine unmanaged Umgebung übergeben. Es handelt sich um gänzlich andere Welten.