C#学习教程14——进程与线程

最新推荐文章于 2024-04-12 10:03:05 发布
最新推荐文章于 2024-04-12 10:03:05 发布
阅读量1.7k 收藏 13
点赞数 3
分类专栏： C#学习 文章标签： c# microsoft
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46003347/article/details/123361373
版权

文章目录

14.进程与线程

在操作系统中，每运行一个程序都会开启一个进程，一个进程由多个线程构成。线程是程序执行流中最小的单元。

在应用程序中分为单线程程序和多线程程序。

  • 单线程程序是指在一个进程空间中只有一个线程在执行；
  • 多线程程序是指在一个进程空间中有多个线程在执行，并共享同一个进程的大小。

进程指在每个操作系统中自动启动的系统进程和一些自动启动的应用程序进程，在Windows操作系统中提供了任务管理器来查看当前启动的进程，并能关闭指定的进程。

14.1 Process：进程类

Process类主要提供对本地和远程进程的访问，并提供对本地进程的启动、停止等操作，该类所在的命名空间是System.Diagnostics。

属性或方法说明
MachineName属性，获取关联进程正在其上运行的计算机的名称
Id属性，获取关联进程的唯一标识符
ExitTime属性，获取关联进程退出的时间
ProcessName属性，获取该进程的名称
StartTime属性，获取关联进程启动的时间
Threads属性，获取在关联进程中运行的一组线程
TotalProcessorTime属性，获取此进程的总的处理器时间
UserProcessorTime属性，获取此进程的用户处理器时间
Close()方法，释放与此组件关联的所有资源
CloseMainWindow()方法，通过向进程的主窗口发送关闭消息来关闭拥有用户界面的进程
Dispose()方法，释放由 Component 使用的所有资源
GetCurrentProcess()方法，获取新的 Process 组件，并将其与当前活动的进程关联
GetProcesses()方法，为本地计算机上的每个进程资源创建一个新的 Process 组件
GetProcesses(String)方法，为指定计算机上的每个进程资源创建一个新的 Process 组件
GetProcessesByName(String)方法，创建新的 Process 组件的数组，并将它们与本地计算机上共享指定的进程名称的所有进程资源关联
Kill()方法，立即停止关联的进程
Start()方法，启动（或重用）此 Process 组件的 Startinfo 属性指定的进程资源， 并将其与该组件关联
Start(String)方法，通过指定文档或应用程序文件的名称来启动进程资源，并将资源与新的 Process 组件关联

下面通过例子来显示所有当前系统中正在运行的进程。

using System;
using System.Diagnostics;
using System.Windows.Forms;
namespace WinFormsApp1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Process[] processes = Process.GetProcesses();
            foreach (Process p in processes)
            {
                richTextBox1.Text = richTextBox1.Text + p.ProcessName + "\r\n";
            }
        }
    }
}

在这里插入图片描述

如果要启动进程，主要代码如下。

//获取进程名称
string ProcessName = {ProcessName};
//创建Process 类的对象
Process p = new Process();
//设置进程名称
p.StartInfo.FileName = ProcessName;
//启动进程
p.Start();

需要注意的是，一些进程由于权限不够是无法关闭的，因此在关闭进程的代码中要做异常处理。

14.2 Thread：线程及与线程有关的类

线程（Thread）是包含在进程中的，它位于System.Threading命名空间中，与线程有关的类同样也都在System.Threading命名空间中。

类名说明
Thread在初始的应用程序中创建其他的线程
ThreadState指定 Thread 的执行状态，包括开始、运行、挂起等
ThreadPriority线程在调度时的优先级枚举值，包括 Highest、AboveNormal、Normal、BelowNormal、Lowest
ThreadPool提供一个线程池，用于执行任务、发送工作项、处理异步I/O等操作
Monitor提供同步访问对象的机制
Mutex用于线程间同步的操作
ThreadAbortException调用Thread类中的Abort方法时出现的异常
ThreadStateExceptionThead处于对方法调用无效的ThreadState时出现的异常

Thread类主要用于实现线程的创建以及执行，其常用的属性和方法如下表所示。

