C# 异步编程 WinForm中的常见问题

已于 2024-02-22 19:09:48 修改
阅读量4.2k 收藏 15
点赞数 5
分类专栏： 假装会写C# 文章标签： c# ui .net
于 2022-12-17 12:52:45 首次发布
本文为博主原创文章，未经许可不得用于商业用途。转载请注明出处，否则保留追究法律责任的权利。
本文链接：https://blog.csdn.net/Raink_LH/article/details/128352458
版权

目录

1、异步更新界面

1.1、问题

1.2、解决问题

1.3、AsyncOperationManager和AsyncOperation

1.4、Invoke、BeginInvoke、EndInvoke及InvokeRequired

Invoke

InvokeRequired

BeginInvoke

EndInvoke

2、死锁

2.1、问题

2.2、 解决方法

2.2.1、不要await

2.2.2、用await代替Wait()/Result

2.2.3、使用新的异步方法中转

2.2.4、ConfigAwaiter(false)

3、ConfigAwaiter(false)

1、异步更新界面

1.1、问题

先新建个简单winform窗体程序（取名WinFormsTPL）

界面及按钮实现如下：

namespace WinFormsTPL
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void btnAsyncUpdate_Click(object sender, EventArgs e)
		{
            Task.Factory.StartNew(() =>
            {    
                this.lbText.Text = "你好，世界！";
            });
        }
    }
}

然后运行，就能得到WinForm开发中做异步编程时最常遇到的问题了，就是下面这个报错。

简单的理解就是不能跨线程访问UI。因为UI的变更绘制有专门的线程。

但是深究这个问题，法相想理解清楚似乎有点难度。看了很多资料，总是逃不过两个主要的动东西：UI线程和同步上下文（SynchronizationContext）。

具象化一点，打个可能不恰当的比喻，公司里面办事的员工相当于线程，部门以及办公室相当于同步上下文。员工（线程）的工作需要办公场所（同步上下文）。但员工可以在不同办公场所穿行走动去完成他的工作，例如去装配间组转设备然后去厂房调试设备，然后去办公室写ppt……

看一下巨硬家大佬的文章怎么说的（似乎有点久远）：

MSDN 杂志：并行计算 - SynchronizationContext 综述 | Microsoft Learn

SynchronizationContext 的实际“上下文”并没有明确的定义。不同的框架和主机可以自行定义自己的上下文。通过了解这些不同的实现及其限制，可以清楚了解 SynchronizationContext 概念可以和不可以实现的功能。我将简单讨论部分实现。

WindowsFormsSynchronizationContext（System.Windows.Forms.dll：System.Windows.Forms）Windows 窗体应用程序会创建并安装一个 WindowsFormsSynchronizationContext 作为创建 UI 控件的任意线程的当前上下文。这一 SynchronizationContext 使用 UI 控件的 ISynchronizeInvoke 方法，该方法将委托传递给基础 Win32 消息循环。WindowsFormsSynchronizationContext 的上下文是一个单独的 UI 线程。

在 WindowsFormsSynchronizationContext 列队的所有委托一次一个地执行；它们通过一个特定 UI 线程执行以便列队。当前实现为每个 UI 线程创建一个 WindowsFormsSynchronizationContext。

DispatcherSynchronizationContext（WindowsBase.dll：System.Windows.Threading）WPF 和 Silverlight 应用程序使用 DispatcherSynchronizationContext，这样，委托按“常规”优先级在 UI 线程的调度程序中列队。当一个线程通过调用 Dispatcher.Run 开始其调度程序时，这一 SynchronizationContext 作为当前上下文安装。DispatcherSynchronizationContext 的上下文是一个单独的 UI 线程。

在 DispatcherSynchronizationContext 列队的所有委托一次一个地执行；它们通过一个特定 UI 线程执行以便列队。当前实现为每个顶层窗口创建一个 DispatcherSynchronizationContext，即使它们都使用相同的基础调度程序也是如此。

本人WPF不熟，单说Winform的SynchronizationContext也就是WindowsFormsSynchronizationContext

，作为创建 UI 控件的任意线程的当前上下文。那就是说一个窗体程序（winform）只能有一个同步上下文。

那么能不能在一个同步上下文里启动另一个winfom程序呢？

在窗体上bia一个按钮，按钮事件中调用

Application.Run(new Form2());

ok，报错：

窗体程序的UI线程底层就是消息循环机制，一个线程上只能有一个消息循环。（没有找到比较明确的官方文档说明）

