C#多线程开发详解

有诗亦有远方2023-08-14 15:58

C#多线程开发详解

持续更新中。。。。。

一、为什么要使用多线程开发

1.提高性能

多线程允许程序同时执行多个任务，从而有效利用多核处理器，加快程序的执行速度。特别是在需要处理大量计算、I/O 操作或并行任务的应用中，多线程可以显著提高性能。

2.响应性

多线程使应用能够同时处理多个用户请求或事件，提高了应用的响应性。例如，多线程可以保持用户界面的响应，即使在执行长时间操作时也能让用户继续交互。

3.资源利用

多线程可以更有效地利用系统资源，如内存和网络连接。这对于高并发服务器、网络应用和数据处理任务特别有用。

4.任务分解

将复杂任务分解为多个小任务，每个任务在不同的线程中执行，可以简化问题并提高可维护性。

5.并行计算

多线程可以用于并行计算，例如在科学计算、数据分析和图像处理领域。这有助于加速大规模计算。

6.实时处理

在实时系统中，多线程可以保证任务在规定的时间内完成，从而满足对时间敏感性的需求。

二、多线程开发缺点

1.竞态条件

多线程可能会导致竞态条件，即多个线程竞争访问共享资源，可能导致数据不一致性和错误。

2.死锁和饥饿

不正确的线程同步可能导致死锁（多个线程无法继续执行）或饥饿（某些线程无法获取所需资源）问题。
线程1，2启动，分别占用锁lock1，lock2。之后线程1请求lock2，但是线程2已经占用lock2，线程1无法继续执行，进入等待。线程2请求lock1，但是线程1已经占用lock1，线程2无法继续执行，进入等待。这里陷入死锁，线程1，线程2，都在等待对方释放锁来给自己使用，程序一直无法运行，一直在等待中。

csharp 复制代码 
using System;
using System.Threading;

class DeadlockExample
{
    static object lock1 = new object();
    static object lock2 = new object();

    static void Main()
    {
        Thread thread1 = new Thread(Method1);
        Thread thread2 = new Thread(Method2);

        thread1.Start();
        thread2.Start();

        thread1.Join();
        thread2.Join();

        Console.WriteLine("Main thread finished.");
    }

    static void Method1()
    {
        lock (lock1)
        {
            Console.WriteLine("Method1 acquired lock1.");
            Thread.Sleep(1000);

            Console.WriteLine("Method1 trying to acquire lock2.");
            lock (lock2)
            {
                Console.WriteLine("Method1 acquired lock2.");
            }
        }
    }

    static void Method2()
    {
        lock (lock2)
        {
            Console.WriteLine("Method2 acquired lock2.");
            Thread.Sleep(1000);

            Console.WriteLine("Method2 trying to acquire lock1.");
            lock (lock1)
            {
                Console.WriteLine("Method2 acquired lock1.");
            }
        }
    }
}

3.调试复杂性

多线程程序的调试和错误跟踪可能会更加复杂，因为线程间的交互和排错可能变得更难。

4.上下文切换开销

上下文切换（Context Switching）是多线程环境中的一种操作，指的是在一个 CPU 核心上切换正在执行的线程，从当前线程的执行上下文（包括寄存器状态、程序计数器等）切换到另一个线程的执行上下文, 线程的切换需要额外的开销，因此在某些情况下，过多的线程可能会导致性能下降。

  1. 当一个线程的时间片（时间片轮转调度算法）用完，操作系统需要挂起该线程并切换到另一个线程。

  2. 当一个线程主动放弃 CPU，例如通过调用 Thread.Sleep()、Thread.Yield() 或等待某个事件时
    3.当一个线程被高优先级的线程抢占
    上下文切换的过程涉及以下步骤：

  3. 保存当前线程的上下文: 操作系统将当前线程的寄存器状态、程序计数器等信息保存到该线程的内存空间中，以便稍后能够恢复该线程的执行
    2.恢复目标线程的上下文： 操作系统从目标线程的内存空间中恢复寄存器状态、程序计数器等信息，准备让目标线程继续执行。

  4. 切换内核堆栈： 每个线程都有自己的内核堆栈，上下文切换时，操作系统会切换内核堆栈，以确保线程的隔离性。
    上下文切换开销指的是从一个线程切换到另一个线程的过程中所涉及的时间和资源开销。这些开销主要包括以下几个方面：

  5. 寄存器保存和恢复： 当线程切换时，操作系统需要保存当前线程的寄存器状态，然后恢复目标线程的寄存器状态。这涉及到大量的数据拷贝和计算。
    2.内存访问： 上下文切换过程中需要频繁访问内存，包括将寄存器状态和其他上下文信息写入内存，以及从内存中读取目标线程的上下文信息。
    3.调度开销： 操作系统需要决定要切换到哪个线程，这涉及到调度算法的开销，包括选择合适的线程并进行必要的线程队列操作。
    4.TLB（Translation Lookaside Buffer）失效： 当线程切换时，虚拟内存的映射可能会发生变化，导致 TLB 缓存失效，从而增加了内存访问的开销。
    上下文切换开销会影响系统的整体性能，特别是在高并发、频繁切换的情况下。因此，在设计多线程应用程序时，需要考虑如何减少上下文切换的发生，以提高程序的执行效率。一些方法包括：

  6. 使用线程池：线程池可以减少线程的创建和销毁，从而减少上下文切换的频率。

  7. 合理设置线程数量：避免创建过多线程，以减少不必要的上下文切换。
    3.使用异步编程模型：使用异步操作和任务可以减少线程的使用，从而减少上下文切换。

