Должны ли функции, которые принимают функции в качестве параметров, также принимать параметры этих функций в качестве параметров?

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

public static string GetFormattedRate(
        Func<string, RateType>> getRate,
        string rateKey)
{
    var rate = getRate(rateKey);
    var formattedRate = rate.DollarsPerMonth.ToString("C0");
    return formattedRate;
}

Или

public static string GetFormattedRate(
        Func<RateType, string> formatRate,
        Func<string, RateType>> getRate,
        string rateKey)
{
    var rate = getRate(rateKey);
    var formattedRate = formatRate(rate);
    return formattedRate;
}

Тогда я использую что-то вроде этого:

using FormatterModule;

public static Main()
{
    var getRate = GetRateFunc(connectionStr);
    var formattedRate = GetFormattedRate(getRate, rateType);
    // or alternatively
    var formattedRate = GetFormattedRate(getRate, FormatterModule.FormatRate, rateKey);

    System.PrintLn(formattedRate);
}

Это обычная практика? Я чувствую, что должен делать что-то более похожее

public static string GetFormattedRate(
        Func<RateType> getRate())
{
    var rate = getRate();
    return rate.DollarsPerMonth.ToString("C0");
}

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

Иногда я чувствую, что должен делать

public static string GetFormattedRate(RateType rate)
{
   return rate.DollarsPerMonth.ToString("C0");
}

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

Что мне не хватает в функциональном программировании? Это правильный способ сделать это, или есть лучший шаблон, который легко поддерживать и использовать?

Если вы будете делать это достаточно долго, вы в конечном итоге будете писать эту функцию снова и снова:

public static Type3 CombineFunc1AndFunc2(
    Func<Type1, Type2> func1,
    Func<Type2, Type3>> func2,
    Type1 input)
{
    return func2(func1(input))
}

Поздравляем, вы придумали композицию функций .

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

public static Func<A, C> Compose(
    Func<B, C> outer, Func<A, B>> inner)
{
    return (input) => outer(inner(input))
}

var GetFormattedRate = Compose(FormatRate, GetRate);
var formattedRate = GetFormattedRate(rateKey);

Как бы то ни было, то, что вы делаете, имеет мало смысла. Это не универсальный, поэтому вы должны дублировать этот код повсюду. Это усложняет ваш код, потому что теперь ваш код должен собрать все, что ему нужно, из тысячи крошечных функций самостоятельно. Однако ваше сердце находится в нужном месте: вам просто нужно привыкнуть к использованию этих видов универсальных функций высшего порядка для объединения вещей. Или использовать хорошую старую моды лямбду превратить Func<A, B>и Aв Func<B>.

Не повторяйся.

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

Подумайте об этом - вместо использования:

var formattedRate = GetFormattedRate(getRate, rateType);

почему бы просто не использовать:

var formattedRate = GetFormattedRate(getRate(rateType));

?

Наряду с уменьшением ненужного кода это также уменьшает сцепление - если вы хотите изменить способ получения скорости (скажем, если getRateтеперь нужно два аргумента), вам не нужно менять GetFormattedRate.

Точно так же нет причин писать GetFormattedRate(formatRate, getRate, rateKey)вместо того, чтобы писать formatRate(getRate(rateKey)).

Не переусердствуйте.

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

public static string GetFormattedRate(
        Func<string> getRate)
{
    var rate = getRate();
    var formattedRate = rate.DollarsPerMonth.ToString("C0");
    return formattedRate;
}

var formattedRate = GetFormattedRate(()=>getRate(rateKey));

Лямбда свяжет аргументы, о которых функция не знает, и скроет, что они даже существуют.

Разве это не то, что вы хотите?

class RateFormatter
{
    public abstract RateType GetRate(string rateKey);

    public abstract string FormatRate(RateType rate);

    public string GetFormattedRate(string rateKey)
    {
        var rate = GetRate(rateKey);
        var formattedRate = FormatRate(rate);
        return formattedRate;
    }
}

И затем назовите это так:

static class Program
{
    public static void Main()
    {
        var rateFormatter = new StandardRateFormatter(connectionStr);
        var formattedRate = rateFormatter.GetFormattedRate(rateKey);

        System.PrintLn(formattedRate);
    }
}

Если вам нужен метод, который может вести себя по-разному в объектно-ориентированном языке, таком как C #, обычный способ сделать это - вызвать метод абстрактным методом. Если у вас нет конкретной причины сделать это по-другому, вы должны сделать это таким образом.

Похоже ли это на хорошее решение или есть недостатки?