Passing string from c# to c++ dll

Question

I am trying to pass a string from C# to C++ dll. The string that I recieve in the dll is some wierd characters. Here is my code.

In C++ dll:

#include "stdafx.h"
#include <tlhelp32.h>
#include <tchar.h>
#include "ProcessCheckerDll.h"
#include <fstream>
#include <algorithm>
#include <iostream>
#include <stdio.h>
#include <psapi.h>
#include "Shlwapi.h"
#include <string>
#include <windows.h>


namespace ProcessCheck
{
string GetRunningProcessFromHierarchy(char* argStrRoot)
{ 
    char ch;
    printf("Reached here 1.");
    scanf_s("%c",&ch);

    std::string strRoot(argStrRoot,strlen(argStrRoot));
    printf_s("strRoot = %s",strRoot);
    std::ifstream input("d:\\filelist.txt");
    std::string line;

    printf("Reached here 2.");
    scanf_s("%c",&ch);

    //printf("cdsroot=%ls",strRoot);

    std::transform(strRoot.begin(), strRoot.end(), strRoot.begin(), ::tolower);
    std::vector<std::string> collection;
    string result="";


    printf("Reached here 3.");
    scanf_s("%c",&ch);

    HANDLE hProcessSnap=nullptr;
    HANDLE hProcess;
    PROCESSENTRY32 pe32;
    DWORD dwPriorityClass;


    while( std::getline( input, line ) )
    {
        //Get the file name from path
        std::wstring strPathFromTextFile = std::wstring(line.begin(), line.end());
        LPCWSTR absolutePathToFile = strPathFromTextFile.c_str();
        LPCWSTR onlyFileName = PathFindFileName(absolutePathToFile); 

        // Take a snapshot of all processes in the system.
        hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        if(hProcessSnap == INVALID_HANDLE_VALUE)
        {
            printf("Failed to get the snapshot of running processes");
            return result;
        }

        pe32.dwSize = sizeof(PROCESSENTRY32);

        // Retrieve information about the first process and exit if unsuccessful
        if(!Process32First(hProcessSnap, &pe32))
        {
            printf("Failed to get the first process from the list");
            CloseHandle(hProcessSnap);     // clean the snapshot object
            return result;
        }

        // Now walk the snapshot of processes, and display information about each process in turn
        do
        {
            LPCWSTR processFileName = pe32.szExeFile;

            if(lstrcmpi(onlyFileName,processFileName)==0)
            {
                //If file name is same, check if path starts with cdsroot
                HANDLE processHandle = NULL;
                TCHAR filePath[MAX_PATH];

                processHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pe32.th32ProcessID);


                if (processHandle != NULL)
                {
                    if (GetModuleFileNameEx(processHandle, NULL, filePath, MAX_PATH) == 0)
                    {
                        printf("\nFailed to get module filename.");
                    }
                    else
                    {
                        std::wstring w_str(filePath);
                        std::string absolutePath(w_str.begin(), w_str.end());
                        std::transform(absolutePath.begin(), absolutePath.end(), absolutePath.begin(), ::tolower);

                        printf_s("Absolute path = %s", absolutePath);
                        printf_s("Matching with cdsroot = %s",strRoot);
                        if(absolutePath.find(strRoot)==0)
                        {
                            std::wstring processName(processFileName);
                            std::string strProcess(processName.begin(),processName.end());
                            printf_s("\nROOT match for Process name = %s",strProcess);

                            if (std::find(collection.begin(), collection.end(), strProcess) == collection.end())
                            {
                                collection.push_back(strProcess);
                                printf_s("\nAdding to collection Process name = %s",strProcess);
                                result = result + strProcess + ";";
                            }
                        }
                    }
                    CloseHandle(processHandle);
                }
                else
                {
                    printf("\nFailed to open process.");
                }
            }
        }
        while(Process32Next(hProcessSnap, &pe32));
    }

    CloseHandle(hProcessSnap);
    printf("Returning result %s", result);
    scanf_s("%c",&ch);
    return result;
}
}

The header file contains:

#include <stdexcept>
#include <vector>
using namespace std;

namespace ProcessCheck
{
extern "C" { __declspec(dllexport) string GetRunningProcessFromHierarchy(char* argStrRoot); }
}

And the code in C# is:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Runtime.InteropServices;

namespace ProcCheckTest
{
class Program
{

    [DllImport("C:\\Users\\himanshu\\Documents\\Visual Studio 2012\\Projects\\ProcessCheck\\Release\\ProcessCheckerDll.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern string GetRunningProcessFromHierarchy([MarshalAs(UnmanagedType.LPStr)] string strRoot);

    static void Main(string[] args)
    {
        string strRoot = "C:\\test\\today_16.6";
        string returnValue = GetRunningProcessFromHierarchy(strRoot);
    }
}
}

The string that I am passing is "C:\test\today_16.6" but when I print the same in the dll code, it prints weird characters. What is wrong here?

Answer 1

The main issue appears to be here:

printf_s("strRoot = %s",strRoot);

The problem is that strRoot is of type std::string but the format string needs a char*. Change this to:

printf_s("strRoot = %s",strRoot.c_str());

Or use argStrRoot directly.

Your other problem is the return value of the function. Currently you return std::string. You can't marshal that with p/invoke. You'll need to return char*. What's more, as it stands, the marshaller will call CoTaskMemFree on the pointer it receives as the return value. So you'd need to allocate the char* that you return with CoTaskMemAlloc.