属性或方法说明
Name属性，获取或设置线程的名称
Priority属性，获取或设置线程的优先级
ThreadState属性，获取线程当前的状态
IsAlive属性，获取当前线程是否处于启动状态
IsBackground属性，获取或设置值，表示该线程是否为后台线程
CurrentThread属性，获取当前正在运行的线程
Start()方法，启动线程
Sleep(int millisecondsTimout)方法，将当前线程暂停指定的毫秒数
Suspend()方法，挂起当前线程（已经被弃用）
Join()方法，阻塞调用线程，直到某个线程终止为止
Interrupt()方法，中断当前线程
Resume()方法，继续已经挂起的线程（已经被弃用）
Abort()方法，终止线程

14.3 ThreadStart：创建线程

使用线程时首先需要创建线程，在使用Thread类的构造方法创建其实例时，需要用到ThreadStart委托或者ParameterizedThreadStart委托创建 Thread 类的实例。ThreadStart委托只能用于无返回值、无参数的方法，ParameterizedThreadStart委托则可以用于带参数的方法。

使用ThreadStart创建线程首先需要创建ThreadStart委托的实例，然后再创建Thread类的实例。

ThreadStart ts = new ThreadStart(方法名);
Thread t = new Thread(ts);

下面的例子使用ThreadStart委托创建线程，并输出0-10中所有的偶数。

using System;
using System.Threading;
class Program
{
    static void Main(string[] args)
    {
        ThreadStart ts1 = new ThreadStart(PrintEven);
        Thread t1 = new Thread(ts1);
        ThreadStart ts2 = new ThreadStart(PrintOdd);
        Thread t2 = new Thread(ts2);
        t1.Start();
        t2.Start();
    }
    //打印0-10中的偶数
    private static void PrintEven()
    {
        Console.WriteLine("打印0-10之间的偶数：");
        for (int i = 0; i <= 10; i = i + 2)
        {
            Console.WriteLine(i);
        }
    }
    //打印1-10 中的奇数
    public static void PrintOdd()
    {
        Console.WriteLine("打印0-10之间的奇数：");
        for (int i = 1; i <= 10; i = i + 2)
        {
            Console.WriteLine(i);
        }
    }
}
// 打印0-10之间的偶数：
// 0
// 2
// 4
// 6
// 8
// 10
// 打印0-10之间的奇数：
// 1
// 3
// 5
// 7
// 9

使用Threadstart委托为PrintEven方法创建了线程，通过线程的Start方法启动线程并调用了PrintEven方法。

14.4 ParameterizedThreadStart：创建进程

创建ParameterizedThreadStart委托的实例，然后再创建 Thread 类的实例。

ParameterizedThreadStart pts=new ParameterizedThreadStart( 方法名 );
Thread t=new Thread(pts);

下面的例子使用ParameterizedThreadStart委托打印0-n中的所有偶数。

using System;
using System.Threading;
class Program
{
    static void Main(string[] args)
    {
        ParameterizedThreadStart pts = new ParameterizedThreadStart(PrintEven);
        Thread t = new Thread(pts);
        t.Start(9);
    }
    //打印0~n中的偶数
    private static void PrintEven(Object n)
    {
        for (int i = 0; i <= (int)n; i = i + 2)
        {
            Console.WriteLine(i);
        }
    }
}
// 0
// 2
// 4
// 6
// 8

在使用ParameterizedThreadStart委托调用带参数的方法时，方法中的参数只能是object类型并且只能含有一个参数，在启动线程时要在线程的Start()方法中为委托的方法传递参数。

传递多个参数可以通过类的实例来实现。

using System;
using System.Threading;
class Program
{
    static void Main(string[] args)
    {
        ParameterizedThreadStart pts = new ParameterizedThreadStart(PrintEven);
        ParameterTest pt = new ParameterTest(1, 10);
        Thread t = new Thread(pts);
        t.Start(pt);
    }
    private static void PrintEven(Object n)
    {
        //判断n是否为ParameterTest 类的对象
        if (n is ParameterTest)
        {
            int beginNum = ((ParameterTest)n).beginNum;
            int endNum = ((ParameterTest)n).endNum;
            for (int i = beginNum; i <= endNum; i++)
            {
                if (i % 2 == 0)
                {
                    Console.WriteLine(i);
                }
            }
        }
    }
}
public class ParameterTest
{
    public int beginNum;
    public int endNum;
    public ParameterTest(int a, int b)
    {
        this.beginNum = a;
        this.endNum = b;
    }
}
// 2
// 4
// 6
// 8
// 10

通过给ParameterTest类中的字段赋值，并将其通过线程的Start方法传递给委托引用的方法PrintEven，即可实现在委托引用的方法中传递多个参数的操作。

