C# 如何将WinForms中的progressBar更改为本机C++；密码？

我尝试在WinForms中使用来自的代码来更改progressBar。 但是，如果我创建表单，从C++ DLL调用的函数不会启动（cSARPREPORTPrimeStStaseSUMER（））。没有形式的创造，它工作得很好

CppLayer.h：

#define DLLAPI __declspec(dllexport)

extern "C" 
{
    typedef void (__stdcall *ReportProgressCallback)(int, char *);
    typedef bool (__stdcall *CancellationPendingCallback)();

    struct DLLAPI WorkProgressInteropNegotiator 
    {
        ReportProgressCallback progressCallback;
        CancellationPendingCallback cancellationPending;
        bool cancel;
    };

    DLLAPI void __stdcall CppLongFunction(WorkProgressInteropNegotiator& negotiator);
}

CppLayer.cpp：

#include "CppLayer.h"
#include <iostream>
#include <windows.h> //Для sleep

typedef void (__stdcall * pfnCallback)(int progress, int* cancel);

extern "C"
{
    DLLAPI void __stdcall CppLongFunction(WorkProgressInteropNegotiator& negotiator)
    {
        const int STEP_COUNT = 12;

        char * messages[3] = {"ONE", "TWO", "THREE"};

        for (int i = 0; i < STEP_COUNT; i++)
        {
            Sleep(100);

            if (negotiator.cancellationPending()) {
                negotiator.cancel = true; 
                break;
            }

            std::cout << "Calculate " << i << std::endl;
            negotiator.progressCallback((i + 1) * 100 / STEP_COUNT, messages[i % 3]);
        }
    }
};

表格1.cs：

Presenter.cs：

---

该问题通过在单独的线程中传输dll调用和通过调用从该线程进行GUI更新得到解决

表格1.cs：

using System;
using System.ComponentModel;
using System.Windows.Forms;

namespace CallBackFromCpp
{
    public partial class Form1 : Form
    {
        public event EventHandler StartEvent;

        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            if (StartEvent != null)
                StartEvent(this, e);
        }

        private void button2_Click(object sender, EventArgs e)
        {
            if (StopEvent != null)
                StopEvent(this, e);
        }
    }
}

Presenter.cs：

using System;
using System.Threading;
using System.Windows.Forms;

namespace CallBackFromCpp
{
    public class Presenter
    {
        Form1 _view;
        WorkerClass _wc;

        public ApplicationContext Init()
        {
            _view = new Form1();
            _view.StartEvent += _view_StartEvent;
            _view.StopEvent += _view_StopEvent;

            return new ApplicationContext(_view);
        }

        void _view_StopEvent(object sender, EventArgs e)
        {
            if (_wc != null)
                _wc.Stop = true;
        }

        delegate void ShowProgressDelegate(int progressPercentage, string message);

        private void ShowProgress(int progressPercentage, string message)
        {
            _view.richTextBox1.Text += String.Format("Report {0:00}% with message '{1}'\n", progressPercentage, message);
            _view.progressBar1.PerformStep();
        }

        void _view_StartEvent(object sender, EventArgs e)
        {
            ShowProgressDelegate showProgress = new ShowProgressDelegate(ShowProgress);
            _wc = new WorkerClass(_view, showProgress);
            Thread t = new Thread(new ThreadStart(_wc.RunProcess));
            t.IsBackground = true; //make them a daemon - prevent thread callback issues
            t.Start();
        }
   }
}

WorkerClass.cs：

using System;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows.Forms;

namespace CallBackFromCpp
{
    public class WorkerClass
    {
        /// <summary>
        /// Usually a form or a winform control that implements "Invoke/BeginInvode"
        /// </summary>
        ContainerControl _sender = null;

        /// <summary>
        /// The delegate method (callback) on the sender to call
        /// </summary>
        Delegate _senderDelegate = null;

        public delegate void ReportProgressCallback(int percentage, string message);

        public delegate bool CancellationPendingCallback();

        [StructLayout(LayoutKind.Sequential)]
        public class WorkProgressInteropNegotiator
        {
            public ReportProgressCallback reportProgress;

