277. Freezing mutable objects

התחלתי ללמוד לא מזמן Ruby, כך שהדבר אולי ישפיע על הפינה.

בRuby בניגוד לJava וC# מחרוזות הן Mutable, כלומר ניתן לשנות את ערכיהן.

למשל, קוד בסגנון הזה יעבוד בRuby:

string helloWorld = "hello World";
helloWorld[0] = "H";
Console.WriteLine(helloWorld); // Hello World

אבל רגע! אמרנו שחשוב שאובייקטים יהיו Immutable, בין השאר כדי שיהיו מפתחות של Dictionary.

אז איך מסתדרים החבר’ה שם בRuby?

ובכן, יש אפשרות להקפיא מחרוזות (ואובייקטים נוספים שהם Mutable) ע"י קריאה למתודה בשם Freeze.

המתודה הזאת גורמת לכך שאם ננסה לשנות את האובייקט, ייזרק לנו Exception. למשל, זה יכול להיות מימוש של אובייקט עם מתודת Freeze בC#:

public class Person
{
    private string mName;
    private string mLastName;
    private int mAge;
    private bool mIsFrozen = false;

    public string Name
    {
        get
        {
            return mName;
        }
        set
        {
            if (mIsFrozen)
            {
                throw new ArgumentException("The object is frozen.");
            }

            mName = value;
        }
    }

    public string LastName
    {
        get
        {
            return mLastName;
        }
        set
        {
            if (mIsFrozen)
            {
                throw new ArgumentException("The object is frozen.");
            }

            mLastName = value;
        }
    }

    public int Age
    {
        get
        {
            return mAge;
        }
        set
        {
            if (mIsFrozen)
            {
                throw new ArgumentException("The object is frozen.");
            }

            mAge = value;
        }
    }

    public void Freeze()
    {
        mIsFrozen = true;
    }

    public bool IsFrozen
    {
        get
        {
            return mIsFrozen;
        }
    }
}

ברגע שאובייקט מוקפא, הוא נהיה Immutable – אי אפשר יותר לשנות אותו.

שימו לב – אין דרך "להפשיר" אובייקט ברגע שהקפאנו אותו!

כך הוא יכול לשמש כמפתח בDictionary וכו’ בלי חשש שישתנה.

למעשה, הDictionary בRuby (מה שנקרא Hash), דואג לכך שאם הוא מקבל כמפתח מחרוזת שהיא לא קפואה (ע"י בדיקת הפונקציה frozen?, אצלנו זה הProperty ששמו IsFrozen), הוא משכפל אותה ומקפיא אותה.

רגע, ואם בא לנו "להפשיר" את האובייקט?

אז Ruby מספקת לנו שתי מתודות: dup וclone:

שתיהן משכפלות את האובייקט, רק שאחת יוצרת אובייקט חדש שהוא כבר לא קפוא…

דיברתי פה הרבה על Ruby, אבל אפשר להעתיק את הקונספט גם לC#: אפשר ליצור ממשק פשוט כזה:

public interface IFreezable : ICloneable
{
    void Freeze();

    bool IsFrozen
    {
        get;
    }
}

ואז ליצור מחלקת Dictionary משלנו שמקבל מפתחות שהם IFreezableשדואג לקרוא לClone ואז לFreeze ברגע שמכניסים מפתח שהוא לא מוקפא.

ההגדרה של המחלקה היא משהו כזה:

public class FreezingDictionary<TKey, TValue> : 
    IDictionary<TKey, TValue> where TKey : IFreezable
{
}

שבוע קפוא בלי הרבה שינויים טוב!