5.线程安全性

多线程编程需要谨慎处理线程安全性，以避免数据竞争和共享资源的冲突。

三、多线程开发涉及的相关概念

常用概念

(1)lock

在 C# 中，lock 关键字用于实现线程同步，以确保在多线程环境中对共享资源的访问是安全的。lock 关键字会创建一个互斥锁（也称为监视器锁），只有一个线程可以获得该锁，从而确保在同一时间只有一个线程能够执行被 lock 包围的代码块。

csharp 复制代码 
lock (lockObject)
{
    // 在这里执行需要同步的代码
}

其中，lockObject 是一个用于同步的对象。它可以是任何引用类型的对象，但通常是一个专门用于同步的对象。多个线程可以共享同一个 lockObject，并且只有一个线程能够获得锁并执行被 lock 包围的代码块。

csharp 复制代码 
class Program
{
    static readonly object lockObject = new object(); // 同步对象

    static void Main(string[] args)
    {
        for (int i = 0; i < 5; i++)
        {
            ThreadStart start = () =>
            {
                lock (lockObject)
                {
                    Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} is in the critical section.");
                    Thread.Sleep(1000);
                    Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} has exited the critical section.");
                }
            };

            Thread thread = new Thread(start);
            thread.Start();
        }

        Console.ReadKey();
    }
}

(2)查看当前工作线程信息

可以使用 Thread.CurrentThread 属性来获取当前正在执行的线程的信息。这个属性返回一个表示当前线程的 Thread 对象，你可以使用它来查询线程的各种属性和状态。
Thread 类还提供了 Priority 属性，允许你设置线程的优先级。然而，操作系统不一定会完全遵循线程的优先级，这取决于操作系统的调度机制。
线程可以分为前台线程和后台线程。前台线程是主线程的一部分，如果所有前台线程都完成，程序将终止。后台线程是在后台运行的线程，如果所有前台线程都完成，程序会立即终止，不会等待后台线程完成。

csharp 复制代码 
using System;
using System.Threading;

class Program
{
    static void Main()
    {
        Thread currentThread = Thread.CurrentThread;

        Console.WriteLine($"Thread ID: {currentThread.ManagedThreadId}");
        Console.WriteLine($"Thread Name: {currentThread.Name}");
        Console.WriteLine($"Is Thread Background: {currentThread.IsBackground}");
        Console.WriteLine($"Thread Priority: {currentThread.Priority}");
        Console.WriteLine($"Thread State: {currentThread.ThreadState}");
    }
}

(3)主线程、前台线程、后台线程

主线程（Main Thread），它是程序的入口点，并且在程序启动时自动创建。主线程负责启动其他线程，并且通常是其他线程的父线程，但并不是所有线程都是主线程的子线程。
线程之间没有严格的父子关系。主线程和其他线程之间通常是平等的，没有直接的父子关系。但是，你可以通过编程来模拟一种线程间的层次关系，使得某些线程在逻辑上看起来是其他线程的子线程。这通常涉及线程的创建、协调和通信
以下是一个示例，演示了如何通过逻辑上的组织来模拟一种主线程和子线程的关系：

csharp 复制代码 
using System;
using System.Threading;

class Program
{
    static void Main()
    {
        Console.WriteLine("Main thread starts.");

        Thread parentThread = new Thread(ParentThreadMethod);
        parentThread.Start();

        parentThread.Join();

        Console.WriteLine("Main thread ends.");
    }

