C#异步编程案例学习——异步加载大资源文件1 之 使用 BeginInvoke 与 EndInvoke

最新推荐文章于 2023-10-08 20:13:28 发布
最新推荐文章于 2023-10-08 20:13:28 发布
阅读量676 收藏 3
点赞数
分类专栏： # C#异步编程 C# 文章标签： wpf c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SQWH_SSGS/article/details/109600637
版权

C#异步编程案例学习——异步加载大资源文件1 之 使用 BeginInvoke 与 EndInvoke

本文主要是根据一个项目中遇到的异步的小例子，研究学习异步编程模型(APM)模式如何使用 BeginInvoke 与 EndInvoke。

C# 中 BeginInvoke 与 EndInvoke 的一个简单的使用案例

在使用 WPF 开发桌面软件过程中，遇到一个需要预加载大量文件的需求，具体需求如下：

  • 在软件启动后，需要加载大量的 CAD 资源文件，文件供软件中后续使用。
  • 文件加载过程中非常耗时，若同步加载则界面会出现假死的状态。
  • 在文件加载过程中，需要保证界面仍然可以进行其他操作，屏蔽跟资源文件有关的操作。
  • 文件加载完成后，开放跟资源文件有关的操作。

解决方案：
在软件启动后，软件页面正常完成加载后，后台继续进行异步加载资源文件，此时可操作正在加载的资源文件的按钮设置为不可操作。文件加载完成之后开发操作资源文件的按钮可操作。

具体实现如下：

1、WPF 页面 Window 中存在一个事件：ContentRendered。该事件在窗口的内容呈现完毕之后发生。定义一个方法，方法中进行文件加载的操作，并将该方法绑定到 ContentRendered 事件。
代码如下：
其中，LoadingResources() 方法为实际加载文件的方法；
ShowProgressBarFile 方法中具体实现异步，并更改页面按钮状态

private void Window_ContentRendered(object sender, EventArgs e)
{
    //禁用对应的操作按钮
    this.btnThreeView.IsEnabled = false;

    Func<bool> action = (() => LoadingResources());
    ShowProgressBarFile(action, "文件加载中...");
}

2、方法 LoadingResources()，实现文件加载的功能。
文件加载使用多线程编程。一个线程为真加载线程，加载对应的资源文件，文件完成加载后，对应页面的操作按钮放开显示；
一个线程为假加载线程，可以用于加载进度条显示在页面。
具体详细的学习和分析见文章：
C#异步编程案例学习——异步加载大资源文件 2 之 多线程加载

 private bool LoadingResources()
 {
 	//......实现具体文件加载
    Thread t1 = new Thread(new ThreadStart(loadReal));  //loadReal 是真线程加载
    t1.Name = "真加载线程";
    t1.IsBackground = false;
    Thread t2 = new Thread(new ThreadStart(loadNotTrue));  //loadNotTrue 是假线程加载
    t2.Name = "假加载线程";
    t2.IsBackground = true;
    t1.Start();
    t2.Start();

    while (trueLoad == 0 && falseLoad == 0)
    {
        //阻塞
    }
    //下面的代码是在完成加载后，屏蔽页面假线程加载显示的进度条信息
    this.pb_info.Dispatcher.Invoke(DispatcherPriority.Normal, (ThreadStart)delegate ()
    {
        this.pb_info.Visibility = Visibility.Collapsed;
    });
    this.pb_test.Dispatcher.Invoke(DispatcherPriority.Normal, (ThreadStart)delegate ()
    {
        this.pb_test.Visibility = Visibility.Collapsed;
    });
    return true;
 }

3、方法ShowProgressBarFile 实现异步：
其中，func.BeginInvoke 开启异步；
asyncResult.IsCompleted 用于检查异步方法是否执行完成；
func.EndInvoke 结束异步。
这种异步编程的方法叫做“异步编程模型(APM)模式”

private bool ShowProgressBarFile(Func<bool> func, string text)
{
    var asyncResult = func.BeginInvoke(null, null);
    while (!asyncResult.IsCompleted)
    {
        System.Windows.Forms.Application.DoEvents();
    }
    
    return func.EndInvoke(asyncResult);
}

