Как вы используете Func <> и Action <> при разработке приложений? - PullRequest
Новая
       35

Как вы используете Func <> и Action <> при разработке приложений?

69 голосов
/ 08 октября 2009

Все примеры, которые я могу найти о Func <> и Action <>: simple , как показано ниже, где вы видите как они технически работают, но я бы хотел их увидеть используется в примерах, где они решают проблемы, которые ранее не могли быть решены или могли быть решены только более сложным способом, то есть я знаю, как они работают, и я вижу, что они краткие и мощные , поэтому я хочу понимать их в большем смысле о том, какие проблемы они решают, и как я могу использовать их при разработке приложений.

Каким образом (шаблонами) вы используете Func <> и Action <> для решения реальных проблем? 

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();

        }
    }
}

Ответы [ 9 ]

56 голосов
/ 08 октября 2009

Они также удобны для рефакторинга операторов 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);
}
15 голосов
/ 08 октября 2009

Использование linq. 

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

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

Параметром для Where является Func<int, bool>.

Лямбда-выражения - одна из моих любимых частей C #. :)

14 голосов
/ 08 октября 2009

Я использую делегатов Action и Func все время. Я обычно объявляю их с помощью лямбда-синтаксиса для экономии места и использую их в первую очередь для уменьшения размера больших методов. Когда я рассматриваю свой метод, иногда сегменты кода, которые похожи, будут выделяться. В этих случаях я заключаю похожие сегменты кода в 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);
}
9 голосов
/ 08 октября 2009

Я использую это для кэширования вызовов дорогих методов, которые никогда не меняются при одинаковом вводе: 

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));
  }
}
6 голосов
/ 09 октября 2009

Не знаю, плохо ли отвечать на один и тот же вопрос дважды или нет, но чтобы получить некоторые идеи для лучшего использования этих типов в целом, я предлагаю прочитать статью Джереми Миллера по функциональному программированию:

Функциональное программирование для повседневной разработки .NET

6 голосов
/ 08 октября 2009

Я использую Действие, чтобы красиво инкапсулировать выполнение операций базы данных в транзакции: 

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 может находиться в общей библиотеке, уменьшая дублирование и предоставляя отдельное место для будущих настроек функциональности.

2 голосов
/ 08 октября 2009

Сохраняя их универсальными и поддерживая несколько аргументов, это позволяет нам избежать необходимости создавать строго типизированные делегаты или избыточные делегаты, которые делают то же самое.

2 голосов
/ 08 октября 2009

На самом деле, я нашел это в 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;
}
0 голосов
/ 08 октября 2009

У меня есть отдельная форма, которая принимает общий Func или Action в конструкторе, а также некоторый текст. Он выполняет Func / Action в отдельном потоке, отображая некоторый текст в форме и показывая анимацию.

Он находится в моей личной библиотеке Util, и я использую его всякий раз, когда хочу выполнить операцию средней длины и блокировать пользовательский интерфейс ненавязчивым образом.

Я также подумал о том, чтобы добавить в форму индикатор выполнения, чтобы он мог выполнять более длительные операции, но мне это пока не нужно.

...