ควรใช้ฟังก์ชั่นที่ทำหน้าที่เป็นพารามิเตอร์หรือไม่และนำพารามิเตอร์ไปใช้กับฟังก์ชันเหล่านั้นเป็นพารามิเตอร์ด้วยหรือไม่

ฉันมักจะพบว่าตัวเองกำลังเขียนฟังก์ชั่นที่มีลักษณะเช่นนี้เพราะพวกเขาทำให้ฉันสามารถเข้าถึงข้อมูลได้อย่างง่ายดายและยังมีลายเซ็นที่ยอมรับพารามิเตอร์เพื่อกำหนดข้อมูลที่จะเข้าถึง

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

สิ่งที่คุณกำลังทำมีจุดประสงค์เล็กน้อย ไม่ใช่รหัสทั่วไปดังนั้นคุณต้องทำซ้ำรหัสนั้นทุกที่ มัน overcomplicates รหัสของคุณเพราะตอนนี้รหัสของคุณมีการรวบรวมทุกสิ่งที่ต้องการจากฟังก์ชั่นเล็ก ๆ พันของตัวเอง หัวใจของคุณอยู่ในที่ที่เหมาะสม: คุณเพียงแค่ต้องคุ้นเคยกับการใช้ฟังก์ชั่นการเรียงลำดับทั่วไปที่สูงกว่าเหล่านี้เพื่อรวบรวมสิ่งต่างๆเข้าด้วยกัน หรือใช้แลมบ์ดาแฟชั่นดีเก่าที่จะเปิดFunc<A, B>และเข้าAFunc<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 # วิธีปกติในการทำเช่นนั้นคือการให้วิธีการนี้เรียกวิธีนามธรรม หากคุณไม่มีเหตุผลที่เฉพาะเจาะจงที่จะทำในลักษณะที่แตกต่างคุณควรทำอย่างนั้น

สิ่งนี้ดูเหมือนเป็นวิธีแก้ปัญหาที่ดีหรือมีข้อเสียอยู่หรือเปล่า?