精华内容
下载资源
问答
  • C# Action用法

    千次阅读 2021-05-07 04:10:26
    Action是无返回值的泛型委托可以使用 Action<T1, T2, T3, T4> 委托以参数形式传递方法,而不用显式声明自定义的委托。封装的方法必须与此委托定义的方法签名...

    Action是无返回值的泛型委托

    可以使用 Action<T1, T2, T3, T4> 委托以参数形式传递方法,而不用显式声明自定义的委托。封装的方法必须与此委托定义的方法签名相对应。也就是说,封装的方法必须具有四个均通过值传递给它的参数,并且不能返回值。(在 C# 中,该方法必须返回 void)通常,这种方法用于执行某个操作。

    1、Action 表示无参,无返回值的委托

    2、 Action<int,string> 表示有传入参数int,string无返回值的委托

    3、Action<int,string,bool> 表示有传入参数int,string,bool无返回值的委托

      4、 Action<int,int,int,int> 
      表示有传入4个int型参数,无返回值的委托
    

    5、 Action至少0个参数,至多16个参数,无返回值。

    class Program
        {
            static void Main(string[] args)
            {
                //循环调用,action不传参
                List<Action> actions = new List<Action>();
                for (int i = 0; i < 10; i++)
                {
                    //因为是按地址传递参数,所以要声明变量,不如结果都是10
                    int k = i;
                    actions.Add(() => Console.WriteLine(k));
                }
                foreach (Action a in actions)
                {
                    a();
                }
    
                //传递两个参数
                Action<string, int> action = new Action<string, int>(ShowAction);
                Show("张三",29,action);
    
                //传递一个参数
                Show("张三",o=>Console.WriteLine(o));
    
                //不传递参数调用
                Show(()=>Console.WriteLine("张三"));
            }
            public static void ShowAction(string name, int age)
            {
                Console.WriteLine(name + "的年龄:" + age);
            }
            public static void Show(string name, int age, Action<string, int> action)
            {
                action(name, age);
            }
            public static void Show(string name, Action<string> action)
            {
                action(name);
            }
            public static void Show(Action action)
            {
                action();
            }
        }
    

    输出结果:

    0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    张三的年龄:29
    张三
    张三
    
    展开全文
  • C# Action 委托

    2020-04-17 20:21:13
    1、什么是Action泛型委托 Action<T>是.NET Framework内置的泛型委托,可以使用Action<T>委托以参数形式传递方法,而不用显示声明自定义的委托。封装的方法必须与此委托定义的方法签名相对应。也就是说,...

    本文转自:https://www.cnblogs.com/dotnet261010/p/10108791.html

    1、什么是Action泛型委托

    Action<T>是.NET Framework内置的泛型委托,可以使用Action<T>委托以参数形式传递方法,而不用显示声明自定义的委托。封装的方法必须与此委托定义的方法签名相对应。也就是说,封装的方法必须具有一个通过值传递给它的参数,并且不能有返回值。

    2、Action委托定义

    查看Action的定义:

    复制代码
    using System.Runtime.CompilerServices;
    
    namespace System
    {
        //
        // 摘要:
        //     封装一个方法,该方法不具有参数且不返回值。
        [TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089")]
        public delegate void Action();
    }
    复制代码

     你会发现,Action其实就是没有返回值的delegate。

    3、示例

     Action委托至少0个参数,至多16个参数,无返回值。

    Action 表示无参,无返回值的委托。

    Action<int,string> 表示有传入参数int,string无返回值的委托。

    Action<int,string,bool> 表示有传入参数int,string,bool无返回值的委托。

    Action<int,int,int,int> 表示有传入4个int型参数,无返回值的委托。

    代码示例如下:

    复制代码
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace ActionDemo
    {
        class Program
        {
            static void Main(string[] args)
            {
                // 无参数无返回值的委托
                Action action1 = new Action(ActionWithNoParaNoReturn);
                action1();
                Console.WriteLine("----------------------------");
                // 使用delegate
                Action action2 = delegate { Console.WriteLine("这里是使用delegate"); };
                // 执行
                action2();
                Console.WriteLine("----------------------------");
                // 使用匿名委托
                Action action3 = () => { Console.WriteLine("这里是匿名委托"); };
                action3();
                Console.WriteLine("----------------------------");
                // 有参数无返回值的委托
                Action<int> action4 = new Action<int>(ActionWithPara);
                action4(23);
                Console.WriteLine("----------------------------");
                // 使用delegate
                Action<int> action5 = delegate (int i) { Console.WriteLine($"这里是使用delegate的委托,参数值是:{i}"); };
                action5(45);
                Console.WriteLine("----------------------------");
                // 使用匿名委托
                Action<string> action6 = (string s) => { Console.WriteLine($"这里是使用匿名委托,参数值是:{s}"); };
                action6("345");
                Console.WriteLine("----------------------------");
                // 多个参数无返回值的委托
                Action<int, string> action7 = new Action<int, string>(ActionWithMulitPara);
                action7(7, "abc");
                Console.WriteLine("----------------------------");
                // 使用delegate
                Action<int, int, string> action8 = delegate (int i1, int i2, string s) 
                {
                    Console.WriteLine($"这里是三个参数的Action委托,参数1的值是:{i1},参数2的值是:{i2},参数3的值是:{s}");
                };
                action8(12, 34, "abc");
                Console.WriteLine("----------------------------");
                Action<int,int,string, string> action9 = (int i1,int i2, string s1,string s2) => 
                {
                    Console.WriteLine($"这里是使用四个参数的委托,参数1的值是:{i1},参数2的值是:{i2},参数3的值是:{s1},参数4的值是:{s2}");
                };
                // 执行委托
                action9(34,56, "abc","def");
                Console.ReadKey();
            }
    
    
    
    
            static void ActionWithNoParaNoReturn()
            {
                Console.WriteLine("这是无参数无返回值的Action委托");
            }
    
            static void ActionWithPara(int i)
            {
                Console.WriteLine($"这里是有参数无返回值的委托,参数值是:{i}");
            }
    
            static void ActionWithMulitPara(int i,string s)
            {
                Console.WriteLine($"这里是有两个参数无返回值的委托,参数1的值是:{i},参数2的值是:{s}");
            }
        }
    }
    复制代码

     运行结果:

    4、真实示例

    先看下面一张截图:

     

     从截图中可以看出:ForEach()方法的参数是一个参数类型是T的无返回值的Action委托,下面的示例中利用Action委托作为参数传递给ForEach()方法。

    1、定义Student实体类

    复制代码
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace ActionDemo
    {
        public class Student
        {
            public int Id { get; set; }
    
            public string Name { get; set; }
    
            public int Age { get; set; }
    
            public int Sex { get; set; }
        }
    }
    复制代码

    2、利用ForEach()方法输出集合内容

    复制代码
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace ActionDemo
    {
        public class ActionTest
        {
            public static void Test()
            {
                List<Student> list = new List<Student>()
                {
                  new Student(){Id=1,Name="张三",Age=19,Sex=1},
                  new Student(){Id=2,Name="李四",Age=20,Sex=2},
                  new Student(){Id=3,Name="王五",Age=23,Sex=1},
                  new Student(){Id=4,Name="赵六",Age=18,Sex=1}
                };
    
                // Action<Student>委托作为参数传递给ForEach()方法
                list.ForEach(student =>
                {
                    Console.WriteLine($"姓名:{student.Name},年龄:{student.Age}");
                });
            }
        }
    }
    复制代码

    3、在Main()方法中调用

    ActionTest.Test();

    4、结果

     

    展开全文
  • C# Action委托、Func委托

    千次阅读 2018-07-13 13:42:14
    如果我们要把方法当作参数传递的话就要用到委托。... Action委托action委托指向的方法没有返回值c#代码如下:class ActionTest { void printStr() { Console.WriteLine("printStr()"); } ...

    如果我们要把方法当作参数传递的话就要用到委托。简单来说委托是一个类型,这个类型可以赋值一个方法的引用。

    一 . Action委托

    action委托指向的方法没有返回值

    c#代码如下:

    class ActionTest
        {
            void printStr()
            {
                Console.WriteLine("printStr()");
            }

            void printStr(int i)
            {
                Console.WriteLine(i);
            }

            public void mainAction()
            {
                // action后面可以通过泛型去指定action指向的方法的多个参数类型,参数的类型跟action后面声明的委托类型是对应这的
                // action委托可以指向一个无返回值、无参的方法
                Action ac = printStr; // action是系统内置(预定义)的一个委托类型
                ac(); // 调用

                Action<int> ac2 = printStr; // 定义了一个委托类型,这个类型可以指向一个没有返回值、有一个参数的方法.在这里方法中的参数最多可以16个
                ac2(100);
            }

        }


    二 . Func委托

    如果委托需要有获取返回值,那就要用到func委托

    func委托要求必须指向带返回值的方法

    class FuncTest
        {
            // 如果委托需要有获取返回值,那就要用到func委托
            // func委托要求必须指向带返回值的方法

            int printInt()
            {
                return 999;
            }

            int printInt(string str)
            {
                Console.WriteLine(str);
                return 1000;
            }

            public void mainFunc()
            {
                Func<int> fu = printInt; // func中的泛型类型指定的是方法的返回值类型
                Console.WriteLine(fu());

                Func<string, int> fu2 = printInt;// func后面可以跟很多类型,前面的参数是参数类型,后面的是返回值类型,参数类型必须跟指定方法的参数类型对应
                Console.WriteLine(fu2("zhili"));
                Console.ReadKey();
            }
        }

    展开全文
  • C# Action<T> 委托

    千次阅读 2019-10-29 09:21:18
    可以使用 Action< T> 委托以参数形式传递方法,而不用显式声明自定义的委托。封装的方法必须与此委托定义的方法相对应。 即封装的方法必须具有一个通过值传递给它的参数,并且不能返回值。Action<T1,T2 ......

    简介:

             封装一个方法,该方法只有一个参数并且不返回值。可以使用 Action< T> 委托以参数形式传递方法,而不用显式声明自定义的委托。封装的方法必须与此委托定义的方法相对应。 即封装的方法必须具有一个通过值传递给它的参数,并且不能返回值。 Action<T1,T2 ......> 委托还可以多个参数传入。如果有返回值,则使用Fun<T, TResult>。

     

    介绍:

     

    public delegate void Action<in T>( T obj )

    类型参数 in T

    此委托封装的方法的参数类型。

    参数 obj

    类型:T,此委托封装的方法的参数。

     

    使用:

    在使用 Action< T> 委托时,不必显式定义一个封装只有一个参数的方法的委托。

    1. 声明了一个名为 DisplayMessage 的委托,并将对 WriteLine 方法或 ShowWindowsMessage 方法的引用分配给其委托实例。

    using System;
    using System.Windows.Forms;
    
    //声明委托
    delegate void DisplayMessage(string message);
    
    public class TestCustomDelegate
    {
       public static void Main()
       {
          //实例化委托
          DisplayMessage messageTarget; 
    
          //分配委托
          if (Environment.GetCommandLineArgs().Length > 1)
             messageTarget = ShowWindowsMessage;
          else
             messageTarget = Console.WriteLine;
    
          messageTarget("Hello, World!");   
       }      
    
       private static void ShowWindowsMessage(string message)
       {
          MessageBox.Show(message);      
       }
    }

     

    2.实例化 Action< T> 委托,而不是显式定义一个新委托并将命名方法分配给该委托。

    using System;
    using System.Windows.Forms;
    
    public class TestAction1
    {
       public static void Main()
       { 
          //实例化Action委托
          Action<string> messageTarget; 
    
          //直接分配
          if (Environment.GetCommandLineArgs().Length > 1)
             messageTarget = ShowWindowsMessage;
          else
             messageTarget = Console.WriteLine;
    
          messageTarget("Hello, World!");   
       }      
    
       private static void ShowWindowsMessage(string message)
       {
          MessageBox.Show(message);      
       }
    }

     

    3.Action< T> 委托与匿名方法一起使用。

    using System;
    using System.Windows.Forms;
    
    public class TestAnonMethod
    {
       public static void Main()
       {
          //实例化Action委托
          Action<string> messageTarget; 
    
          //通过匿名方法分配给委托
          if (Environment.GetCommandLineArgs().Length > 1)
             messageTarget = delegate(string s) { ShowWindowsMessage(s); };
          else
             messageTarget = delegate(string s) { Console.WriteLine(s); };
    
          messageTarget("Hello, World!");
       }
    
       private static void ShowWindowsMessage(string message)
       {
          MessageBox.Show(message);      
       }
    }

     

    4.lambda 表达式分配给 Action< T> 委托实例。

    using System;
    using System.Windows.Forms;
    
    public class TestLambdaExpression
    {
       public static void Main()
       {
          //实例化委托
          Action<string> messageTarget; 
    
          //通过lambda表达式分配给委托
          if (Environment.GetCommandLineArgs().Length > 1)
             messageTarget = s => ShowWindowsMessage(s); 
          else
             messageTarget = s => Console.WriteLine(s);
    
          messageTarget("Hello, World!");
       }
    
       private static void ShowWindowsMessage(string message)
       {
          MessageBox.Show(message);      
       }
    }

     

    5.ForEach 和 ForEach< T> 方法都采用Action< T> 委托作为参数。通过使用由委托封装的方法,可以对数组或列表中的每个元素执行操作。

    using System;
    using System.Collections.Generic;
    
    class Program
    {
        static void Main()
        {
            List<String> names = new List<String>();
            names.Add("Bruce");
            names.Add("Alfred");
            names.Add("Tim");
            names.Add("Richard");
    
            // 使用Print方法显示列表的内容
            names.ForEach(Print);
    
            // 通过匿名方法显示列表的内容
            names.ForEach(delegate(String name)
            {
                Console.WriteLine(name);
            });
        }
    
        private static void Print(string s)
        {
            Console.WriteLine(s);
        }
    }

     

    展开全文
  • C# Action 的一般用法

    千次阅读 2020-12-02 15:44:54
    看过今天大叔发的一篇博文,在js的回调函数中想到了一点关于Action的用法。 发一段简单不能在简单的程序 1 class Program 2 { 3 static void Main(string[] args) 4 { 5 string myName = "CC"; 6 ...
  • C# Action和Func的用法详解

    千次阅读 多人点赞 2019-01-25 10:24:52
    以前我都是通过定义一个delegate来写委托的,但是最近看一些外国人写的源码都是用action和func方式来写,当时感觉对这很陌生所以看起源码也觉得陌生,所以我就花费时间来学习下这两种方式,然后发现确实代码简洁了...
  • C# Action委托方法

    万次阅读 2016-08-31 13:57:12
    第一次看到Action感觉很迷茫,它是干什么的,原来是个委托方法,这样就好理解了 看源码的声明 // // 摘要: // 封装一个方法,该方法只有一个参数并且不返回值。 // // 参数: // obj: // 此委托封装的方法的...
  • C# Action委托类型

    2017-03-16 21:18:06
    最后是通过 Action<> 委托类型 来实现!以下是Action的定义: #region 程序集 mscorlib.dll, v4.0.0.0 // C:\Program Files\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\mscorlib.dll #...
  • C# action,delegate,func的用法和区别

    千次阅读 2019-05-08 11:46:19
    以前我都是通过定义一个delegate来写委托的,但是最近看一些外国人写的源码都是用action和func方式来写,当时感觉对这很陌生所以看起源码也觉得陌生,所以我就花费时间来学习下这两种方式,然后发现确实代码简洁了...
  • //服务器 public class Server { ... public event Action<string> MyEvent; public void Send(string msg) { if (MyEvent != null) { Console.WriteLine("Server推送消息:" + msg);.
  • C# Action 委托 + lambda 表达式

    千次阅读 2012-01-17 09:10:06
    using System; using System.Collections; public class Test ... static public Action A; static public Action B; static public Action C; static public Action D; static public Action E;
  • C#action和func的使用

    千次阅读 2018-05-16 22:48:09
    以前我都是通过定义一个delegate来写委托的,但是最近看一些外国人写的源码都是用action和func方式来写,当时感觉对这很陌生所以看起源码也觉得陌生,所以我就花费时间来学习下这两种方式,然后发现确实代码简洁了...
  • java模拟C# Action作为方法参数传递

    千次阅读 2019-05-03 20:00:44
    1.定义Action的接口 public class pubInterface { public static interface action<T>{ void invoke(T o); } } 2.调用的地方使用方式 pubdialog.ShowAskMsg(this,"你是我的提示信息",new pub...
  • Action是一个泛型的委托,其内部即使用delegate去实现,当普通的delegate定义的参数与Action个数、类型一致时,两者实现的功能是一样的。只是Action的方式更加简洁、规范。  (1). delegate delegate我们常用到的...
  • C# Action和Func<T>

    2018-12-13 09:17:38
    Action和Func在实际开发中很常用,个人觉得很抽象,下面两个小例子用来入门 //Action无返回值 Action&lt;int, int&gt; act = null; act = (int a, int b) =&gt; { Console.WriteLine(a + b); }; ...
  • Java实现泛型委托类似C#Action<T>

    千次阅读 2014-08-26 13:03:41
    一、C# Action 泛型委托(帮助理解委托) 描述: 封装一个方法,该方法只采用一个参数并且不返回值. 语法: public delegate void Action(T arg); T: 参数类型:此委托封装的方法的参数类型 arg: 参数:此委托封装的...
  • 假设我在某个后台线程里面要使用 Action 定义一个委托更新一个pictureBox1 的图片应该怎么写?
  • C#定义好的委托还是很多的,这是典型的一个。这个委托是一系列无参无返回值的方法的封装。毕竟很多时候我们所定义的一系列方法都是无参数无返回值的所以这个委托还是具有相当大和普遍的用处。 MSDN的简单注义是:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 65,599
精华内容 26,239
关键字:

c#action

c# 订阅