C#该委托必须有一个目标且仅有一个目标，使用【同步Invoke】代替【异步BeginInvoke】即可解决

在代理调用BeginInvoke(new AsyncCallback(callBack), null);时,会抛这个异常的原因是该代理变量代理了一个以上的方法.。

解决方案：

事件使用Invoke代替原来的BeginInvoke

因更新界面已经是BeginInvoke了，因此触发事件使用BeginInvoke可能会弹出【委托必须有一个目标且仅有一个目标】错误。

在线程中触发事件使用BeginInvoke，同时更新刷新界面也使用BeginInvoke就会出现这种问题。

出现Bug的相关源程序如下：

定义事件【事件是一种特殊的委托】

/// <summary>
        /// 刷新工单剩余数量:工单号：工单总数，已释放数，剩余数量
        /// </summary>
        static event Action<string, decimal, decimal, decimal> EventUpdateQuantity;

初始化方法时绑定事件

public FormWorkOrder()
        {
            InitializeComponent();
            //其他逻辑

            EventUpdateQuantity -= FrmWorkOrderConfig_EventUpdateQuantity;
            EventUpdateQuantity += FrmWorkOrderConfig_EventUpdateQuantity;            
        }

        /// <summary>
        /// 工单号：工单总数，已释放数，剩余数量
        /// </summary>
        /// <param name="workOrderPara"></param>
        /// <param name="totalQuantity"></param>
        /// <param name="releasedQuantity"></param>
        /// <param name="remainderQuantity"></param>
        private void FrmWorkOrderConfig_EventUpdateQuantity(string workOrderPara, decimal totalQuantity, decimal releasedQuantity, decimal remainderQuantity)
        {
            try
            {
                //异步刷新工单列表
                this.BeginInvoke(new Action(() =>
                {
                    for (int i = 0; i < dgvData.Rows.Count; i++)
                    {
                        string workOrder = Convert.ToString(dgvData["dgvcWorkOrder", i].Value);
                        if (!string.IsNullOrWhiteSpace(workOrder) && workOrder.Trim() == workOrderPara)
                        {
                            //如果类型代码不为空 和 模组PN码为空，就出错
                            dgvData["dgvcTotal", i].Value = totalQuantity;
                            dgvData["dgvcReleased", i].Value = releasedQuantity;
                            dgvData["dgvcRemainder", i].Value = remainderQuantity;
                            break;
                        }
                    }
                }));
            }
            catch (Exception ex)
            {
                MessageBox.Show($"当前工单刷新错误:{ex.Message}");
            }
        }

Load事件中开启一个线程，每个2秒就刷新工单剩余数量：

