Brauche Hilfe bei unmanaged C++ Code und C++/CLI Wrapper in C#

[cppUser (Gast)]

Hallo,
hoffe jemand kann mir helfen. Habe nach dieser Anleitung meinen 
unmanaged C++ Code über einen C++/CLI Wrapper in mein C# Projekt 
eingebunden.
http://drthitirat.wordpress.com/2013/06/03/use-c-codes-in-a-c-project-wrapping-native-c-with-a-managed-clr-wrapper/

Funktioniert auch, allerdings verwenden meine Funktionen in C++ einen 
Parameter const char*:

C++
[code}
float Funcs::ValueFunction(const char* filename, int num) {
....
return a;
}
[/code}

Im C++/CLI Wrapper passiert eigentlich nichts.

In C# kann ich auf die Funktion auch zugreifen, allerdings wird mir der 
Parameter der Funktion als sbyte* angezeigt und meinen C# string kann 
ich ja nicht damit nutzen.

Kann mir jemand ein gutes Beispiel senden? Habe schon einiges über 
marshal gelesen, aber kein gutes Beipiel gefunden. Danke

[Peter II (Gast)]

http://stackoverflow.com/questions/7283820/dllimport-with-char-arguments-only-one-character-being-passed

[cppUset (Gast)]

Danke,
leider hat mich das noch nicht weiter gebracht. Ich lade heute Abend mal 
ein Beispiel hier hoch.
Möchte gerne den C++/CLI wrapper nutzen und nicht die unmanaged C++ DLL 
in C# laden, wie in dem verlinkten Beispiel.

PS: Auch wenn ich im nativ C++ Code strings in der Funktion nutze und 
die Funktion über den Wrapper an C# weitergeben kann ich keinen String 
als Parameter an die Funktion übergeben. Ich stehe irgendwie mit den 
Datentypen aufm Schlauch.

[cppUser (Gast)]

Hallo,
die Konvertierung vom C# String zu char* muss ich im Wrapper durchführen 
oder? So wie unten funktioniert der C# Code natürlich nicht.


SimpleFunctions.h

#pragma once
#include <stdexcept>

using namespace std;

class MySimpleFunctions {
public:
  int TextOK(const char* text);
};

SimpleFunctions.cpp

#pragma once
#include "SimpleFunctions.h"

int MySimpleFunctions::TextOK(const char* text) {
  int a = 0;

  if (text == "Hello")
    a = 1;
  else
    a = 2;
  
  return a;
}

nativeCppWrapper.h

// nativeCppWrapper.h

#pragma once

#include "SimpleFunctions.cpp"
#include "SimpleFunctions.h"

using namespace System;

namespace nativeCppWrapper {
  public ref class MySimpleFunctionsWrapper
  {
  public:
    MySimpleFunctionsWrapper();
    int TextOK(const char* text);
    
  private:
    MySimpleFunctions *myCppClass;
  };
}

nativeCppWrapper.cpp

// This is the main DLL file.

#include "stdafx.h"
#include "nativeCppWrapper.h"

nativeCppWrapper::MySimpleFunctionsWrapper::MySimpleFunctionsWrapper()
{
  myCppClass = new MySimpleFunctions();
}

int nativeCppWrapper::MySimpleFunctionsWrapper::TextOK(const char* text)
{
  return myCppClass->TextOK(text);
}

Form1.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using nativeCppWrapper;

namespace CsharpApp
{
    public partial class Form1 : Form
    {
        MySimpleFunctionsWrapper myFunction = new MySimpleFunctionsWrapper();
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            String str = "Hello";
            int x = myFunction.TextOK(str);
        }
    }
}

[Georg B. (diereinegier)]

Der CLI-Wrapper sollte einen .net-String entgegennehmen und zwar per 
Referenz:

MySimpleFunctionsWrapper::TextOK(String% txt)

So kann C# die Methode ganz einfach als TextOK("text") aufrufen.

Dann mußt Du den String entweder mit dem gewünschten Encoding in ein 
Byte-Array schreiben (das kannst Du auch erstmal in C# üben) oder Dir 
den Zeiger auf die interne UTF-16 Representation geben lassen.

Das Netz ist voll von Beispielen dazu, weil es ja auch wirklich eine 
immer wiederkehrende nervige Aufgabe ist.

Siehe z.B. hier:
http://support.microsoft.com/kb/311259

Wichtig ist, zu verstehen warum und wann man Pinnen muß bzw. wann man 
GC.keepalive() benutzen muß.

[cppUser (Gast)]

Danke für den Tipp. Kann jetzt die Funktion richtig aufrufen, allerdings 
wird der String nicht korrekt übergeben.
Zumindest bekomme ich nicht das korrekte Ergebnis von der Funktion 
geliefert.

int nativeCppWrapper::MySimpleFunctionsWrapper::TextOK(String^ text)
{
  using namespace Runtime::InteropServices;
  const char* str = (const char*)(Marshal::StringToHGlobalAnsi(text)).ToPointer();
  return myCppClass->TextOK(str);
  Marshal::FreeHGlobal(IntPtr((void*)str));
}

[cppUser (Gast)]

Ok,
funktioniert alles ;) Hatte noch einen anderen Fehler.

Danke!