C# 多线程(1)

已于 2024-07-17 21:09:27 修改
阅读量625 收藏 17
点赞数 15
文章标签： c# 开发语言
于 2024-07-17 21:08:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/meibianchuidi123/article/details/139754522
版权
  • 两个名词解释：进程和线程

进程：简单说是指在系统中正在运行的一个应用程序。在windows系统中，通过资源管理器可以看到每个应用进程。

线程：是系统分配处理器时间资源的基本单元。一个进程里包含多个进程。

  • 多线程作用

执行比较耗时任务时，也同时可以解决一些非常耗时的程序长时间占用CPU资源。比如：迅雷下载影片时，可以一边下着，一边观看其他影片，这就是开了多线程

  • 多线程特点

运行顺序不确定；线程之间并行(其实是交替执行)

 初步演示代码如下：

/*
 * 作者：WangYadong
 */
using System;
using System.Threading;

namespace 学习多线程
{
    class Demo1
    {
        //无参方法
        private void ThreadMethod_1()
        {
            for (int i = 0; i < 100; i++)
            {
                Console.WriteLine("我是线程1");
            }
        }

        //无参方法
        private void ThreadMethod_2()
        {
            for (int i = 0; i < 100; i++)
            {
                Console.WriteLine("我是线程2");
            }
        }

        private void Test1()
        {
            Thread th1 = new Thread(ThreadMethod_1);
            th1.Start();

            Thread th2 = new Thread(ThreadMethod_2);
            th2.Start();
        }
        static void Main(string[] args)
        {
            Demo1 obj = new Demo1();
            obj.Test1();
        }
    }
}

新建两个方法ThreadMethod_1()和ThreadMethod_2()，然后在Test1()中开两个线程th1和th2，分别调用这两个方法

我们可以看到这两个方法被以参数的形式传递给了新起线程的构造函数中(本质还是委托)，然后再用Start()启用该线程 

运行结果如下：

可以看到两个线程的输出结果是交替的 

  • 开启带参线程

方法一（此方式只能传递一个参数）： 

   //带参方法
        private void ThreadMethod_3(object paraName)
        {
            Console.WriteLine("我是线程3: " + Thread.CurrentThread.ManagedThreadId + " 参数为： " + paraName.ToString());
        }

 调用如下：

   /// <summary>
        /// 此种方式只能传递一个参数
        /// </summary>
        private void Test2()
        {

            Thread th3 = new Thread(ThreadMethod_3);
            th3.Start("AAA"); //参数在这里传递
        }

方法二（使用“类”进行传参）：

新建一个MyThread类：

/***************
 * 
 * Title:
 * 
 * Description:
 *            功能：
 *            
 * Author:王亚东
 * 
 * Date:2024
 * 
 * Modify:
 * 
 * ****/

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace 学习多线程
{
    class MyThread
    {
        private string _FilePath;
        private string _FileName;

        public MyThread(string filePath,string fileName)
        {
            _FilePath = filePath;
            _FileName = fileName;
        }

        public void DownFileLoad()
        {
            Console.WriteLine("开始下载： " + _FilePath + "/" + _FileName);
            Thread.Sleep(2);
            Console.WriteLine("下载完毕！");
        }
    }
}

调用如下：

  /// <summary>
        /// 传递多个参数--使用类进行传参
        /// </summary>
        private void Test3()
        {
            MyThread myThreadObj = new MyThread("D:/File", "abc.mp4");
            Thread th = new Thread(myThreadObj.DownFileLoad);
            th.Start();
        } 

  • 委托开启线程 （使用委托开启的线程都是后台线程）

1、委托开启线程，调无参方法： 

  //无参方法
        private void ThreadMethod_1()
        {
            for (int i = 0; i < 100; i++)
            {
                Console.WriteLine("我是线程1");
            }
        }

调用如下：

 /// <summary>
        /// 委托开启线程（无参）
        /// </summary>
        private void Test4()
        {
            Action ac = ThreadMethod_1;
            ac.BeginInvoke(null, null); //新版本的VS更新后不再支持这个委托方法了，所以运行报错
            Console.ReadLine(); //这里必须要加这句代码，否则该委托线程不执行，因为委托开启的是后台线程，Main是主线程，是前台线程，前台线程瞬间执行完后，后台线程还没来得及执行
        } 

2、委托开启线程 ，调有参方法：