异步编程模型模式 APM

.NET Framework 中提供了执行异步操作的 3 种模式：

  • 基于任务的异步模式（Task-based Asynchronous Pattern, TAP）使用一种方法来表示异步操作的启动和完成。TAP 是在 .NET Framework 4 中引入的。C# 中的 async 和 await 关键词为 TAP 添加了语言支持。
  • 异步编程模型（Asynchronous Programming Model）模式（也称 IAsyncResult模式），在此模式中异步操作需要 Beginxxx 和 Endxxx 方法。
  • 基于事件的异步模式（Event-based Asynchronous Pattern，EAP），这种模式需要 Async 后缀，也需要一个或多个事件、事件处理程序委托类型和 EventArg 派生类型。

APM 和 EAP 两种模式是早期版本引入的，.Net 4 版本之后，Visual Studio 建议对于新的开发工作不再使用它们。对于 TAP 在《C#异步编程学习笔记》的文章中有相关学习笔记，后续详细学习使用后补充学习博客。
本文主要介绍的 BeginInvoke 与 EndInvoke 方式是基于 APM 的。.net中有很多类实现了该模式(比如HttpWebRequest)，同时我们也可以自定义类来实现APM模式(继承IAsyncResult接口并且实现BeginXXX和EndXXX方法)。

异步编程中的 BeginInvoke 和 EndInvoke

运行原理

如果委托对象的调用列表中只有一个方法（引用方法），就可以异步执行这个方法，通过调用委托类特有的两个方法 BeginInvoke 和 EndInvoke 去执行。
当我们调用委托的 BeginInvoke 方法时，它开始在一个独立线程上执行引用方法，并且立即返回到原始线程。原始线程可以继续，而引用方法会在线程此的线程中并行执行。
当程序希望获取已完成的异步方法的结果时，可以检测 BeginInvoke 返回的 IAsyncResult 的 IsCompleted 属性，或调用委托的 EndInvoke 方法来等待委托完成。

BeginInvoke方法

 IAsyncResult   BeginInvoke(-------,AsyncCallback callback,object state)
  1. 在调用BeginInvoke时，参数列表中的实参组成如下：
    1. 引用方法需要的参数。
    2. 两个额外的参数——callback参数和state参数。
      1. callback,回调方法的名字;
      2. state可以为null,或发送给回调函数的参数的对象，参数类型是object，在回调函数中必须转换成正确的类型。
  2. BeginInvoke从线程池中获取一个线程并且在新的线程开始时运行引用方法。
  3. BeginInvoke返回给调用线程一个实现IAsyncResult接口的对象。这个接口引用包含了异步方法的当前状态，原始线程然后可以继续执行。

EndInvoke方法

  1. 它接受一个由BeginInvoke方法返回的IAsyncResult对象的引用，并找到它关联的线程。
  2. 如果线程池的线程已经退出，EndInvoke做如下的事情。
    1. 它清理退出线程的状态并且释放它的资源。
    2. 它找到引用方法返回的值并且把它的值作为返回值。
  3. 如果当EndInvoke被调用时线程池的线程仍然在运行，调用线程就会停止并等待，直到清理完毕并返回值。因为EndInvoke是为开启的线程进行清理，所以必须确保对每一个BeginInvoke都调用EndInvoke。
  4. 如果异步方法触发了异常，在调用EndInvoke时会抛出异常。

AsyncResult类

当调用委托的BeginInvoke方法时，系统会创建一个AsyncResult类对象， BeginInvoke方法执行完后，方法返回属于AsyncResult类对象中的一个IAsyncResult接口类型的引用。IAsyncResult 是使用 BeginInvoke 和 EndInvoke 方法的必要部分。
在这里插入图片描述

  1. 当我们调用委托对象的BeginInvoke方法时，系统创建了一个AsyncResult类的对象。然而，它不返回类的对象的引用，而是返回对象中包含的IAsyncResult接口的引用。
  2. AsyncResult对象包含一个叫做AsyncDelegate的属性，它返回一个指向被调用来开启异步方法的委托的引用。但是这个属性是类对象的一部分而不是接口的一部分。
  3. IsCompleted属性返回一个布尔值，表示异步方法是否完成。
  4. AsyncState属性返回一个对象的引用，它被作为 BeginInvoke 方法调用时的state参数。它返回object类型的引用。

