从ac＃应用程序中的dll调用和使用C ++异步成员函数的问题

Question

我的C ++类中有几个成员函数，这些成员函数将它们打包为dll，并试图在C＃应用程序中使用它们。 我试图创建两个异步函数，方法是简单地使用线程执行它们，然后对它们进行detach（）以便它们在结束之前不会阻塞调用者线程。
在基于C ++的应用程序中，每当我使用线程以这种方式调用函数时，它们都起作用，但是当我尝试从C＃调用我的异步函数之一时，它们似乎执行了，但没有结果。
这两个异步函数应该在完成工作后创建文本文件，但是它们不会像普通计数器那样工作！
我将发布我的类定义的代码片段，以及C包装程序（用于dll）和c＃应用程序部分。

//xGramManipulator.h file
#pragma once
#include <regex>
#include <string>
#include <map>
#include <thread>
#include <mutex>
#include <vector>

class xGramManipulator
{

public:
    xGramManipulator();
    xGramManipulator(wchar_t* fileToRead);
    xGramManipulator(std::wregex monoReg, std::wregex biReg, wchar_t* fileToRead = L"ftext.txt");
    ~xGramManipulator();

    double CreateMonoGram();
    double ReadMonoGram();
    void SaveMonoGram();

    double CreateBiGram();
    double ReadBiGram();
    void SaveBiGram();

    double CreateLists();
    void CreateMonoGramAsync();
    void CreateBiGramAsync();



priavte: 
    template<class TypeOne, class TypeTwo>
    void WriteToFile(const wchar_t* filePath, std::map<TypeOne, TypeTwo>& container);

private:
    std::map<std::wstring, int> monogramStatMap;
    std::map<std::wstring, int> bigramStatMap;
    std::map<std::wstring, std::wstring> bigramListMap;
    std::vector<std::wstring> nextWordResults;
std::unordered_multimap< std::wstring, std::wstring > container;

    std::mutex mutex_;

    wchar_t* fileToReadFrom;
    wchar_t **CStringArraybuffer;

    std::wregex monoRegx;
    std::wregex biRegx;

    std::thread tr1;
    std::thread tr2;

    std::chrono::high_resolution_clock::time_point startTime;
std::chrono::high_resolution_clock::time_point endTime;
std::chrono::high_resolution_clock::time_point elapsedTime;

};

template <class TypeOne, class TypeTwo>
void xGramManipulator::WriteToFile(const wchar_t* filePath, std::map<TypeOne, TypeTwo>& container)
{
    //Because of possible use of threads and inorder to avoid any thread interferance 
    //i decided to declare it local instead of global.
    FILE* filePointer;

    //for converting To UTF8 so that our contents are in farsi and not some numeric nonsense!
    _wfopen_s(&filePointer, filePath, L"w");
    _setmode(_fileno(filePointer), _O_U8TEXT);

    wofstream output(filePointer);

    for (auto item : container)
    {
        //write output to file
        output << item.first << " : " << item.second << endl;
    }

    fclose(filePointer);
}

//xGramManipulator.cpp文件

#include <regex>
#include <fstream>
#include <iostream>
#include <string>
#include <map>
#include <fcntl.h>  //for _wfopen_s
#include <io.h> //for _setmode
#include <memory>   //for shared_ptr
#include <chrono>   //for time benchmarks
#include <thread>
#include <mutex>
#include <unordered_map>
#include <algorithm>
#include <vector>
#include "xGramManipulator.h"

using namespace std;
using namespace chrono;
typedef high_resolution_clock Time;

xGramManipulator::xGramManipulator() : monoRegx(L"\\w+"), biRegx(L"\\w+ \\w+"), fileToReadFrom(L"ftext.txt")
{}
xGramManipulator::xGramManipulator(wchar_t* fileToRead) : monoRegx(L"\\w+"), biRegx(L"\\w+ \\w+"), fileToReadFrom(fileToRead)
{
    if (!FileExits(fileToReadFrom))
    {
        cout << "File doesnt Exists" << endl;
    }
}
xGramManipulator::xGramManipulator(wregex monoReg, wregex biReg, wchar_t* fileToRead) : monoRegx(monoReg), biRegx(biReg), fileToReadFrom(fileToRead)
{
    if (!FileExits(fileToReadFrom))
    {
        cout << "File doesnt Exists";
    }
}

xGramManipulator::~xGramManipulator()
{
}

