Unmanaged c++ to managed c# dll calls passing strings

extern "C" __declspec(dllexport) void FillString(char* myString, int length)
{
    //check that length is enough for your string
    ...
    //simple test
    strcpy_s(myString, length, "hello");
}

[DllImport("YouNativeDLL")]
static extern void FillString(StringBuilder myString, int length);
public Test()
{
    //reserve storage
    StringBuilder str = new StringBuilder(100);
    //get my string from native code
    FillString(str, str.Capacity);
    string myString = str.ToString();
    ...
}

//declare the callback prototype
typedef BOOL (__stdcall *MY_CALLBACK)(char* str, int length);
//cette fonction appelle la callback
extern "C" __declspec(dllexport) void SetCallback(MY_CALLBACK callback)
{
    //you can store the callback for a later use
    //or do a simple test:
    char buffer[1000] = { 0 };
    BOOL result = callback(buffer, 1000);
    if (result)
	MessageBox(NULL, "Callback returned true", buffer, MB_OK);
    else
	MessageBox(NULL, "Callback returned false", "", MB_OK);
}

//declare the callback prototype
delegate bool CALLBACK(IntPtr myString, int length);
//native function to set the callback
[DllImport("Native")]
static extern void SetCallback(CALLBACK callback);
//the callback
static bool Callback(IntPtr myString, int length)
{
    //a test string to copy
    string str = "hello";
    //make sure the buffer is big enough
    if (str.Length + 1 > length)
        return false;
    //convert the managed string into a unmanaged ANSI string
    IntPtr ptr = Marshal.StringToHGlobalAnsi(str);
    //get the bytes of the unmanaged string
    byte[] bytes = new byte[str.Length + 1];
    Marshal.Copy(ptr, bytes, 0, str.Length);
    //copy these bytes into myString
    Marshal.Copy(bytes, 0, myString, bytes.Length);
    //free the unmanaged memory
    Marshal.FreeHGlobal(ptr);
    return true;
}
void SomeFunction()
{
    //set the callback somewhere in your code
    SetCallback(Callback);
}