BeginInvoke和EndInvoke 的三种模式

  • 等待模式，在发起了异步方法以及做了一些其它处理之后，原始线程就中断，并且等待异步方法完成之后再继续。
  • 轮询模式，原始线程定期检查发起的线程是否完成，如果没有则可以继续做一些其它的事情。
  • 回调模式，原始线程一直在执行，无需等待或检查发起的线程是否完成。在发起的线程中的引用方法完成之后，发起的线程就会调用回调方法，由回调方法在调用EndInvoke之前处理异步方法的结构。

等待模式

在这种模式里，原始线程发起一个异步方法的调用，做一些其它处理，然后停止并等待，直到开启的线程结束。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace waitModel
{
	// 1、声明一个委托
    delegate int MyDel(int x, int y);
    class Program
    {
        static int sum(int x,int y)              //异步方法
        {
            Console.WriteLine("inside sum");
            Thread.Sleep(8000);
            return x+y;
        }
        static void Main(string[] args)
        {
			// 2、创建委托变量
			// 3、为委托绑定一个方法
            MyDel Del = new MyDel(sum);
            Console.WriteLine("Before BeginInvoke"); 
            // 4、异步调用委托。
            //	开始异步执行，封装回调函数：BeginInvoke(参数，回调函数，回调函数多需的对象/参数)
            IAsyncResult iresult = Del.BeginInvoke(4,6,null,null);      //开始异步执行 
            Console.WriteLine("After BeginInvoke");                //程序在执行异步方法的同时，执行该语句                
            Console.WriteLine("Doing something");
            int result = Del.EndInvoke(iresult);                        //等待，直到异步方法执行完毕，将结果
            Console.WriteLine("After EndInvoke, result = {0}",result);
            Console.ReadKey();
        }
    }
}
异步操作步骤（等待模式/轮询模式）

异步操作代码实现一般需要经过以下四个步骤，这四个步骤适用于等待模式和轮询模式。

  1. 声明一个委托类型
  2. 创建委托类型的变量
  3. 为委托绑定一个方法（返回值和参数列表与委托相同）
  4. 异步调用委托

如上四个步骤均在等待模式和轮询模式的代码中标注

轮询模式

在轮询模式中，原始线程发起了异步方法的调用，做一些其它处理，然后使用 IAsyncResult 对象的 IsCompleted 属性来定期检查开启的线程是否完成。如果异步方法已经完成，原始线程就调用 EndInvoke 并继续。否则，它做一些其它处理，然后过一会儿再检查。

轮询模式与等待模式相比，只增加了一步：通过检查 IAsnyResult 接口对象的 IsComplete 属性的判断异步方法是否完成，如没完成，在检查过程中可以做其它事情。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
//轮询模式与等待一直完成模式相比只增加了iresult.IsCompleted判断是否完成的步骤
namespace polling
{
    class Program
    {
    	// 1、声明一个委托
        delegate int MyDel(int x,int y);
        static int sum(int x, int y)
        {
            Console.WriteLine("insid sum");
            Thread.Sleep(1000);
            return x + y;
        }
        static void Main(string[] args)
        {
			// 2、创建委托变量
			// 3、为委托绑定一个方法
            MyDel Del = new MyDel(sum);
            Console.WriteLine("Before BeginInvoke");
            // 4、异步调用委托
            IAsyncResult iresult =  Del.BeginInvoke(2,3,null,null); //发起异步调用
            Console.WriteLine("After BeginInvoke");
            while (!iresult.IsCompleted)                           //检测IAsyncResult接口的IsCompleted属性判断异步方法是否完成   
            {
                Console.WriteLine("Sum Not Complete");
            	Thread.Sleep(1000);
            }
            
            Console.WriteLine("Sum Completed."); 
            int result = Del.EndInvoke(iresult);                  //异步方法执行完后才会执行这一句  
            Console.WriteLine("Result: {0}",result);
            Console.ReadKey();
        }
    }
}

回调模式