//Reads from a file specified in the constructor or through SetFilePathToReadFrom() function
//And then creates a list of monograms.When function execution ends, the elapsed time is returned.
double xGramManipulator::CreateMonoGram()
{
    Time::time_point start = Time::now();
    ReadMonoGram();
    SaveMonoGram();
    Time::time_point end = Time::now();

    return ElapsedTime(start, end);
}

//Reads from a file specified in the constructor or through SetFilePathToReadFrom() function
//And then creates a list of bigrams.When function execution ends, the elapsed time is returned.
double xGramManipulator::CreateBiGram()
{
    Time::time_point  start = Time::now();
    ReadBiGram();
    SaveBiGram();
    Time::time_point  end = Time::now();

    return ElapsedTime(start, end);
}

double xGramManipulator::ReadMonoGram()
{
    FILE* filePointer;
    wstring inputString = L"";
    Time::time_point start = Time::now();
    try
    {

        //converting UTF16 to UTF8 so that we dont get rubbish result!
        _wfopen_s(&filePointer, fileToReadFrom, L"r");
        _setmode(_fileno(filePointer), _O_U8TEXT);

        wifstream file(filePointer);

        monogramStatMap.clear();
        while (file.good())
        {
            getline(file, inputString);

            for (wsregex_iterator it(inputString.begin(), inputString.end(), monoRegx), it_end; it != it_end; ++it)
            {
                //Filling the bigram container
                //unorderedmap estrefade beshe baraye soorate bishtar
                monogramStatMap[(wstring) (*it)[0]]++;
            }
        }
        fclose(filePointer);

    }
    catch (exception ex)
    {
        cout << ex.what() << endl;
    }

    Time::time_point end = Time::now();
    return ElapsedTime(start, end);
}

void xGramManipulator::SaveMonoGram()
{
    WriteToFile(L"monogramLists.txt", monogramStatMap);
}

double xGramManipulator::ReadBiGram()
{
    FILE* filePointer;
    wstring inputString = L"";
    wstring wstr = L"";
    Time::time_point start = Time::now();
    try
    {

        //converting UTF16 to UTF8 so that we dont get rubbish result!
        _wfopen_s(&filePointer, fileToReadFrom, L"r");
        _setmode(_fileno(filePointer), _O_U8TEXT);

        wifstream file(filePointer);

        bigramStatMap.clear();
        container.clear();

        while (file.good())
        {
            getline(file, inputString);

            for (wsregex_iterator it(inputString.begin(), inputString.end(), biRegx), it_end; it != it_end; ++it)
            {
                //Filling the bigram container
                wstr = (wstring) (*it)[0];
                bigramStatMap[wstr]++;

                //spliting the two words into two items.
                bigramListMap[wstr.substr(0, wstr.find(L' '))] = wstr.substr(wstr.find(L' '), wstr.size());
                container.emplace(wstr.substr(0, wstr.find(L' ')), wstr.substr(wstr.find(L' '), wstr.size()));
            }
        }
        fclose(filePointer);

    }
    catch (exception ex)
    {
        cout << ex.what() << endl;
    }

    Time::time_point end = Time::now();
    return ElapsedTime(start, end);
}

void xGramManipulator::SaveBiGram()
{
    WriteToFile(L"bigramStatList.txt", bigramStatMap);
    WriteToFile(L"bigramList.txt", bigramListMap);
}

double xGramManipulator::CreateLists()
{
    startTime = Time::now();
    tr1 = thread(&xGramManipulator::CreateMonoGram, this);
    tr2 = thread(&xGramManipulator::CreateBiGram, this);
    tr1.join();
    tr2.join();
    endTime = Time::now();

    return ElapsedTime(startTime, endTime);
}

void xGramManipulator::CreateMonoGramAsync()
{
    thread t(&xGramManipulator::ReadMonoGram, this);
    t.detach();
}

void xGramManipulator::CreateBiGramAsync()
{
    //static_cast<void (xGramManipulator::*)()>(&xGramManipulator::ReadMonoGram)
    thread t = thread(&xGramManipulator::ReadBiGram, this);
    t.detach();
}

这是我的Dll定义：//CDll.h

#ifdef CDLL_EXPORTS
#define CDLL_API __declspec(dllexport)
#else
#define CDLL_API __declspec(dllimport)
#endif