那么对于一个winform程序，其UI线程是单一线程，与其对应的同步上下文（SynchronizationContext）也只有一个。

不过也不是不能有多UI线程的窗体程序，比如这样写就不会报错：

private void btn_Click(object sender, EventArgs e)
{
    var thread = new Thread(() =>
    {
        Form f = new Form();
        Application.Run(f);
    });
    thread.SetApartmentState(ApartmentState.STA);
    thread.Start();
}

这样即在新线程里启动新窗体，但新的窗体也会有新的同步上下文。

在之前提到的官方文档MSDN 杂志：并行计算 - SynchronizationContext 综述 | Microsoft Learn 中也能看到说明

SynchronizationContext 实例和线程之间没有 1:1 的对应关系。WindowsFormsSynchronizationContext 确实 1:1 映射到一个线程（只要不调用 SynchronizationContext.CreateCopy），但任何其他实现都不是这样。一般而言，最好不要假设任何上下文实例将在任何指定线程上运行。

回过头来再看一下最初的报错信息：“从不是创建控件“xxx”的线程访问它”。即一个控件、一个窗体的同步上下文是在new它的时候确定的，如果在新线程中，则也会有新的同步上下文。

1.2、解决问题

大致了解清楚原有后，解决这个问题的方式就明确了，无非就是两条路，一是回到创建它的线程，二是回到它的同步上下文。

先看第一种

private void btnAsyncUpdate_Click(object sender, EventArgs e)
{
    Task.Factory.StartNew(() =>
    {
    });
    this.lbText.Text = "你好，世界！";
}

emmm……“避免bug的最好方式就是不写代码！”避免异步报错的方式就是不要异步！

看过废话文学后看第二种方法：

private async void btnAsyncUpdate_Click(object sender, EventArgs e)
{
    SynchronizationContext currentContext = SynchronizationContext.Current;
    await Task.Factory.StartNew((c) =>
    {
        SendOrPostCallback sendCallback = (o) =>
        {
            this.lbText.Text = "你好，世界！";
        };
        if (c is WindowsFormsSynchronizationContext context)
        {
            context.Send(sendCallback, null);
        }

    }, currentContext);           
}

即使用SynchronizationContext.Send()方法。将界面操作封送会原有的同步上下文，执行时对控件的赋值自然在原有的同步上下文对应的线程上执行了，就不会报错。

SynchronizationContext有Send和Post()两个常用方法，有很多文章来详细介绍两者不同，总结的说，Send()是封送到同步执行，Post()是异步执行。具体看下源码，结合之前对线程和线程池的说明就很好理解了：

public virtual void Send(SendOrPostCallback d, Object state)
{
    d(state);
}
 
public virtual void Post(SendOrPostCallback d, Object state)
{
    ThreadPool.QueueUserWorkItem(new WaitCallback(d), state);
}

1.3、AsyncOperationManager和AsyncOperation

在VS中编写1.2中方法二的代码时，可以看到VS的一个提示：

即是说SynchronizationContext.Current是可能未空的，实际上控制台程序中该项即默认为空的。

更加推荐使用AsyncOperationManager和AsyncOperation

.NET Framework 中的 AsyncOperationManager 和 AsyncOperation 类是 SynchronizationContext 抽象的轻型包装。AsyncOperationManager 在第一次创建 AsyncOperation 时捕获当前 SynchronizationContext，如果当前 SynchronizationContext 为 null，则使用默认 SynchronizationContext。AsyncOperation 将委托异步发布到捕获的 SynchronizationContext。

最新的.Net7中也是有这两个类的。

public static class AsyncOperationManager
{
    public static AsyncOperation CreateOperation(object userSuppliedState)
    {
        return AsyncOperation.CreateOperation(userSuppliedState, SynchronizationContext);
    }

    /// <include file='doc\AsyncOperationManager.uex' path='docs/doc[@for="AsyncOperationManager.SynchronizationContext"]/*' />
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public static SynchronizationContext SynchronizationContext
    {
        get
        {
            if (SynchronizationContext.Current == null)
            {
                SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
            }

            return SynchronizationContext.Current;
        }

#if SILVERLIGHT
        // a thread should set this to null  when it is done, else the context will never be disposed/GC'd
        [SecurityCritical]
        [FriendAccessAllowed]
        internal set {
            SynchronizationContext.SetSynchronizationContext(value);
        }
#else
        // a thread should set this to null  when it is done, else the context will never be disposed/GC'd
        [PermissionSetAttribute(SecurityAction.LinkDemand, Name = "FullTrust")]
        set
        {
            SynchronizationContext.SetSynchronizationContext(value);
        }
#endif
    }
}