//带参方法
        private void ThreadMethod_4(int num)
        {
            Console.WriteLine("我是线程3: " + Thread.CurrentThread.ManagedThreadId + " 参数为： " + num);
        } 

调用如下：

 /// <summary>
        /// 委托开启线程（带参）
        /// </summary>
        private void Test5()
        {
            Action<int> ac = ThreadMethod_4;
            ac.BeginInvoke(100, null, null); //新版本的VS更新后不再支持这个委托方法了，所以运行报错
            Console.ReadLine(); //这里必须要加这句代码，否则该委托线程不执行，因为委托开启的是后台线程，Main是主线程，是前台线程，前台线程瞬间执行完后，后台线程还没来得及执行 
        }  

3、委托开启线程，使用“状态结果”，来等待子线程结束，接收子线程的结果：

 private int DownFileMoreFile(int num)
        {
            Console.WriteLine("下载很多文件");
            Thread.Sleep(3000);
            return num + 2000;
        }

调用如下：

 /// <summary>
        /// 委托开启线程，传参，有返回值
        /// </summary>
        private void Test6()
        {
            Func<int, int> fu = DownFileMoreFile;
            IAsyncResult result = fu.BeginInvoke(100, null, null);  //新版本的VS更新后不再支持这个委托方法了，所以运行报错
            while (!result.IsCompleted)
            {
                Console.WriteLine(".");
            }
            int endResult = fu.EndInvoke(result);
            Console.WriteLine("线程结束，返回值为：" + endResult);
            //Console.ReadLine();  //这里可以不用加这行代码，因为while循环已经在执行了
        } 

4、委托开启线程，使用“等待句柄”，来等待子线程结束，接收子线程的结果：

  private int DownFileMoreFile(int num)
        {
            Console.WriteLine("下载很多文件");
            Thread.Sleep(3000);
            return num + 2000;
        }

调用如下： 

  /// <summary>
        /// 委托开启线程，传参，有返回值，用等待句柄的方式代替上个方法中的while循环(二者效果一样)
        /// </summary>
        private void Test7()
        {
            Func<int, int> fu = DownFileMoreFile;
            IAsyncResult result = fu.BeginInvoke(100, null, null);  //新版本的VS更新后不再支持这个委托方法了，所以运行报错
            bool boResult = result.AsyncWaitHandle.WaitOne(1000);  //用“等待句柄”，等待1秒钟，且有状态返回值
            if (boResult)
            {
                int endResult = fu.EndInvoke(result);
                Console.WriteLine("线程结束，返回值为：" + endResult);
            }
            else
            {
                Console.Write("规定时间内，没有取得子线程的结果。"); //会执行else，不会再执行if，因为DownFileMoreFile方法里是等待3秒，而这里只等待1秒，所以无法取得结果
            }
            //Console.ReadLine();  //这里可以不用加这行代码，因为等待句柄已经在执行了
        }

5、委托开启线程，使用“回调函数”，来接收子线程的结果

  private void Test8()
        {
            Console.WriteLine("使用‘回调函数’方式");
            Func<int, int> fu = DownFileMoreFile;
            //当子线程结束的时候，自动调用回调函数OnCallBack
            fu.BeginInvoke(100, OnCallBack, fu); //这里的 fu 参数是传递给回调函数中的ar参数
            Console.ReadLine(); //这里必须加这行代码，因为子线程中是等待3秒，而主线程(即前台线程)瞬间执行完毕
        }

  void OnCallBack(IAsyncResult ar)
        {
            Func<int, int> res = ar.AsyncState as Func<int, int>;
            int intRessult = res.EndInvoke(ar);
            Console.WriteLine("在回调函数中取得结果");
        }

注：在Main函数中调用Test8方法即可

  • 线程优先级

    /// <summary>
        /// 线程优先级学习
        /// </summary>
        private void Test9()
        {
            Thread th1 = new Thread(ThreadMethod_1);
            Thread th2 = new Thread(ThreadMethod_2);
            Thread th3 = new Thread(ThreadMethod_2_1);

            //总共有5种优先级状态，线程的优先级决定了它应该在操作系统中被分配多少CPU时间。
            //高优先级的线程可能会在低优先级的线程之前执行。但是，请注意，设置线程的优先级并不保证它会获得更多的CPU时间。这完全取决于操作系统的调度策略。
            th1.Priority = ThreadPriority.Lowest;   //线程共有5个优先级
            th2.Priority = ThreadPriority.AboveNormal;
            th3.Priority = ThreadPriority.Highest;

            th1.Start();
            th2.Start();
            th3.Start();           
        }

  • 线程状态 