14.5 Priority：多线程优先级设置

如果需要控制输出值的顺序，可以通过对线程优先级的设置以及线程调度来实现。线程的优先级使用线程的Priority属性设置即可，默认的优先级是Normal。在设置优先级后，优先级高的线程将优先执行。

优先级的值通过ThreadPriority枚举类型来设置，从低到高分别为Lowest、BelowNormal、Normal、AboveNormal、Highest。

14.5.1 实例1：设置线程优先级

using System;
using System.Threading;
class Program
{
    static void Main(string[] args)
    {
        ThreadStart ts1 = new ThreadStart(PrintEven);
        Thread t1 = new Thread(ts1);
        //设置打印偶数线程的优先级
        t1.Priority = ThreadPriority.Lowest;
        ThreadStart ts2 = new ThreadStart(PrintOdd);
        Thread t2 = new Thread(ts2);
        //设置打印奇数线程的优先级
        t2.Priority = ThreadPriority.Highest;
        t1.Start();
        t2.Start();
    }
    //打印1~100中的奇数
    public static void PrintOdd()
    {
        for (int i = 1; i <= 100; i = i + 2)
        {
            Console.WriteLine(i);
        }
    }
    //打印0~100中的偶数
    public static void PrintEven()
    {
        for (int i = 0; i <= 100; i = i + 2)
        {
            Console.WriteLine(i);
        }
    }
}

在这里插入图片描述

由于输岀奇数的线程的优先级高于输出偶数的线程，所以在输出结果中优先输出奇数。此外，每次输出的结果也不是固定的。通过优先级是不能控制线程中的先后执行顺序的，只能是优先级高的线程优先执行的次数多而已。

线程状态控制的方法包括暂停线程 (Sleep)、中断线程 (Interrupt)、挂起线程 (Suspend)、唤醒线程 (Resume)、终止线程 (Abort)。

14.5.2 实例2：线程交替

下面的例子使用暂停线程 (Sleep) 的方法让打印奇数和打印偶数的线程交替执行。

using System;
using System.Threading;
class Program
{
    static void Main(string[] args)
    {
        ThreadStart ts1 = new ThreadStart(PrintOdd);
        Thread t1 = new Thread(ts1);
        ThreadStart ts2 = new ThreadStart(PrintEven);
        Thread t2 = new Thread(ts2);
        t1.Start();
        t2.Start();
    }
    //打印1~100中的奇数
    public static void PrintOdd()
    {
        for (int i = 1; i <= 10; i = i + 2)
        {
            //让线程休眠 1 秒
            Thread.Sleep(1000);
            Console.WriteLine(i);
        }
    }
    //打印0~100中的偶数
    public static void PrintEven()
    {
        for (int i = 0; i <= 10; i = i + 2)
        {
            Console.WriteLine(i);
            //让线程休眠 1 秒
            Thread.Sleep(1000);
        }
    }
}
// 0
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
// 9
// 10

通过Sleep方法能控制两个线程执行的先后顺序。两个线程虽然交替执行，但每次运行该程序的效果依然是不同的。

14.5.3 实例3：终止线程

using System;
using System.Threading;
class Program
{
    private static int count = 10;
    private static void GiveRedEnvelop()
    {
        while (count > 0)
        {
            count--;
            if (count == 4)
            {
                //终止当前线程
                Console.WriteLine("红包暂停发放！");
                Thread.CurrentThread.Abort();
            }
            Console.WriteLine("剩余 {0} 个红包", count);
        }
    }
    static void Main(string[] args)
    {
        ThreadStart ts = new ThreadStart(GiveRedEnvelop);
        Thread t = new Thread(ts);
        t.Start();
    }
}

在这里插入图片描述

Unhandled exception. System.PlatformNotSupportedException: Thread abort is not supported on this platform.

报错原因：Thread.AbortAPI已过时。 如果调用这些方法，则面向.NET 5或更高版本的项目将遇到编译时警告SYSLIB0006。

目前，由于挂起线程 (Suspend) 和唤醒线程 (Resume) 的操作很容易造成线程的死锁状态，已经被弃用了，而是使用标识字段来设置线程挂起和唤醒的状态。所谓线程死锁就是多个线程之间处于相互等待的状态。

线程分为前台线程和后台线程，前台线程不用等主程序结束，后台线程则需要应用程序运行结束后才能结束。此外，在应用程序运行结束后，后台线程即使没有运行完也会结束，前台线程必须等待自身线程运行结束后才会结束。