            public CancellationPendingCallback cancellationPending;

#pragma warning disable 0649
            // C# does not see this member is set up in native code, we disable warning to avoid it.
            public bool cancel;
#pragma warning restore 0649
        }

        [DllImport("CppLayer.dll")]
        public static extern void CppLongFunction([In, Out] WorkProgressInteropNegotiator negotiator);

        /// <summary>
        /// Constructor called by calle using ThreadPool OR ThreadStart
        /// </summary>
        public WorkerClass(ContainerControl sender, Delegate senderDelegate)
        {
            _sender = sender;
            _senderDelegate = senderDelegate;
        }

        /// <summary>
        /// Method for ThreadStart delegate
        /// </summary>
        public void RunProcess()
        {
            Thread.CurrentThread.IsBackground = true; //make them a daemon

            WorkProgressInteropNegotiator negotiator = new WorkProgressInteropNegotiator();
            negotiator.reportProgress = new ReportProgressCallback(ReportProgress);
            negotiator.cancellationPending = new CancellationPendingCallback(() => { return Stop; });

            // Refer for details to
            // "How to: Marshal Callbacks and Delegates Using C++ Interop" 
            // http://msdn.microsoft.com/en-us/library/367eeye0%28v=vs.100%29.aspx
            GCHandle gch = GCHandle.Alloc(negotiator);

            CppLongFunction(negotiator);

            gch.Free();
        }

        private void ReportProgress(int progressPercentage, string message)
        {
            _sender.BeginInvoke(_senderDelegate, new object[] { progressPercentage, message });
        }

        volatile bool _stop = false;
        public bool Stop
        {
            set 
            {
                 _stop = value;
            }
            get
            {
                return _stop;
            }
        }
    }
}

使用系统；
使用System.Runtime.InteropServices；
使用系统线程；
使用System.Windows.Forms；
命名空间CallBackFromCpp
{
公营工人班
{
/// 
///通常是实现“Invoke/BeginInvode”的窗体或winform控件
/// 
ContainerControl\u sender=null；
/// 
///要调用的发送方上的委托方法（回调）
/// 
委托_senderDelegate=null；
公共委托void ReportProgressCallback（整数百分比，字符串消息）；
公共委托bool CancellationPendingCallback（）；
[StructLayout（LayoutKind.Sequential）]
公共类WorkProgressInteropNegotiator
{
公共报告进度回调报告进度；
公共取消挂起回调取消挂起；
#pragma警告禁用0649
//C#没有看到此成员是在本机代码中设置的，我们禁用警告以避免它。
公共图书馆取消；
#pragma警告恢复0649
}
[DllImport（“CppLayer.dll”）]
公共静态外部无效CppLongFunction（[In，Out]WorkProgressInteropnPnegotiator谈判者）；
/// 
///被调用方使用ThreadPool或ThreadStart调用的构造函数
/// 
公共WorkerClass（容器控制发送器、代理发送器Delegate）
{
_发送方=发送方；
_senderDelegate=senderDelegate；
}
/// 
///ThreadStart委托的方法
/// 
公共无效运行进程（）
{
Thread.CurrentThread.IsBackground=true；//使它们成为守护进程
WorkProgressInteropNegotiator谈判者=新的WorkProgressInteropNegotiator（）；
reportProgress=新的ReportProgressCallback（reportProgress）；
congregator.cancellationPending=新的CancellationPendingCallback（（）=>{return Stop；}）；
//有关详细信息，请参阅
//“如何：使用C++互操作封送回调和委托”
// http://msdn.microsoft.com/en-us/library/367eeye0%28v=vs.100%29.aspx
GCHandle gch=GCHandle.Alloc（谈判者）；
首席谈判代表（谈判代表）；
gch.Free（）；
}
私有void报告进度（int progressPercentage，字符串消息）
{
_sender.BeginInvoke（_senderDelegate，新对象[]{progressPercentage，message}）；
}
易失性bool_stop=false；
公共车站
{
设置
{
_停止=值；
}
得到
{
返回-停止；
}
}
}
}

