C sharp

מתוך ויקיפדיה, האנציקלופדיה החופשית

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

#C היא שפת תכנות מונחת עצמים, שפותחה על־ידי חברת מיקרוסופט כחלק מיוזמת NET. שלה. בשנת 2005 ו־2006 תוקננה השפה על־ידי הארגונים Ecma International וארגון התקינה הבינלאומי. #C מתבססת על שפות התכנות ++C,‏ Visual Basic ו־Java. התחביר שלה דומה לזה של ++C ו־Java, אך עם דגש על יותר פשטות משפות אלו.

[עריכה] מהות השפה

שפת #C היא שפה מונחית עצמים חזקה: כל סוגי המשתנים בה הם אובייקטים (עצמים, במינוח העברי), ובפרט הסוגים "הפרימיטיביים", כמו int (מספר שלם בן 32 סיביות), float (מספר נקודה צפה בדיוק יחיד) ו-char (תו בודד), ודומיהם. זאת בניגוד לשפת Java, בה הסוגים הפרימיטיביים אינם אובייקטים. כמו בשפת Java, כל המחלקות יורשות, ישירות או דרך מחלקות אחרות, מהמחלקה הראשית, שנקראת Object. האובייקטים הפרימיטיביים הם מבנים (structures) היורשים מ-Object דרך המחלקה ValueType.

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

בנוסף, בניגוד לשפת ++C, לא ניתן לכתוב פונקציות גלובליות. כל הפונקציות חייבות להיות מאוגדות במחלקות, ובפרט הפונקציה Main, שהיא נקודת הכניסה (ההתחלה) של התוכנית. בדומה לשפת ++C ו-Java, פונקצייה יכולה להיות סטטית, אבל אז ניתן להפעיל אותה רק דרך שם המחלקה שלה ולא דרך אובייקט, להבדיל משפת ++C בה ניתן להפעיל פונקציה סטטית דרך אובייקט כלשהו שלה או ללא אובייקט, דרך שם המחלקה עצמה.

שפת #C ירשה משפת ++C את רעיון המבנים, והרחיבה אותו. בשפת #C ניתן להוסיף למבנים פונקציות (פונקציות השייכות למבנים או מחלקות נקראות "שיטות", Methods, כמו בשפת Java) ומבנים יכולים לממש ממשקים (Interface). אך מחלקות ומבנים אחרים לא יכולים לרשת ממבנים.

[עריכה] משתני ערך לעומת משתני התייחסות

בדומה לשפת Java, ובניגוד ל-++C, המשתנים מתחלקים למשתני ערך (value types) ומשתני התייחסות (reference types). ההבדל בין שני הסוגים הוא שבהעברה לפונקציה, משתני ערך מועברים כעותק של המשתנה המקורי, וכל שינוי שנעשה בפונקציה מבוצע על העותק, ולא במשתנה המקורי. כאשר משתני התייחסות מועברים לפונקציה, למעשה מועברת התייחסות (הכתובת בזיכרון) של המשתנה, והשינויים בערכו שמבוצעים בפונקציה מבוצעים על המשתנה המקורי.

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

מבנים נחשבים גם הם כמשתני ערך.

[עריכה] עקרונות התכנות מונחה העצמים בשפה

בשפת #C ממומשים העקרונות הכלליים של התכנות מונחה העצמים: כימוס, הורשה ורב-צורתיות (פולימורפיזם). בשונה מ-++C ובדומה ל-Java, ההורשה שמאפשרת #C יכולה להיות רק מטיפוס בסיס, ואינה מאפשרת הורשה מרובה. לעומת זאת ישנה אפשרות לרשת ממספר "ממשקים" (Interfaces) שהם מעין חוזים המכריחים את המחלקות היורשות להכניס לתוכם את המתודות, אך הממשק לא כולל בתוכו איזה מימוש למתודות האלה.

#C מוסיפה שתי רמות הרשאה לגישה לשיטות, בנוסף ל-private,‏ public ו-protected, המאפשרות בהתאמה, גישה מתוך המחלקה בלבד, גישה כללית, וגישה מתוך המחלקה ומתוך מחלקות יורשות, המקובלת ב-Java ו-++C: הרמה internal מאפשרת גישה כללית רק מתוך היישום המשתמש במחלקה (ליתר דיוק, מתוך ה-Assembly של התוכנית), והגישה protected internal, המאפשרת גישה בתוך היישום ומתוך מחלקות יורשות, גם אם הן ב-Assembly אחר.

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

[עריכה] זכרון מנוהל

שפת C#, כחלק מטכנולוגיית .NET, מוגדרת כ"קוד מנוהל" (Managed Code). המתכנת פטור מן האחריות לשחרור מפורש של זכרון המוקצה לאובייקט. סביבת ההרצה (CLR - Common Language Runtime) היא המפוקדת על שחרור הזכרון שתופסים עצמים שאינם בשימוש יותר. הסביבה מזהה שעצם אינו בשימוש, אם אין אף עצם אחר שמחזיק בו("מצביע" עליו).