    static void ParentThreadMethod()
    {
        Console.WriteLine("Parent thread starts.");

        Thread childThread = new Thread(ChildThreadMethod);
        childThread.Start();

        childThread.Join();

        Console.WriteLine("Parent thread ends.");
    }

    static void ChildThreadMethod()
    {
        Console.WriteLine("Child thread starts.");
        Thread.Sleep(2000);
        Console.WriteLine("Child thread ends.");
    }
}

前台线程（Foreground Threads）：

这些线程是由主线程或其他前台线程创建的，它们的生命周期独立于主线程，但它们不是主线程的子线程。前台线程与主线程之间的关系是平级的。当所有前台线程都执行完毕时，程序才会退出，无论主线程是否结束。

  1. 生命周期：
    前台线程的生命周期不受其他线程的影响。即使主线程退出，前台线程仍然可以继续执行，直到完成。
  2. 程序退出：
    如果程序中还有前台线程在运行，主程序将等待所有前台线程完成后才会退出。主线程也是前台线程，如果主线程退出，会等待其他前台线程完成后再退出。
  3. 影响程序：
    前台线程会阻塞程序的退出，直到所有前台线程完成。这可能会影响程序的退出速度。
  4. 默认类型：
    == 通过 new Thread(...) 创建的线程默认是前台线程。==

后台线程（Background Threads）：

这些线程也是由主线程或其他前台线程创建的，它们同样是平级的，不是主线程的子线程。后台线程与主线程之间的关系也是平级的。当所有前台线程结束，程序会退出，同时会终止所有后台线程，不管后台线程是否执行完毕。

  1. 生命周期：
    后台线程的生命周期受到主线程的影响。如果所有前台线程（包括主线程）都已经完成，程序会立即退出，同时终止后台线程，不管后台线程是否执行完毕。
  2. 程序退出：
    如果程序中只剩下后台线程在运行，即使主线程结束，程序也会立即退出，不会等待后台线程完成。
  3. 影响程序：
    后台线程不会阻塞程序的退出，它们对程序的退出速度没有影响。
  4. 设置后台线程：
    可以通过设置线程的 IsBackground 属性为 true 将线程设置为后台线程。通过 Thread 类创建的线程可以使用这个属性进行设置。

使用场景：

  1. 前台线程通常用于执行一些关键任务，确保这些任务的完成。例如，在主线程需要等待其他线程的结果时，可以使用前台线程。

  2. 后台线程通常用于执行一些非关键性的任务，如日志记录、监控等。它们不会阻止程序的退出，适用于在程序退出时不需要保证任务完全执行的情况。
    错误使用后台线程，可能引起资源泄露或意外行为

  3. 资源泄露：
    如果后台线程在程序退出时还在执行，可能会导致资源无法正确释放。例如，如果后台线程打开了文件、网络连接或其他资源，但程序退出时这些资源没有被正确关闭，就会发生资源泄露。

  4. 不完整的操作：
    如果后台线程执行一些需要完整执行的操作，例如数据的写入、状态的更新等，但程序退出时这些操作未完成，可能会导致数据不一致或损坏。

  5. 异常处理：
    后台线程的异常不会被捕获并传播到主线程，可能会导致未处理的异常，影响程序的稳定性。
    4.线程同步：
    在程序退出时，后台线程可能还在等待某些同步操作完成，但这些操作可能无法在后台线程终止之前完成，可能会导致死锁或其他线程同步问题。

1.Thread（线程）