即使用AsyncOperationManager.CreateOperation()实例化AsyncOperation对象时是会判断有没有SynchronizationContext，没有则会创建一个SynchronizationContext，以确保其不为空。

再来看AsyncOperation，源码如下：

namespace System.ComponentModel
{
    using System.Security.Permissions;
    using System.Threading;
    
    [HostProtection(SharedState = true)]
    public sealed class AsyncOperation
    {
        private SynchronizationContext syncContext;
        private object userSuppliedState; 
        private bool alreadyCompleted;
 
        /// <summary>
        ///     Constructor. Protected to avoid unwitting usage - AsyncOperation objects
        ///     are typically created by AsyncOperationManager calling CreateOperation.
        /// </summary>
        private AsyncOperation(object userSuppliedState, SynchronizationContext syncContext)
        {
            this.userSuppliedState = userSuppliedState;
            this.syncContext = syncContext;
            this.alreadyCompleted = false;
            this.syncContext.OperationStarted();
        }
 
        /// <summary>
        ///     Destructor. Guarantees that sync context will always get notified of completion.
        /// </summary>
        ~AsyncOperation()
        {
            if (!alreadyCompleted && syncContext != null)
            {
                syncContext.OperationCompleted();
            }
        }
 
        public object UserSuppliedState
        {
            get { return userSuppliedState; }
        }
 
        /// <include file='doc\AsyncOperation.uex' path='docs/doc[@for="AsyncOperation.SynchronizationContext"]/*' />
        public SynchronizationContext SynchronizationContext
        {
            get
            {
                return syncContext;
            }
        }
 
        public void Post(SendOrPostCallback d, object arg)
        {
            VerifyNotCompleted();
            VerifyDelegateNotNull(d);
            syncContext.Post(d, arg);
        }
 
        public void PostOperationCompleted(SendOrPostCallback d, object arg)
        {
            Post(d, arg);
            OperationCompletedCore();
        }
 
        public void OperationCompleted()
        {
            VerifyNotCompleted();
            OperationCompletedCore();
        }
 
        private void OperationCompletedCore()
        {
            try
            {
                syncContext.OperationCompleted();
            }
            finally
            {
                alreadyCompleted = true;
                GC.SuppressFinalize(this);
            }
        }
 
        private void VerifyNotCompleted()
        {
            if (alreadyCompleted)
            {
                throw new InvalidOperationException(SR.GetString(SR.Async_OperationAlreadyCompleted));
            }
        }
 
        private void VerifyDelegateNotNull(SendOrPostCallback d)
        {
            if (d == null)
            {
                throw new ArgumentNullException(SR.GetString(SR.Async_NullDelegate), "d");
            }
        }
 
        /// <summary>
        ///     Only for use by AsyncOperationManager to create new AsyncOperation objects
        /// </summary>
        internal static AsyncOperation CreateOperation(object userSuppliedState, SynchronizationContext syncContext)
        {
            AsyncOperation newOp = new AsyncOperation(userSuppliedState, syncContext); 
            return newOp;
        }
    }
}

从源码看，一方面可以获取到不为空的SynchronizationContext，并且可以直接使用Post()方式进行调用，Post（）内部处理前做了校验，一个委托只能在OperationCompleted()之前调用，使用PostOperationCompleted（）即调用一次边关闭，Completed之后内部会调用GC回收这个AsyncOperation对象。

还有一点要说，就是更多的是在基于事件的异步编程中使用的，基于事件的异步编程已经不被推荐，更多的使用基于任务的异步编程。

新组件不应使用基于事件的异步模式。Visual Studio 异步社区技术预览 (CTP) 包含一篇描述基于任务的异步模式的文档，在这种模式下，组件返回 Task 和 Task<TResult> 对象，而不是通过 SynchronizationContext 引发事件。基于任务的 API 是 .NET 中异步编程的发展方向。

1.4、Invoke、BeginInvoke、EndInvoke及InvokeRequired

如1.1和1.2中所说，如果有窗体或者控件（假设Form2）是在新的线程中（new Thread）创建，但是又想在主界面的UI线程(From1)中去操作这个窗体（Form2）的更新。例如下面的代码，应该怎么改更合适呢？