上面使用等待和轮询模式的方式需要等待。等待是个让人很恼火的事情。.Net考虑了这一点，为我们准备了回调的方式：你异步调用后继续干你的事儿，等你执行完后，你告我一声就ok了。

回调模式的不同之处在于，一旦主线程线程发起了异步方法，它就自己管自己了，不再考虑异步方法是否执行完成，当异步方法执行完后，系统会通过调用一个回调方法处理异步方法的结果，和调用委托的 EndInvoke 方法。

回调方法：回调方法的返回类型为void，以一个IAsyncResult接口类型的参数做为形参：

void AsyncCallback(IAsyncResult iresult)

上文提到 BeginInvoke方法的参数意义

 IAsyncResult BeginInvoke(-------,AsyncCallback callback,object state)
  • 第一个参数callback,回调方法的名字
  • 第二个参数state可以为null,或发送给回调函数的参数的对象，参数类型是object，在回调函数中必须转换成正确的类型。

回调方法和BeginInvoke方法是通过BeginInvoke方法内部的最后两个参数关联的

两种方法为BeginInvoke方法第一个参数赋值：

  1. 使用回调方法创建 AsyncCallback 类型的委托
  2. 只提供回调方法的名称，编译器会自动创建委托

回调模式是在回调方法内部，通过调用委托的 EndInvoke 方法来处理异步方法返回的结果，释放线程所占用的资源，而等待模式和轮询模式是在主线程中调用的；

要调用委托的EndInvoke方法，必须要有委托的引用，在回调方法内部，先是将回调方法的 IAsyncResult 接口类型通过里氏转换转换为 AsyncResult 类类型，然后再调用 AsyncResult 类的 AsyncDelegate 属性转化为合适的委托类型。

  • 给回调方法的参数只有一个，就是刚结束的异步方法的IAsyncResult接口的引用，要记住，IAsyncResult接口对象在AsyncResult类对象的内部。
  • 尽管IAsyncResult接口没有委托对象的引用，而包含它的AsyncResult类对象却有委托对象的引用。
  • 有了类对象的引用，我们现在就可以调用类对象的AsyncDelegate属性并且把它转化为合适的委托类型。这样就得到了委托引用，我们可以用它来调用EndInvoke。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Remoting.Messaging;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace callback
{
 
    delegate int Mydel(int x,int y);
    class Program
    {
        static int sum(int x,int y)                 //异步方法
        {
            Console.WriteLine("                   InSide Sum1");
            Thread.Sleep(1000);
            Console.WriteLine("                   InSide Sum2");
            return x + y;
        }
        //回调模式是在回调方法内部，通过调用委托的EndInvoke方法来处理异步方法返回的结果，释放线程所占用的资源而等待直到完成模式和轮询模式是在主线程中调用;
        //要调用委托的EndInvoke方法，必须要有委托的引用，在回调方法内部,先是将回调方法的IAsyncResult接口类型通过里氏转换转换为AsyncResult类类型，
        //然后再调用AsyncResult类的AsyncDelegate属性转化为合适的委托类型
 
 
        static  void callback_(IAsyncResult iar)    //回调方法        无论如何回调方法中的内容必须在异步方法执行完后才执行    
        {
            Console.WriteLine("                     Inside CallWhenDone");
            AsyncResult ar = (AsyncResult)iar;      //里氏转换，如果父类中装的是子类的对象，那么可以将这个父类转换为子类对象   
            Mydel del = (Mydel)ar.AsyncDelegate;    //通过AsyncResult类对象的AsyncDelegate属性转化为合适的Mydel委托类型
            long result = del.EndInvoke(iar);
            Console.WriteLine("                     The result is: {0}",result);
 
        }
        static void Main(string[] args)
        {
            Mydel Del = new Mydel(sum);
            Console.WriteLine("Before BeginInvoke");
            IAsyncResult iar = Del.BeginInvoke(7,8,new AsyncCallback(callback_),Del);                   //Del焕成null结果也一样
            Console.WriteLine("Doing more work in main");
            Thread.Sleep(500);
            Console.WriteLine("Done with Main.Exiting");
            Console.ReadKey();
        }
    }
}
异步操作步骤（回调模式）