表示一个执行线程，用于并行执行代码。可以使用 Thread 类来创建和管理线程。线程是执行程序的最小单位，多线程编程允许程序同时执行多个任务，从而提高性能和响应性。
Thread 类是 C# 中用于线程操作的基础类之一。然而，对于更高级的线程编程需求，你可能会使用 Task、ThreadPool、异步编程模型等更高级的机制，以便更好地管理和协调多线程操作。
Thead常用方法

  1. Start()： 启动线程，使其开始执行指定的方法。
  2. Join()： 阻塞当前线程，直到目标线程完成。
  3. Abort()： 强制终止线程的执行。不建议使用，因为可能导致资源泄漏或不稳定的状态。
  4. Sleep(int millisecondsTimeout)： 使当前线程休眠指定的毫秒数。
  5. IsAlive()： 返回一个布尔值，指示线程是否处于活动状态。
  6. Interrupt()： 中断线程，引发一个 ThreadInterruptedException 异常。
  7. Suspend() 和 Resume()： 已过时，不推荐使用。用于暂停和恢复线程的执行。
  8. GetDomain() 和 GetDomainID()： 获取线程所属的应用程序域和域标识符。
  9. SetApartmentState(ApartmentState state)： 设置线程的单元状态，用于控制线程的COM互操作行为。
  10. GetCurrentThreadId() 和 GetDomainID()： 获取当前线程的唯一标识符。
  11. Interrupt()： 中断线程的等待状态，引发 ThreadInterruptedException 异常。
  12. Yield()： 提示系统允许其他等待线程运行。
  13. Name 和 CurrentThread.Name： 获取或设置线程的名称。
  14. SetData 和 GetData： 在线程范围内设置和获取线程本地存储数据。
  15. Start(ParameterizedThreadStart) 和 Start(ParameterizedThreadStart, Object)： 启动线程并传递参数给线程方法。
  16. TrySetApartmentState(ApartmentState)： 尝试设置线程的单元状态，返回是否成功。
  17. StartNew(Action) 和 StartNew(Action, CancellationToken)： 使用 Task 类来启动线程。

这些方法提供了各种线程管理和操作的能力。然而，需要注意，一些方法已经过时，不推荐使用，而且一些方法可能会涉及多线程编程的复杂性，需要谨慎使用。在编写多线程应用程序时，确保仔细阅读文档并根据需求选择适当的方法。

(1)创建线程

通常，你需要传递一个方法作为线程的入口点，然后调用 Start 方法来启动线程。

csharp 复制代码 
using System;
using System.Threading;

class Program
{
    static void Main()
    {
        Thread thread = new Thread(WorkerMethod);
        thread.Start(); // 启动线程
    }

    static void WorkerMethod()
    {
        Console.WriteLine("Thread is running.");
    }
}

(2) 线程同步

在多线程环境中，线程同步是一种确保多个线程协调工作的机制。Thread 类提供了 Join 方法，允许一个线程等待另一个线程完成。这在需要等待某个线程的结果时特别有用。

csharp 复制代码 
using System;
using System.Threading;

class Program
{
    static void Main()
    {
    	Thread currentThread = Thread.CurrentThread;
        Console.WriteLine($"Thread ID: {currentThread.ManagedThreadId}");
        Thread thread = new Thread(WorkerMethod);
        thread.Start();

        // 主线程等待子线程完成
        thread.Join();
        Console.WriteLine("Thread has finished.");
    }

    static void WorkerMethod()
    {
      	Thread currentThread = Thread.CurrentThread;
        Console.WriteLine($"Thread ID: {currentThread.ManagedThreadId}");
        Console.WriteLine("Thread is running.");
        Thread.Sleep(2000); // 模拟耗时操作
    }
}

(3)线程异步

csharp 复制代码 
using System;
using System.Threading;

class Program
{
    static void Main()
    {
    	            Thread currentThread = Thread.CurrentThread;

            Console.WriteLine($"Thread ID: {currentThread.ManagedThreadId}");
            Thread thread = new Thread(WorkerMethod);
            thread.Start();

            // 主线程等待子线程完成
            //thread.Join();
            Console.WriteLine("Thread has finished.");
            //这里子线程虽然还没有处理完，但是直接返回了，没有继续等待子线程，但是子线程还在继续处理工作，没有出现阻塞现象
            return "ok";
    }

    static void WorkerMethod()
    {
      	 Thread currentThread = Thread.CurrentThread;

            Console.WriteLine($"Thread ID: {currentThread.ManagedThreadId}");
            Console.WriteLine("Thread is running.");
            Thread.Sleep(10000); // 模拟耗时操作
            //这里在主线程结束后，继续在处理10s后打印Thread is WordEnd；
            Console.WriteLine("Thread is WordEnd.");
    }
}

可以思考下，主线程返回成功了，但是子线程执行失败了，这可怎么办？

2.ThreadPool（线程池）