private void btnAsyncUpdate_Click(object sender, EventArgs e)
{
    Form2 form2 = null;
    Task.Factory.StartNew(() =>
    {
        form2 = new Form2();
        form2.ShowDialog();
    });
    Thread.Sleep(1000);//确保form2被实例化了
    form2.Text = "新窗体";//会报跨线程访问的错误
}

按前文的方法们就得在Form2中添加公共的SynchronizationContext或AsyncOperation属性，然后在form1中再去定义委托，再用form2的这个属性去传递这个委托，就会很麻烦。

WinForm中实际上已经封装了更为直接的方法，即Invoke

Invoke的注释翻译过来大概如下：

在拥有此控件的基础窗口句柄的线程上执行给定的委托。在该控件所属的同一线程上调用此方法是错误的。如果控件的句柄尚不存在，这将跟随控件的父链，直到找到确实具有窗口句柄的控件或窗体。如果找不到合适的句柄，Invoke将引发异常。在调用期间引发的异常将被传递回调用方。

从任何线程都可以安全地调用控件上的五个函数：GetInvokeRequired、Invoke、BeginInvoke、EndInvoke和CreateGraphics。对于所有其他方法调用，应使用其中一个Invoke方法来封送对控件线程的调用。

GetInvokeRequired、Invoke、BeginInvoke、EndInvoke和CreateGraphics都是System.Windows.Forms.Control下的方法。

GetInvokeRequired应该是较旧的方法，最新的与之对应的应该是InvokeRequired

InvokeRequired、Invoke、BeginInvoke、EndInvoke都是借口ISynchronizeInvoke所规定的。

Invoke

在拥有此控件的基础窗口句柄的线程上执行委托。

因此前面的例子可以直接改写为：

private void btnAsyncUpdate_Click(object sender, EventArgs e)
{
    Form2 form2 = null;
    Task.Factory.StartNew(() =>
    {
        form2 = new Form2();
        form2.ShowDialog();
    });
    Thread.Sleep(1000);//确保form2被实例化了
    form2.Invoke(() =>
        {
            form2.Text = "新窗体"
        });
}

在创建控件的线程上使用Invoke会报错。并且是根据控件或控件的父级中存在的窗体控件句柄（Handle）去查找底层的消息循环线程做处理的，所以控件或其父级必须具有实例的句柄，否则会抛异常。

InvokeRequired

获取一个bool值，该值指示调用方在对控件进行方法调用时是否必须调用 Invoke 方法，因为调用方位于创建控件所在的线程以外的线程中。

在创建控件的线程中使用Invoke会报错，所以当代码比较复杂时，提前做判断还是必要的：

private void btnAsyncUpdate_Click(object sender, EventArgs e)
{
    Form2 form2 = null;
    Task.Factory.StartNew(() =>
    {
        form2 = new Form2();
        form2.ShowDialog();
    });
    Thread.Sleep(1000);
    if (form2.InvokeRequired)
    {
        form2.Invoke(() =>
        {
            form2.Text = "新窗体";
        });
    }
}

BeginInvoke

先参考下源码：

public IAsyncResult BeginInvoke(Delegate method, params Object[] args) 
{
    using (new MultithreadSafeCallScope()) 
    {
        Control marshaler = FindMarshalingControl();
        return(IAsyncResult)marshaler.MarshaledInvoke(this, method, args, false);
    }
}

返回值是IAsyncResult类型的，有点熟悉哎，因为Task就是继承自IAsyncResult的。

BeginInvoke是异步的方法。即当需要Invoke一个比较耗时的任务时，可以考虑使用BeginInvoke，并不是要在这个方法中传入异步任务，而是它本身就是以异步方式执行。这样防止某个控件或窗体长时间的更新而对调用窗体造成假死状态。

比如：

private void btnAsyncUpdate_Click(object sender, EventArgs e)
{
    Form2 form2 = null;
    Task.Factory.StartNew(() =>
    {
        form2 = new Form2();
        form2.ShowDialog();
    });
    Thread.Sleep(500);
    if (form2.InvokeRequired)
    {
        form2.BeginInvoke(() =>
        {
            Thread.Sleep(1000);
            form2.Text = "新窗体";
        });
    }
    this.lbText.Text = "按钮事件执行完毕";
}

运行效果如下：先弹出form2窗体，然后form1主窗体中的label更新，然后form2窗体的标题才更新完毕。

看下关于BeginInvoke的官方注解

