C# 如何取消执行非托管C++；外部例行程序

我尝试修复C++异步代码，启动一个在非托管C++例程中编写的外部DLL中执行的可取消操作。 <> P>是否有一个方法使用一个取消令牌来取消任务，如果用户委托调用外部非托管C++例程，则在创建时传递给任务 据我所知，任务取消涉及用户代理和请求取消的代码之间的合作。成功的取消涉及到请求代码调用CancellationTokenSource.Cancel方法，以及用户委托及时终止操作，或者在他注意到A取消请求已提出时，通过简单地从委托返回（通过轮询CancellationToken.IsCancellationRequested方法）或者使用CancellationToken.ThrowIfCancellationRequested方法引发OperationCanceledException。（比照）

这两种方式涉及的是，由用户委托执行的非托管C++例程通过接收取消令牌作为参数来协作，并通过定期调用其取消请求和/或SoWiFielCopelielDebug方法来调用。

是否可以从非托管外部C++程序中执行？< /P>

如果不存在，在请求代码请求取消时，是否有强制终止用户委托执行任务的方法（执行非托管C++例程）？< /P>

这是一个例子（摘录），我试图修复混合C++的C/C++ CLI/unc++ C++代码，以便能够取消C++委托非托管代码部分中的用户委托执行的操作：

FrmDemo.cs：-------------------------------------------------------------------------

public class FrmDemo : Form
{
    private CliClass m_CliObject;
    private System.Threading.CancellationTokenSource m_Cts;
    private System.Threading.CancellationToken m_Ct;

    private void FrmDemo_Load(object sender, EventArgs e)
    {
        // Creating the external CliObject:
        this.m_CliObject = new NSDemo.CliClass();
        ...
    }

    // Event handler of the button starting the cancelable asynchrone operation:
    private async void btnStart_Click(object sender, EventArgs e)
    {
        m_Cts = new System.Threading.CancellationTokenSource();
        m_Ct = m_Cts.Token;
        await Task.Factory.StartNew(() =>
        {
              // Launching a cancelable operation performed by a managed C++Cli Object :
              this.m_CliObject.DoSomething();   // How to eventually pass the CancellationToken m_ct to the m_CliObject ?
        }, m_ct);
        ...
    }


    //Event handler of the cancel button:
    private void btnCancel_Click(object sender, EventArgs e)
    {
        // Requesting cancellation:
        m_Cts.Cancel();
        // (Or alternatively, how to eventually force the termination of the async Task without collaboration from it ?)
    }

#include "DemoCore.h"

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace cli;

namespace NSDemo
{
    public ref class CliClass
    {

    public:

        CliClass();

        ~CliClass(); 

        void DoSomething()
        {
            // Performing the operation in the unmanaged coreObject:
            _coreObject->DoSomething();
        }

    private:
        UNSDemo::CoreClass *_coreObject;
        bool _disposed;

    };
}

namespace NSDemo
{
    CliClass::CliClass()
    {
         _coreObject = new UNSDemo::CoreClass(...);
        ....
    }

    CliClass::~CliClass()
    {
        if (_disposed)
            return;               
        if (_coreObject != nullptr) {
            delete _coreObject;
            _coreObject = nullptr;
        }
        _disposed = true;
        GC::SuppressFinalize(this);
    }

CoreClass.h-----------------------------------------------------------------

namespace UNSDemo {

    class __declspec(dllexport) CoreClass {
    public:
        ScanningCore();

        ~ScanningCore();

        void DoSomething();

    private:

    ...

    };

}

#include "CoreClass.h"

namespace UNSDemo {

    CoreClass::CoreClass()
    {
        ...
    }

    CoreClass::~CoreClass()
    {
        ...
    }

    // Method actually performing the cancelable operation:
    void CoreClass::DoSomething()
    {
        // Main loop of the unmanaged cancelable operation:
        while (...) {
            ...
            // How to check the cancellation request from here ? (How to access the CancellationToken ?)
            // and if cancellation is requested, how to eventually throw the OperationCanceledException ?

        }
    }
}

CliClass.h：-----------------------------------------------------

public class FrmDemo : Form
{
    private CliClass m_CliObject;
    private System.Threading.CancellationTokenSource m_Cts;
    private System.Threading.CancellationToken m_Ct;

    private void FrmDemo_Load(object sender, EventArgs e)
    {
        // Creating the external CliObject:
        this.m_CliObject = new NSDemo.CliClass();
        ...
    }

    // Event handler of the button starting the cancelable asynchrone operation:
    private async void btnStart_Click(object sender, EventArgs e)
    {
        m_Cts = new System.Threading.CancellationTokenSource();
        m_Ct = m_Cts.Token;
        await Task.Factory.StartNew(() =>
        {
              // Launching a cancelable operation performed by a managed C++Cli Object :
              this.m_CliObject.DoSomething();   // How to eventually pass the CancellationToken m_ct to the m_CliObject ?
        }, m_ct);
        ...
    }