extern "C"
{
    CDLL_API double CreateMonoAndBioGramLists(void);                            //reads and creates two files for each
    CDLL_API double CreateMonoGram(void);                                       //reads and creates a file 
    CDLL_API double CreateBiGram(void);                                         //reads and creates a file
    CDLL_API wchar_t** GetResults(wchar_t* word , int threshold, int* lemgth);              //returns the result of the search

    CDLL_API double ReadMonoGram(void);
    CDLL_API double ReadBiGram(void);

    CDLL_API void CreateMonoGramAsync(void);
    CDLL_API void CreateBiGramAsync(void);

    CDLL_API void*  CreateHandle();
    CDLL_API void*  GetCurrentHandle();
    CDLL_API void  DisposeCurrentHandle();
    CDLL_API void  SetCurrentHandle(void* handle);
    CDLL_API void*  GetHandle();
    CDLL_API void  DisposeHandle(void*);
}

//CDLL.cpp

#include "CDll.h"
#include "xGramManipulator.h"

#define DLL_EXPORT

extern "C"
{
    xGramManipulator *xG;
    CDLL_API double CreateMonoAndBioGramLists(void)
    {
        //return xG.CreateLists();
        xG = reinterpret_cast<xGramManipulator*>(GetHandle());
        return xG->CreateLists();
    }
    CDLL_API double CreateMonoGram(void)
    {
        //return xG.CreateMonoGram();
        xG = reinterpret_cast<xGramManipulator*>(GetHandle());
        return xG->CreateMonoGram();
    }
    CDLL_API double CreateBiGram(void)
    {
        //return xG.CreateBiGram();
        xG = reinterpret_cast<xGramManipulator*>(GetHandle());
        return xG->CreateBiGram();
    }
    CDLL_API wchar_t** GetResults(wchar_t* word, int threshold, int* length)
    {
        //return xG.CGetNextWordsList(word, length, threshold);
        xG = reinterpret_cast<xGramManipulator*>(GetHandle());
        return xG->CGetNextWordsList(word, length, threshold);
    }

    CDLL_API double ReadMonoGram(void)
    {
        //return xG.ReadMonoGram();
        xG = reinterpret_cast<xGramManipulator*>(GetHandle());
        return xG->ReadMonoGram();
    }
    CDLL_API double ReadBiGram(void)
    {
        //return xG.ReadBiGram();
        xG = reinterpret_cast<xGramManipulator*>(GetHandle());
        return xG->ReadBiGram();
    }

    CDLL_API void CreateMonoGramAsync(void)
    {
        //xG.CreateMonoGramAsync();
        xG = reinterpret_cast<xGramManipulator*>(GetHandle());
        return xG->CreateMonoGramAsync();
    }
    CDLL_API void CreateBiGramAsync(void)
    {
        //xG.CreateBiGramAsync();
        xG = reinterpret_cast<xGramManipulator*>(GetHandle());
        return xG->CreateBiGramAsync();
    }

    //Handle operations
    CDLL_API void* CreateHandle()
    {
        if (xG == nullptr)
        {
            xG = new xGramManipulator;
        }
        else
        {
            delete xG;
            xG = new xGramManipulator;
        }
        return reinterpret_cast<void*>(xG);
    }

    CDLL_API void* GetCurrentHandle()
    {
        return reinterpret_cast<void*>(xG);
    }

    CDLL_API void  DisposeCurrentHandle()
    {
        delete xG;
        xG = nullptr;
    }

    CDLL_API void  SetCurrentHandle(void* handle)
    {
        if (handle != nullptr)
        {
            xG = reinterpret_cast<xGramManipulator*>(handle);
        }
        else
        {
            xG = new xGramManipulator;
        }

    }
    //factory utility function
    //ask question on how to do it.
    CDLL_API void* GetHandle()
    {
        HANDLE handle = GetCurrentHandle();
        if (handle != nullptr)
        {
            return handle;
        }
        else
        {
            xG = new xGramManipulator;
            handle = reinterpret_cast <void*>(xG);
        }
        return handle;
    }

    CDLL_API void  DisposeHandle(void* handle)
    {
        xGramManipulator * tmp = reinterpret_cast<xGramManipulator*>(handle);
        delete tmp;
    }

注意：
首先代替

 xGramManipulator *xG;

我有

xGramManipulator xG;  

我只是使用该全局对象来调用成员函数。经过一番思考，我认为这可能不好，我应该以某种方式使其变得动态！ 所以我将其更改为当前状态。
如果以前的解决方案（使用全局对象xG）是对还是错，以及如果错了，我将面临什么样的问题，请指导我。
如果当前的方法有误，那我该怎么办？