委托以异步方式调用，此方法会立即返回。 你可以从任何线程调用此方法，即使是拥有控件句柄的线程。 如果控件的句柄尚不存在，此方法将搜索控件的父链，直到找到具有窗口句柄的控件或窗体。 如果未找到适当的句柄， BeginInvoke 将引发异常。 委托方法中的异常被视为未捕获，并将发送到应用程序的未捕获异常处理程序。

这里隐藏了一些坑，控件不一定有句柄，如果按父链找到句柄就是调用BeginInvoke的窗体，这到底会怎样呢。

比如下面的操作

private void btnAsyncUpdate_Click(object sender, EventArgs e)
{    
    this.lbText.BeginInvoke(() =>
    {
        this.lbText.Text = "BeginInvoke正在执行";
        Thread.Sleep(2000);
        this.lbText.Text = "BeginInvoke执行完毕";
    });
    this.lbText.Text = "按钮事件执行完毕";
}

按异步的原理，应该会先看到"按钮事件执行完毕"，然后"BeginInvoke正在执行"等待2秒后看到"BeginInvoke执行完毕"。然而实际上只看到最后加一句。

也就是说BeginInvoke的时候实际上时将对应句柄的窗体控件挂起，知道异步方法执行结束后再绘制界面。label控件没有句柄，会找到父窗体的句柄在其上执行，所以即使上面的例子中，窗体中引入其他控件，最终也是等BeginInvoke的内容全部执行完后才更新整个界面。

所以在使用BeginInvoke时还是要多注意，尽量是跨窗体使用。

EndInvoke

BeginInvoke官方注解中的另一段话是这个：

可以调用 EndInvoke 以从委托中检索返回值（如果为 neccesary），但这不是必需的。 EndInvoke 将阻止，直到可以检索返回值。

即EndInvoke是将异步边同步，类似于Task的Wait()方法。

使用方式是将BeginInvoke返回的IAsyncResult对象传入。

private void btnAsyncUpdate_Click(object sender, EventArgs e)
{
    Form2 form2 = null;
    Task.Factory.StartNew(() =>
    {
        form2 = new Form2();
        form2.ShowDialog();
    });
    Thread.Sleep(500);
    if (form2.InvokeRequired)
    {
        IAsyncResult asyncResult = form2.BeginInvoke(() =>
        {
            Thread.Sleep(1000);
            form2.Text = "新窗体";
        });
        form2.EndInvoke(asyncResult);
    }
    this.lbText.Text = "按钮事件执行完毕";
}

2、死锁

2.1、问题

死锁是擦winform等界面编程中比较常见又很诡异的情况。

前文的例子中，在form1中加一个按钮（btnAsyncFunc）

按钮事件如下：

private void btnAsyncFunc_Click(object sender, EventArgs e)
{
    AsyncFunc().Wait();
    this.lbText.Text = "AsyncFunc执行完毕";
}
private async Task AsyncFunc()
{
    await Task.Run(() =>
    {
        Thread.Sleep(100);
    });
}

看似再简单不过的一段代码了，但是点击按钮时，界面会完美卡死，无法操作。

为什么？

参考之前的笔记：「C#」异步编程玩法笔记-async、await_Raink_LH的博客-CSDN博客

里面有说明async和await的执行顺序。异步方法AsyncFunc会同步运行到await处，然后运行Task并把Task返回，返回后发现是Wait()，就得等待Task执行完毕，Task执行完毕后，Task语句之后的代码是同步执行的，这里的同步执行是在创建Task的线程，例子中也就是UI线程。而UI线程只有一个，此时线程中正在运行的是调用方的Wait()方法，Wait()没有执行完毕就不会运行到Task之后的语句，所以AsyncFunc方法中Task.Run(...);之后的代码不会执行（虽然末尾没有代码了，但方法末尾的后大括号也可以认为是代码），但是AsyncFunc方法不执行到后大括号，AsyncFunc方法就不能结束，从而不能让Wait()结束。互相等，从而死锁。

由此也可以知道，在调用异步方法时使用Wait()、Result等阻塞方法时都有可能出现这种情况。

但这样的死锁不会在控制台程序中出现。且最大并发数没有做限制，await之后的代码与Wait()/Result的执行是在不同线程上发生的，两者是可以同时运行的，所以不会有影响。比如这个就不会有问题。

static void Main(string[] args)
{
    LockTest();
    Console.WriteLine("程序结束");
    Console.ReadLine();
}
private static void LockTest()
{
    Console.WriteLine("调用并等待异步方法");
    ConeoleAsyncFunc().Wait();
    Console.WriteLine("异步方法结束");
}
private static async Task ConeoleAsyncFunc()
{
    await Task.Run(() =>
    {
        Thread.Sleep(100);
        Console.WriteLine("ConeoleAsyncFunc"); 
    });
}

