C#Linq与delegate(委托)

最新推荐文章于 2024-09-11 09:32:06 发布
最新推荐文章于 2024-09-11 09:32:06 发布
阅读量186 收藏
点赞数 2
分类专栏： 学习记录 文章标签： c# linq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48365841/article/details/132617913
版权

文章目录

前言

本文章是本人对Linq与委托的一些理解，不对的地方还望指正
文章在说Linq之前会先说明委托，因为委托是组成Linq的一部分

假如有以下代码 需要筛选分数>=60的对象 你会怎么做

/// <summary>
/// 测试
/// </summary>
public void Test()
{
    List<Student> students = new List<Student>();
    Random random = new Random();
    for (int i = 0; i < 100; i++)
    {
        students.Add(new Student
        {
            Name = i.ToString(),
            Sex = random.Next(0, 2),
            Mark = random.Next(0, 101),
        });
    }
}

public class Student
{
    /// <summary>
    /// 名字
    /// </summary>
    public string Name { get; set; }

    /// <summary>
    /// 性别 0 男 1 女
    /// </summary>
    public int Sex { get; set; }

    /// <summary>
    /// 分数
    /// </summary>
    public int Mark { get; set; }
}

在使用Linq的做法是

var IEList = students.Where(t => t.Mark >= 60);

一、什么是delegate（委托） ？

委托是将方法包装成参数传递到其他地方执行的工具

1.委托的定义

下面代码块中定义了一些委托与方法

/// <summary>
/// 定义无参，无返回值的 委托
/// </summary>
delegate void Delegate1();

/// <summary>
/// 定义1个参数，无返回值的 委托
/// </summary>
delegate void Delegate2(string val1);

/// <summary>
/// 定义2个参数，无返回值的 委托
/// </summary>
delegate void Delegate3(string val1, string val2);

/// <summary>
/// 定义无参，返回int值的 委托
/// </summary>
delegate int Delegate4();

/// <summary>
/// 定义无参，无返回值的 方法
/// </summary>
private void Method1()
{
    Console.WriteLine("我是无参 无返回值 方法");
}

/// <summary>
/// 定义1个参数，无返回值的 方法
/// </summary>
/// <param name="val1"></param>
private void Method2(string val1)
{
    Console.WriteLine("我是有1个参数 无返回值 方法");
}

/// <summary>
/// 定义2个参数，无返回值的 方法
/// </summary>
/// <param name="val1"></param>
/// <param name="val2"></param>
private void Method3(string val1, string val2)
{
    Console.WriteLine("我是有2个参数 无返回值 方法");
}

/// <summary>
/// 定义无参，返回int值的 方法
/// </summary>
/// <returns></returns>
private int Method4()
{
    Console.WriteLine("我是无参 无返回值 方法");
    return 0;
}

2.使用自定义委托

/// <summary>
/// 测试委托
/// </summary>
public void TestDelegate()
{
    //委托的各种写法
    Delegate1 delegate1_1 = new Delegate1(() => { });//匿名
    Delegate1 delegate1_2 = () => { };//匿名
    Delegate1 delegate1_3 = new Delegate1(Method1);
    Delegate1 delegate1_4 = Method1;
    //当委托只有一行代码时，可以去掉{}
    Delegate1 delegate1_5 = () => Console.WriteLine("111");//匿名

    Delegate2 delegate2_1 = new Delegate2((val1) => { });//匿名
    Delegate2 delegate2_2 = (val1) => { };//匿名
    Delegate2 delegate2_3 = new Delegate2(Method2);
    Delegate2 delegate2_4 = Method2;
    //当委托只有一个参数时 参数两边的括号可以去掉
    Delegate2 delegate2_5 = new Delegate2(val1 => { });//匿名
    Delegate2 delegate2_6 = val1 => { };//匿名

    Delegate3 delegate3_1 = new Delegate3((val1, val2) => { });//匿名
    Delegate3 delegate3_2 = (val1, val2) => { };//匿名
    Delegate3 delegate3_3 = new Delegate3(Method3);
    Delegate3 delegate3_4 = Method3;

    Delegate4 delegate4_1 = new Delegate4(() => { return 1; });//匿名
    Delegate4 delegate4_2 = () => { return 1; };//匿名
    Delegate4 delegate4_3 = new Delegate4(Method4);
    Delegate4 delegate4_4 = Method4;
    //当委托只有一行代码时，可以去掉{}，如果是有返回值 则 需要忽略掉return
    Delegate4 delegate4_5 = new Delegate4(() => 1);//匿名
    Delegate4 delegate4_6 = () => 1;//匿名
}

