関数をパラメーターとして取る関数は、それらの関数へのパラメーターもパラメーターとして取る必要がありますか？

多くの場合、データアクセスを簡単にモックでき、アクセスするデータを決定するパラメーターを受け入れる署名を提供するため、このような関数を作成していることに気付きます。

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");
}

しかし、それはフェッチとフォーマットの再利用性を奪うようです。フェッチしてフォーマットしたいときはいつでも、フェッチ用とフォーマット用の2行を書く必要があります。

関数型プログラミングについて何が欠けていますか？これはそれを行う正しい方法ですか、それとも保守と使用が簡単なより良いパターンがありますか？

これを十分に長く行うと、最終的にこの関数を何度も何度も書くことになります。

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

おめでとうございます、あなたは関数合成を発明しました。

このようなラッパー関数は、1つのタイプに特化されている場合はあまり使用されません。ただし、いくつかの型変数を導入し、入力パラメーターを省略すると、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);

現状では、あなたがしていることにはほとんど目的がありません。それは一般的ではないので、あちこちでそのコードを複製する必要があります。コードはそれ自体で1000の小さな関数から必要なものすべてをアセンブルする必要があるため、コードが複雑になります。しかし、あなたの心は正しい場所にあります。これらの種類の汎用高階関数を使用して物事をまとめることに慣れる必要があります。または、有効にする古き良きファッションのラムダを使用Func<A, B>してAにをFunc<B>。

繰り返してはいけません。

関数とそのパラメーターを渡す理由はまったくなく、それらのパラメーターを使用して呼び出すだけです。実際には、あなたのケースでは、あなたは関数を渡すべき理由がないすべてでは。呼び出し元は、関数自体を呼び出して結果を渡すこともできます。

それについて考えてください-使用する代わりに：

var formattedRate = GetFormattedRate(getRate, rateType);

なぜ単に使用しないのですか：

var formattedRate = GetFormattedRate(getRate(rateType));

？

不要なコードを削減するだけでなく、結合も削減します。レートのフェッチ方法を変更する場合（たとえば、getRate2つの引数が必要な場合）、変更する必要はありません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＃などのオブジェクト指向言語で複数の異なる方法で動作できるメソッドが必要な場合、それを行う通常の方法は、メソッドに抽象メソッドを呼び出させることです。別の方法で行う特定の理由がない場合は、そのようにする必要があります。

これは良い解決策のように見えますか、それともあなたが考えている欠点がありますか？