但如果我们使用自定义的任务调度器，限定最大并发数为1，且拒绝内联的方式执行任务（重写TaskScheduler中的TryExecuteTaskInline方法直接return false）,如下，程序就会自锁卡住。

static void Main(string[] args)
{
    TaskScheduler scheduler = new LimitedConcurrencyTaskScheduler(1);
    TaskFactory factory = new TaskFactory(scheduler);
    var t = factory.StartNew(LockTest);
    t.Wait();
    Console.WriteLine("程序结束");
    Console.ReadLine();
}

private static void LockTest()
{
    Console.WriteLine("调用并等待异步方法");
    ConeoleAsyncFunc().Wait();
    Console.WriteLine("异步方法结束");
}
private static async Task ConeoleAsyncFunc()
{
    await Task.Run(() =>
    {
        Thread.Sleep(100);
        Console.WriteLine("ConeoleAsyncFunc"); 
    });
}

2.2、 解决方法

2.2.1、不要await

既然要Wait()，要阻塞，那就最好把原方法改成同步的，不要有async，不要有await。

private void btnAsyncFunc_Click(object sender, EventArgs e)
{
    AsyncFunc().Wait();
    this.lbText.Text = "AsyncFunc执行完毕";
}
private Task AsyncFunc()
{
    var t =Task.Run(() =>
    {
        Thread.Sleep(100);
    });
    t.Wait();
}

嗯..........我承认这样有点脱裤子放屁，总之意思就是如果需要阻塞，就尽量不要用异步方法。

2.2.2、用await代替Wait()/Result

既然必须要异步，那么就异步到底，异步方法的调用者也使用async await。即：

private async void btnAsyncFunc_Click(object sender, EventArgs e)
{
    await AsyncFunc();
    this.lbText.Text = "AsyncFunc执行完毕";
}
private async Task AsyncFunc()
{
    await Task.Run(() =>
    {
        Thread.Sleep(100);
    });
}

对于异步方法有返回值TResult的，也已用await

private async void btnAsyncFunc_Click(object sender, EventArgs e)
{
    int num = await AsyncFunc();
    this.lbText.Text = "AsyncFunc执行完毕";
}
private async Task<int> AsyncFunc()
{
    await Task.Run(() =>
    {
        Thread.Sleep(100);
    });
    return 0;
}

2.2.3、使用新的异步方法中转

即再加一个异步方法，新的异步方法像2.2.1中说的，不要用async、await，而完全用Wait()/Result

private void btnAsyncFunc_Click(object sender, EventArgs e)
{
    RunAsyncFunc();
    this.lbText.Text = "AsyncFunc执行完毕";
}
private void RunAsyncFunc()
{
    var t = Task.Run(() =>
    {
        AsyncFunc().Wait();
    });
    t.Wait();
}
private async Task AsyncFunc()
{
    await Task.Run(() =>
    {
        Thread.Sleep(100);
        int a = 0;
    });
}

虽然异步方法AsyncFunc()后面还是用了Wait()，但是这个Wait()是在另一个线程中发生的，即AsyncFunc()中await之后的代码是在另一个线程中发生，而不是界面的UI主线程，所以不会造成死锁。

2.2.4、ConfigAwaiter(false)

这个是Task的一个公共方法。官方的注解如下：

异步方法直接等待 Task 时，延续任务通常会出现在创建任务的同一线程中，具体取决于异步上下文。 此行为可能会降低性能，并且可能会导致 UI 线程发生死锁。 若要避免这些问题，请调用 Task.ConfigureAwait(false)。

也就是说，ConfigAwaiter()传入false时，是不要将延续任务安排在创建任务的同一线程中。

按照第一节中的问题和本节死锁的问题分析，死锁根源是await结束后返回了UI线程，UI线程由呗占用。

所以如果将await之后的续接任务，安排在别的线程中，就不会死锁了。

比如这样

private async void btnAsyncFunc_Click(object sender, EventArgs e)
{
    int num = await AsyncFunc();
    this.lbText.Text = "AsyncFunc执行完毕";
}
private async Task<int> AsyncFunc()
{
    await Task.Run(() =>
    {
        Thread.Sleep(100);
    }).ConfigAwaiter(false);//使用ConfigAwaiter（false）
    return 0;
}

也可以解决死锁的问题。