线程池（ThreadPool）是一种用于管理和复用线程的技术，旨在提高多线程编程的性能和效率。线程池允许在应用程序中维护一组预先创建的线程，这些线程可以在需要时被重复使用来执行任务，而不必频繁地创建和销毁线程。
线程池的主要优势包括：

  1. 减少线程创建和销毁的开销： 创建和销毁线程是昂贵的操作，会消耗大量的系统资源。线程池可以避免这种开销，通过重用现有线程来执行多个任务。
  2. 提高系统性能：
    线程池可以有效地管理线程的数量，防止过多的线程竞争系统资源，从而提高系统的性能和响应速度。
  3. 控制并发度：线程池允许您控制同时执行的线程数量，以防止系统资源被耗尽。这有助于避免过度并发和线程之间的竞争。
  4. 简化编程： 使用线程池可以简化多线程编程，您只需将任务提交到线程池，而不必手动管理线程的生命周期。
    .NET Core API 中默认情况下会使用一个称为线程池（ThreadPool）的机制来管理和调度线程。线程池是一种用于管理多个工作线程的技术，它可以帮助您更有效地管理系统资源，避免频繁地创建和销毁线程。在 .NET Core API 中，默认情况下，您可以使用线程池来执行异步操作，如通过 Task.Run、async 和 await 等方式。线程池会根据系统的资源状况自动管理线程的数量，并尝试最优地分配线程以提高性能。
    需要注意的是，使用 async 和 await 并不代表一定会使用线程池中的线程。某些异步操作（例如 I/O 操作）可能会利用其他机制，如异步 I/O，而不一定会占用线程池中的线程。但总体而言，async 和 await 是一种有效地利用线程池资源来处理异步任务的方式。
csharp 复制代码 
using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        Console.WriteLine("Start of Main");

        // 使用线程池执行异步操作
        await Task.Run(() =>
        {
            Console.WriteLine("Async operation in thread pool");
        });

        Console.WriteLine("End of Main");
    }
}

(1)查看默认线程池的信息

  1. 最小线程数（MinThreads）：
    最小线程数是线程池中允许的最少活动线程数。当线程池中的线程数低于最小线程数时，线程池会自动创建新的线程，以满足活动任务的需求。最小线程数的设置可以确保在线程池中始终有一定数量的线程可用，从而减少任务启动和销毁线程的开销。
  2. 最大线程数（MaxThreads）
    最大线程数是线程池中允许的最大活动线程数。当线程池中的线程数达到最大线程数时，线程池不会再创建新的线程。超过最大线程数的任务会排队等待，直到有线程可用为止。设置适当的最大线程数可以防止线程池无限制地创建过多的线程，从而导致资源耗尽或性能下降。
csharp 复制代码 
        public void TheadPoolInfo()
        {
            //获取当前线程池的线程数
            int workerThreads, ioThreads;
            ThreadPool.GetAvailableThreads(out workerThreads, out ioThreads);
            Console.WriteLine($"Available worker threads: {workerThreads}");
            Console.WriteLine($"Available I/O threads: {ioThreads}");
            //获取当前线程池的最大线程数：
            int maxWorkerThreads, maxIoThreads;
            ThreadPool.GetMaxThreads(out maxWorkerThreads, out maxIoThreads);
            Console.WriteLine($"Max worker threads: {maxWorkerThreads}");
            Console.WriteLine($"Max I/O threads: {maxIoThreads}");
            //获取当前线程池的最小线程数
            int minWorkerThreads, minIoThreads;
            ThreadPool.GetMinThreads(out minWorkerThreads, out minIoThreads);
            Console.WriteLine($"Min worker threads: {minWorkerThreads}");
            Console.WriteLine($"Min I/O threads: {minIoThreads}");
        }

(2)工作线程与I/O线程

工作线程（Worker Threads）和 I/O 线程（I/O Threads）是线程池中的两种不同类型的线程，用于执行不同类型的任务。线程池通过合理分配这些线程，以提高多线程编程的性能和效率。
工作线程（Worker Threads）：

  1. 工作线程主要用于执行计算密集型的任务，即需要进行大量计算和处理的操作。这些线程执行 CPU 密集型的工作，如执行复杂的算法、数据处理、数值计算等。

  2. 工作线程执行的任务可能会占用较长的 CPU 时间，因此线程池会根据需要创建和回收工作线程，以便高效地利用系统资源。

  3. 线程池维护工作线程的数量，确保系统不会过度并发，避免消耗过多的 CPU 资源。
    I/O 线程（I/O Threads）：

  4. I/O 线程主要用于执行 I/O 操作，如文件读写、网络通信、数据库访问等。这些操作通常涉及等待外部资源的响应，因此适合异步执行，以充分利用系统的并发性能。

  5. I/O 线程执行的任务通常不会占用大量的 CPU 时间，大部分时间都是在等待 I/O 完成。因此，线程池可以创建更多的 I/O 线程，以处理多个 I/O 操作。

  6. 通过异步执行 I/O 操作，可以避免阻塞主线程，提高应用程序的响应性。

3.Task（任务）