线程共有4中状态：Start()//开始   Abort() //结束  Join(1000)//阻塞  Sleep(1000)//休眠

Join和Sleep比较相似

代码示例如下：

 private void Test10()
        {
            Thread t1 = new Thread(ThreadMethod_1);
            t1.Start();     //开始
            t1.Abort();     //结束
            t1.Join(1000); //阻塞1秒
            Thread.Sleep(1000); //休眠1秒

        }

  • 前台线程与后台线程 

 前台与后台线程区别：

前台线程:重要的，核心的，或者需要长时间等待的任务（例如：UI界面线程、发送数据的线程）

 后台线程：非常适合于完成后台任务，非核心且用于处理时间较短的任务使用（例如：监听客户端的请求、word拼写检查）

*   Thread构造的线程默认是前台线程，将isBackground设置为true后就是后台线程
*   线程池中的线程是后台线程
*   后台线程随着前台线程的关闭而关闭
*   用委托开启的线程都是后台线程

  private void Test11()
        {
            Thread t1 = new Thread(ThreadMethod_3);
            t1.Start("abc");


            //............在这之前t1还是前台线程
            t1.IsBackground = true; //将线程设置为后台线程，加上这一行代码后，         

ThreadMethod_3方法就不执行，因为设置为后台线程后，随着前台线程结束而瞬间结束


            Console.ReadLine(); //加上这句代码，ThreadMethod_3方法就又执行了，因为前台线程未结束

        }

完整代码如下：

/*
 * 作者：WangYadong
 * 1、了解无参线程，及线程特性(无序)
 * 2、带参方法，开线程
 * 3、使用类传递多参数线程
 * 4、委托开启线程
 *    注意：委托开启的线程都是后台线程。“后台”线程会随着“前台”线程的关闭而自动关闭
 *    4.1：使用“状态结果”，来等待子线程结束，接收子线程的结果
 *    4.2：使用“等待句柄”，来等待子线程结束，接收子线程的结果
 *    4.3：使用“回调函数”，来接收子线程的结果
 * 5：学习线程优先级
 * 6：学习线程的状态控制
 * 7：学习前台线程与后台线程
 *    7.1：Thread构造的线程默认是前台线程，将isBackground设置为true后就是后台线程
 *    7.2：线程池中的线程是后台线程
 *    7.3：后台线程随着前台线程的关闭而关闭
 *    7.4：用委托开启的线程都是后台线程
 *    前台线程:重要的，核心的，或者需要长时间等待的任务（例如：UI界面线程、发送数据的线程）
 *    后台线程：非常适合于完成后台任务，非核心且用于处理时间较短的任务使用（例如：监听客户端的请求、word拼写检查）
 *    
 */
using System;
using System.Threading;

namespace 学习多线程
{
    class Demo1
    {
        //无参方法
        private void ThreadMethod_1()
        {
            for (int i = 0; i < 100; i++)
            {
                Console.WriteLine("我是线程1");
            }
        }

        //无参方法
        private void ThreadMethod_2()
        {
            for (int i = 0; i < 100; i++)
            {
                Console.WriteLine("我是线程2");
            }
        }

        private void ThreadMethod_2_1()
        {
            for (int i = 0; i < 100; i++)
            {
                Console.WriteLine("我是线程2_1");
            }
        }

        //带参方法
        private void ThreadMethod_3(object paraName)
        {
            Console.WriteLine("我是线程3: " + Thread.CurrentThread.ManagedThreadId + " 参数为： " + paraName.ToString());
        }

        //带参方法
        private void ThreadMethod_4(int num)
        {
            Console.WriteLine("我是线程3: " + Thread.CurrentThread.ManagedThreadId + " 参数为： " + num);
        }

        private int DownFileMoreFile(int num)
        {
            Console.WriteLine("下载很多文件");
            Thread.Sleep(3000);
            return num + 2000;
        }

        private void Test1()
        {
            Thread th1 = new Thread(ThreadMethod_1);
            th1.Start();

            Thread th2 = new Thread(ThreadMethod_2);
            th2.Start();
        }