3、ConfigAwaiter(false)

为什么把这个方法单独又列出来作为一节内容呢。再看一眼官方注解：

异步方法直接等待 Task 时，延续任务通常会出现在创建任务的同一线程中，具体取决于异步上下文。 此行为可能会降低性能，并且可能会导致 UI 线程发生死锁。 若要避免这些问题，请调用 Task.ConfigureAwait(false)。

似乎在UI编程中基于任务的多线程处理都应添加这个方法以避免死锁。

然后无脑使用这个方法，在避免第二节的死锁问题时，就很容易引发第一节的跨线程调用UI的错误。

ConfigureAwait(false)之后，也就是await的后续任务代码会在Task的上下文中执行，而如果后续任务是操作UI空间，则会触发“线程间操作无效……”的异常。

比如将上面的示例稍作调整，如下：

private void btnAsyncFunc_Click(object sender, EventArgs e)
{
    AsyncFunc().Wait();
}
private async Task AsyncFunc()
{
    await Task.Run(() =>
    {
        Thread.Sleep(100);
        int a = 0;
    }).ConfigureAwait(false);
    
    //异步完成后更新界面
    this.lbText.Text = "AsyncFunc执行完毕";
    }
}

运行后就是这样的结果。

所以ConfigAwaiter(false)不能无脑用，使用时一定主要，其后面不能有对UI界面的操作。

