כיצד להשתמש בבלתי משתנה ב- C #

אי-משתנות היא תכונה של שפות תכנות פונקציונליות המקלה על כתיבה, בדיקה ותחזוקה של תוכניות. עם זאת, אי-משתנות אינה נתמכת בשפות תכנות חיוניות רבות. עד לאחרונה, C # לא תמך במשתנות החוצה מהקופסה. 

זה משתנה עם הצגת רשומות ב- C # 9, שזמינות לתצוגה מקדימה ב- .NET 5. עם זאת, אנו יכולים ליישם אי-שינוי בגרסאות קודמות של C # באמצעות מרחב השמות System.Collections.Immutable, הזמין כחבילה של NuGet. 

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

כדי לעבוד עם דוגמאות הקוד המופיעות במאמר זה, עליך להתקין במערכת Visual Studio 2019 שלך. אם עדיין אין לך עותק, תוכל להוריד את Visual Studio 2019 כאן. 

צור פרויקט יישומי קונסולת .NET Core ב- Visual Studio

ראשית, בואו ניצור פרויקט יישומי קונסולת .NET Core ב- Visual Studio. בהנחה ש- Visual Studio 2019 מותקן במערכת שלך, בצע את הצעדים המתוארים להלן כדי ליצור פרויקט יישום חדש של מסוף ה- NET Core ב- Visual Studio.

  1. הפעל את Visual Studio IDE.
  2. לחץ על "צור פרויקט חדש".
  3. בחלון "צור פרויקט חדש" בחר "יישום קונסולה (.NET Core)" מרשימת התבניות המוצגות.
  4. הקש "הבא. 
  5. בחלון "הגדר את הפרויקט החדש שלך" שמוצג הבא, ציין את השם והמיקום של הפרויקט החדש.
  6. לחץ על צור. 

פעולה זו תיצור פרויקט יישום קונסולת .NET Core חדש ב- Visual Studio 2019. נשתמש בפרויקט זה כדי להמחיש אי-שינוי בקטעים הבאים במאמר זה.

התקן את החבילה System.Collection.Imutable

כדי לעבוד עם סוגים בלתי ניתנים לשינוי, עליך להתקין את החבילה System.Collections.Immutable מ- NuGet. אתה יכול לעשות זאת באמצעות מנהל החבילות של NuGet בתוך Visual Studio 2019 IDE, או על ידי ביצוע הפקודה הבאה במסוף מנהל החבילות של NuGet:

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

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

הבן את חוסר השינוי והרישומים ב- C # 9

אובייקט העברת נתונים הוא דוגמה קלאסית למועד שבו ברצונך לשנות את השינוי. מופע של DTO מסודר לעתים קרובות כך שהוא יכול להיות בלתי תלוי בטכנולוגיה המשמשת בקצה הצרכן. מטבע הדברים, בעת העברת אובייקט נתונים בין מסד נתונים ללקוח, ברצונך להבטיח שלא ניתן לשנות את האובייקט - וזו בדיוק המטרה של DTO. אתה יכול לקרוא עוד על השימוש באובייקטים של העברת נתונים ב- C # מתוך המאמר הקודם שלי כאן. 

כדי ליצור DTOs בלתי ניתנים לשינוי, אתה יכול לנצל את ReadOnlyCollection או את סוגי האוספים הבלתי ניתנים לשינוי ללא חוטים במרחב השמות System.Collections.Imutable. לחלופין, תוכל לנצל את סוגי הרשומות ב- C # 9 כדי ליישם DTOs בלתי ניתנים לשינוי.

סוג רשומה ב- C # 9 הוא סוג נתונים קל משקל, שאינו משתנה (או סוג קל), בעל תכונות לקריאה בלבד. מכיוון שסוג רשומה אינו ניתן לשינוי, הוא חסין חוט ולא יכול לשנות או לשנות לאחר שנוצר.

אתה יכול לאתחל סוג רשומה רק בתוך קונסטרוקטור. יצירת סוג רשומה עבור מחלקה (מחבר בדוגמה זו) היא פשוטה כמו קטע הקוד הבא.

נתוני מחלקה מחבר (מזהה int, שם פרטי מחרוזת, שם משפחה מחרוזת, כתובת מחרוזת);

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

מחלקת נתונים ציבורית מחבר {

    ID מזהה ציבורי {get; init; }

    מחרוזת ציבורית firstName {get; init; }

    שם משפחה ציבורי שם {get; init; }

    כתובת מחרוזת ציבורית {get; init; }

}

שים לב לשימוש במילת מפתח הנתונים בעת הצהרת סוג הרשומה. מילת המפתח של הנתונים כאשר משתמשים בה בהצהרה של מחלקה מסמנת את הסוג כרישום. אתה יכול לנצל מופע מסוג רשומה כדי להעביר נתונים על פני השכבות ובמקביל להבטיח אי-שינוי של ה- DTO.

