Action<T> 和 Func<T>，匿名方法

最新推荐文章于 2024-04-21 13:35:55 发布
最新推荐文章于 2024-04-21 13:35:55 发布
阅读量298 收藏
点赞数
分类专栏： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44547407/article/details/98497774
版权 
#region Action<T> 和 Func<T>

/*
* 详细资料 https://www.cnblogs.com/kissdodog/p/5674629.html
*
* Action 引用一个void 返回类型的方法，可以传递 16 种不同类型的方法
* Action 没有泛型的话可以调用没有参数的方法
*
*
* Func 允许调用有返回类型的方法，和 Action 类似 也可以传递 16 种不同类型的方法和一个返回类型
* Func委托类型可以调用带返回类型且无参数的方法
* Func<in T1,out TResult> 调用带有一个参数的方法
*
*
* 区别：
* Func有返回类型；
* Action只有参数类型，不能传返回类型。所以Action的委托函数都是没有返回值的。
*
*
*/

  //class T
    //{
    //    //public static void DH()
    //    //{
    //    //    for (;;)Console.WriteLine("DH今天，你敲代码了吗？");
    //    //}

    //}
//***********************************
/*
 * Func<T>
 * 
 * 代码思路：
 * 首先要有一个Main入口啥的，然后就是在 main 里面声明要排序的数组
 * 然后后就是要有排序的类（BubbleSorter）了
 * 将声明的数组通过 构造的委托类（Employee） 传递到这个方法（Sort）
 * 
 * public static void DH()
 * {
 *    for (;;)Console.WriteLine("DH,今天你思考了吗？");
 * }
 */
//class Program
//{
//    static void Main()
//    {
//        Employee[] employees =
//        {   new Employee("热爱生命                      ", 1),
//            new Employee("既然选择了远方                ", 2),
//            new Employee("我不去想是否能够成功          ", 1),
//            new Employee("便只顾风雨兼程                ", 3),
//            new Employee("就勇敢地吐露真诚              ", 6),
//            new Employee("我不去想能否赢得爱情          ", 4),
//            new Employee("我不去想身后会不会袭来寒风冷雨", 7),
//            new Employee("一切，都在意料之中            ", 12),
//            new Employee("我不去想未来是平坦还是泥泞    ", 10),
//            new Employee("既然钟情于玫瑰                ", 5),
//            new Employee("留给世界的只能是背影          ", 9),
//            new Employee("只要热爱生命                  ", 11),
//            new Employee("既然目标是地平线              ", 8)
//        };

//        foreach (var employee in employees)
//        {
//           Console.WriteLine(employee);
//        }
//    }
//}
构造类，用来放置 Main 传递过来的值
//class Employee 
//{
//    public Employee(string name, decimal salary)
//    {
//        this.Name = name;
//        this.Salary = salary;
//    }
//    public string Name { get; }
//    public decimal Salary { get; private set; }
//    public override string ToString() => $"{Name}, {Salary:C}";
//    public static bool CompareSalary(Employee e1, Employee e2) =>
//      e1.Salary < e2.Salary;
//}
//class BubbleSorter
//{                                     
//    static public void Sort<T> (IList<T> sortArray, Func<T, T, bool> comparison)//sortArray 转递的是值  comparison 就是传递的方法的返回值
//    {
//        bool swapped = true;
//        do
//        {
//            swapped = false;
//            for (int i = 0; i < sortArray.Count - 1; i++)
//            {
//                if (comparison(sortArray[i + 1], sortArray[i]))
//                   //将 i+1 和 i 委托到 Employee 里面进行比较 注意，这个 i 代表的是 这个值在数组中的位置
//                {
//                    T temp = sortArray[i]; //将 这个 数 提取出来
//                    sortArray[i] = sortArray[i + 1];//赋值给 第 i+1 个
//                    sortArray[i + 1] = temp; //将 第 i 个数的值赋值给第i+1个
//                    swapped = true;
//                }
//            }
//        } while (swapped);
//    }
//}
//*************************************

/*
* 多播委托
*
* Action 这个委托可以被多次显式调用 ，委托里面包含多个方法的委托 就叫多播委托，类似于 Udp 那个多播协议
* 多播委托，可以按顺序调用多个方法。因此 委托的签名就必须返回void 否则 就只能得到最后一个方法的结果
*
*
* https://www.cnblogs.com/bianlan/archive/2013/01/18/2867065.html
*
*
*
* 和其他委托不一样，它可以调用多个方法，而其他委托只能调用一个（类似于 单线程，多线程 的区别，一顿吃一吨，一顿吃多吨）
*
* 支持运算符，就像这个
*
* 用于从委托中删除或添加方法的调用
*
*
* Action operation = K.M;
* operation += K.N;
* Action action3 = action1 + action2;
*
*/

  //class T
    //{
    //    static void Main()
    //    {             // Action 封装具有单个参数且不返回值的方法。
    //        Action<double> a = K.M;//将 a 的值 委托到这个方法
    //        a += K.N;
    //        a += K.V;
    //        // 感觉像一个数组，不断调用数组里面的值
    //        //这里是和 Fun 地区别 对方法 可以像运算符一样， 
    //        G(a,2);
    //        G(a,3);
    //        G(a,5);
    //        G(a,8);
    //        //Console.WriteLine(Math.PI);
    //    }
    //    public static void G(Action<double> action, double value)
    //    {
    //        Console.WriteLine();
    //        Console.WriteLine($"传递的值 {value}");
    //        action(value);//通过这个多播委托将值传递
    //    }
    //}
    //class K
    //{
    //    public static void M(double value)
    //    {
    //        double result = value * 2;
    //          Console.WriteLine($"乘2, 2 X {value} ={result}");
    //        //throw new Exception("哎呀，出错了。");//如果某一个环节报了异常，委托会停止 但有时候我并不希望这样 和他的执行顺序有关
    //    }                                                                                 
    //    public static void N(double value)
    //    {
    //        double result = value * value;
    //        Console.WriteLine($"{value} 的平方值为{result}");
    //    }
    //    public static void V(double value)
    //    {
    //        double result = Math.PI;
    //        Console.WriteLine($"乘圆周率 {value} X π = {result}");       
    //    }
    //}
    //*********************  利用 delegate 里面的 getinvoactionlist 这个方法  获取委托的链表
    //class T
    //{
    //    public static void V()
    //    {
    //        Console.WriteLine($"量子叠加态");
    //    }
    //    public static void W()
    //    {
    //        Console.WriteLine($"量子纠缠");
    //        throw new Exception();
    //    }
    //    public static void M()
    //    {
    //        Console.WriteLine("量子自旋");
    //    }
    //    static void Main()
    //    {
    //        Action  a = V;
    //        a += W;
    //        a += M;
    //        //如果某一个环节报了异常，委托会停止 但有时候我并不希望这样 
    //        // delegate 类 定义了一个 GetInvocationlist() 方法 返回一个 delegate 地对象数组， 
    //        //可以使用委托调用委托直接相关的方法 异常不影响
    //        Delegate[] delegates = a.GetInvocationList();//一个委托数组，其调用列表与此实例的调用列表相匹配。
    //        foreach (Action d in delegates)
    //        {
    //            try
    //            {
    //                d();    
    //            }
    //            catch (Exception)
    //            {
    //                Console.WriteLine("波函数坍塌");
    //            }
    //        }
    //    }
    //}
    //class K
    //{
    //}
    //************************************************************

/*

  • 匿名方法
  • 委托是用于引用与其具有相同标签的方法。换句话说，
  • 可以使用委托对象调用可由委托引用的方法。
  • 匿名方法（Anonymous methods） 提供了一种传递代码块作为委托参数的技术。
  • 匿名方法是没有名称只有主体的方法。
  • 在匿名方法中不需要指定返回类型，它是从方法主体内的 return 语句推断的。
  • 值得一提的是，在匿名方法中不能使用跳转语句 (break,goto,continue )跳转到匿名方法的外部，反之亦然

*/

  //class T
    //{
    //    static void Main()
    //    {
    //        string mid = ", middle part,";
    //        //Func<string, string> anonDel = delegate (string param)//一个委托
    //        //{   
    //        //    param += mid;
    //        //    param += " and this was added to the string.";
    //        //    return param;
    //        //};
    //        //lambad 写法
    //        Func<string, string> lambad = param =>
    //         {
    //             param += mid;
    //             param += "and this was added to the string.";
    //             return param;
    //         };
    //        Console.WriteLine(lambad("Start of string"));
    //    }
    /*
     * 在匿名方法的外面定义一个 字符串变量 mid ,并将变量添加到要传递的参数中，
     * 代码返回字符串的值，在调用委托时，把一个字符串作为参数传递，将返回的字符串输出到控制台上
     * 
     * 
     * 可以用 lambda 表示
     */**

// }
//*****************************************