3.匿名委托独有特性

匿名委托独有特性 匿名委托类可以直接访问方法类的参数

public void TestDelegate()
{
    //匿名委托独有特性 匿名委托类可以直接访问方法类的参数
    int test = 123;
    Delegate1 delegate1_5 = () =>
    {
        //访问 委托外面的test参数
        Console.WriteLine(test);
    };
}

4.如何触发委托中的方法

匿名委托独有特性 匿名委托类可以直接访问方法类的参数

public void TestDelegate()
{
    //匿名委托独有特性 匿名委托类可以直接访问方法类的参数
    int test = 123;
    Delegate1 delegate1_5 = () =>
    {
        //访问 委托外面的test参数
        Console.WriteLine(test);
    };
    delegate1_5();//方式1
    delegate1_5.Invoke();//方式2
}

4.Action与Func

一般情况下不建议使用自定义委托
因为 .Net里面已经有了现成的委托
Action与Func
Action是无返回值的委托，而且Action与泛型进行了结合 并且有很多重载
Func是具有返回值的委托，而且Func与泛型进行了结合 并且有很多重载
大部分情况下使用这两个委托就可以了

使用这两个委托的最大好处
比如有两个委托
delegate void Delegate1();
delegate void Delegate2();
Delegate1 delegate1 = () => Console.WriteLine(“111”);
Delegate2 delegate2 = () => Console.WriteLine(“111”);
以下代码中 就只能传递delegate1 而无法传递delegate2
虽然他们都是无参无返回值委托
public void TestDelegate(Delegate1 delegate1)
{
delegate1();
}
如果都使用Action则不会存在上述问题
Func同理

5.将自定义委托改为Action与Func的写法

/// <summary>
/// 测试
/// </summary>
public void TestDelegate()
{
    Action delegate1_1 = new Action(() => { });//匿名
    Action delegate1_2 = () => { };//匿名
    Action delegate1_3 = new Action(Method1);
    Action delegate1_4 = Method1;
    //当委托只有一行代码时，可以去掉{}
    Action delegate1_5 = () => Console.WriteLine("111");//匿名

    Action<string> delegate2_1 = new Action<string>((val1) => { });//匿名
    Action<string> delegate2_2 = (val1) => { };//匿名
    Action<string> delegate2_3 = new Action<string>(Method2);
    Action<string> delegate2_4 = Method2;
    //当委托只有一个参数时 参数两边的括号可以去掉
    Action<string> delegate2_5 = new Action<string>(val1 => { });//匿名
    Action<string> delegate2_6 = val1 => { };//匿名

    Action<string,string> delegate3_1 = new Action<string, string>((val1, val2) => { });//匿名
    Action<string, string> delegate3_2 = (val1, val2) => { };//匿名
    Action<string, string> delegate3_3 = new Action<string, string>(Method3);
    Action<string, string> delegate3_4 = Method3;

    Func<int> delegate4_1 = new Func<int>(() => { return 1; });//匿名
    Func<int> delegate4_2 = () => { return 1; };//匿名
    Func<int> delegate4_3 = new Func<int>(Method4);
    Func<int> delegate4_4 = Method4;
    //当委托只有一行代码时，可以去掉{}，如果是有返回值 则 需要忽略掉return
    Func<int> delegate4_5 = new Func<int>(() => 1);//匿名
    Func<int> delegate4_6 = () => 1;//匿名
}

二、Linq的组成 ？

Linq由 扩展方法、迭代、委托、泛型 组合而成的

1.各种方法的定义

