İşlevleri parametre olarak alan işlevler de parametreleri bu işlevlere parametre olarak mı almalıdır?

Sıklıkla kendime böyle görünen işlevleri yazarken buluyorum çünkü veri erişimine kolayca takılmama izin veriyorlar ve yine de hangi verilere erişileceğini belirlemek için parametreleri kabul eden bir imza sağlıyorlar.

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

Veya

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

Sonra böyle bir şey kullanıyorum:

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

Bu yaygın bir uygulama mı? Daha fazla bir şey yapmam gerektiğini hissediyorum

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

Ama bu çok iyi görünmüyor çünkü her ücret türü için yönteme geçmek için yeni bir işlev yapmak zorunda kalıyordum.

Bazen yapmam gerektiğini hissediyorum

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

Ancak bu, getirme ve biçim yeniden kullanılabilirliğini ortadan kaldırıyor gibi görünüyor. Ne zaman almak ve biçimlendirmek istersem, biri getirmek için diğeri biçimlendirmek için iki satır yazmak zorundayım.

İşlevsel programlamada eksik olan ne? Bunu yapmanın doğru yolu mu, yoksa bakımı ve kullanımı kolay olan daha iyi bir kalıp var mı?

Bunu yeterince uzun yaparsanız, sonunda bu işlevi tekrar tekrar yazarken bulacaksınız:

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

Tebrikler, fonksiyon kompozisyonunu icat ettiniz .

Bunun gibi sarmalayıcı işlevlerinin, tek bir tipte uzmanlaştıklarında fazla bir kullanımı yoktur. Ancak, bazı tür değişkenleri tanıtırsanız ve input parametresini atlarsanız, GetFormattedRate tanımınız şöyle görünür:

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

Haliyle, yaptığınız şeyin çok az amacı vardır. Genel değildir, bu yüzden bu kodu her yerde çoğaltmanız gerekir. Kodunuzu çok karmaşık hale getiriyor, çünkü şimdi kodunuz bin küçük işlevden ihtiyaç duyduğu her şeyi kendi başına bir araya getirmek zorunda. Kalbiniz doğru yerde: sadece şeyleri bir araya getirmek için bu tür yüksek dereceli fonksiyonları kullanmaya alışmanız gerekir. Ya da, bırakmak için iyi bir eski moda lambda kullanmak Func<A, B>ve Aiçine Func<B>.

Kendinizi tekrarlamayın.

Bir işlevi ve parametrelerini iletmek için kesinlikle hiçbir neden yoktur, ancak o zaman bu parametrelerle çağırmak için. Aslında, durumda bir işlev geçmesine sebep yok hiç . Arayan kişi sadece işlevin kendisini çağırabilir ve sonucu iletebilir.

Bunu düşün - kullanmak yerine:

var formattedRate = GetFormattedRate(getRate, rateType);

neden sadece kullanmıyorsunuz:

var formattedRate = GetFormattedRate(getRate(rateType));

?

Gereksiz kodu azaltmanın yanı sıra bağlantıyı da azaltır - oranın getirilme şeklini değiştirmek istiyorsanız (örneğin, getRateşimdi iki bağımsız değişkene ihtiyaç duyuyorsanız) değiştirmeniz gerekmez GetFormattedRate.

Aynı şekilde, yazmak GetFormattedRate(formatRate, getRate, rateKey)yerine yazmak için hiçbir neden yoktur formatRate(getRate(rateKey)).

Aşırı karmaşık şeyler yapmayın.

Fonksiyona kesinlikle bir işlev iletmeniz gerekiyorsa, çünkü ekstra bir argüman geçirir veya bir döngüde çağırırsa, bunun yerine bir lambda iletebilirsiniz:

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

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

Lambda, işlevin bilmediği argümanları bağlayacak ve var olduklarını bile gizleyecektir.

İstediğin bu değil mi?

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

Ve sonra şöyle deyin:

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

        System.PrintLn(formattedRate);
    }
}

C # gibi nesne yönelimli bir dilde birden çok farklı şekilde davranabilen bir yöntem istiyorsanız, bunu yapmanın genel yolu, yöntemin soyut bir yöntem çağırmasıdır. Farklı bir şekilde yapmak için özel bir nedeniniz yoksa, bu şekilde yapmalısınız.

Bu iyi bir çözüm gibi mi görünüyor, yoksa düşündüğünüz dezavantajlar var mı?