14.5.4 实例4：判断后台进程

在上一实例的基础上判断发红包的线程是否为后台线程，如果不是后台线程，将其设置为后台线程。使用Thread对象的IsBackground属性来判断线程是否为后台线程。

using System;
using System.Threading;
class Program
{
    private static int count = 10;
    private static void GiveRedEnvelop()
    {
        while (count > 0)
        {
            count--;
            if (count == 4)
            {
                //终止当前线程
                Console.WriteLine("红包暂停发放！");
                Thread.CurrentThread.Abort();
            }
            Console.WriteLine("剩余 {0} 个红包", count);
        }
    }
    static void Main(string[] args)
    {
        ThreadStart ts = new ThreadStart(GiveRedEnvelop);
        Thread t = new Thread(ts);
        t.Start();
        if (t.IsBackground == false)
        {
            Console.WriteLine("该线程不是后台线程！");
            t.IsBackground = true;
        }
        else
        {
            Console.WriteLine("该线程是后台线程！");
        }
    }
}
// 该线程不是后台线程！
// 剩余 9 个红包

运行该程序，直接输出“该线程不是后台线程!”，由于将该线程设置为后台线程，则不会输出红包发放的信息。

14.6 lock：线程加锁

虽然Sleep方法能控制线程的暂停时间，从而改变多个线程之间的先后顺序，但每次调用线程的结果是随机的。线程同步的方法是将线程资源共享，允许控制每次执行一个线程，并交替执行每个线程。实现线程同步可以使用lock关键字和Monitor类、Mutex类来解决。

对于线程同步操作最简单的一种方式就是使用lock关键字，通过lock关键字能保证加锁的线程只有在执行完成后才能执行其他线程。

// 参数通常是一个Object类型的值，也可以使用this关键字来表示。
lock(object)
{
    //临界区代码
}

最好是在lock中使用私有的非静态或负变量或私有的静态成员变量，即使用Private或Private static修饰的成员。

private Object obj = new Object();
lock (obj)
{
    //临界区代码
}

下面的例子使用lock关键字控制打印奇数和偶数的线程，要求先执行奇数线程，再执行偶数线程。

using System;
using System.Threading;
class Program
{
    public void PrintEven()
    {
        lock (this)
        {
            for (int i = 0; i <= 10; i = i + 2)
            {
                Console.WriteLine(Thread.CurrentThread.Name + "--" + i);
            }
        }
    }
    public void PrintOdd()
    {
        lock (this)
        {
            for (int i = 1; i <= 10; i = i + 2)
            {
                Console.WriteLine(Thread.CurrentThread.Name + "--" + i);
            }
        }
    }
    static void Main(string[] args)
    {
        Program program = new Program();
        ThreadStart ts1 = new ThreadStart(program.PrintOdd);
        Thread t1 = new Thread(ts1);
        t1.Name = "打印奇数的线程";
        t1.Start();
        ThreadStart ts2 = new ThreadStart(program.PrintEven);
        Thread t2 = new Thread(ts2);
        t2.Name = "打印偶数的线程";
        t2.Start();
    }
}

在这里插入图片描述

当打印奇数的线程结束后才执行打印偶数的线程，并且每次打印的效果是一样的。

14.7 Monitor：锁定资源

Monitor类的命名空间是System.Threading。

Monitor.Enter(object);
try
{
    //临界区代码
}
finally
{
    Monitor.Exit(object);
}

将14.6节例子中的lock关键字替换成Monitor类。

using System;
using System.Threading;
class Program
{
    public void PrintEven()
    {
        Monitor.Enter(this);
        try
        {
            for (int i = 0; i <= 10; i = i + 2)
            {
                Console.WriteLine(Thread.CurrentThread.Name + "--" + i);
            }
        }
        finally
        {
            Monitor.Exit(this);
        }
    }
    public void PrintOdd()
    {
        Monitor.Enter(this);
        try
        {
            for (int i = 1; i <= 10; i = i + 2)
            {
                Console.WriteLine(Thread.CurrentThread.Name + "--" + i);
            }
        }
        finally
        {
            Monitor.Exit(this);
        }
    }
    static void Main(string[] args)
    {
        Program program = new Program();
        ThreadStart ts1 = new ThreadStart(program.PrintOdd);
        Thread t1 = new Thread(ts1);
        t1.Name = "打印奇数的线程";
        t1.Start();
        ThreadStart ts2 = new ThreadStart(program.PrintEven);
        Thread t2 = new Thread(ts2);
        t2.Name = "打印偶数的线程";
        t2.Start();
    }
}

