Question

我可以找到关于Func＆lt;＆gt;的所有示例和行动＆lt;＆gt;是简单，如下所示，您可以看到他们在技术上如何工作<但是我希望看到它们用于解决以前无法解决的问题的示例中只能以更复杂的方式解决，即我知道它们是如何工作的，我可以看到它们简洁而强大，所以我想以更大的意义来理解它们他们解决了哪些问题以及如何在应用程序设计中使用它们。

你在哪些方面（模式）使用Func＆lt;＆gt;和行动＆lt;＆gt;解决实际问题？

using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace TestFunc8282 { class Program { static void Main(string[] args) { //func with delegate Func<string, string> convert = delegate(string s) { return s.ToUpper(); }; //func with lambda Func<string, string> convert2 = s => s.Substring(3, 10); //action Action<int,string> recordIt = (i,title) => { Console.WriteLine("--- {0}:",title); Console.WriteLine("Adding five to {0}:", i); Console.WriteLine(i + 5); }; Console.WriteLine(convert("This is the first test.")); Console.WriteLine(convert2("This is the second test.")); recordIt(5, "First one"); recordIt(3, "Second one"); Console.ReadLine(); } } }

Answer 1

它们对于重构switch语句也很方便。

采取以下（虽然简单）示例：

public void Move(int distance, Direction direction)
{
    switch (direction)
    {
        case Direction.Up :
            Position.Y += distance;
            break;
        case Direction.Down:
            Position.Y -= distance;
            break;
        case Direction.Left:
            Position.X -= distance;
            break;
        case Direction.Right:
            Position.X += distance;
            break;
    }
}

使用Action委托，您可以按如下方式重构它：

static Something()
{
    _directionMap = new Dictionary<Direction, Action<Position, int>>
    {
        { Direction.Up,    (position, distance) => position.Y +=  distance },
        { Direction.Down,  (position, distance) => position.Y -=  distance },
        { Direction.Left,  (position, distance) => position.X -=  distance },
        { Direction.Right, (position, distance) => position.X +=  distance },
    };
}

public void Move(int distance, Direction direction)
{
    _directionMap[direction](this.Position, distance);
}

Answer 2

使用linq。

List<int> list = { 1, 2, 3, 4 };

var even = list.Where(i => i % 2);

Where的参数是Func<int, bool>。

Lambda表达式是我最喜欢的C＃部分之一。：）

Answer 3

我一直使用Action和Func代表。我通常使用lambda语法声明它们以节省空间，并主要使用它们来减小大型方法的大小。当我查看我的方法时，有时相似的代码段会很突出。在这些情况下，我将类似的代码段包装到Action或Func中。使用委托减少了冗余代码，为代码段提供了一个很好的签名，如果需要，可以很容易地将其提升为方法。

我曾经写过Delphi代码，你可以在函数中声明一个函数。 Action和Func在c＃中为我完成了同样的行为。

以下是使用委托重新定位控件的示例：

private void Form1_Load(object sender, EventArgs e)
{
    //adjust control positions without delegate
    int left = 24;

    label1.Left = left;
    left += label1.Width + 24;

    button1.Left = left;
    left += button1.Width + 24;

    checkBox1.Left = left;
    left += checkBox1.Width + 24;

    //adjust control positions with delegate. better
    left = 24;
    Action<Control> moveLeft = c => 
    {
        c.Left = left;
        left += c.Width + 24; 
    };
    moveLeft(label1);
    moveLeft(button1);
    moveLeft(checkBox1);
}

Answer 4

我使用它的一个方法是缓存昂贵的方法调用，这些调用在给定相同输入的情况下永远不会改变：

public static Func<TArgument, TResult> Memoize<TArgument, TResult>(this Func<TArgument, TResult> f)
{
    Dictionary<TArgument, TResult> values;

    var methodDictionaries = new Dictionary<string, Dictionary<TArgument, TResult>>();

    var name = f.Method.Name;
    if (!methodDictionaries.TryGetValue(name, out values))
    {
        values = new Dictionary<TArgument, TResult>();

        methodDictionaries.Add(name, values);
    }

    return a =>
    {
        TResult value;

        if (!values.TryGetValue(a, out value))
        {
            value = f(a);
            values.Add(a, value);
        }

        return value;
    };
}

默认的递归斐波纳契示例：

class Foo
{
  public Func<int,int> Fibonacci = (n) =>
  {
    return n > 1 ? Fibonacci(n-1) + Fibonacci(n-2) : n;
  };

  public Foo()
  {
    Fibonacci = Fibonacci.Memoize();

    for (int i=0; i<50; i++)
      Console.WriteLine(Fibonacci(i));
  }
}

Answer 5

我使用Action来很好地封装在事务中执行数据库操作：

public class InTran
{
    protected virtual string ConnString
    {
        get { return ConfigurationManager.AppSettings["YourDBConnString"]; }
    }

    public void Exec(Action<DBTransaction> a)
    {
        using (var dbTran = new DBTransaction(ConnString))
        {
            try
            {
                a(dbTran);
                dbTran.Commit();
            }
            catch
            {
                dbTran.Rollback();
                throw;
            }
        }
    }
}

现在要在事务中执行，我只需执行

new InTran().Exec(tran => ...some SQL operation...);

InTran类可以驻留在一个公共库中，减少重复并为将来的功能调整提供一个单一的位置。

Answer 6

Dunno如果两次回答同一个问题是不好的形式，但为了更好地利用这些类型，我建议阅读Jeremy Miller关于功能编程的MSDN文章：

Functional Programming for Everyday .NET Development

Answer 7

实际上，我在stackoverflow（至少 - 这个想法）中找到了这个：

public static T Get<T>  
    (string cacheKey, HttpContextBase context, Func<T> getItemCallback)
            where T : class
{
    T item = Get<T>(cacheKey, context);
    if (item == null) {
        item = getItemCallback();
        context.Cache.Insert(cacheKey, item);
    }

    return item;
}

Answer 8

通过保持它们的通用性并支持多个参数，它允许我们避免创建强类型委托或执行相同操作的冗余委托。

Answer 9

我有一个单独的表单，它接受构造函数中的泛型Func或Action以及一些文本。它在单独的线程上执行Func / Action，同时在表单中显示一些文本并显示动画。

它位于我的个人Util库中，每当我想进行中等长度操作并以非侵入方式阻止UI时，我就会使用它。

我考虑在表单上放置一个进度条，这样它可以执行更长时间的运行操作，但我还没有真正需要它。

你如何使用Func＆lt;＆gt;和行动＆lt;＆gt;设计应用程序时？

9 个答案: