הַצהָרָה:
מערכים מוכרזים באמצעות ה-'type[] ArrayName;' תחביר שבו הטיפוס מסמל את סוג האיברים באוסף המערך, ו-'ArrName' הוא הכותרת המוקצה למערך. הצהרה של מערך מסומנת בסוגריים מרובעים [].
סוּג [ ] שם מערך = סוג חדש [ ] ; רשימות מוצהרות באמצעות 'List
רשימה < סוּג > רשימת שמות = רשימה חדשה < סוּג > ( ) ;
אִתחוּל:
מערכים משתמשים בסוגריים מסולסלים {} כדי להקיף את הערכים, בעוד שרשימות משתמשות בבנאי List
סוּג [ ] שם מערך = { v1 , v2 , v3 , ... } ;
רשימה < סוּג > רשימת שמות = רשימה חדשה < סוּג > { v1 , v2 , v3 , ... } ;
הוספת ערכים:
חשוב לזכור שלמערכי C# יש גודל מסוים. אם נדרש גודל אחר, יש ליצור מערך חדש 'newArr' בגודל הרצוי (אורך נוכחי + מספר ערכים חדשים). הוסף את המערך המקורי 'OrgArr' למערך החדש והקצה את הערכים החדשים למיקומים החדשים במערך החדש ועדכן את ההפניה למערך החדש.
מַעֲרָך. עותק ( OrgArr , newArr , OrgArr. אורך ) ;
newArr [ OrgArr. אורך ] = 14 ; // ערך חדש
newArr [ OrgArr. אורך + 1 ] = 2 ; // ערך חדש
OrgArr = newArr ; // עדכן את ההפניה int[] NewArr = new int[OrgArr.Length + 2];
רשימות מציעות גמישות במונחים של ניהול גודל. כאשר רשימה מאותחלת, היא מתחילה בקיבולת ראשונית, אך היא יכולה להתרחב אוטומטית ככל שמתווסף אלמנטים נוספים. יכולת שינוי גודל דינמי זו מאפשרת לרשימות להסתגל לדרישות המשתנות. רשימות C# מספקות פונקציה Add() להוספת הערכים לרשימה. כך תוכל להוסיף ערכים לרשימת C#:
מערכים לעומת רשימות : השוואת שימוש ב-C #
גישה לערכים
הגישה לערכים במספרי המערך מתבצעת באמצעות סימון האינדקס [], כלומר באמצעות מספר האינדקס בסוגריים ונשמר למשתנה אחר.
סוג אלמנט = שם מערך [ אינדקס ] ;כדי לגשת לערכים ברשימת C#, אתה יכול גם להשתמש בסימון האינדקס [] יחד עם מיקום האינדקס הרצוי בדומה למערכים.
סוג אלמנט = רשימת שמות [ אינדקס ] ;
הסרת הערכים
למערכים יש אורך מוגדר. לכן, כדי להסיר את האלמנטים, יש ליצור מערך חדש בגודל קטן יותר, ולהעתיק את האלמנטים הקיימים. ניתן לעשות זאת על ידי שימוש בפונקציה Array.Copy() כפי שהוסבר בסעיף 'הוספת ערכים'. ברשימות C#, הסרת הערכים היא הרבה יותר פשוטה ואינטואיטיבית. המחלקה List
ספר את הערכים
כדי לספור את הערכים במערך C#, תוכל להשתמש בתכונת האורך של המערך. המאפיין length נותן לך את המספר הכולל של ערכים במערך.
int לספור = arrayName. אורך ;כדי לספור את הערכים ברשימת C#, אתה יכול להשתמש בתכונת 'ספירה' של הרשימה. הכמות הכוללת של הרכיבים שנמצאים כעת ברשימה מוחזרת גם על ידי התכונה 'count'.
int לספור = רשימת שמות. לספור ;חזר על הערכים
כדי לחזור על ערכים במערך C#, אתה יכול להשתמש בלולאה 'for' עם אורך המערך כתנאי הלולאה.
ל ( int אני = 0 ; אני < שם מערך. אורך ; אני ++ ) {סוג ה = arrayName [ אני ] ;
לְנַחֵם. WriteLine ( זה ) ;
}
כדי לחזור על הערכים ברשימת C#, אתה יכול להשתמש בלולאה 'foreach' מכיוון שהיא מפשטת את תהליך האיטרציה על ידי איטרציה אוטומטית על האלמנטים.
לכל אחד ( הקלד e ב-listName ) {לְנַחֵם. WriteLine ( זה ) ;
}
דוגמה 1: מערכי C#
הקוד הנתון מכריז ומאתחל מערך שלמים בשם 'Arr' באורך של 5 ומקצה את הערכים לאלמנטים שלו. הערכים שהוקצו לרכיבי המערך הם 11, 12, 13, 14 ו-15. לאחר מכן הקוד ממשיך להציג את רכיבי המערך באמצעות לולאת 'for'. כל רכיב מוצג בשורה נפרדת בשיטת Console.WriteLine() .
לאחר הצגת האלמנטים המקוריים, הקוד משנה את האלמנט באינדקס 2 על ידי הקצאת ערך חדש של 10. לאחר מכן, הקוד מציג את המערך שהשתנה על ידי איטרציה דרך האלמנטים שוב באמצעות לולאה 'for'. לבסוף, הקוד מציג את המספר הכולל של ערכים השוכנים במערך באמצעות המאפיין 'Arr.Length' אשר מניב את אורך המערך.
באמצעות System ;דמה בכיתה {
סטָטִי בָּטֵל רָאשִׁי ( ) {
int [ ] Arr = חָדָשׁ int [ 5 ] { אחד עשר , 12 , 13 , 14 , חֲמֵשׁ עֶשׂרֵה } ;
לְנַחֵם. WriteLine ( 'אלמנטים:' ) ;
ל ( int אני = 0 ; אני < Arr. אורך ; אני ++ )
{
לְנַחֵם. WriteLine ( Arr [ אני ] ) ;
}
Arr [ 2 ] = 10 ;
לְנַחֵם. WriteLine ( 'מערך שונה:' ) ;
ל ( int אני = 0 ; אני < Arr. אורך ; אני ++ )
{
לְנַחֵם. WriteLine ( Arr [ אני ] ) ;
}
לְנַחֵם. WriteLine ( 'מספר אלמנטים: ' + Arr. אורך ) ;
}
}
דוגמה 2: רשימות C#
הקוד הבא מדגים את השימוש ברשימת C# לאחסון ולתפעל אוסף של מספרים שלמים. ראשית, הקוד מאתחל רשימה בשם 'Arr' עם חמישה מספרים שלמים: 11, 12, 13, 14 ו-15. הדבר מושג באמצעות המחלקה List
לאחר מכן, התוכנית מדפיסה את הודעת 'Elements:' וממשיכה לחזור על כל רכיב ברשימה באמצעות לולאה 'foreach'. במהלך כל איטרציה, האלמנט הנוכחי מודפס למסוף באמצעות שיטת Console.WriteLine() .
לאחר מכן, הקוד משנה את הערך באינדקס 2 של הרשימה על ידי הקצאת הערך של 10 (Arr[2] = 10). שורה זו משנה את האלמנט השלישי ברשימה מ-13 ל-10. לאחר השינוי, התוכנה מדפיסה שוב את הודעת 'רשימה שונה:' וחוזרת על הרשימה המעודכנת, מדפיסה כל רכיב למסוף. לאחר מכן הקוד מציג את מספר הערכים ברשימה באמצעות 'Arr.Count'. מאפיין זה מחזיר את ספירת הפריטים הקיימים ברשימה, אשר בתרחיש הבא היא במקרה 5.
לבסוף, הקוד מסיר את האלמנט בעל הערך 4 מהרשימה באמצעות שיטת Arr.Remove(4). שיטה זו מחפשת את הערך שצוין ברשימה ומסירה את המופע הראשון שלו. לבסוף, התוכנית מדפיסה את ההודעה 'רשימה לאחר ההסרה:' וחוזרת על הרשימה פעם נוספת, ומציגה כל רכיב שנותר לאחר פעולת ההסרה.
באמצעות System ;באמצעות System. אוספים . גנרית ;
דמה בכיתה {
סטָטִי בָּטֵל רָאשִׁי ( ) {
רשימה < int > Arr = רשימה חדשה < int > ( ) { אחד עשר , 12 , 13 , 14 , חֲמֵשׁ עֶשׂרֵה } ;
לְנַחֵם. WriteLine ( 'אלמנטים:' ) ;
לכל אחד ( int n ב Arr )
{
לְנַחֵם. WriteLine ( נ ) ;
}
Arr [ 2 ] = 10 ;
לְנַחֵם. WriteLine ( 'רשימה שונה:' ) ;
לכל אחד ( int n ב Arr )
{
לְנַחֵם. WriteLine ( נ ) ;
}
לְנַחֵם. WriteLine ( 'מספר אלמנטים: ' + Arr. לספור ) ;
Arr. לְהַסִיר ( 4 ) ;
לְנַחֵם. WriteLine ( 'רשימה לאחר הסרה:' ) ;
לכל אחד ( int n ב Arr )
{
לְנַחֵם. WriteLine ( נ ) ;
}
}
}
סיכום
מדריך זה כיסה את הבדלי התחביר הבסיסיים בין מערכי C# ורשימות C#. למערכים יש אורך קבוע והגישה אליהם מתבצעת באמצעות אינדקס, בעוד שהרשימות הן בגודל דינמי ומספקות שיטות נוספות להוספה והסרה של האלמנטים. יחד עם זה, סיפקנו את תוכניות רשימת C# המציגות את ההצהרה, האתחול, הגישה, השינוי, הספירה והוספה של האלמנטים.