מרחב השמות System.Collections.Imutable

אוספים בלתי ניתנים לשינוי הם אלה שחבריהם אינם יכולים להשתנות לאחר שנוצרו. מרחב השמות System.Collections.Imutable כולל כמה אוספים בלתי ניתנים לשינוי. מרחב שמות זה מכיל גרסאות בלתי ניתנות לשינוי של רשימות, מילונים, מערכים, האש, ערימות ותורים.

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

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

var stack = ImmutableStack.Empty;

עבור (int i = 0; i <10; i ++)

{

    מחסנית = מחסנית. לחץ (i);

}

התוכנית הבאה מדגימה כי לא ניתן לשנות את האלמנטים של ערימה בלתי ניתנת לשינוי.

תכנית כיתתית

    {      

        ריק סטטי ראשי (מחרוזת [] טענות)

        {

            var stack = ImmutableStack.Empty;

            עבור (int i = 0; i <10; i ++)

            {

                מחסנית = מחסנית. לחץ (i);

            }

            Console.WriteLine ("אין אלמנטים בערימה המקורית:

             "+ stack.Count ());

            var newStack = stack.Pop ();

            Console.WriteLine ("אין אלמנטים בערימה חדשה:" +

            newStack.Count ());

            Console.ReadKey ();

        }

    }

כאשר אתה מבצע את התוכנית שלעיל, כך יופיע הפלט בחלון המסוף.

כפי שניתן לראות באיור 1, הערימה המקורית שאינה ניתנת לשינוי (המכילה 10 אלמנטים) אינה משתנה לאחר קריאה לשיטת Pop (). במקום זאת, נוצרת ערימה בלתי משתנה חדשה עם 9 אלמנטים.

אוספים בלתי ניתנים לשינוי אינם מציעים בנאים, אך תוכל לנצל את שיטת המפעל הסטטית הנקראת Create כפי שמוצג בקטע הקוד המופיע למטה.

var list = ImmutableList.Create (1, 2, 3, 4, 5);

אם תרצה להוסיף או להסיר אלמנט מאוסף זה, תיווצר רשימה בלתי ניתנת לשינוי ורשימה שאינה ניתנת לשינוי המקורית תישאר ללא שינוי.

אי-משתנות היא בחירה עיצובית; המשמעות היא שלא ניתן לשנות מופע מסוג לאחר שנוצר. למעט ערימות בלתי ניתנות לשינוי ותורים בלתי ניתנים לשינוי, כל האוספים הבלתי ניתנים לשינוי מבוססים על עצי AVL. מכאן שאתה יכול להוסיף אלמנטים בכל מיקום של האוסף, כלומר, התחלה, אמצע או סוף, מבלי שתצטרך להעתיק את העץ בשלמותו.

כיצד לעשות יותר ב- C #:

  • כיצד להשתמש בהערות נתונים ב- C #
  • כיצד לעבוד עם GUIDs ב- C # 8
  • מתי להשתמש בכיתה מופשטת לעומת ממשק ב- C #
  • כיצד לעבוד עם AutoMapper ב- C #
  • כיצד להשתמש בביטויי למבדה ב- C #
  • כיצד לעבוד עם נציגי Action, Func ו- Predicate ב- C #
  • כיצד לעבוד עם נציגים ב- C #
  • כיצד ליישם לוגר פשוט ב- C #
  • כיצד לעבוד עם תכונות ב- C #
  • כיצד לעבוד עם log4net ב- C #
  • כיצד ליישם את דפוס עיצוב המאגר ב- C #
  • כיצד לעבוד עם השתקפות ב- C #
  • כיצד לעבוד עם מערכת קבצים ב- C #
  • כיצד לבצע אתחול עצל ב- C #
  • כיצד לעבוד עם MSMQ ב- C #
  • כיצד לעבוד עם שיטות הרחבה ב- C #
  • איך לנו ביטויים למבדה ב- C #
  • מתי להשתמש במילת המפתח ההפכפכה ב- C #
  • כיצד להשתמש במילת המפתח תשואה ב- C #
  • כיצד ליישם פולימורפיזם ב- C #
  • כיצד לבנות מתזמן משימות משלך ב- C #
  • כיצד לעבוד עם RabbitMQ ב- C #
  • איך לעבוד עם ציצית ב C #
  • חקר שיטות וירטואליות ומופשטות ב- C #
  • כיצד להשתמש ב- Dapper ORM ב- C #
  • כיצד להשתמש בתבנית העיצוב במשקל זבוב ב- C #