在这里插入图片描述

Monitor类的用法虽然比lock关键字复杂，但其能添加等待获得锁定的超时值，这样就不会无限期等待获得对象锁。使用TryEnter()方法可以给它传送一个超时值，决定等待获得对象锁的最长时间。该方法能在指定的毫秒数内结束线程，这样能避免线程之间的死锁现象。

Monitor.TryEnter(object, 毫秒数 );

此外，还能使用Monitor类中的Wait()方法让线程等待一定的时间，使用Pulse()方法通知处于等待状态的线程。

14.8 Mutex：（互斥锁）线程同步

Mutex类也是用于线程同步操作的类，例如，当多个线程同时访问一个资源时保证一次只能有一个线程访问资源。

在Mutex类中，WaitOne()方法用于等待资源被释放， ReleaseMutex()方法用于释放资源。WaitOne()方法在等待ReleaseMutex()方法执行后才会结束。

下面的例子使用线程互斥实现每个车位每次只能停一辆车的功能。

using System;
using System.Threading;
class Program
{
    private static Mutex mutex = new Mutex();
    public static void PakingSpace(object num)
    {
        if (mutex.WaitOne())
        {
            try
            {
                Console.WriteLine("车牌号{0}的车驶入！", num);
                Thread.Sleep(1000);
            }
            finally
            {
                Console.WriteLine("车牌号{0}的车离开！", num);
                mutex.ReleaseMutex();
            }
        }
    }
    static void Main(string[] args)
    {
        ParameterizedThreadStart ts = new ParameterizedThreadStart(PakingSpace);
        Thread t1 = new Thread(ts);
        t1.Start("冀A12345");
        Thread t2 = new Thread(ts);
        t2.Start("京A00000");
    }
}

在这里插入图片描述

从上面的运行效果可以看出，每辆车驶入并离开后其他车才能占用停车位，即当一个线程占用资源时，其他线程是不使用该资源的。

暄踽
关注
  • 3
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
详解C#多线程编程之进程与线程
01-19
 简单来说，进程是对资源的抽象，是资源的容器，在传统操作系统中，进程是资源分配的基本单位，而且是执行的基本单位，进程支持并发执行，因为每个进程有独立的数据，独立的堆栈空间。一个程序想要并发执行，开多个...
C# 多线程——可执行源代码
03-15
【C# 多线程】是C#编程中一种重要的技术，它允许程序在同一时间执行多个任务，提高程序的响应速度和效率。多线程在现代软件开发中扮演着核心角色...通过学习和实践，开发者可以有效地在C#环境中构建健壮的多线程应用。
出现System.PlatformNotSupportedException报错解决方法
热门推荐
dark9spring的博客
06-15 1万+
                               最近学习委托及异步调用碰到了这个报错Unhandled exception. System.PlatformNotSupportedException: Operatio