表示一个异步操作，可以使用 Task 类或 Task.Run 方法来创建和管理任务。

（1）Task与Thead的关系

Task 和 Thread 在并发和异步编程中都有各自的作用和优势。在现代的 C# 编程中，通常优先考虑使用 Task 进行异步操作，Task是Thead的更高的抽象和更简洁的代码。同时，了解 Thread 也是重要的，因为在某些情况下可能需要直接控制线程的创建和管理。

4.Task Parallel Library (TPL)（任务并行库）

是 C# 中用于并行编程的高级库，用于处理异步和并行操作，包括数据并行和任务并行。

5.Async/Await（异步/等待）

是 C# 5.0 引入的异步编程模型，用于创建和管理异步方法和操作。

6.Monitor（监视器）

是用于实现线程同步的一种机制，用于保护共享资源，避免竞态条件。可以使用 Monitor 类或 lock 关键字来实现。
首先lock和Minitor有什么区别呢？

其实lock在IL代码中会被翻译成Monitor。也就是Monitor.Enter(obj)和Monitor.Exit(obj).

csharp 复制代码 
lock（obj）
{}

//等价为：
try

{    
      Monitor.Enter(obj)
}

catch（）
{}
finally
{
      Monitor.Exit(obj)
}

7.Semaphore（信号量）

用于控制并发访问资源的数量，可以使用 Semaphore 类来创建和管理信号量。

8.SemaphoreSlim

是 Semaphore 的改进版本，提供更好的性能和可伸缩性。

9.AutoResetEvent（自动复位事件）

用于线程同步，允许一个线程等待另一个线程发出信号。

10.ManualResetEvent（手动复位事件）

用于线程同步，允许一个线程等待多个线程发出信号。

11.CancellationToken（取消标记）

用于在异步操作中请求取消操作，可以在异步方法中传递给取消标记。

12.volatile（易失性修饰符）

用于标记字段，指示编译器不应该对标记字段进行优化，以确保多线程环境下的正确性。

13.Mutex（互斥锁）

是一种用于实现线程同步的机制，用于保护共享资源，防止多个线程同时访问。

14.ReaderWriterLock（读写锁）

允许多个线程同时读取共享资源，但只允许一个线程写入资源。适用于读操作频繁、写操作较少的场景。

15.ReaderWriterLockSlim（轻量级读写锁）

是 ReaderWriterLock 的改进版本，提供更好的性能和可伸缩性。

16.SpinLock

是一种自旋锁，用于短时间内的临界区保护。它使用忙等待来尝试获取锁，适用于临界区很小的情况。

17.SpinWait

用于在自旋等待期间执行自旋操作，可以根据不同的条件进行自旋。

18.Barrier（屏障）

允许多个线程在一个点上等待，直到所有线程都达到该点。适用于需要所有线程协调同步的场景。

四、多线程的异常捕获问题

相关文章

相关推荐
单音GG1 小时前
推荐一个基于协程的C++(lua)游戏服务器
服务器·c++·游戏·lua
wyh要好好学习1 小时前
C# WPF 记录DataGrid的表头顺序，下次打开界面时应用到表格中
开发语言·c#·wpf
AitTech1 小时前
C#实现：电脑系统信息的全面获取与监控
开发语言·c#
shitian08111 小时前
用轻量云服务器搭建一个开源的商城系统，含小程序和pc端
服务器·小程序·开源
咩咩觉主2 小时前
尽量通俗易懂地概述.Net && U nity跨语言/跨平台相关知识
unity·c#·.net·.netcore
Biomamba生信基地2 小时前
Linux也有百度云喔~
linux·运维·服务器·百度云
米饭是菜qy2 小时前
TCP 三次握手意义及为什么是三次握手
服务器·网络·tcp/ip
yaoxin5211232 小时前
第十九章 TCP 客户端 服务器通信 - 数据包模式
服务器·网络·tcp/ip
yngsqq2 小时前
035集——BOUNDARY获取图形外轮廓（CAD—C#二次开发入门）
开发语言·javascript·c#
鹿鸣天涯2 小时前
‌华为交换机在Spine-Leaf架构中的使用场景
运维·服务器·网络
热门推荐
01软件工程从理论到实践客观题汇总(头歌第一章至第八章)02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04VSCode插件 —— Cody AI （免费AI助手！）05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06Windows10安装PCL1.14.0及点云配准07Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO08文件或文件夹名称中有空格如何批量去除09基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测10【QuikGraph】C#调用第三方库实现迪杰斯特拉(Dijkstra)算法功能