Các hàm có nên lấy các hàm làm tham số, cũng nên lấy tham số cho các hàm đó làm tham số?

Tôi thường thấy mình viết các hàm trông như thế này vì chúng cho phép tôi dễ dàng giả định truy cập dữ liệu và vẫn cung cấp chữ ký chấp nhận các tham số để xác định dữ liệu nào sẽ truy cập.

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

Hoặc là

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

Sau đó, tôi sử dụng nó như thế này:

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

Đây có phải là một thực tế phổ biến? Tôi cảm thấy mình nên làm một cái gì đó giống như

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

Nhưng điều đó dường như không hoạt động tốt bởi vì tôi phải tạo một hàm mới để truyền vào phương thức cho mọi loại tỷ lệ.

Đôi khi tôi cảm thấy mình nên làm

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

Nhưng điều đó dường như lấy đi mọi khả năng tìm nạp và định dạng lại. Bất cứ khi nào tôi muốn tìm nạp và định dạng, tôi phải viết hai dòng, một để tìm nạp và một để định dạng.

Tôi còn thiếu gì về lập trình chức năng? Đây có phải là cách đúng đắn để làm điều đó, hay có một mô hình tốt hơn vừa dễ bảo trì và sử dụng?

Nếu bạn làm điều này đủ lâu, cuối cùng bạn sẽ thấy mình viết chức năng này nhiều lần:

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

Xin chúc mừng, bạn đã phát minh ra thành phần chức năng .

Các hàm bao bọc như thế này không được sử dụng nhiều khi chúng chuyên dùng cho một loại. Tuy nhiên, nếu bạn giới thiệu một số biến loại và bỏ qua tham số đầu vào, thì định nghĩa GetFormattedRate của bạn sẽ như sau:

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

Khi nó đứng, những gì bạn đang làm có rất ít mục đích. Nó không chung chung, vì vậy bạn cần sao chép mã đó ở mọi nơi. Nó quá phức tạp mã của bạn bởi vì bây giờ mã của bạn phải tự lắp ráp mọi thứ nó cần từ một nghìn hàm nhỏ. Trái tim của bạn đang ở đúng chỗ: bạn chỉ cần quen với việc sử dụng các loại hàm bậc cao chung này để đặt mọi thứ lại với nhau. Hoặc, sử dụng một lambda thời trang cũ tốt để biến Func<A, B>và Athành Func<B>.

Đừng lặp lại chính mình.

Hoàn toàn không có lý do để truyền một hàm và các tham số của nó, chỉ sau đó gọi nó với các tham số đó. Trong thực tế, trong trường hợp của bạn, bạn không có lý do gì để vượt qua một chức năng cả . Người gọi cũng có thể chỉ gọi hàm và truyền kết quả.

Hãy suy nghĩ về nó - thay vì sử dụng:

var formattedRate = GetFormattedRate(getRate, rateType);

Tại sao không sử dụng đơn giản:

var formattedRate = GetFormattedRate(getRate(rateType));

?

Ngoài việc giảm mã không cần thiết, nó cũng làm giảm việc ghép nối - nếu bạn muốn thay đổi cách tìm nạp tốc độ (giả sử, nếu getRatebây giờ cần hai đối số), bạn không phải thay đổi GetFormattedRate.

Tương tự như vậy, không có lý do để viết GetFormattedRate(formatRate, getRate, rateKey)thay vì viết formatRate(getRate(rateKey)).

Đừng quá phức tạp.

Nếu bạn thực sự cần phải truyền một hàm vào hàm vì nó truyền một số đối số phụ hoặc gọi nó trong một vòng lặp thì thay vào đó bạn có thể truyền lambda:

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

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

Lambda sẽ ràng buộc các đối số mà hàm không biết và che giấu rằng chúng thậm chí còn tồn tại.

Đây không phải là những gì bạn muốn?

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

Và sau đó gọi nó như thế này:

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

        System.PrintLn(formattedRate);
    }
}

Nếu bạn muốn một phương thức có thể hành xử theo nhiều cách khác nhau trong một ngôn ngữ hướng đối tượng như C #, thì cách thông thường để làm điều đó là gọi phương thức đó là một phương thức trừu tượng. Nếu bạn không có lý do cụ thể để làm theo cách khác, bạn nên làm theo cách đó.

Đây có phải là một giải pháp tốt, hoặc có những nhược điểm bạn đang nghĩ đến?