    //Event handler of the cancel button:
    private void btnCancel_Click(object sender, EventArgs e)
    {
        // Requesting cancellation:
        m_Cts.Cancel();
        // (Or alternatively, how to eventually force the termination of the async Task without collaboration from it ?)
    }

#include "DemoCore.h"

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace cli;

namespace NSDemo
{
    public ref class CliClass
    {

    public:

        CliClass();

        ~CliClass(); 

        void DoSomething()
        {
            // Performing the operation in the unmanaged coreObject:
            _coreObject->DoSomething();
        }

    private:
        UNSDemo::CoreClass *_coreObject;
        bool _disposed;

    };
}

namespace NSDemo
{
    CliClass::CliClass()
    {
         _coreObject = new UNSDemo::CoreClass(...);
        ....
    }

    CliClass::~CliClass()
    {
        if (_disposed)
            return;               
        if (_coreObject != nullptr) {
            delete _coreObject;
            _coreObject = nullptr;
        }
        _disposed = true;
        GC::SuppressFinalize(this);
    }

CoreClass.h-----------------------------------------------------------------

namespace UNSDemo {

    class __declspec(dllexport) CoreClass {
    public:
        ScanningCore();

        ~ScanningCore();

        void DoSomething();

    private:

    ...

    };

}

#include "CoreClass.h"

namespace UNSDemo {

    CoreClass::CoreClass()
    {
        ...
    }

    CoreClass::~CoreClass()
    {
        ...
    }

    // Method actually performing the cancelable operation:
    void CoreClass::DoSomething()
    {
        // Main loop of the unmanaged cancelable operation:
        while (...) {
            ...
            // How to check the cancellation request from here ? (How to access the CancellationToken ?)
            // and if cancellation is requested, how to eventually throw the OperationCanceledException ?

        }
    }
}

CliClass.cpp：------------------------------------------

public class FrmDemo : Form
{
    private CliClass m_CliObject;
    private System.Threading.CancellationTokenSource m_Cts;
    private System.Threading.CancellationToken m_Ct;

    private void FrmDemo_Load(object sender, EventArgs e)
    {
        // Creating the external CliObject:
        this.m_CliObject = new NSDemo.CliClass();
        ...
    }

    // Event handler of the button starting the cancelable asynchrone operation:
    private async void btnStart_Click(object sender, EventArgs e)
    {
        m_Cts = new System.Threading.CancellationTokenSource();
        m_Ct = m_Cts.Token;
        await Task.Factory.StartNew(() =>
        {
              // Launching a cancelable operation performed by a managed C++Cli Object :
              this.m_CliObject.DoSomething();   // How to eventually pass the CancellationToken m_ct to the m_CliObject ?
        }, m_ct);
        ...
    }


    //Event handler of the cancel button:
    private void btnCancel_Click(object sender, EventArgs e)
    {
        // Requesting cancellation:
        m_Cts.Cancel();
        // (Or alternatively, how to eventually force the termination of the async Task without collaboration from it ?)
    }

#include "DemoCore.h"

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace cli;

namespace NSDemo
{
    public ref class CliClass
    {

    public:

        CliClass();

        ~CliClass(); 

        void DoSomething()
        {
            // Performing the operation in the unmanaged coreObject:
            _coreObject->DoSomething();
        }

    private:
        UNSDemo::CoreClass *_coreObject;
        bool _disposed;

    };
}

namespace NSDemo
{
    CliClass::CliClass()
    {
         _coreObject = new UNSDemo::CoreClass(...);
        ....
    }

    CliClass::~CliClass()
    {
        if (_disposed)
            return;               
        if (_coreObject != nullptr) {
            delete _coreObject;
            _coreObject = nullptr;
        }
        _disposed = true;
        GC::SuppressFinalize(this);
    }

CoreClass.h-----------------------------------------------------------------

namespace UNSDemo {

    class __declspec(dllexport) CoreClass {
    public:
        ScanningCore();

        ~ScanningCore();

        void DoSomething();

    private:

    ...

    };

}

#include "CoreClass.h"

namespace UNSDemo {

    CoreClass::CoreClass()
    {
        ...
    }

    CoreClass::~CoreClass()
    {
        ...
    }

    // Method actually performing the cancelable operation:
    void CoreClass::DoSomething()
    {
        // Main loop of the unmanaged cancelable operation:
        while (...) {
            ...
            // How to check the cancellation request from here ? (How to access the CancellationToken ?)
            // and if cancellation is requested, how to eventually throw the OperationCanceledException ?

        }
    }
}

CoreClass.cpp：----------------------------------------------------------------------------

public class FrmDemo : Form
{
    private CliClass m_CliObject;
    private System.Threading.CancellationTokenSource m_Cts;
    private System.Threading.CancellationToken m_Ct;

