함수를 매개 변수로 사용하는 함수도 해당 함수에 매개 변수를 매개 변수로 사용해야합니까?

데이터 액세스를 쉽게 조롱하고 액세스 할 데이터를 결정하기 위해 매개 변수를 허용하는 서명을 제공하기 때문에 이와 같은 함수를 작성하는 경우가 많습니다.

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

축하합니다 . 함수 구성을 발명했습니다 .

이와 같은 래퍼 함수는 한 유형에 특화된 경우 많이 사용되지 않습니다. 그러나 일부 유형 변수를 도입하고 입력 매개 변수를 생략하면 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)writing 대신 쓸 이유가 없습니다 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 #과 같은 객체 지향 언어에서 여러 가지 다른 방식으로 동작 할 수있는 메소드를 원할 경우 일반적인 방법은 메소드를 추상 메소드로 호출하는 것입니다. 다른 방법으로해야 할 특별한 이유가 없다면 그렇게해야합니다.

이것이 좋은 해결책처럼 보입니까, 아니면 당신이 생각하는 단점이 있습니까?