        /// <summary>
        /// 此种方式只能传递一个参数
        /// </summary>
        private void Test2()
        {

            Thread th3 = new Thread(ThreadMethod_3);
            th3.Start("AAA"); //参数在这里传递
        }

        /// <summary>
        /// 传递多个参数--使用类进行传参
        /// </summary>
        private void Test3()
        {
            MyThread myThreadObj = new MyThread("D:/File", "abc.mp4");
            Thread th = new Thread(myThreadObj.DownFileLoad);
            th.Start();
        }

        /// <summary>
        /// 委托开启线程（无参）
        /// </summary>
        private void Test4()
        {
            Action ac = ThreadMethod_1;
            ac.BeginInvoke(null, null); //新版本的VS更新后不再支持这个委托方法了，所以运行报错
            Console.ReadLine(); //这里必须要加这句代码，否则该委托线程不执行，因为委托开启的是后台线程，Main是主线程，是前台线程，前台线程瞬间执行完后，后台线程还没来得及执行
        }

        /// <summary>
        /// 委托开启线程（带参）
        /// </summary>
        private void Test5()
        {
            Action<int> ac = ThreadMethod_4;
            ac.BeginInvoke(100, null, null); //新版本的VS更新后不再支持这个委托方法了，所以运行报错
            Console.ReadLine(); //这里必须要加这句代码，否则该委托线程不执行，因为委托开启的是后台线程，Main是主线程，是前台线程，前台线程瞬间执行完后，后台线程还没来得及执行 
        }

        /// <summary>
        /// 委托开启线程，传参，有返回值
        /// </summary>
        private void Test6()
        {
            Func<int, int> fu = DownFileMoreFile;
            IAsyncResult result = fu.BeginInvoke(100, null, null);  //新版本的VS更新后不再支持这个委托方法了，所以运行报错
            while (!result.IsCompleted)
            {
                Console.WriteLine(".");
            }
            int endResult = fu.EndInvoke(result);
            Console.WriteLine("线程结束，返回值为：" + endResult);
            //Console.ReadLine();  //这里可以不用加这行代码，因为while循环已经在执行了
        }

        /// <summary>
        /// 委托开启线程，传参，有返回值，用等待句柄的方式代替上个方法中的while循环(二者效果一样)
        /// </summary>
        private void Test7()
        {
            Func<int, int> fu = DownFileMoreFile;
            IAsyncResult result = fu.BeginInvoke(100, null, null);  //新版本的VS更新后不再支持这个委托方法了，所以运行报错
            bool boResult = result.AsyncWaitHandle.WaitOne(1000);  //用“等待句柄”，等待1秒钟，且有状态返回值
            if (boResult)
            {
                int endResult = fu.EndInvoke(result);
                Console.WriteLine("线程结束，返回值为：" + endResult);
            }
            else
            {
                Console.Write("规定时间内，没有取得子线程的结果。"); //会执行else，不会再执行if，因为DownFileMoreFile方法里是等待3秒，而这里只等待1秒，所以无法取得结果
            }
            //Console.ReadLine();  //这里可以不用加这行代码，因为等待句柄已经在执行了
        }

        /// <summary>
        /// 委托开启线程，传参，有返回值，用“回调函数”获取返回结果
        /// </summary>
        private void Test8()
        {
            Console.WriteLine("使用‘回调函数’方式");
            Func<int, int> fu = DownFileMoreFile;
            //当子线程结束的时候，自动调用回调函数OnCallBack
            fu.BeginInvoke(100, OnCallBack, fu); //这里的 fu 参数是传递给回调函数中的ar参数
            Console.ReadLine(); //这里必须加这行代码，因为子线程中是等待3秒，而主线程(即前台线程)瞬间执行完毕
        }

        void OnCallBack(IAsyncResult ar)
        {
            Func<int, int> res = ar.AsyncState as Func<int, int>;
            int intRessult = res.EndInvoke(ar);
            Console.WriteLine("在回调函数中取得结果");
        }


        /// <summary>
        /// 线程优先级学习
        /// </summary>
        private void Test9()
        {
            Thread th1 = new Thread(ThreadMethod_1);
            Thread th2 = new Thread(ThreadMethod_2);
            Thread th3 = new Thread(ThreadMethod_2_1);

            //总共有5种优先级状态，线程的优先级决定了它应该在操作系统中被分配多少CPU时间。
            //高优先级的线程可能会在低优先级的线程之前执行。但是，请注意，设置线程的优先级并不保证它会获得更多的CPU时间。这完全取决于操作系统的调度策略。
            th1.Priority = ThreadPriority.Lowest;
            th2.Priority = ThreadPriority.AboveNormal;
            th3.Priority = ThreadPriority.Highest;

            th1.Start();
            th2.Start();
            th3.Start();           
        }