Raink_LH
关注
  • 5
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C# 多线程 异步加载 窗体
Coeus
05-28 1万+
我们在使用 windowform 编程的时候，我们或许可能会越到，各种在窗体加载的时候，会进行其他的操作： 1.若是在加载之前，操作---》整个界面出来的很慢，而且若是时间长的话，页面很久才能出来， 2.若是写在加载之后处理的话，虽然界面出来了，这个时候，出现了假死的状体。但是不能乱点，一点，就有卡死的现象。 现在我们利用异步，和多线程来控制，并且加上进度条。来做一个
C# winform OCR文字识别
03-26
在本项目“C# winform OCR文字识别”中，我们将探讨如何利用C#编程语言和Windows Forms（winform）框架来实现一个简单的OCR应用。 首先，我们需要理解C#和Winform的基本概念。C#是一种面向对象的编程语言，由微软...
winform/wpf调用异步api正确姿势，界面不卡
qq_18932003的博客
02-20 1608
api用的框架Flurl; 复制代码 public async Task<ApiRespone<QueryDocLoginModel>> QueryDocLogin(string ysdm, string pwd) { try { Thread.Sleep(50...
开发winform中遇到的一些问题汇总（持续更新）
liheao的博客
07-26 316
开发winform中遇到的一些问题汇总（持续跟新）
【小白专用24.6.8】C# WinForms 异步访问或更新控件
最新发布
zgscwxd的博客
06-08 310
C# WinForms 异步访问或更新控件C# WinForms 异步访问或更新控件
winform 线程中的BeginInvoke和Invoke
Pei_hua100的专栏
09-26 212
线程中使用BeginInvoke。线程中使用Invoke。
【WinForm】C#多线程Demo (线程池线程、异步任务、异步IO)
cxyhjl的博客
03-17 1214
一、随机进度条状态-线程池线程using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; using System.Windows.Forms; namespace Multithreadi...
C# 主线程和工作线程、为什么要有InvokeRequired
qq_45793468的博客
02-02 1671
在C#中，主线程和工作线程是两种不同类型的线程，它们在应用程序中的作用有很大的区别。在理解他们的区别后，就能理解为什么要有InvokeRequired。
C#异步async/await在WinForm中的使用
热门推荐
Dahlin哥's 博客
02-28 1万+
以前的WinForm项目大多数是用基础的多线程技术来实现的，或者用线程池将事件扔到并发队列中去异步执行，很少有用async/await异步方式来实现的，正巧我最近在学习这方面的知识，也浏览了几位大神的博客，在此总结汇总一下。
C# WinForm程序完全退出的问题解决
09-05
在C# WinForm编程中，有时我们可能会遇到程序无法完全退出的问题。这通常是由于程序的生命周期管理不正确或者后台线程未被妥善处理导致的。本文将深入探讨如何正确地解决这个问题，确保C# WinForm程序能够干净、彻底...
c# winform实例大全(198个Csharp WinForm实例源码)
04-27
7. **多线程与异步编程**：了解如何在WinForm应用中使用后台线程执行耗时任务，以避免阻塞UI线程，提升用户体验。 8. **网络通信**：包括TCP/IP、HTTP、FTP等网络协议的使用，实现客户端与服务器的通信。 9. **...
c# winform异步不卡界面的实现方法
12-31
快速阅读 如何在winform程序中，让界面不再卡死。 关于委托和AsyncCallback的使用。 界面卡死的原因是因为耗时任务的计算占用了主线程，导致主界面没有办法进行其它操作，比如拖动。造成界面卡死的现象。我们只需要把耗时任务放在子线程中执行就可以了。 子线程的计算结果 要更新到界面中，怎么更新呢，因为不能操作主线程 ，所以要用委托来实现 。 我们来看个例子。 场景 界面上一个按钮加一人richbox , 点击以后获得当前所在年份 代码实现 定义一个委托实现子线程更新主线程 public delegate void UpdateText(string message); pu
c#Winform异步线程刷新UI
12-27
使用开发工具为VS2013;.net：4.0 多线程异步刷新ui界面，实时获取任务进度并进行反馈。
C#Winform仓库管理系统
02-23
C#提供了线程类(Thread)和异步编程模型(Await/Async)，用于实现后台任务处理。 6. **错误处理和日志记录**：为确保系统的稳定性和可靠性，开发者需要添加错误处理代码，捕获和处理可能出现的异常。同时，使用日志...
C# Winform 支付宝扫码支付
04-20
在C# Winform应用中集成支付宝扫码支付功能是一项常见的任务，尤其对于开发电子商务或零售类应用程序来说至关重要。本文将深入探讨如何实现这个功能，以及涉及的相关技术知识点。 首先，我们需要了解的是C#语言本身...
Winform异步执行非UI耗时操作
qq_44284055的博客
03-19 473
在用Winform打开窗口，或是执行某些操作时，总会有一些操作非常耗时。而在执行这些方法时，界面却是处于卡死状态的，这对于用户来说是非常不好的体验。本文就介绍，如何将一些与UI无关的耗时操作放在后台执行，而不影响当前用户的界面。
c# 异步更新UI 不阻塞
weixin_34186128的博客
11-08 1895
c# 异步更新UI 不阻塞 流畅 Task task = Task.Factory.StartNew(() =>{ DoLongRunningWork(); // 耗时运算}); Task UITask= task.ContinueWith(() => { this.TextBlock1.Text = "Comp...
C#异步编程方式以及示例
coderK2014
07-12 5289
C#异步编程，这里列举一下几种方式：1、通过委托来实现异步（在委托类型中定义了BeginInvoke()和EndInvoke()两个方法）；2、await async (.net4.5新特性）3、task（.net 4.0 新特性）下面看示例：一、通过委托来实现异步class Program { static void Main(string[] args)...
C# 异步编程资源释放问题
07-13
在C#异步编程中，正确释放资源非常重要，以确保程序的性能和稳定性。以下是一些处理异步编程资源释放的最佳实践： 1. 使用`using`语句：对于实现了`IDisposable`接口的资源，可以使用`using`语句来自动释放资源。`using`语句在代码块结束时会自动调用资源的`Dispose`方法。 ```csharp using (var resource = new SomeDisposableResource()) { // 使用资源的代码 } ``` 2. 取消异步操作：如果异步操作涉及到需要手动释放的资源，可以考虑在取消异步操作时进行资源释放。使用`CancellationTokenSource`来取消异步操作，并在取消回调中释放资源。 ```csharp private CancellationTokenSource cts = new CancellationTokenSource(); async Task MyAsyncMethod() { try { await SomeAsyncOperation(cts.Token); } catch (OperationCanceledException) { // 处理取消操作 } finally { // 释放资源 // ... } } void CancelAsyncOperation() { cts.Cancel(); } ``` 3. 使用`TaskCompletionSource`：如果异步操作依赖于需要手动释放的资源，可以使用`TaskCompletionSource`来包装异步操作，并在任务完成时释放资源。 ```csharp Task SomeAsyncOperationWithResource() { var tcs = new TaskCompletionSource<object>(); using (var resource = new SomeResource()) { // 异步操作代码 // ... // 异步操作完成后释放资源 resource.Dispose(); tcs.SetResult(null); } return tcs.Task; } ``` 通过合理使用`using`语句、取消异步操作和`TaskCompletionSource`，可以确保在异步编程中正确释放资源，避免资源泄漏和性能问题。根据具体情况选择合适的方法来处理资源释放，以确保程序的可靠性和稳定性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值