351. Introducing Interception

שבוע מיורט טוב
Design Patterns, Interce

המשך לסדרה על Proxies, נתחיל היום סדרה שמדברת על המושג של Interception.

כפי שראינו, Proxy הוא בעצם אפשרות ליצור ממשק שמפנה את כל הקריאות למתודה אחת.

כך אנחנו יכולים להנות מהיכולת לבצע דברים בצורה אוטומטית ע”י הפניה למתודה אחת שמבצעת עבורנו את העבודה.

המושג של Interception הוא מושג שמאוד קשור למושג של Proxy.

בגדול, Interception מאפשר לנו להוסיף או לשנות ההתנהגות של פונקציות שלנו.

למה הכוונה?

נניח, למשל, שכתבנו איזושהי מחלקה, למשל:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Bank : IBank
{
    public void Deposit(string id, int amount)
    {
        // Implementation of Deposit
    }
    public void Withdraw(string id, int amount)
    {
        // Implementation of Withdraw
    }
    public int GetAvailableBudget(string id)
    {
        // Implementation of GetAvailableBudget
    }
}

עכשיו פתאום נזכרנו שאנחנו רוצים לעשות משהו בקריאות לפונקציות.

למשל, כל פעם שאנחנו נכנסים או יוצאים מפונקציה כלשהי, אנחנו מעוניינים לכתוב לConsole.

אז נוכל לעשות זאת כך:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
public class Bank : IBank
{
    public void Deposit(string id, int amount)
    {
        WriteCall(new MethodCallInfo("Deposit")
                       {
                           {"id", id},
                           {"amount", amount}
                       });
        // Implementation of Deposit
        WriteCallReturn(new MethodReturnInfo("Deposit"));
    }
    public void Withdraw(string id, int amount)
    {
        WriteCall(new MethodCallInfo("Withdraw")
                       {
                           {"id", id},
                           {"amount", amount}
                       });
        // Implementation of Withdraw
        WriteCallReturn(new MethodReturnInfo("Withdraw"));
    }
    public int GetAvailableBudget(string id)
    {
        WriteCall(new MethodCallInfo("GetAvailableBudget")
                       {
                           {"id", id},
                       });
        // Implementation of GetAvailableBudget
        int result;
        // End implementation of GetAvailableBudget
        WriteCallReturn(new MethodReturnInfo("GetAvailableBudget") { ReturnValue = result });
    }
    private void WriteCall(MethodCallInfo methodCallInfo)
    {
        Console.WriteLine("Called {0} with arguments:");
        foreach (KeyValuePair<string, object> argument in methodCallInfo)
        {
            Console.WriteLine("\t{0} : {1}",
                              argument.Key,
                              argument.Value);
        }
    }
    private void WriteCallReturn(MethodReturnInfo methodReturnInfo)
    {
        Console.WriteLine("Returned from {0} with value {1}.",
                          methodReturnInfo.Name,
                          methodReturnInfo.ReturnValue);
    }
}

בעצם מה שעשינו זה דחפנו בהתחלה ובסוף של כל הפונקציות שלנו קריאה לשתי מתודות חדשות.

כרגע זה לא נראה מרגש מדי, וכנראה רובנו מכירים את הקונספט הזה של לקרוא לפונקציות בהתחלה ובסוף של הפונקציות שלנו, אבל זה העיקרון של Interception.

שימו לב לדמיון בדוגמה שמופיעה כאן לProxy: בשתיהן אנחנו קוראים לפונקציה כלשהי קבועה בעת הקריאה לפונקציה.

אבל יש גם הבדל: בProxy היינו קוראים רק לפונקציה הקבועה. בInterception אנחנו יכולים גם לקרוא לפונקציה לא קבועה (מה שמופיע בהערה כImplementation).

בפעם הבאה ננסה לתאר טיפה יותר מה אנחנו רוצים להשיג בInterception, ובהמשך נראה שימושים (מדהימים!) של Interception ומימושים אפשריים בFramework.

המשך יום מיורט לטובה.

שתף