//delegate void NumberChanger(int n);
//    namespace DelegateAppl
//    {
//        class TestDelegate
//        {
//            static int num = 10;
//            public static void AddNum(int p)
//            {
//                num += p;
//                Console.WriteLine("Named Method: {0}", num);
//            }
//            public static void MultNum(int q)
//            {
//                num *= q;
//                Console.WriteLine("Named Method: {0}", num);
//            }
//            static void Main(string[] args)
//            {
//                // 使用匿名方法创建委托实例
//                NumberChanger nc = delegate (int x)
//                {
//                    Console.WriteLine("Anonymous Method: {0}", x);
//                };
//                // 使用匿名方法调用委托
//                nc(10);
//                // 使用命名方法实例化委托
//                nc = new NumberChanger(AddNum);
//                // 使用命名方法调用委托
//                nc(5);
//                // 使用另一个命名方法实例化委托
//                nc = new NumberChanger(MultNum);
//                // 使用命名方法调用委托
//                nc(2);
//                Console.ReadKey();
//            }
//        }
//    }
#endregion
沉淀粉条形变量
关注
专栏目录
c# Action＜T＞ 委托详解、事件、线程使用
jiyanghao19的博客
01-12 928
C# 委托 和在事件、线程中使用
【C# & 委托】C#中的内置泛型委托Action、Func＜TResult＞
简介
03-01 1100
内置泛型委托是编程语言提供的预定义委托类型。内置的泛型委托有 Func < TResult >、Action、Predicate< T >、Comparison< T > 和 Converter<TInput, TOutput>。无需显式声明自定义的委托。灵活性且简洁。委托实例本身是有成本的，并且委托调用通常比直接方法调用慢。因此，在高性能场景中，需要谨慎使用委托。一般的委托定义方式：需要先定义一个委托，再声明创建一个委托实例。// 定义一个委托// 创建委托实例并绑定到方法。
C#学习日记25---匿名方法 与 Func委托 与 lambda表达式
HC666的博客
10-18 4783
在 2.0 之前的 C# 版本中，声明委托的唯一方法是使用命名方法。C# 2.0 引入了匿名方法（委托），而在 C# 3.0 及更高版本中，Lambda 表达式取代了匿名方法，作为编写内联代码的首选方式。 匿名委托（方法）：        匿名委托的叫法并不准确，准确的应该叫做匿名方法，（总之两者是一个意思啦）。前面  委托类型  中我已经提到过，委托是用于引用与其具有相同标签的方
温故而知新：Delegate,Action,Func,匿名方法,匿名委托,事件
weixin_34198453的博客
11-23 154
一、委托Delegate 一般的方法(Method)中，我们的参数总是string,int,DateTime...这些基本的数据类型（或者没有参数），比如 public void HelloWorld() {    Console.WriteLine("Hello World!");}public void HelloWorld(string name) {    Console.WriteL...
深入理解 c# 第五章 匿名方法用于Action<T>委托类型 反转字符 求平方根 求平均数
eyetired的博客
04-09 175
class SimpleAnonymousMethods { static void Main() { Action&lt;string&gt; printReverse = delegate(string text) //匿名方法创建 Action&lt;string&gt; { ...
匿名方法
Hello_leiyuanyi的博客
07-29 543
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace 匿名方法 { //自定义委托类型 delegate void DelOutput(string s); class Pr...
Action匿名委托示例
weixin_34293902的博客
09-04 161
class Program { static void Main(string[] args) { string mid = ",mid"; Action<string> anonDel = delegate (string param) { ...
Action<T>和Func<T>泛型委托，委托，泛型，匿名函数，Lambda表达式的综合使用
define_LIN的博客
10-22 1125
前言 在上篇文章C#中委托(delegate)和多播委托的理解中已经基本了解了委托的用法。 由于委托封装的方法我们不一定知道其传入的参数和返回值，例如之前说的的排序方法—————在对象的排序算法中,需要对对象进行比较,而不同对象比较的方法不同,所以比较两个对象的方法的引用可以作为参数传递到排序算法中,这个时候就需要传递方法。 当我们要生成一个封装比较对象的方法的委托时，我们并不知道该方法传入对象是...
详解Func<T>与Action<T>区别
10-21
Func<T>和Action<T>是.NET框架中非常重要的泛型委托，它们在方法参数传递、回调函数的实现中发挥着核心作用。Func<T>和Action<T>委托都是在.NET 3.5引入的，并且是支持Lambda表达式的关键元素。Func委托通常用于那些...
Spark常用API<Java>
sinat_32176267的博客
04-18 558
1.Transformation操作<Java> 主要做的是就是将一个已有的RDD生成另外一个RDD。Transformation具有lazy特性(延迟加载)。Transformation算子的代码不会真正被执行。只有当我们的程序里面遇到一个action算子的时候，代码才会真正的被执行对 1.1一个RDD进行转换操作 举例：对一个数组为{1, 2, 3, 3}的RDD进行基本的R...
详解FuncT与ActionT区别
01-02
Func<T>、Action<T> 的区别于说明 一、Func Func是一个.Net内置的委托。 Func<Result>，Func<T1>是一个.Net内置的泛型委托。 Func<TResult> Func<T> Func<T1> Func<T1> Func<T1> 它有5种形式，只是参数个数不同；第一个是无参数，但是有返回值； 下面是一个简单的普通委托来传方法的示例。 private delegate string Say(); public static string
JavaScript之基础-13 JavaScript Functions (Function对象、创建函数、匿名函数、闭包)
weixin_34413802的博客
03-28 92
一、JavaScript Function 对象函数与 Function 对象 - 在JavaScript中，函数也是以对象的形式存在的，每个函数都是一个Function对象实例arguments 对象 - 每个函数对象都有一个arguments属性;此属性只能在函数执行体内使用 - arguments属性中保存着当前函数接收到的所有实际参数，故可以使用argument...
C#笔记 委托 事件 匿各方法 Action
fjl2007的博客
07-10 5231
事件event 委托delegate 的基本用法。事件和委托的区别。匿名函数是什么。
C# delegate、 Action(Fun)和匿名方法、 Lambda 简单用法
dongxxxx的博客
07-03 541
每次用到委拖（代理）都有点晕，今天把汇总一下，方便后面回顾。 一 、delegate、 Action(Fun) //委托是一个类型，继承自System.MulticastDelegate 声明委托 public delegate void NoReturnNoPara(); //无参无返回值 public delegate void NoReturnWithPara(string name);//有参无返回...
Func 参数或返回 匿名类 anonymous
weixin_30888707的博客
03-08 95
How do you declare a Func with an anonymous return type? Question I need to be able to do this: var getHed = () => { // do stuff return new { Property1 = value, Property2 = value2,...
C#匿名方法介绍Action、Func、柯里化Currying
琅嬛福地
11-16 1367
在这个示例中，我们使用Lambda表达式创建了两个匿名方法，它们都接受一个整数，计算它的平方，并将结果打印到控制台。在C#中，匿名方法是一种没有名称的方法，可以被用作委托的参数或者赋值给委托类型的变量。匿名方法主要有两种形式：匿名方法和lambda表达式。在这个示例中，我们创建了一个匿名方法，该方法接受一个整数，计算它的平方，并将结果打印到控制台。然后我们将这个匿名方法赋值给。总的来说，匿名方法提供了一种方便的方式来创建和使用小的、简单的方法，而不需要定义一个完整的方法。类型的变量，并调用这些方法。
【C#】Func委托类型和匿名方法
热门推荐
Zok93
11-23 1万+
using System; /// /// Func 必须有一个返回值类型，当前为无参数，返回值类型是int的方法 /// Func 这种情况，string是方法的参数，int是方法的返回值 /// 方法的返回值在<>的最后一个，除了最后一个类型，都是方法的参数 /// 返回值类型在0-16个之间，返回值类型必须是1个 /// namespace Func委托类型 { class Main
C# 通过Delegate，action,func关键字创建委托匿名方法
最新发布
qq_35320456的博客
04-21 1296
在C#中，委托（Delegate）是一种用于封装方法的类型，它可以将方法当作参数传递，也可以将方法作为返回值。Action和Func是两种特殊的委托类型，它们分别用于表示没有返回值的函数（Action）和有返回值的函数（Func）。Delegate、Action和Func关键字提供了一种灵活的方式来创建和使用匿名方法。通过lambda表达式和delegate关键字，你可以定义简单的或复杂的匿名方法，并根据需要使用它们。
关于Action 委托和匿名方法以及lambda 表达式的一些理解
weixin_30408165的博客
07-07 167
最近要因为要使用到多线程，经常要把一些方法封起来，给线程去执行，刚开始的时候，根据自己之前学的C#知识，去创建一些委托，然后把方法作为参数传递给其中一个方法的线程去执行，每次都要new一些委托，实在是烦，其实知道有一些简便的方法去做的(比如使用Action和匿名方法以及lambda 表达式)，但本人有点懒，本想能自己自定义 委托就自定义委托去实现呗，最后由于越来越多这样情况出现，就干...
C#中详解Func, Action与Predicate委托及其应用场景
2. Action<T>()：接受一个参数 T。 3. Action<T1, T2>()：接受两个参数。 例如，创建一个简单的方法打印消息并使用Action委托。 Predicate委托用于执行一个条件测试并返回布尔值，它有两个泛型版本： 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值