    private void FrmDemo_Load(object sender, EventArgs e)
    {
        // Creating the external CliObject:
        this.m_CliObject = new NSDemo.CliClass();
        ...
    }

    // Event handler of the button starting the cancelable asynchrone operation:
    private async void btnStart_Click(object sender, EventArgs e)
    {
        m_Cts = new System.Threading.CancellationTokenSource();
        m_Ct = m_Cts.Token;
        await Task.Factory.StartNew(() =>
        {
              // Launching a cancelable operation performed by a managed C++Cli Object :
              this.m_CliObject.DoSomething();   // How to eventually pass the CancellationToken m_ct to the m_CliObject ?
        }, m_ct);
        ...
    }


    //Event handler of the cancel button:
    private void btnCancel_Click(object sender, EventArgs e)
    {
        // Requesting cancellation:
        m_Cts.Cancel();
        // (Or alternatively, how to eventually force the termination of the async Task without collaboration from it ?)
    }

#include "DemoCore.h"

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace cli;

namespace NSDemo
{
    public ref class CliClass
    {

    public:

        CliClass();

        ~CliClass(); 

        void DoSomething()
        {
            // Performing the operation in the unmanaged coreObject:
            _coreObject->DoSomething();
        }

    private:
        UNSDemo::CoreClass *_coreObject;
        bool _disposed;

    };
}

namespace NSDemo
{
    CliClass::CliClass()
    {
         _coreObject = new UNSDemo::CoreClass(...);
        ....
    }

    CliClass::~CliClass()
    {
        if (_disposed)
            return;               
        if (_coreObject != nullptr) {
            delete _coreObject;
            _coreObject = nullptr;
        }
        _disposed = true;
        GC::SuppressFinalize(this);
    }

CoreClass.h-----------------------------------------------------------------

namespace UNSDemo {

    class __declspec(dllexport) CoreClass {
    public:
        ScanningCore();

        ~ScanningCore();

        void DoSomething();

    private:

    ...

    };

}

#include "CoreClass.h"

namespace UNSDemo {

    CoreClass::CoreClass()
    {
        ...
    }

    CoreClass::~CoreClass()
    {
        ...
    }

    // Method actually performing the cancelable operation:
    void CoreClass::DoSomething()
    {
        // Main loop of the unmanaged cancelable operation:
        while (...) {
            ...
            // How to check the cancellation request from here ? (How to access the CancellationToken ?)
            // and if cancellation is requested, how to eventually throw the OperationCanceledException ?

        }
    }
}

---

感谢您的帮助。

如果您处理的是纯非托管代码，它不知道CancellationToken类，因此您不能像处理托管代码那样传递它

我要做的是声明您的非托管方法获取指向布尔值的指针，如果布尔值设置为true，则让非托管代码本身中止。在包装器中，使用CancellationToken.Register注册回调，该回调将在取消CancellationToken时将布尔值设置为true

从表面上看，这听起来很简单，但有点复杂，因为您需要一个托管事件处理程序，它可以访问允许您获取其地址的布尔值

public ref class CancelableTaskWrapper
{
private:
    bool* isCanceled;
    void (*unmanagedFunctionPointer)(bool*);

    void Canceled() { if (isCanceled != nullptr) *isCanceled = true; }

public:
    CancelableTaskWrapper(void (*unmanagedFunctionPointer)(bool*))
    {
        this->unmanagedFunctionPointer = unmanagedFunctionPointer;

        isCanceled = new bool;
    }

    ~CancelableTaskWrapper() { if (isCanceled != nullptr) delete isCanceled; isCanceled = nullptr; }
    !CancelableTaskWrapper() { if (isCanceled != nullptr) delete isCanceled; isCanceled = nullptr; }

    void RunTask(CancellationToken cancelToken)
    {
        *isCanceled = false;
        CancellationTokenRegistration reg = cancelToken.Register(
            gcnew Action(this, &CancelableTaskWrapper::Canceled));
        unmanagedFunctionPointer(isCanceled);
    }
};

void someUnmanagedFunction(bool* isCanceled)
{
    doSomethingLongRunning();
    if(*isCanceled) return;
    doSomethingLongRunning();
}

• 因为

  isCanceled

  是指向bool的指针，所以它在堆上。因此，我们可以传递指向它的指针，而无需执行任何特殊操作（例如，固定托管对象）

• CancellationTokenRegistration

  实现了

  IDisposable

  ，当

  reg

  超出范围时，它将自动注销自身。（您可以使用C#中的

  语句执行此操作。）

免责声明：我现在不在编译器处；可能存在语法错误