C# 使用HttpListener时候异常（此平台不支持此操作：System.PlatformNotSupportedException）
LongtengGensSupreme博客
07-04 916
解决办法如下：管理员运行cmd，输入如下。解决办法如下：管理员运行cmd，输入如下。执行完成后，再启动试试，基本可以解决。
详解 System.PlatformNotSupportedException
最新发布
牛肉胡辣汤
04-12 603
在计算机编程中，"Platform"（平台）是指特定的硬件或软件环境，用于运行和支持应用程序或软件库。软件平台是指特定的软件环境，例如操作系统和相关的运行时环境、库和工具。在处理这个异常时，你可以进行平台检查、确保应用程序的最低要求、使用跨平台或通用解决方案、更新依赖项或提供替代方案。处理 System.PlatformNotSupportedException 异常的方法取决于你的应用程序和当前平台的要求。在现实应用中，可以根据不同的平台要求执行特定的操作，或者向用户提供相应的错误提示。
.net 5 .net 6 Thread.Abort is not supported
蓝创精英团队
05-28 5001
.net 5 ++ 版本 不支持 Thread.Abort 所以，采用另外一种方案 class Program { static void Main(string[] args) { var thread = new Thread(Test); thread.Start(); SpinWait.SpinUntil(() => false, 5 * 1000); .
C#之线程ParameterizedThreadStart
Pei_hua100的专栏
09-07 831
ParameterizedThreadStart class Program { static void Main(string[] args) { Work work = new Work()； //两种实例化委托的方法； //ParameterizedThreadStart ParameterizedThreadStartDelegate = new Param...
C#中的线程之Abort陷阱
CJyoung的博客
08-04 3091
1.简介 C#中通常使用线程类Thread来进行线程的创建与调度，博主在本文中将分享多年C#开发中遇到的Thread使用陷阱。 Thread调度其实官方文档已经说明很详细了。本文只简单说明，不做深入探讨。 如下代码展示了一个线程的创建与启动 static void Main(string[] args) { Thread thd = new Thread(new ThreadStart(TestThread)); thd.IsBac
BasicEfrel-whird.rar_进程与线程_C/C++_
08-09
标题中的"BasicEfrel-whird.rar_进程与线程_C/C++_"可能是一个拼写错误，根据上下文，应该是"BasicExcel"相关的资料，主要涉及C/C++编程语言中的进程与线程概念。这里我们将深入探讨这两个核心的计算机科学概念。 *...
C#多线程及同步示例简析
01-20
60年代，在OS中能拥有资源和独立运行的基本单位是进程，然而随着计算机技术的发展，进程出现了很多弊端，一是由于进程是资源拥有者，创建、撤消与切换存在较大的时空开销，因此需要引入轻型进程；二是由于对称多处理...
《C#考试题》——多项选择题.doc
11-25
本资源摘要信息主要总结了C#考试题的知识点，包括C#语言的基本语法、变量类型、对象内部数据的隐藏、ArrayList对象的容量调整、类继承、数据库访问、XML Web Service、线程和进程、.NET Framework、程序集、类型转换...
abortonerror_显示已经过时的警告
weixin_39525617的博客
12-21 822
apply plugin: 'com.android.application'android {compileSdkVersion 27/*** 显示已过时的警告*/allprojects{gradle.projectsEvaluated {tasks.withType(JavaCompile) {options.compilerArgs << "-Xlint:unchecked" &...
C#中 ThreadStart和ParameterizedThreadStart区别
weixin_34129696的博客
11-01 400
最主要区别： 1.Thread 是启动一个线程，但是没有参数。 2.ParameterThreadStart  线程可以接受一个输入参数 ThreadStart： ThreadStart这个委托定义为void ThreadStart(),也就是说,所执行的方法不能有参数。 ThreadStart threadStart=new ThreadStart(ProcessData); Thread t...
[C#学习笔记之多线程1]使用ParameterizedThreadStart委托向线程函数传送参数
tansitongba
05-21 652
在不传递参数情况下，一般大家都使用ThreadStart代理来连接执行函数，ThreadStart委托接收的函数不能有参数，也不能有返回值。如果希望传递参数给执行函数，则可以使用带参数的ParameterizedThreadStart委托, public delegate void ParameterizedThreadStart(Object obj) 可以将要传送给线程函数的信息...
C#基础--线程Thread和线程池ThreadPool
YSの陈憨憨
07-18 2081
ThreadStart 是属于System.Threading 中的一个内置委托ParameterizedThreadStart 是属于System.Threading 中的一个内置委托。
.net异常处理
kalvin_y_liu的博客
11-04 931
3、非可等待的Task内部异常会触发TaskScheduler_UnobservedTaskException事件，导致系统崩溃，所以建议Task内部自行处理根异常或将异常封装为事件推到主线程。2、 组件或控件抛出异常时可以根据需要自定义一些异常，不要抛出根异常，可以直接使用的常用异常有：FormatException、IndexOutOfRangException、InvalidOperationException、InvalidEnumArgumentException；在发生未捕获线程异常时发生。
VS：System.PlatformNotSupportedException: ‘Operation is not supported on this platform.‘
Read by heart
01-22 8709
在使用委托隐式异步调用的时候遇到这个问题，目前的解决办法是重新创建一个解决方案，把代码copy过去后，就没有异常了。
C# 准确获取系统 CPU 进程与线程
06-09
要获取系统 CPU 进程与线程的信息，可以使用 C# 中的 System.Diagnostics 命名空间中的 Process 类和 PerformanceCounter 类。 使用 Process 类可以获取系统中运行的进程，可以通过 Process 类的属性和方法获取进程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

暄踽

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值