异步操作代码（回调模式）相较于前面的增加了一个回调，这三个步骤适用于等待模式和轮询模式。

  1. 声明一个委托类型
  2. 创建委托类型的变量
  3. 为委托绑定一个方法（返回值和参数列表与委托相同）
  4. 异步调用委托
  5. 回调函数
	 //【1】声明一个名为Operation的委托，并交代执行方法
	 // 这里完成了1. 声明一个委托类型；2. 创建委托类型的变量；3. 为委托绑定一个方法
 	 //int:传入参数  string：返回值
        public Func<int, string> Operation = (num) => 
        {
            Thread.Sleep(num * 1000);
            return num.ToString();
        };
        private void button1_Click(object sender, EventArgs e)
        {
            //【2】异步调用
            IAsyncResult str = Operation.BeginInvoke(2, CallBack, "发送给回调函数的参数");
        }
        //【3】回调函数
        public void CallBack(IAsyncResult result)
        {
            string res = Operation.EndInvoke(result); //返回结果（结果类型，与委托返回值类型一致）
            var v = result.AsyncState;	//获取传递给回调函数的参数
        }

笔记参考：
http://www.cnblogs.com/zwt-blog/p/4812530.html#3611906
https://blog.csdn.net/ABC13222880223/article/details/85317621