/// <summary>
        /// 刷新工单剩余数量，每隔60秒刷新一次
        /// </summary>
        private void RefreshWorkOrderQuantity()
        {
            int scanPeriodSecond = 2;//扫描周期默认2秒
            Task.Factory.StartNew(() =>
            {
                try
                {
                    while (isMonitor)
                    {
                        //读取所有工单信息
                        List<string> workOrderList = new List<string>();
                        for (int i = 0; i < dgvData.Rows.Count; i++)
                        {
                            string workOrder = Convert.ToString(dgvData["dgvcWorkOrder", i].Value);
                            if (!string.IsNullOrWhiteSpace(workOrder))
                            {
                                if (!workOrderList.Contains(workOrder.Trim()))
                                {
                                    workOrderList.Add(workOrder.Trim());
                                }
                            }
                        }

                        //获取每个工单对应的 工单总数，已释放数，剩余数量
                        for (int i = 0; i < workOrderList.Count; i++)
                        {
                            Tuple<string, decimal, decimal> tuple = GetWorkOrderQuantity(workOrderList[i]);
                            decimal remainderQuantity = tuple.Item2 - tuple.Item3;
                            if (EventUpdateQuantity != null)
                            {
                                //原来的代码 委托不能重新绑定，只能绑定一次
                                EventUpdateQuantity.BeginInvoke(workOrderList[i], tuple.Item2, tuple.Item3, remainderQuantity, null, null);
                                //EventUpdateQuantity.Invoke(workOrderList[i], tuple.Item2, tuple.Item3, remainderQuantity);
                            }
                        }
                        Thread.Sleep(scanPeriodSecond * 1000);
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show($"出错:【{ex.Message}】", "错误");
                }
            });
        }

        /// <summary>
        /// 获取工单总数与已释放数
        /// </summary>
        /// <param name="workOrder"></param>
        /// <returns></returns>
        private Tuple<string, decimal, decimal> GetWorkOrderQuantity(string workOrder)
        {
            return ListWorkOrder.Find(tuple => tuple.Item1 == workOrder);
        }

运行的时候，界面不刷新工单数量，有时还会弹出【该委托必须有一个目标且仅有一个目标】

解决方案：将事件触发调用由【异步BeginInvoke】修改为【同步Invoke】。

新建窗体应用程序DelegateTestDemo，将默认的Form1重命名为FormWorkOrder。

窗体设计如图：

 窗体FormWorkOrder源程序如下【忽略设计器自动生成的代码】

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace DelegateTestDemo
{
    public partial class FormWorkOrder : Form
    {
        /// <summary>
        /// 开启监控工单剩余数量,已释放数
        /// </summary>
        static bool isMonitor = false;
        /// <summary>
        /// 刷新工单剩余数量:工单号：工单总数，已释放数，剩余数量
        /// </summary>
        static event Action<string, decimal, decimal, decimal> EventUpdateQuantity;
        /// <summary>
        /// 工单列表：元组的第一个代表工单编号，第二个代表工单总数，第三代表已释放数
        /// </summary>
        static List<Tuple<string, decimal, decimal>> ListWorkOrder = new List<Tuple<string, decimal, decimal>>();
        public FormWorkOrder()
        {
            InitializeComponent();

            //改变DataGridview的列标题字体颜色
            dgvcWorkOrder.HeaderCell.Style = new DataGridViewCellStyle() { ForeColor = Color.Red };
            dgvcRemainder.HeaderCell.Style = new DataGridViewCellStyle() { ForeColor = Color.Red };
            this.dgvData.EnableHeadersVisualStyles = false;

            dgvcTotal.ReadOnly = true;
            dgvcReleased.ReadOnly = true;
            dgvcRemainder.ReadOnly = true;

            this.FormClosing += FormWorkOrder_FormClosing;

            EventUpdateQuantity -= FrmWorkOrderConfig_EventUpdateQuantity;
            EventUpdateQuantity += FrmWorkOrderConfig_EventUpdateQuantity;
            InitAllWorkOrder();
        }

        /// <summary>
        /// 关闭窗体前移除事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void FormWorkOrder_FormClosing(object sender, FormClosingEventArgs e)
        {
            isMonitor = false;
            EventUpdateQuantity -= FrmWorkOrderConfig_EventUpdateQuantity;
        }

        /// <summary>
        /// 初始化加载所有工单
        /// </summary>
        void InitAllWorkOrder()
        {
            ListWorkOrder = new List<Tuple<string, decimal, decimal>>();
            ListWorkOrder.Add(Tuple.Create("123456", 1000M, 200M));
            ListWorkOrder.Add(Tuple.Create("234567", 800M, 300M));
            ListWorkOrder.Add(Tuple.Create("345678", 700M, 256M));
            ListWorkOrder.Add(Tuple.Create("456789", 900M, 499M));

            dgvData.Rows.Clear();
            for (int i = 0; i < ListWorkOrder.Count; i++)
            {
                dgvData.Rows.Add(ListWorkOrder[i].Item1, ListWorkOrder[i].Item2, ListWorkOrder[i].Item3, ListWorkOrder[i].Item2 - ListWorkOrder[i].Item3);
            }
        }

        /// <summary>
        /// 工单号：工单总数，已释放数，剩余数量
        /// </summary>
        /// <param name="workOrderPara"></param>
        /// <param name="totalQuantity"></param>
        /// <param name="releasedQuantity"></param>
        /// <param name="remainderQuantity"></param>
        private void FrmWorkOrderConfig_EventUpdateQuantity(string workOrderPara, decimal totalQuantity, decimal releasedQuantity, decimal remainderQuantity)
        {
            try
            {
                //异步刷新工单列表
                this.BeginInvoke(new Action(() =>
                {
                    for (int i = 0; i < dgvData.Rows.Count; i++)
                    {
                        string workOrder = Convert.ToString(dgvData["dgvcWorkOrder", i].Value);
                        if (!string.IsNullOrWhiteSpace(workOrder) && workOrder.Trim() == workOrderPara)
                        {
                            //如果类型代码不为空 和 模组PN码为空，就出错
                            dgvData["dgvcTotal", i].Value = totalQuantity;
                            dgvData["dgvcReleased", i].Value = releasedQuantity;
                            dgvData["dgvcRemainder", i].Value = remainderQuantity;
                            break;
                        }
                    }
                }));
            }
            catch (Exception ex)
            {
                MessageBox.Show($"当前工单刷新错误:{ex.Message}");
            }
        }

        /// <summary>
        /// 窗体加载事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void FormWorkOrder_Load(object sender, EventArgs e)
        {
            isMonitor = true;
            RefreshWorkOrderQuantity();
        }

        /// <summary>
        /// 刷新工单剩余数量，每隔60秒刷新一次
        /// </summary>
        private void RefreshWorkOrderQuantity()
        {
            int scanPeriodSecond = 2;//扫描周期默认2秒
            Task.Factory.StartNew(() =>
            {
                try
                {
                    while (isMonitor)
                    {
                        //读取所有工单信息
                        List<string> workOrderList = new List<string>();
                        for (int i = 0; i < dgvData.Rows.Count; i++)
                        {
                            string workOrder = Convert.ToString(dgvData["dgvcWorkOrder", i].Value);
                            if (!string.IsNullOrWhiteSpace(workOrder))
                            {
                                if (!workOrderList.Contains(workOrder.Trim()))
                                {
                                    workOrderList.Add(workOrder.Trim());
                                }
                            }
                        }

                        //获取每个工单对应的 工单总数，已释放数，剩余数量
                        for (int i = 0; i < workOrderList.Count; i++)
                        {
                            Tuple<string, decimal, decimal> tuple = GetWorkOrderQuantity(workOrderList[i]);
                            decimal remainderQuantity = tuple.Item2 - tuple.Item3;
                            if (EventUpdateQuantity != null)
                            {
                                //原来的代码 委托不能重新绑定，只能绑定一次
                                //EventUpdateQuantity.BeginInvoke(workOrderList[i], tuple.Item2, tuple.Item3, remainderQuantity, null, null);
                                EventUpdateQuantity.Invoke(workOrderList[i], tuple.Item2, tuple.Item3, remainderQuantity);
                            }
                        }
                        Thread.Sleep(scanPeriodSecond * 1000);
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show($"出错:【{ex.Message}】", "错误");
                }
            });
        }

        /// <summary>
        /// 获取工单总数与已释放数
        /// </summary>
        /// <param name="workOrder"></param>
        /// <returns></returns>
        private Tuple<string, decimal, decimal> GetWorkOrderQuantity(string workOrder)
        {
            return ListWorkOrder.Find(tuple => tuple.Item1 == workOrder);
        }

        /// <summary>
        /// 刷新按钮
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnRefresh_Click(object sender, EventArgs e)
        {
            FormWorkOrder_Load(null, e);
        }

        private void btnAdd_Click(object sender, EventArgs e)
        {
            isMonitor = false;
            int index = new Random().Next(0, ListWorkOrder.Count);
            if (ListWorkOrder[index].Item3 < ListWorkOrder[index].Item2)
            {
                ListWorkOrder[index] = Tuple.Create(ListWorkOrder[index].Item1, ListWorkOrder[index].Item2, ListWorkOrder[index].Item3 + 1);
            }

            FormWorkOrder_Load(null, e);
            isMonitor = true;
        }
    }
}

运行测试如图：