Dot Net Basic Terms and Versions
פרקי ההרצאה: Dot Net Basic Terms and Versions
תמלול ההרצאה: Dot Net Basic Terms and Versions
הטקסט המלא של הדקות הראשונות בהרצאה «Dot Net Basic Terms and Versions» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
כמתכנתי .NET חשוב שנכיר את המונחים הבסיסיים בעולם ה- .NET וחשוב שנכיר את ההבדלים בין הגרסאות השונות של .NET.
לכן אנחנו מגיעים להבנה לגבי מונחים בסיסיים ב- .NET ומהם הגרסאות השונות שקיימות. אז בואו נתחיל עם מונחים בסיסיים. דבר ראשון, אנחנו יודעים שכאשר אנחנו מתכנתים אנחנו עובדים עם visualstudio.net.
visualstudio.net כמובן זאת סביבת הפיתוח שאיתה אנחנו בתור מתכנתים מתכנתים. היא מאפשרת לנו לכתוב קוד C-Sharp בקובץ אחד או יותר.
כאן אנחנו משתמשים בשפת C-Sharp בכדי לכתוב את ה-source code שלנו. עכשיו אנחנו בתור מתכנתים מבצעים פעולה שנקראת Compilation.
קיצור מקלדת ctrl-shift-b והפעולה הזאת לוקחת את כל קבצי ה-C-Sharp שכתבנו ויוצרת מכל קבצי ה-C-Sharp קובץ אחד ויחיד שהוא או Execution או DLL. הקובץ הזה נקרא בשפה מקצועית Assembly והוא כתוב בשפה שנקראת MSIL שדיברנו עליה בעבר Microsoft Intermediate Language.
זאת בעצם שפת ביניים שקוד ה-C-Sharp שכתבנו הומר אליה. השפה הזאת לא יכולה לרוץ כמו שהיא במעבד המחשב, מעבד המחשב לא יכול לקרוא את השפה הזאת, מעבד המחשב יכול להוציא לפועל רק פקודות בשפה שנקראת שפת מכונה.
אלו פקודות ב-0 ו-1, וזאתי שפת מכונה בעצם. אנחנו צריכים עכשיו לבצע תרגום בין קוד ה-MSIL שכתוב בקובץ ה-Execution או ה-DLL לשפת מכונה, ואז להכניס את קוד המכונה למעבד המחשב.
אוקיי, זאת אומרת אם יש לנו את קובץ ה-execution הזה ואנחנו לוחצים עליו double-click מה שאנחנו עושים בעצם אנחנו מריצים אותו executing.
ברגע שאנחנו עושים את זה קובץ ה-exe הזה או ה-dll נכנסים ליחידה בתוך המחשב שנקראת common language runtime. זה בעצם הרכיב שהולך לתרגם לנו את msil לקוד המכונה.
common language runtime מורכב מכמה חלקים, יש לו שני חלקים מרכזיים, יש לו את ה-class loader שטוען את אותה מחלקה שאנחנו כרגע רוצים להריץ או לבצע, וברגע שהוא מגיע לפקודה מסוימת שנדרשת להרצה הוא מכניס את אותה פקודה לאזור אחר שנקרא just-in-time JIT והרכיב הזה מוציא מהצד השני שלו את קוד המכונה של אותה פקודה שכרגע הוא
מתרגם, במהלך הריצה. רק ברגע שהוא מגיע לפקודה שאותה הוא צריך לתרגם, אז הוא מתרגם אותה.
אם הוא לא מגיע לפקודה, הוא לא מתרגם אותה. אבל אם הוא תרגם אותה, אז הוא שומר אותה בצד באיזשהו זיכרון, בכדי לא לתרגם אותה בפעם הבאה שנרצה להריץ אותה. מכאן השפת מכונה הזאת נכנסת ישירות למעבד המחשב ל-CPU.
כך יש לנו פה הרצה של קובץ ה-execution שלב שלב, שהפקודות נכנסות ל-CPU, זאת אומרת אם אנחנו כתבנו בקוד ה-C-Sharp שלנו את הפקודה if A גדול מ-B אז תכניס לתוך C את המספר 8 הפקודה הזאת מ-C-Sharp עוברת תרגום ל-MSIL ונמצאת בתוך האסמבלי כאשר אנחנו מריצים את זה המחלקה נטענת דרך הקלאס לאודר ורק כאשר אנחנו באים להריץ את הפקודה if a
גדול מ-b אז ה-just-in-time מתרגם אותה לקוד מכונה ומוציא אותה לפועל. כמובן אם יש לנו בתוכו את הפקודה c שווה 8 אין שום בעיה, הפקודה הזאת גם כן מתורגמת לשפת מכונה והשפת מכונה הזאת מתבצעת על ידי המעבד של המחשב.
אבל הדוגמה שהראתי כרגע זה קוד שאנחנו כתבנו. מה קורה אם בתוך ה-c-sharp תובא לנו הפקודה console? קונסול נקודה רייטליין הלואו אז כמובן שהפקודה קונסול נקודה רייטליין הלואו זאת קריאה לפונקציה רייטליין שנמצאת במחלקה קונסול אז הפקודה הזאת של הקריאה
לפונקציה שכתובה בקובץ הפישראפ כמובן מתורגמת ל-MSIL ובתוך MSIL יש עכשיו את הקריאה לפונקציה רייטליין שנמצאת בתוך המחלקה קונסול אבל איפה הפונקציה רייטליין עצמה?
הרי יש פה קפיצה לפונקציה, אנחנו צריכים לתרגם את הפונקציה ולהוציא אותה לפועל. אז מה שקורה זה שקודם כל המחלקה Console והפונקציה Rightline לא נמצאות בקוד ה-C-Sharp שלנו, הן נמצאות באיזשהו DLL חיצוני שהוא חלק מהתשתית של .NET.
לכן אם ה-Classloader רואה שהוא צריך בעצם פונקציה שנמצאת באיזשהו DLL אחר, DLL חיצוני, הוא כמובן הולך וטוען את ה-DLL החיצוני, או ליתר דיוק את המחלקה שנמצאת ב-DLL החיצוני.
כל המחלקות של התשתית של .NET יושבות ב-DLLים שנמצאים באזור ה-Global Assembly Cache, או בקיצור GAC. אלו קבוצה של המון המון המון DLLים שבתוכם יש אלפים של אלפים של מחלקות תשתית של .NET, והן גם כן צריכות להיות לנו בתוך המחשב.
אם ה-Classloader רואה שהוא בעצם צריך DLL משמה, או ה-CLR רואה שיש פנייה או שימוש ב-DLL שנמצא בגג, אין שום בעיה.
גם כאן ה-DLL הזה או המחלקה הזאת נטענים לתוך ה-Classloader. אז במקרה של console.rightline כמובן שאנחנו מבצעים פה טעינה של המחלקה console, ויש לנו עכשיו אפשרות לבצע את הפונקציה rightline.
אוקיי, אם אנחנו מסתכלים על כל התרשים הזה, מה בעצם צריך להיות אצלנו במחשב של הפיתוח? במחשב הפיתוח אנחנו צריכים את כל מה שאנחנו רואים פה בתרשים. אנחנו צריכים את visualstudio.net בכדי לכתוב קוד C-Sharp.
אנחנו צריכים את שפת C-Sharp. אנחנו צריכים את הקומפיילר בשביל להמיר את הקוד שכתבנו לקובץ האסמבלי. אנחנו צריכים את ה-CLR בשביל להריץ ואת הגג וכל מה שיש פה אנחנו צריכים.
אבל אם אנחנו מסתכלים על הלקוח הסופי, End-User, מה הוא צריך שיהיה לו במחשב בכדי שהוא יוכל להריץ את האפליקציה שכתבנו לו. הרי האנד יוזר לא צריך את ויז'ואל סטודיו ולא צריך את שפת C-Sharp כי הוא לא הולך לתכנת C-Sharp, הוא לא צריך את הקומפיילר.
כל מה שהוא מקבל מאיתנו זה את קובץ האקסקיושן, או קובץ אקסקיושן וסדרה של DLLים, כנראה שאנחנו ניתן לו את הכל בעזרת ערכת התקנה שתתקין לו את זה במחשב.
אז הוא מקבל את קובץ האקסקיושן, לוחץ עליו דאבל קליק והקובץ רץ. כאן מה הוא חייב שיהיה לו במחשב בכדי שבכלל הקובץ הזה יוכל לרוץ. אז כמו שאתם רואים הוא חייב שיהיה לו את רכיב ה-CLR במחשב והוא חייב שיהיה לו גם את ה-גאק במחשב.
כל ה-DLLים שאינם התשתית של .NET חייבים להיות לו אישית בתוך המחשב ולא בשום מחשב אחר, ממש אישית אצלו במחשב, אפילו שאנחנו לא השתמשנו עם כל התשתית של .NET והשתמשנו רק במחלקה אחת.
עדיין הדבר הזה חייב להיות לו בתוך המחשב. אז איך הוא משיג את שני הדברים האלה? האם זה אוטומטית קיים לו במחשב ברגע שהוא מתקין מערכת ההפעלה? מה זה הדבר הזה?
אז שני הרכיבים האלה, ה-CLR והגה, נמצאים בתוך ערכה אחת שנקראת פריימוורק. אם שמעתם פעם את השם פריימוורק, פריימוורק זה סך הכל ערכת התקנה חינמית שניתן להורדה מהאתר של מיקרוסופט, כל מה שיש בה זה שני חלקים מרכזיים שנקראים CLR ו-GAC.
אם היוזר מתקין את הפריימוורק אז יש לו את ה-CLR ואת ה-GAC והוא יכול להריץ אפליקציות שלנו. יש פה כמובן את ה-issue של הגרסאות שכבר אנחנו הולכים להיכנס אליו אבל הלקוח חייב שיהיה לו את הפריימוורק הנכון מותקן אצלו במחשב בכדי שהוא יוכל בכלל להריץ את קובץ ה-execution שאנחנו נותנים לו לתרגם אותו
וכמובן להשתמש בכל המחלקות שנמצאות בגג. אז אחרי שהכרנו את כל המונחים הבסיסיים האלה של .NET אנחנו הולכים לראות את הגרסאות השונות אבל שנייה לפני שנראה את הגרסאות השונות שקיימות כאן בואו נבין שיש פה כמה דברים שונים בתרשים הזה שאנחנו רואים.
קודם כל יש לנו את visualstudio.net visualstudio.net זאת סביבת הפיתוח. יש לנו את ה-framework שמכיל את ה-CLR ואת הגג ויש לנו את FAT C-Sharp שאיתה אנחנו מתכנתים.
כל אחד משלושת המרכיבים האלה יכול להשתדרג לגרסה עדכנית יותר או גרסה אחרת. אבל מה המשמעות של השדרוג של כל אחד מהם? אז אנחנו יכולים לראות לפי ההיגיון שאם מייקרוסופט משדרגים את visualstudio.net זה אומר שהם שדרגו את סביבת הפיתוח, וזה יכול להיות שהם שיפרו את האינטליסנס שמציע לנו הצעות, זה יכול להיות שהם שיפרו
את התיעוד שהאינטליסנס מראה לנו, זה יכול להיות שהם הוסיפו לנו כל מיני חלוניות בתוך ויז'ואל סטודיו בכדי שיהיה לנו יותר קל לתכנת כלים נוספים ששייכים לסביבת הפיתוח, את הצבע של סביבת הפיתוח.
כל הדברים האלה שייכים לvisualstudio.net כסביבת פיתוח. אם מייקרופופט משדרגים את הפריימוורק זה אומר או שהם שדרגו את ה-CLR ועשו אותו יותר יעיל יותר חסכוני וכולי או שהם שדרגו את הגג מה זה אומר לשדרג את הגג זה אומר להוסיף עוד DLLים ועוד מחלקות תשתית של .NET כך שיהיה לנו
יותר תשתית לעבוד איתה כדי שנכתוב פחות קוד ולבסוף מה זה אומר שמייקרוסופט משדרגים את C-Sharp. אז ממה מורכבת C-Sharp? C-Sharp מורכבת מסדרה של מילים שמורות של שפת התכנות וסדרה של סימנים.
לדוגמה, נקודותיים וסימן של הורשה. לדוגמה, סוגריים משולשים וסימן של ג'נריק. אז אם אנחנו משדרגים את C-Sharp זה אומר שאנחנו מוסיפים עוד מילים שמורות לשפת התכנות, עוד סימנים לשפת התכנות.
אחרי שאנחנו מבינים את שלושת המרכיבים האלה, .NET עצמה זה סך הכל שלושת אלה. .NET זה שם שמכיל בתוכו את Visual Studio .NET, את הפריימורק, את שפת C-Sharp, שפות אחרות ואת כל הקונספט התכנותי הזה.
עכשיו אנחנו יכולים לעבור ולראות את הגרסאות השונות. אז אנחנו ב- .NET ורז'נס. אז קודם כל, כאשר אנחנו מדברים על גרסאות, אנחנו בעצם צריכים לעשות את ההבדלה בין גרסה שהיא visualstudio.net סביבת הפיתוח לגרסה שהיא framework לגרסה שהיא c-sharp ונראה גם את התוספת המרכזית או השדרוג המרכזי שיש בכל אחת מהגרסאות.
אז הגרסה הראשונה יצאה ב-2002 ונקראה visualstudio.net 2002. הפריימורק שיצא הייתה נקרא 1.0 שפת התכנות נקרא c-sharp ופשוט מאוד זאת הייתה הגרסה הראשונה שוויז'ואל סטודיו יצאה לעולם בגרסה הרשמית.
ב-2003 היה שדרוג של visualstudio.net ולכן היא נקראה vs.net/2003. הפריימוורק שודרגה ל-1.1, C-sharp נשארה C-sharp, אבל השדרוג היה פשוט מאוד שיפור מסוים שהתבצע ב-CLR.
זאת הסיבה שהפריימוורק השתדרגה. בוויז'ואל סטודיו שיפרו טיפה את האינטליסנס. ב-2005 visualstudio.net יצא כ-visualstudio.net 2005 הוסיפו המון מחלקות חדשות שקשורות בעולם ה-Web ב-asp.net, המון מחלקות שקשורות ב-ado.net ולכן הפריימוורק שודרגה כי הוסיפו מחלקות ל-גאק ואנחנו רואים 2.0 זה היה שדרוג יותר משמעותי מבחינת הפריימוורק.
אבל מה שמעניין לראות זה למה C-Sharp שודרגה. ובכן השיפור המרכזי שהתבצע ב-2005 היה הוספה של ג'נריקס שלא היו לפני זה. ג'נריקס מורכבים מהסימן של הסוגריים המשולשים, לכן היו צריכים ללמד את הקומפיילר של C-Sharp להבין מה זה הסימן של הסוגריים המשולשים, וזאת הסיבה שהיו צריכים לשדרג את שפת התכנות
C-Sharp, שמאז נקראת C-Sharp 2, או שליתר דיוק בשדרוג הזה נקראה C-Sharp 2. לאחר מכן היה שדרוג נוסף של הפריימורק, שהפכה לפריימורק 3.0, C-Sharp עדיין נשארה C-Sharp 2. אבל מה שהוסיפו זה מגוון של מחלקות תשתית שמייצרות לנו את האפשרות להשתמש בשלושה פרויקטים
מרכזיים WCF שזה Windows Communication Foundation שזה בעצם אפשרות לבנות סרוויסס ותקשורת בין מחשבים בעזרת הפרויקטים הללו והמחלקות הללו WPF זה Windows פרזנטיישן ופאונדיישן זה בעצם סדרה של מחלקות