SQWH_SSGS
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#线程 BeginInvoke和EndInvoke使用方法
09-05
本文开始C#线程系列讲座之一，即BeginInvoke和EndInvoke的使用方法，需要的朋友可以参考下
Invoke、BeginInvoke和EndInvoke用法
小目标一个亿
05-08 6702
先看代码： Action act = () => { Console.WriteLine("我是无参无返回值"); }; Func<int> func = () => { Thread.S...
C# 异步多线程实现（一）异步委托——Action和Func
xiaoyaolangwj的博客
12-14 4299
异步多线程实现：异步委托：Action和Func。调用BeginInvoke，开启线程。
C# 多线程 异步委托BeginInvoke
吴启林的博客
06-06 1017
异步委托解决了线程池不能返回值的问题，允许双向传递参数，同时可以在调用线程上抛出委托方法中未处理的异常。注：EndInvoke是必须的。相互学习，共同富裕。
c#学习系列相关之多线程（三）----invoke和begininvoke
最新发布
qiaodahua的博客
10-08 2226
本文具体介绍了begininvoke异步的过程，同时和invoke 的对比
【编程随笔】C# BeginInvoke+EndInvoke实现异步操作
qq_36602234的博客
07-13 399
使用方法 BeginInvoke 代码示例 private void Begin() { //声明委托函数 Func<GDAL.GDAL.GeoBitmap, Color, GDAL.GDAL.GeoBitmap> GetGeoBitmap = (_bitmap, _transparent) => { _bitmap.Bitmap.MakeTransparent(_transparent); _bitmap.midBitmap
[C#基础]c#中的BeginInvoke和EndEndInvoke
weixin_34014555的博客
07-16 1203
摘要 异步这东西，真正用起来的时候，发现事情还是挺多的，最近在项目中用到了异步的知识，发现对它还是不了解，处理起来，走了不少弯路。觉得还是补一补还是很有必要的。 MSDN原文地址：https://msdn.microsoft.com/en-us/library/2e08f6yc(v=vs.110).aspx 正文 .Net framework可以让你异步调用任何方法。为达这样的目的，你可以...
C#Invoke和BeginInvoke应用详解
qq_57798018的博客
12-07 8214
最近，在研究Invoke的使用，但是真的是一头雾水，网上看了很多资料，感觉还是看不懂，因为对于入门级的小白，想像不出Invoke的应用场景，更谈不上如何用了？Invoke的本质只是一个方法，方法一定是要通过对象来调用的。一般来说，Invoke其实用法只有两种情况：也就是说，Invoke前面要么是一个控件，要么是一个委托对象。Control的Invoke一般用于解决跨线程访问的问题，比如你想操作一个按钮button，你就要用button.Invoke，你想操作一个文本label，你就要用label.Invok
c# Invoke 与BeginInvoke 的用法(通俗易懂，最全)
jy_1005的博客
07-19 2534
*c# Invoke 与BeginInvoke 的用法大全
C# BeginInvoke实现异步编程
韬光养晦
08-06 9724
C# BeginInvoke实现异步编程 BeginInvoke实现异步编程的三种模式： 1.等待模式 在发起了异步方法以及做了一些其他处理之后，原始线程就中断并且等异步方法完成之后再继续； eg： using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; usi...
c#中委托，事件和BeginInvoke在进程间传递消息的作用
03-08
使用委托，事件和BeginInvoke从另外一个cs文件向form.cs文件传递数据，并把数据赋值给窗体控件
C#异步编程概述
06-11
Windows 应用程序编程中常见的一个模式就是，在GUI用户界面下，将耗时的文件和网络处理放入 子线程，以避免用户界面不能响应的问题。在.NET出现以前，创建线 程并监视线程结束，还要更新 界面等工作，即复杂又要手写...
c# 使用异步编程的方法
12-17
委托类有两个方法，叫做BeginInvoke和EndInvoke，它们是用来异步执行使用。 异步有三种模式 等待模式，在发起了异步方法以及做了一些其它处理之后，原始线程就中断，并且等待异步方法完成之后再继续。 轮询模式，...
C#实现异步编程的方法
01-01
最近在我参与的几个.Net项目中都有用到异步编程，作为一名.Net小白，很有必要好好地学习一下C#异步编程。 什么是异步 异步指的就是不用阻塞当前线程来等待任务的完成，而是将任务扔到线程池中去执行，当前线程可以...
C#用委托BeginInvoke做异步线程
12-31
此文件后台调用文件转换，需要耗费相当长的时间，这样，如果是一个线程同步式的做下去，那么用户在浏览器上感觉就是卡住了，卡卡卡卡，这里我们利用委托的BeginInvoke和EndInvoke方法操作线程，BeginInvoke方法可以...
C#中List集合的常用方法
热门推荐
SQWH_SSGS的博客
10-28 1万+
C#中List集合的常用方法常用方法和属性常用属性常用方法 List类是ArrayList类的泛型等效类，该类使用大小可按需动态增加的数组实现IList泛型接口。 泛型的好处：它为使用c#语言编写面向对象程序增加了极大的效力和灵活性。不会强行对值类型进行装箱和拆箱，或对引用类型进行向下强制类型转换，所以性能得到提高。 性能注意事项：在决定使用IList还是使用ArrayList类(两者具有类似的功能)时，记住IList类在大多数情况下执行得更好并且是类型安全的。如果对IList类的类型T 使用引用类型，则两
C#中委托（delegate、Func、Action、precidate）学习笔记
SQWH_SSGS的博客
10-28 1102
C#中Func和Action的简单使用delegate的简单使用Func声明Func结合Lambda表达式使用结合匿名方法使用Action声明Action结合Lambda表达式使用结合匿名函数使用 通常自定义使用委托是用delegate。Func和Action类是特殊的类型，它们允许程序员在不必指定自定义委托类型的情况下，去使用委托。而通过F12查看函数声明可以发现，Func和Action类本质上也是通过delegate关键字实现的。 Func和Action在使用时非常相似，下面将简单介绍Func和Acti
C#异步编程案例学习——异步加载大资源文件 2 之 多线程加载
SQWH_SSGS的博客
11-12 893
本文具体根据异步加载大资源文件案例中的多线程变成学习 C# 中 BeginInvoke 与 EndInvoke 的一个简单的使用案例 在使用 WPF 开发桌面软件过程中，遇到一个需要预加载大量文件的需求，具体需求如下： 在软件启动后，需要加载大量的 CAD 资源文件，文件供软件中后续使用。 文件加载过程中非常耗时，若同步加载则界面会出现假死的状态。 在文件加载过程中，需要保证界面仍然可以进行其他操作，屏蔽跟资源文件有关的操作。 文件加载完成后，开放跟资源文件有关的操作。 解决方案： 在软件启动后，软件页
c#　.ｎｅｔ３．５实现异步编程　　　实例
05-30
以下是一个使用.NET Framework 3.5实现异步编程的示例： ```csharp using System; using System.Threading; class Program { static void Main(string[] args) { Console.WriteLine("Main thread started."); ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值