סביבת ההרצה יוזמת אחת לזמן תהליך של "איסוף זבל", הממפה את כל העצמים במערכת ומסמן למחיקה את אלו שאינם בשימוש. לצורך המיפוי מוגדרים מספר רכיבים ראשיים ("שורשים"). עצם הוא בשימוש אם הוא מוחזק על ידי אחד הרכיבים הראשיים, או שניתן להגיע אליו מאחד הרכיבים הראשיים דרך סדרה של עצמים אחרים. עצמים שאינם בשימוש מסומנים למחיקה. אם הוגדר עליהם קוד הרצה לפני מחיקה (Finalizer) הוא יבוצע. ולאחר מכן העצם ימחק ונזכרון אתו תפס ישוחרר.

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

[עריכה] Properties

מתכנתי ++C בוודאי זוכרים את כל הפעמים שהיו צריכים לכתוב פונקציות קבלה ושליחה של כל אחד מהמשתנים במחלקה, כדי להקל בנושא זה נלקח רעיון ה"תכונות" מ-Visual Basic, בתכונה צורת הכתיבה היא פשוטה לכתיבה וקריאה. כל מה שיש זה להגדיר את הגבלת ההרשאה על הפונקציות (על פי רעיון הכימוס) להחליט מה יהיה הערך המוחזר ולקבוע את שם הפונקציה, לאחר מכן לקבוע מה יקרה ב-get ומה ב-set ובזמן הריצה כל פעם שיתבקש מהתכונה ערך היא תפנה ל-get וכל פעם שיוכנס לה ערך היא תפנה ל-set.

[עריכה] העמסת אופרטורים

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

#C מאפשרת העמסת אופרטורים, אך באופן מוגבל יותר מאשר ב-++C. ניתן להעמיס את האופרטור '+' ו-'==', אך לא את האופרטור "[ ]" (המשמש לגישה אל איבר במערך). ניתן, עם זאת, לכתוב פונקציה בתחביר מיוחד, השונה מהתחביר הרגיל של העמסת אופרטורים (ודומה יותר לתחביר של תכונה, ראה לעיל), המאפשר לדמות את האופרטור הזה. פונקציה כזו נקראת indexer.

[עריכה] טיפול בחריגות

שפת ++C הציגה יכולת מוגבלת לטיפול בחריגות (מצבים לא צפויים במהלך הריצה של התוכנית) על ידי "זריקת" אובייקטים או משתנים פרימיטיביים אל הפונקציה שקראה לפונקציה בה התרחשה החריגה, כדי להעביר מידע על החריגה. בדומה לשפת Java, גם ב-#C אפשר לזרוק רק אובייקטים מסוג המחלקה Exception. בניגוד ל-Java, אין צורך (ואף לא ניתן) להכריז על שיטה כשיטה הזורקת חריגה, וכן, גם כן בניגוד ל-Java, אין חובה "לתפוס" חריגות שנזרקו, וחריגה יכולה למצוא עצמה נתפסת על ידי סביבת הריצה עצמה.

[עריכה] תאימות לאחור

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

בנוסף, קיימים כינויים למחלקות שאינן קיימות כסוגי משתנים בשפת ++C: הכינוי object למחלקה Object, וכן הקידומת unsigned משפת ++C תהיה בדרך כלל הקידומת u לכינוי המתאים (למעט byte, שהוא כבר unsigned, ולכן קיים הכינוי sbyte, שהוא byte עם סימן). למשל, unsigned int בשפת ++C מקביל ל-uint בשפת #C, שאינו אלא כינוי למבנה UInt32.

המבנה Char בשפת #C מכיל נתון באורך 16 סיביות, כדי שיוכל להכיל תו יוניקוד, בניגוד ל-char של ++C שהוא באורך 8 סיביות (ומכיל תו ANSI).

המבנה Int64 בשפת #C מכיל מספר שלם באורך 64 סיביות, ללא תלות בפלטפורמה עליה התוכנית רצה, בניגוד ל-long של ++C המכיל לרוב מספר שלם באורך 32 סיביות.

ניתן להשתמש בתוכנית, בכינוי של מחלקה או בשם המפורש שלה, ואין לכך כל חשיבות.

[עריכה] דוגמה לתוכנית Hello world

להלן דוגמה לתוכנית Hello world בשפה זו.

Using System;
class ExampleClass
{
    public static void Main(string[] args)
    {
        Console.WriteLine("Hello world!");
    }
 }

[עריכה] ראו גם

• מונחים בתוכנה

[עריכה] קישורים חיצוניים

מיזמי קרן ויקימדיה
ספר לימוד בוויקיספר: NET

• תקן ECMA-334 המגדיר את שפת #C
• מדריך ללימוד C Sharp, סדנאות אית"ן