“不工作”不是适当的问题描述。

using System;
using System.ComponentModel;
using System.Windows.Forms;

namespace CallBackFromCpp
{
    public partial class Form1 : Form
    {
        public event EventHandler StartEvent;

        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            if (StartEvent != null)
                StartEvent(this, e);
        }

        private void button2_Click(object sender, EventArgs e)
        {
            if (StopEvent != null)
                StopEvent(this, e);
        }
    }
}

using System;
using System.Threading;
using System.Windows.Forms;

namespace CallBackFromCpp
{
    public class Presenter
    {
        Form1 _view;
        WorkerClass _wc;

        public ApplicationContext Init()
        {
            _view = new Form1();
            _view.StartEvent += _view_StartEvent;
            _view.StopEvent += _view_StopEvent;

            return new ApplicationContext(_view);
        }

        void _view_StopEvent(object sender, EventArgs e)
        {
            if (_wc != null)
                _wc.Stop = true;
        }

        delegate void ShowProgressDelegate(int progressPercentage, string message);

        private void ShowProgress(int progressPercentage, string message)
        {
            _view.richTextBox1.Text += String.Format("Report {0:00}% with message '{1}'\n", progressPercentage, message);
            _view.progressBar1.PerformStep();
        }

        void _view_StartEvent(object sender, EventArgs e)
        {
            ShowProgressDelegate showProgress = new ShowProgressDelegate(ShowProgress);
            _wc = new WorkerClass(_view, showProgress);
            Thread t = new Thread(new ThreadStart(_wc.RunProcess));
            t.IsBackground = true; //make them a daemon - prevent thread callback issues
            t.Start();
        }
   }
}

using System;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows.Forms;

namespace CallBackFromCpp
{
    public class WorkerClass
    {
        /// <summary>
        /// Usually a form or a winform control that implements "Invoke/BeginInvode"
        /// </summary>
        ContainerControl _sender = null;

        /// <summary>
        /// The delegate method (callback) on the sender to call
        /// </summary>
        Delegate _senderDelegate = null;

        public delegate void ReportProgressCallback(int percentage, string message);

        public delegate bool CancellationPendingCallback();

        [StructLayout(LayoutKind.Sequential)]
        public class WorkProgressInteropNegotiator
        {
            public ReportProgressCallback reportProgress;

            public CancellationPendingCallback cancellationPending;

#pragma warning disable 0649
            // C# does not see this member is set up in native code, we disable warning to avoid it.
            public bool cancel;
#pragma warning restore 0649
        }

        [DllImport("CppLayer.dll")]
        public static extern void CppLongFunction([In, Out] WorkProgressInteropNegotiator negotiator);

        /// <summary>
        /// Constructor called by calle using ThreadPool OR ThreadStart
        /// </summary>
        public WorkerClass(ContainerControl sender, Delegate senderDelegate)
        {
            _sender = sender;
            _senderDelegate = senderDelegate;
        }

        /// <summary>
        /// Method for ThreadStart delegate
        /// </summary>
        public void RunProcess()
        {
            Thread.CurrentThread.IsBackground = true; //make them a daemon

            WorkProgressInteropNegotiator negotiator = new WorkProgressInteropNegotiator();
            negotiator.reportProgress = new ReportProgressCallback(ReportProgress);
            negotiator.cancellationPending = new CancellationPendingCallback(() => { return Stop; });

            // Refer for details to
            // "How to: Marshal Callbacks and Delegates Using C++ Interop" 
            // http://msdn.microsoft.com/en-us/library/367eeye0%28v=vs.100%29.aspx
            GCHandle gch = GCHandle.Alloc(negotiator);

            CppLongFunction(negotiator);

            gch.Free();
        }

        private void ReportProgress(int progressPercentage, string message)
        {
            _sender.BeginInvoke(_senderDelegate, new object[] { progressPercentage, message });
        }

        volatile bool _stop = false;
        public bool Stop
        {
            set 
            {
                 _stop = value;
            }
            get
            {
                return _stop;
            }
        }
    }
}