public class MethodClass
    {
        /// <summary>
        /// 普通方法长这样
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="ResultT"></typeparam>
        /// <param name="list">普通 参数1</param>
        /// <param name="func">转换委托</param>
        /// <returns></returns>
        public List<ResultT> Method1<T, ResultT>(IEnumerable<T> list, Func<T, ResultT> func)
        {
            List<ResultT> reslut = new List<ResultT>();
            foreach (var item in list)
            {
                reslut.Add(func(item));
            }
            return reslut;
        }

        /// <summary>
        /// 静态 普通方法长这样
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="ResultT"></typeparam>
        /// <param name="list">普通 参数1</param>
        /// <param name="func">转换委托</param>
        /// <returns></returns>
        public static List<ResultT> Method2<T, ResultT>(IEnumerable<T> list, Func<T, ResultT> func)
        {
            List<ResultT> reslut = new List<ResultT>();
            foreach (var item in list)
            {
                reslut.Add(func(item));
            }
            return reslut;
        }

        /// <summary>
        /// 静态 迭代方法长这样
        /// 迭代方法与普通方法的区别在于 迭代方法 只有实际需要结果时才会执行里面方法内逻辑 而 普通方法会马上执行方法内逻辑
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="ResultT"></typeparam>
        /// <param name="list">普通 参数1</param>
        /// <param name="func">转换委托</param>
        /// <returns></returns>
        public static IEnumerable<ResultT> Method3<T, ResultT>(IEnumerable<T> list, Func<T, ResultT> func)
        {
            //在迭代方法中 yield break; 表示结束迭代
            //在迭代方法中 yield return 表示返回一次结果
            foreach (var item in list)
            {
                yield return func(item);
            }
        }
    }

在定义扩展方法时尽量不要使用 object 以及 没有约束的泛型 这样会导致所有类型都产生一个扩展方法

public static class MethodClass2
    {
        /// <summary>
        /// 扩展方法长这样
        /// 在定义扩展方法时尽量不要使用 object 以及 没有约束的泛型 这样会导致所有类型都产生一个扩展方法
        /// </summary>
        /// <param name="text">扩展的类型</param>
        public static void Method1(this string text)
        {
            Console.WriteLine(text);
        }
    }

2.Linq方法的定义

比如linq里面的Select与Where，假如自己写的可以像下面这么写

public static class Linq2
    {
        /// <summary>
        /// 结合上面的扩展方法 迭代 以及委托 泛型 即可组成Linq
        /// 示例 Select
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="ResultT"></typeparam>
        /// <param name="list">扩展参数</param>
        /// <param name="func">转换委托</param>
        /// <returns></returns>
        public static IEnumerable<ResultT> Select2<T, ResultT>(this IEnumerable<T> list, Func<T, ResultT> func)
        {
            //在迭代方法中 yield break; 表示结束迭代
            //在迭代方法中 yield return 表示返回一次结果
            foreach (var item in list)
            {
                yield return func(item);
            }
        }

        /// <summary>
        /// 结合上面的扩展方法 迭代 以及委托 泛型 即可组成Linq
        /// 示例 Where
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list">扩展参数</param>
        /// <param name="func">指示如何保留内容的委托</param>
        /// <returns></returns>
        public static IEnumerable<T> Where2<T>(this IEnumerable<T> list, Func<T, bool> func)
        {
            //在迭代方法中 yield break; 表示结束迭代
            //在迭代方法中 yield return 表示返回一次结果
            foreach (var item in list)
            {
                if (func(item))
                {
                    yield return item;
                }
            }
        }
    }

总结

再回到最初的问题
需要筛选分数>=60的对象 你会怎么做
通过调试不难发现这两个方法得到的结果是一样的
而代码中的t => t.Mark >= 60则是匿名委托Func< Student,bool>
由于只有一个参数 可以省略t左右两边的()
由于只有一行代码则可以将{ return t.Mark >= 60; } 写成 t.Mark >= 60

