Func<TResult>委托和Action委托

1.Func<TResult>委托

此委托为封装一个不带有参数但却返回TResult参数指定的类型值得方法。

定义方法为：

public delegate TResult Func<out TResult>();

可以使用此委托表示一种能以参数形式传递的方法，而不用显示声明自定义委托。封装的方法必须与此委托定义的方法签名相对应。这个委托封装一个不带有参数，但却返回TResult类型，也就是说我们可以这样显示定义

delegate string getdata();

实例代码：

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


namespace WorkflowConsoleApplication1
{
    delegate string getData();
    class Class1
    {
        public static void Main()
        {
            myclass abin = new myclass();
            getData instance = abin.getString;
            Console.WriteLine(instance);
        }
    }
    public class myclass
    {
        public  string getString()
        {
            return "你好";
        }
    }
}

或者是不用定义显示委托：

Func<string> instance=abin.getString;

也可以将Func<TResult>委托与匿名方法一起使用

Func<string> instance=delegate(){ return abin.getString();}

下面的示例演示如何使用不带参数的委托。此代码创建了一个具有Func<TResult>类型字段的名为LazyValue的泛型类。此委托字段可以存储所返回的类型值与LazyValue对象的类型参数相对应的任何函数引用。LazyValue类型也具有执行函数（如果尚未执行函数）并返回结果值得Value属性。

此实例创建了两个方法并用调用这些方法的lambda表达式实例化两个LazyValue对象。Lambda表达式并不采用参数，因为它们只需要调用方法。正如输出所显示的那样，只有当检索到每个LazyValue对象的值时才会执行这两个方法。

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


namespace WorkflowConsoleApplication1
{
    delegate string getData();
    class Class1
    {
        public static void Main()
        {
            LazyValue<int> instance_1 = new LazyValue<int>(() => ExpensiveOne());
            LazyValue<long> instance_2 = new LazyValue<long>(()=>ExpensiveTwo("adwwad"));
            Console.WriteLine(instance_1.Value);
            Console.WriteLine(instance_2.Value);
        }


        static int ExpensiveOne()
        {
            Console.WriteLine("");
            return 1;
        }
        static long ExpensiveTwo(string input)
        {
            Console.WriteLine("");
            return (long)input.Length;
        }
    }
    class LazyValue<T> where T : struct
    {
        private Nullable<T> val;
        private Func<T> getValue;
        public LazyValue(Func<T> func)
        {
            val = null;
            getValue = func;
        }
        public T Value
        {
            get
            {
                if (val == null)
                {
                    val = getValue();
                    return (T)val;
                }
                else
                {
                    return (T)val;
                }
            }
            set
            {
                val = value;
            }
        }
    }

2.Action<T>委托

封装一个方法，该方法只有一个参数并且不返回值。

语法为：

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

可以使用此委托表示一种能以参数形式传递的方法，而不用显示声明自定义委托。封装的方法必须与此委托定义的方法签名相对应。这个委托封装带有一个参数，没有返回值的函数，也就是说我们可以这样显示定义：

delegate void DisplayMessage(string message);

实例如下：

    using System;
using System.Windows.Forms;


public class TestAction1
{
   public static void Main()
   {
      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);      
   }
}