        private void Test10()
        {
            Thread t1 = new Thread(ThreadMethod_1);
            t1.Start();     //开始
            t1.Abort();     //结束
            t1.Join(1000); //阻塞1秒
            Thread.Sleep(1000); //休眠1秒

        }

        private void Test11()
        {
            Thread t1 = new Thread(ThreadMethod_3);
            t1.Start("abc");
            //............在这之前t1还是前台线程
            t1.IsBackground = true; //将线程设置为后台线程，加上这一行代码后，ThreadMethod_3方法就不执行，因为设置为后台线程后，随着前台线程结束而瞬间结束
            Console.ReadLine(); //加上这句代码，ThreadMethod_3方法就又执行了，因为前台线程未结束

        }

        static void Main(string[] args)
        {
            Demo1 obj = new Demo1();
            obj.Test11();
        }
    }
}

WYD_Allon
关注
  • 15
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c# window服务多线程实例
08-10
了解这些基础知识后，你就可以创建一个能够充分利用多线程的C# Windows服务了。不过，这只是一个基础起点，实际开发中可能还需要考虑更多因素，如日志记录、配置管理、异常处理策略等，以确保服务的健壮性和可扩展性...
C#多线程读写sqlite
05-25
标题"**C#多线程读写sqlite**"涉及的主要知识点包括： 1. **多线程编程**：C#中的`System.Threading`命名空间提供了丰富的类和方法来创建和管理线程，如`Thread`类、`Task`类以及`ThreadPool`。通过多线程，程序...
C#高级--多线程详解
热门推荐
李宥的博客
10-03 4万+
C#高级–多线程详解 零、文章目录 一、什么是多线程 1、进程 当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。 而一个进程又是由多个线程所组成的。 2、线程 线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。 3、句柄 句柄是Windows系统中对象或实例的标识，这些对象包括模块、应用程序实例、窗口、控制、位图、GDI对象、资源、文件等。 4、多线程 （1）多线程概念 多线程是指程序中
C# 多线程详细讲解
fenglearning的博客
05-27 2万+
C#多线程 一、基本概念 1、进程 首先打开任务管理器，查看当前运行的进程： 从任务管理器里面可以看到当前所有正在运行的进程。那么究竟什么是进程呢？ 进程（Process）是Windows系统中的一个基本概念，它包含着一个运行程序所需要的资源。一个正在运行的应用程序在操作系统中被视为一个进程，进程可以包括一个或多个线程。 线程是操作系统分配处理器时间的基本单元，在进程中可以有多个线程同时执行代码。进程之间是相对独立的，一个进程无法访问另一个进程的数据（除非利用分布式计算方式）， 一个进程运
C#【高级篇】 C# 多线程
星Yeah 的博客
06-29 7505
线程 被定义为程序的执行路径。每个线程都定义了一个独特的控制流。如果您的应用程序涉及到复杂的和耗时的操作，那么设置不同的线程执行路径往往是有益的，每个线程执行特定的工作。 线程是轻量级进程。一个使用线程的常见实例是现代操作系统中并行编程的实现。使用线程节省了 CPU 周期的浪费，同时提高了应用程序的效率。 到目前为止我们编写的程序是一个单线程作为应用程序的运行实例的单一的过程运行的。但是，这样子应用程序同时只能执行一个任务。为了同时执行多个任务，它可以被划分为更小的线程。 ...
C#单线程和多线程
百锦再的博客
01-08 1万+
单线程和多线程是计算机编程中的概念，用于描述程序的执行方式和资源利用方式。
C# 多线程之Task
qq_29821795的博客
08-03 3264
开启多线程 { //第一种方式 Task task = new Task(() => { this.DoSomethingLong("btnTask_Click_1") }); task.Start(); } { //第二种方式 Task task = Task.Run(() => this.DoSomethingLong("btnTask_Click_2")); } { //第三种方式 TaskFactory taskFa
C# 异步 多线程
wokao253615105的专栏
02-24 4621
转载自https://www.cnblogs.com/doforfuture/p/6293926.html C#中 Thread，Task，Async/Await，IAsyncResult 的那些事儿！ 说起异步，Thread，Task，async/await，IAsyncResult 这些东西肯定是绕不开的，今天就来依次聊聊他们 ...
C# 多线程加锁简单示例
一个编程的同学
06-09 4089
private void button8_Click(object sender, EventArgs e) { //for (int i = 0; i < 5; i++) //{ // int k = i; // Thread.Sleep(5); // Task.Run(() => // { ...
C#基础-多线程
jjailsa的博客
08-15 1万+
闲得蛋疼，整理一下C#线程的基础概念和常规用法。
C#实现多线程
程序员之道
12-10 6711
C#实现多线程 进程想要执行任务就需要依赖线程。换句话说，就是进程中的最小执行单位就是线程，并且一个进程中至少有一个线程。多线程分为两种，一种是串行，另一种是并行。 串行 串行是相对于单条线程来执行多个任务来说的，我们就拿下载文件来举个例子：当我们下载多个文件时，在串行中它是按照一定的顺序去进行下载的，也就是说，必须等下载完A之后才能开始下载B，它们在时间上是不可能发生重叠的。 并行 当我们下载多个文件，开启多条线程，多个文件同时进行下载，在同一时刻发生的，并行在时间上是重叠的。 ...
C#多线程调试
dotNET跨平台
05-05 901
概要这篇文章主要分享多线程部分调试技巧，在日常的开发工作中会经常遇到多线程调试的需要。在我们调试的过程中会出现断点的焦点在多个线程之间“反复横跳”根本无法集中跟踪某一个线程的操作链路。那么今天我们来看看如何调试操作。如果有其它需要的可以参考下面微软官方的文档地址。参考文献：https://docs.microsoft.com/zh-cn/visualstudio/debu...
C#多线程下载demo
08-19
本示例“C#多线程下载demo”旨在展示如何利用多线程来加速文件的下载过程。多线程允许程序同时执行多个任务，从而提高效率并改善用户体验。 首先，我们要理解C#中的线程。在.NET框架中，`System.Threading`命名空间...
c#多线程中子线程动态改变ui控件
04-08
C#多线程中子线程动态改变UI控件 在桌面应用程序中，控制UI界面是一个非常重要的任务。特别是在C#多线程编程中，子线程更新UI控件是一个常见的问题。本文将总结C#子线程更新UI控件的方法，介绍两种常用的方法，以便...
C#多线程编程实战 源代码
12-06
本书是一本通俗易懂的C#多线程编程指南，通过70多个容易理解的示例，循序渐进地讲解C#5.0中的异步及并发编程，引导读者了解Windows下C#多线程编程的多样性。 通过阅读本书，你将学到： 使用原始线程、异步线程，...
C#中的栈和队列
最新发布
weixin_64532720的博客
07-20 512
栈和队列是非常重要的两种数据结构,在软件设计中应用很多。栈和队列也是线性结构,线性表、栈和队列这三种数据结构的数据元素以及数据元素间的逻辑关系完全相同,差别是线性表的操作不受限制,而栈和队列的操作受到眼制。栈的操作只能在表的一端进行,队列的插入操作在表的一端进行而其它操作在表的另一端进行,所以,把栈和队列称为操作受限的线性表。BCL中的栈​namespace 栈T Pop();T Peek();​​​​namespace 栈​​top = -1;
C# 删除DataTable里符合条件的行
Pei_hua100的专栏
07-20 86
有时候我们需要删除DataTable里指定的某些行时，常用的做法是foreach遍历。当DataTable的rows.count少时并不会影响效率，但是当行数多时，效率会下降。所以，使用DataTable内置的Select方法来条件筛选就是一个不错的选择。
C# 3.数组遍历和储存对象
weixin_73535261的博客
07-17 314
练习：练习：for循环存放 10 20 30 ……100 遍历数组 计算每一个和元素相加的和10+20+……public string GirlName { get;总结： 1 数组for循环存放对象2 数组for循环遍历元素。创建数组对象，存放10个学生对象；控件：按钮button，label文本。项目目的添加10个学生并展示。
c#中匿名方法的定义和使用
weixin_64532720的博客
07-16 202
在Action里面传入参数变量 action是不需要返回值的。在Func里面也要传入参数变量 但是最后一个是返回值类型。t2("你好",250);

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值