var IEList = students.Where(t => t.Mark >= 60);
var IEList2 = students.Where2(t => t.Mark >= 60);
樱桃丶老丸子
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C#委托delegate实例解析
09-04
主要介绍了C#委托delegate实例解析,对C#的委托做了较为深入的剖析,很适合初学者学习,需要的朋友可以参考下
C# LINQ使用方法
i18039072267的博客
02-17 411
C# LINQ使用方法
.Net C# Linq Select 方法
u010992421的专栏
12-28 5731
.Net C# Linq Select 方法
C#学习--委托 Delegate
RapdoZoroの博客
09-29 1783
最近在学习C#,今天这篇博客就对C#的重要特性--委托（delegate）做一下相关介绍。 在介绍委托之前，我们先看以下代码： private static double Calculate(double param1, double param2) { return Calculate_Add(param1, param2); } static double Calculate
C# LINQ源码分析之Select
热门推荐
weixin_43263355的博客
02-15 1万+
在开发过程中，LINQ代码库中的Select方法经常被使用，为了更好的了解该方法，我们从源码的角度对其进行分析。了解如何以最优的方式，使用该方法，从而提升代码的性能。
LINQ在C#中的使用方法
cfqq1989的博客
10-15 1072
cs是传进去的参数名字，可随意命名，这参数的类型是元素的类型。在集合中找出满足条件的元素。就是说，在这个集合内，找出 名字叫 维修电工的对象出来，给。查询数据内的数据对象。一般是在集合中找出单个元素对象。在成绩表中，找出张三这个对象。是用 delegate 类型。时，上层的对象也会跟着改变。那就要用莱姆达写个条件方法。对象是引用类型，当你修改。
LinQ—基本查询操作符 Select/Where/Group语句
不管风吹浪打，胜似闲庭信步
02-24 5092
LinQ中的基本查询操作和SQL中的功能是一样的，对于其异同点，我们来了解了解： 1）Select 语法： public static IEnumerable<TResult> Select<TSource,TResult>(this IEnumerable<TSource>source,Func<TSource,TResult>selector) 说明： Select方法本身是一个泛型集合扩展方法 它作用于IEnumerable<TSource>类型
C# delegate lambda linq 要注意GC的产生
PangNanGua的专栏
04-09 2455
C#中委托相当于类（不是值类型，而是引用类型）， 当做为形参传入的时候 或者System.Actionb=TestB;//TestB是一个方法， 这样调用一次为产生112bytes的gcalloc 所以我们要避免在update中这样使用。 同理，我们尽量避免使用LINQ语句，因为Linq语句要求我们传入一个委托（delegate）或者方法名，或者lambda表达式。那么GC就产生。...
Linq+lambda表达式+delegate委托详解及代码示例
Fish的博客
12-12 1230
一、Linq 简介：提供一种统一且对称的方式，让程序员在广义的数据上得到和操作“数据”。简单点说，就是在C#后台像sql查询一样操作集合和数组，从而筛选出我们想要的结果。 c#定义的各种简化查询 代码示例： int[] scores1 = new int[] { 97, 92, 81, 60, 541, 1, 88, 81, 79 }; int[] scores2 = n...
深入c# Func委托的详解
09-05
此外，`Action`委托与`Func`类似，但它没有返回值，只用于执行操作。 总的来说，`Func`委托是C#中一个强大的工具，它增强了代码的灵活性，使得函数可以作为参数传递，也可以存储在变量中或返回自其他方法。熟练掌握...
详解C#中的委托
08-31
在C#编程语言中，委托是一种强大的工具，它允许我们将方法作为参数传递给其他方法，或者存储和调用一组相关的...委托在诸如事件处理、LINQ操作和异步编程等高级特性中扮演着核心角色，是理解和掌握C#编程的关键部分。
c#委托学习示例分享
09-04
在C#中，我们可以使用`delegate`关键字来定义一个委托类型，它描述了一个方法的签名。例如，在提供的示例中，`WriteTextBox`就是一个委托类型，它接受一个字符`char`参数并返回无返回值`void`。声明委托变量如`...
深入理解C#中常见的委托
09-05
在C#编程语言中，委托（Delegate）是一种强大的特性，它允许我们将方法作为参数传递给其他方法，或者存储和调用方法。本文将深入探讨C#中常见的三种委托类型：Func、Action和Predicate，以及它们在不同场景下的应用...
在linq中使用委托
hdhai9451的专栏
04-21 686
public List GetProfileList(StockInParam param) { using (var db = new guideDB()) { Expression> filter = p => p.Status == 2; if (!param.TimeStart.ToString().IsNullOrEmpty())
C#搭建WebApi服务
lingxiao16888的博客
09-08 1523
OWIN 的全称是 "Open Web Interface for .NET"， OWIN 在 .NET Web 服务器和 .NET Web 应用之间定义了一套标准的接口， 其目的是为了实现服务器与应用之间的。
c# program中引用日志组件
最新发布
逍遥游的博客
09-11 178
// 应用程序的主入口点。
代码随想录训练营 Day53打卡 图论part04 110. 字符串接龙 105. 有向图的完全可达性 106. 岛屿的周长
qq_42952637的博客
09-08 1016
代码随想录训练营 Day53打卡 图论part04 110. 字符串接龙 105. 有向图的完全可达性 106. 岛屿的周长
C#基础：掌握委托、匿名函数与Lambda表达式
C#基础知识深入解析——委托、匿名函数与Lambda表达式 C#语言中的委托（Delegate）是其核心概念之一，它允许我们将方法作为参数传递，实现事件处理和回调功能。本文将详细介绍委托的基础知识，包括其声明、使用方法...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值