Transcript Slide 1

‫‪ASP.NET‬‬
‫מעבדת ‪DBMS‬‬
‫הדס גרוסמן‬
‫‪2007‬‬
‫‪.NET Platform‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫הרעיון העומד מאחורי ‪ .NET‬של ‪ Microsoft‬הוא הסטת מוקד‬
‫התכנות מעולם שבו התקנים יחידים ואתרי ‪ WEB‬מחוברים זה לזה‬
‫באופן פשוט באמצעות האינטרנט‪ ,‬אל עולם שבו התקנים‪ ,‬שירותים‬
‫ומחשבים פועלים יחד בכדי לספק פתרונות מלאים עבור‬
‫משתמשים‪.‬‬
‫פלטפורמת ‪ .NET‬מספקת את כל הכלים והטכנולוגיות הנחוצים‬
‫לבניית אפליקציות ‪WEB‬יות מבוזרות‪.‬‬
‫היא חושפת אי תלות בשפה ומתודולוגית תכנות עקבית על פני כל‬
‫הנדבכים )‪ )tiers‬של האפליקציה ובו בזמן מספקת אפשרות‬
‫להפעלת והשמשת טכנולוגיות קיימות וכמו כן הגירה )‪(migration‬‬
‫פשוטה מהן‪.‬‬
‫פלטפורמת ‪ .NET‬תומכת במלואה בטכנולוגיות אינטרנט קיימות‪.‬‬
‫כולל‪ XSLT ,SOAP ,XML ,HTML :‬וכו'‬
‫‪The .NET Framework‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫פלטפורמת ‪ .NET‬מספקת מספר טכנולוגיות מרכזיות שהן לב ליבה של ‪, .NET‬‬
‫פלטפורמה זו מתייחסת לכל הטכנולוגיות המרכיבות את סביבת העבודה החדשה‬
‫ליצירה ולהפעלה של יישומים בעלי עוצמה ומבוזרים‪ ,‬הניתנים להרחבה‪ .‬החלק‬
‫של ‪ .NET‬המאפשר לנו לפתח יישומים אלה היא סביבת העבודה ‪.NET‬‬
‫סביבת העבודה (מסגרת) ‪ .NET‬מספקת את יסודות זמן הקומפילציה וזמן הריצה‬
‫ההכרחיים לבנייה והרצה של אפליקציות מבוססות ‪.NET‬‬
‫‪ - Platform substrate‬סביבת העבודה ‪ .NET‬נבנתה לרוץ על מערכות‬
‫הפעלה ‪.Microsoft win32‬‬
‫‪ - Application Services‬ניתן לפנות ולהשתמש בשירותים שונים של מערכת‬
‫ההפעלה דרך מחלקות מובנות שמוגדרות ב – ‪(Base Class Library) BCL‬‬
‫‪‬‬
‫‪Common Language Runtime – CLR‬‬
‫ה – ‪ CLR‬היא סביבת ריצה שבה יישומים שנכתבו בשפות שונות יכולים‬
‫לפעול יחד ולהסתדר בצורה טובה‪ .‬יכולת זו ידועה גם בשם תפעוליות‬
‫שיתופית בין שפות )‪.(cross language interoperability‬‬
‫‪ CLR‬מספקת סביבה נוחה זו עבור יישומים משפות שונות בעזרת אוסף‬
‫חוקים הנקרא ‪.(Common Language Specifications) CLS‬‬
‫כל מהדר שפה חייב לציית לחוקים אלה כדי שיוכל ליצור יישומי ‪.NET‬‬
‫הפועלים ב – ‪ .CLR‬כלומר‪ ,‬לפעול בצורה תקינה לצד כל יישום ‪ .NET‬אחר‬
‫ובאותה מידה של שיתופיות‪.‬‬
‫ה – ‪ CLR‬מפשטת פיתוח אפליקציות‪ ,‬מספקת סביבת ריצה איתנה‬
‫ומאובטחת‪ ,‬תומכת במס' שפות ומפשטת פריסה וניהול של אפליקציות‪.‬‬
‫ה‪ CLR -‬מיוחסת גם כסביבה מנוהלת )‪ (managed environment‬שבה‬
‫שירותים משותפים שמסופקים אוטומטית ‪ ,‬כמו‪garbage collection :‬‬
‫ושירותי אבטחה‪.‬‬
‫בסביבת קוד מנוהל נקבעו מספר חוקים בכדי להבטיח שכל היישומים יתנהגו‬
‫באופן אחיד ברמה הגלובלית‪ ,‬בלי להתחשב בשפות שבהן הם נכתבו‪ .‬חוקים‬
‫גלובליים אלו משפיעים בעיקר על כותבי המהדרים‪.‬‬
‫‪‬‬
‫‪ – .NET Framework Class Library‬ספריות המחלקה‬
‫בסביבת העבודה ‪ .NET‬חשובות מאד ליכולת השיתופיות בין‬
‫יישומים‪ ,‬כי הן מאפשרות להשתמש בממשק תכנות יחיד לכל‬
‫הפונקציונאליות ש‪ CLR -‬חושפת‪.‬‬
‫אוסף ספריות משותף פירושו שמבחינה תיאורטית‪ ,‬כל השפות הן‬
‫בעלות יכולות זהות כי כולן חייבות להשתמש בספריות מחלקה אלו‬
‫כדי לבצע כל משימה‪ ,‬חוץ מהצהרה על משתנים‪.‬‬
‫‪‬‬
‫‪ – System Namespaces‬מכיל מחלקות בסיסיות לשימוש ע"י המפתח‪ .‬כמו‬
‫מחלקות להגדרת ‪ ,reference or value data types‬מחלקות להגדרה‬
‫וטיפול באירועים‪ ,‬מחלקות למניפולציות מתמטיות‪ ,‬חריגות‪ ,‬מאפיינים‪,‬‬
‫המרות‪.‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ – System.collection‬רשימות ממוינות ‪ ,‬טבלאות גיבוב ודרכים נוספות לאסוף‬
‫מידע‬
‫‪ input – System.io‬ו‪output -‬‬
‫‪ – System.net‬מספקת מתודות להעברת מידע דרך פרוטוקולי אינטרנט‬
‫)‪(tcp/ip‬‬
‫‪‬‬
‫‪ – ADO.NET‬הדור הבא של טכנולוגיית ‪Microsoft ActiveX‬‬
‫‪ .Data Object‬מספקת תמיכה משופרת למודלי תכנות לא‬
‫מקושרים ותמיכה נרחבת ב – ‪.XML‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ – System.data‬מכיל מחלקות להגדרת אובייקטים עבור ה‪ ADO.NET -‬כמו‬
‫‪ DataSet‬אשר מציג מס' רב של טבלאות וקשרים בינהם‪.‬‬
‫‪ – System.xml‬מספק תמיכה עבור ‪.XML‬‬
‫‪ – XML Web Services‬אלו הם רכיבי תכנות ‪WEB‬ים שיכולים‬
‫להיות משותפים על פני אפליקציות באינטרנט או באינטראנט ‪.‬‬
‫סביבת העבודה ‪ .NET‬מספקת כלים ומחלקות לבנייה‪ ,‬בדיקה‬
‫וביזור של שירותי ‪WEB XML‬ים‪.‬‬
‫‪‬‬
‫‪ – ASP.NET‬סביבת עבודה תכנותית שבנויה על ה – ‪ . CLR‬ניתנת לשימוש‬
‫בשרת עבור בניית אפליקציות ‪WEB‬יות בעלות עוצמה‪.‬‬
‫‪ ASP.NET Web Forms‬מספקת דרך קלה ובעלת עוצמה לבניית ממשקים‬
‫‪WEB‬ים דינאמיים למשתמשים‪.‬‬
‫‪‬‬
‫‪‬‬
‫‪ – System. web‬ב‪ namespace -‬זה יש שירותים ברמה בסיסית כמו‪,caching :‬‬
‫‪ configuration ,security‬ואחרים שמשותפים ל – ‪XML Web Services‬‬
‫ו – ‪.Web User Interface‬‬
‫* ‪ - system.web.services‬מחלקות וממשקים שמאפשרים תקשורת בין שרתים‬
‫ודפדפנים‪.‬‬
‫* ‪ – system.web.ui‬מחלקות וממשקים שמאפשרים יצירת ‪ controls‬ו – ‪pages‬‬
‫שיופיעו באפליקציה ‪WEB‬ית כממשק המשתמש‪.‬‬
‫‪ – User Interfaces‬סביבת העבודה ‪ .NET‬תומכת ב‪ 3-‬סוגים של ממשקים‬
‫למשתמש‪:‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ – Web Forms‬טפסים שעובדים דרך ‪ASP.NET‬‬
‫‪ – Windows Forms‬טפסים שרצים על מחשבי לקוחות )‪(win32‬‬
‫‪Console Applications‬‬
‫‪‬‬
‫‪‬‬
‫‪ – System.windows.forms‬מחלקות לבניית ממשק המשתמש‬
‫‪ – System.drawing‬מחלקות לבניית פונקציונליות גרפיות‪.‬‬
‫‪‬‬
‫‪ – Languages‬כל שפה שמתאימה לחוקים שנקבעו ב – ‪CLS‬‬
‫יכולה לרוץ ב‪.CLR -‬‬
‫‪ Microsoft‬סיפקה לסביבת העבודה ‪ .NET‬את השפות הבאות‪:‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ - C#‬עוצבה ופותחה עבור פלטפורמת ה ‪ .NET -‬והיא השפה החדשה‬
‫הראשונה שהיא ‪ component oriented‬במשפחת השפות ‪ C‬ו‪.C++ -‬‬
‫היא יכולה להיות משולבת בדפי ‪.ASP.NET‬‬
‫‪ , Managed Extensions to C++ - C++‬הרחבה זו מספקת גישה‬
‫לסביבת העבודה של ‪.NET‬‬
‫‪ – VB.NET‬חידושים לשפת ‪ , VB‬כמו תמיכה בהורשה ‪ ,‬בנאים‪ ,‬רב צורתיות‪,‬‬
‫חריגות וכו'‬
‫‪Jscript.NET‬‬
‫‪ – Visual J#.NET‬כלי פיתוח עבור מפתחים בשפת ‪ Java‬שרוצים לבנות‬
‫אפליקציות ושירותים בסביבת העבודה ‪.NET‬‬
‫‪ – Third – party languages‬מספר שפות צד שלישי נתמכות‬
‫בפלטפורמת ‪ .NET‬כמו‪. Scheme ,Perl ,Pascal ,COBOL ,APL :‬‬
‫‪Benefits of the .NET Framework‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ – Based on web standards and practices‬סביבת העבודה ‪ .NET‬תומכת‬
‫במלואה בטכנולוגיות אינטרנט קיימות‪.‬‬
‫‪ – Designed using unified application models‬הפונקציונאליות של מחלקות‬
‫‪ .NET‬זמינה מכל שפה שתואמת את אוסף החוקים ב – ‪.CLS‬‬
‫‪ – Easy for developers to use‬בסביבה זו‪ ,‬הקוד אורגן באופן היררכי של‬
‫‪ namespaces‬ו – ‪.classes‬‬
‫אחת מתכונות המפתח של כל סביבת פיתוח היא מערכת סוגי הנתונים שלה‪ .‬ה –‬
‫‪ CLR‬של ‪ .NET‬נותנת יותר מאשר מערכת סוגים יחידה ואחידה הניתנת לשימוש‬
‫בכל השפות התואמות ‪ ,CLS‬היא גם מאפשרת למפתחי שפות להרחיב את‬
‫מערכת הסוגים ע"י הוספת סוגים חדשים הנראים והפועלים כמו הסוגים המובנים‬
‫במערכת‪.‬‬
‫הסוגים החדשים ניתנים לשימוש כמו הסוגים המובנים ‪ ‬שימוש בכל סוגי‬
‫הנתונים באופן אחיד‪.‬‬
‫‪ – Extensible classes‬ההיררכיה של סביבת העבודה ‪ .NET‬לא מוסתרת‬
‫מהמפתחים‪ ,‬ניתן לגשת ולהרחיב את מחלקות ‪ .NET‬ע"י הורשה‪ .‬בנוסף ניתן גם‬
‫לממש הורשה בין שפות שונות‪.‬‬
‫הקדמה‬
‫כיצד פועלים דפי האינטרנט )‪?(WEB‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫אתרי ‪ Web‬היו פשוטים מאד במקור‪ .‬הם היו מבוססים על דפי ‪ HTML‬שהיו קיימים‬
‫כמעט בכל נושא שניתן להעלות על הדעת‪ .‬דפים אלו היו סטטיים והניגשים אליהם לא‬
‫יכלו לפעול עליהם באופן אינטרקטיבי בכל דרך שהיא – דבר שהיווה מגבלה חמורה‬
‫על סוגי האתרים השונים‪.‬‬
‫על פי שיטה זו כל הקוד היה כתוב ב‪ HTML -‬או סקריפטים והיה מעובד רק בצד‬
‫הלקוח‪.‬‬
‫האינטרנט פועל לפי מודל שרת‪/‬לקוח‪ :‬שני מחשבים פועלים יחדיו ושולחים הודעות זה‬
‫לזה‪ .‬מחשב לקוח שולח בקשה למידע אל מחשב השרת‪ ,‬מחשב השרת מגיב לבקשה‬
‫זו על ידי סיפוק המידע שנדרש (תבנית בקשה‪/‬תגובה)‪.‬‬
‫שרת ‪ – )Web Server( Web‬הוא מחשב המכיל תוכנת ניהול מתאימה לתוכן האתר‪:‬‬
‫דפי ‪ , HTML‬תמונות ועוד‪ .‬הלקוח הוא המבקר באתר (הכוונה היא לדפדפן)‪.‬‬
‫מודל בקשה‪/‬תגובה‬
‫‪REQUEST‬‬
‫‪Server‬‬
‫‪RESPONSE‬‬
‫‪Browser‬‬
‫למרות שזו דרך נפלאה לתקשר ולהפיץ מידע‪ ,‬עדיין היא סטטית ופשוטה‬
‫למדי ואינה מסוגלת לספק כל מידע או עיבוד דינאמי‪ .‬השרת ממתין‬
‫שהלקוח יבקש נתונים או מידע‪ ,‬וכשמגיעה הבקשה הוא שולח את‬
‫הנתונים שבדיסק מבלי להתבונן או לחקור אותם‪.‬‬
‫באופן כללי‪ ,‬בקשת ‪ Web‬סטטית מורכבת מ‪ 4 -‬שלבי פעולה‪:‬‬
‫‪ .1‬הלקוח (דפדפן ‪ )web‬מאתר את שרת ה‪ web -‬באמצעות ה‪URL -‬‬
‫(כתובת אינטרנט) שלו‪.‬‬
‫‪ .2‬הלקוח מבקש דף (לדוגמא ‪)index.html‬‬
‫‪ .3‬השרת שולח את המסמך המבוקש‪.‬‬
‫‪ .4‬הלקוח מקבל את המסמך ומציג אותו‪.‬‬
‫ברגע שהלקוח קיבל את המידע‪ ,‬הסתיים התהליך‪ .‬לשרת אין כל מושג על‬
‫מה שמתרחש במחשב הלקוח לאחר קבלת הנתונים‪ .‬הם מקושרים‬
‫ביניהם רק בזמן תהליך בקשה‪/‬תגובה וברגע שהדף הועבר ליעד‪,‬‬
‫השרת אינו עוקב יותר אחרי המתרחש‪.‬‬
‫עיבוד שרת )‪ – (Server Processing‬נעשה בדרכים שונות‪,‬‬
‫ביניהן ממשק שער משותף ‪(Common Gateway Interface) CGI‬‬
‫והתוכנה ‪ (Active Sever Pages) ASP‬של ‪ Microsoft‬שכעת מייחסים‬
‫לה את השם ‪ ASP‬הקלאסית‪.‬‬
‫בתסריט זה השרת בוחן את מה שהוא שולח לפני שהוא שולח אותו בפועל‬
‫והוא גם מסוגל לקבל פקודות מהלקוח‪ .‬שרת מסוגל לספק מידע דינמי‬
‫וכל בקשה מהלקוח‪.‬‬
‫הפעולות מבוצעות בסדר הבא‪:‬‬
‫‪ .1‬הלקוח (דפדפן ‪ )web‬מאתר את שרת ה‪ web -‬באמצעות ה‪URL -‬‬
‫(כתובת אינטרנט) שלו‪.‬‬
‫‪ .2‬הלקוח מבקש דף (לדוגמא ‪)index.html‬‬
‫‪ .3‬השרת בוחן את הקובץ המבוקש ומבצע את הקוד שקובץ זה מכיל‪.‬‬
‫‪ .4‬השרת מתרגם את תוצאות העיבוד ל‪( HTML -‬במידת הצורך) ושולח‬
‫את‬
‫המסמך המבוקש ללקוח‪.‬‬
‫‪ .5‬הלקוח מקבל את המסמך ומציג אותו‪.‬‬
‫גם בתסריט זה מסתיים התהליך ברגע שהלקוח מקבל את הדף‪ .‬השרת‬
‫אינו מודע למעשי הלקוח אלא אם הלקוח מגיש בקשה נוספת‪.‬‬
‫ואיך זה מתבצע ב‪?ASP.NET -‬‬
‫קיים מודל אחר לתקשורת בין שרתים ולקוחות‪ ,‬שנקרא מודל מונחה אירועים‬
‫)‪.(Event-Driven Model‬‬
‫השרת ממתין שמשהו יתרחש במחשב הלקוח‪ .‬ברגע שיש התרחשות במחשב‬
‫הלקוח‪ ,‬השרת מבצע פעולות מסוימות‪.‬‬
‫מודל זה פשוט בהרבה לבניית יישומים מאשר שימוש בתסריט של בקשה‪/‬תגובה‬
‫המקובל‪.‬‬
‫‪ ASP.NET‬פועלת בשיטה זו – היא מתארת פעולות ומגיבה עליהן‪.‬‬
‫היא מסתמכת על עיבוד לקוח פיקח )‪ (clever client processing‬כדי לחקות מודל‬
‫מונחה אירועים‬
‫עיבוד בצד הלקוח‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫עיבוד בצד הלקוח יתרחש ברגע שנוסיף לדף ‪ HTML‬קוד תכנות שהלקוח‬
‫מסוגל להבין‪ .‬זהו למעשה תסריט ‪ (script) HTML‬שהדפדפן מסוגל‬
‫להפעיל‪.‬‬
‫קוד בצד הלקוח מופעל בדר"כ באמצעות ‪.JavaScript‬‬
‫דוגמא‪:‬‬
‫>‪<html‬‬
‫>‪<head‬‬
‫>”‪<script language=“JavaScript‬‬
‫‪<!-‬‬‫;)”‪alert(“Hello World‬‬
‫>‪//--‬‬
‫>‪</script‬‬
‫>‪</head‬‬
‫>‪<body‬‬
‫‪Welcome To My First Page‬‬
‫>‪</body‬‬
‫>‪</html‬‬
‫‪1.‬‬
‫‪2.‬‬
‫‪3.‬‬
‫‪4.‬‬
‫‪5.‬‬
‫‪6.‬‬
‫‪7.‬‬
‫‪8.‬‬
‫‪9.‬‬
‫‪10.‬‬
‫‪11.‬‬
‫‪12.‬‬
‫‪‬‬
‫‪‬‬
‫כעת ניתן להפעיל פקודות בשני מקומות‪ :‬בשרת‪ ,‬כאשר הכל‬
‫מוחזר ללקוח כ – ‪ , HTML‬או בלקוח‪ .‬עם זאת‪ ,‬שני מקומות אלו נפרדים‬
‫ואינם מסוגלים לתקשר זה עם זה‪.‬‬
‫תיאור ההבדלים הין צד הלקוח לצד השרת‪:‬‬
‫מיקום‬
‫תיאור‬
‫צד הלקוח קוד זה כלל אינו מבוצע ע"י השרת‪ .‬הוא מבוצע בצד הלקוח ובאחריותו‬
‫בלבד‪ .‬קוד זה נכתב בדר"כ בשפת ‪ JavaScript‬כדי לבדוק תקינותם של‬
‫טפסים‪ ,‬או שינויים במראה ובתוכן הדף – דבר הידוע בשם ‪Dynamic‬‬
‫‪.HTML‬‬
‫צד השרת קוד זה מופעל בשרת בלבד‪ .‬כל מידע שמייצר קוד זה מומר לתסריט‬
‫‪ HTML‬לפני שהוא נשלח אל הלקוח‪.‬‬
‫ניתן לכתוב קוד בעזרת ‪-script‬ים ב‪ , VBScript -‬אבל ‪ASP.NET‬‬
‫משתמשת בשפות שיש להדר לשם הרצה במחשב‬
‫(כל שפה שהיא ‪).NET‬‬
‫קוד בצד השרת משמש לעיבוד תוכן והחזרת נתונים‪.‬‬
‫כיצד ‪ ASP.NET‬משלבת הכל יחד?‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫הדרך היחידה בה יכול לקוח לתקשר עם השרת היא באמצעות בקשה‬
‫)‪ . (Request‬הבקשה יכולה להיות בקשה יזומה – כמו לחיצת לחצן ‪ ,‬או‬
‫יוזמה של המערכת‪.‬‬
‫במקרה של יוזמת המערכת הדפדפן מבצע קוד תסריט בצד הלקוח ושולח‬
‫הודעה שהיא בקשה לשרת‪ .‬פעולה זו מתבצעת ע"י סוכנים‪.‬‬
‫הסוכנים של ‪ ASP.NET‬הם תסריטים בצד הלקוח‪ .‬בכל פעם שקורה משהו‬
‫בצד הלקוח‪ ,‬מופעל בו תסריט ושולח מידע לשרת (כמו שמשלוח טופס‬
‫מעביר מידע לשרת)‪ .‬הדפדפן הוא שותף לא מודע לפעולה זו – התסריט‬
‫בצד הלקוח אינו יכול לתקשר עם השרת אך הוא יכול לשלוח לו הודעות‬
‫באמצעות הרשת‪.‬‬
‫לכן‪ ASP.NET ,‬מחברת יחדיו את השרת והלקוח ‪ ,‬וכך המפתחים יכולים‬
‫לבצע בדפי ‪ Web‬פעולות שלא התאפשרו בעבר‪ .‬קיימת אפשרות להגיב‬
‫לארועים מצד המשתמש באופן מיידי ולא לחכות למשלוח טפסים‪.‬‬
‫מאפייני טכנולוגיית ‪: .Net‬‬
‫‪‬‬
‫)‪:CLR (Common Language Runtime‬‬
‫ב‪ .NET-‬ניתן לכתוב בכל שפה‪ ,‬כל עוד היא נתמכת ב‪ ..NET-‬כל התוכנות ב‪-‬‬
‫‪ .NET‬רצות תחת אותה סביבה (ששמה ‪ .)CLR‬ב‪ CLR-‬מוגדרים‪ ,‬לדוגמא‪,‬‬
‫טיפוסי נתונים בסיסיים‪ ,‬ש ‪ .NET‬דורש שכל השפות יתמכו בהם‪ .‬ה‪CLR-‬‬
‫כולל בתוכו גם את ה‪ ,Garbage Collector-‬ואחראי על הרצת ה‪. MSIL-‬‬
‫‪‬‬
‫‪:Managed Code‬‬
‫קוד שבו יש אובייקטים (כלומר‪ ,)OOP ,‬אבל אין צורך ל"נקות" בו את‬
‫האובייקטים‪ .‬עד עכשיו‪ ,‬ב‪ VB-‬או ב‪ ,C++-‬היינו חייבים לנקות כל אובייקט‬
‫שהיינו יוצרים‪ ,‬כדי לחסוך במשאבים יקרים‪ .‬פקודות "ניקיון" אופייניות הן‬
‫‪ delete‬או ‪ -set obj = nothing‬לעומת ה‪ ,.NET‬בו לא קיים הצורך לסגור‬
‫את האובייקטים‪ .‬הניקיון מתבצע ע"י ה"‪ - "Garbage Collector‬מודול של ה‪-‬‬
‫‪ ,CLR‬שאחראי לניקוי כל האובייקטים שתוכניות רצות יוצרות‪.‬‬
‫‪‬‬
‫‪:Intermediate Language‬‬
‫הידור קוד ב‪ .NET‬איננו מתבצע לשפת מכונה אלא ל"שפת ביניים"‪ .‬שפת ביניים‬
‫זו נקראת ‪ ,Intermediate Language‬או בקיצור‪ .MSIL ,‬לאחר מכן‪ ,‬הקוד של‬
‫שפת הביניים הזאת עובד הידור בזמן ריצה לשפת מכונה ע"י מנגנון שנקרא‬
‫‪ ,Just In Time compiler‬או בקיצור ‪ .JIT -‬תכונה זו מאפשרת לכתוב את הקוד‬
‫בכל שפה שהיא‪ ,‬וגם מאפשרת ל"ערבב" שפות‪ .‬ניתן‪ ,‬למעשה‪ ,‬להשתמש‬
‫ב‪ .NET‬בכל שפה שהיא‪ ,‬כל עוד היא עונה על דרישותיה של ה‪Common -‬‬
‫‪ ,Language Specification‬או בקיצור ‪ .CLS‬ה‪ CLS-‬היא בעצם מערכת חוקים‬
‫שעל כל שפת ‪ .NET‬לעמוד בה‪ .‬תכונה זו גם מאפשרת שקוד מסוים יוכל להיות‬
‫מתאים ליותר ממערכת הפעלה אחת‪ .‬לדוגמא ‪ -‬כיום יש פרויקט שנקרא ‪,mono‬‬
‫אשר פועל להרצת ‪ .NET‬בלינוקס‪ .‬כמו כן‪ ,‬כך ניתן לכתוב בכל שפה שהיא ללא‬
‫איבוד ביצועים ביחס לשפה אחרת‪.‬‬
‫‪‬‬
‫‪:Class Library‬‬
‫ספרייה עצומה של פונקציות ומחלקות מערכת‪ .‬לכל תוכנית ב‪ .NET‬יש גישה‬
‫אליה‪ ,‬ובכל תוכנית ניתן להשתמש בה‪ .‬בתוך הספרייה נמצא את ‪ADO.NET‬‬
‫(שאחראית על גישה למסדי נתונים)‪ ,‬את האובייקטים של ‪( ASP.NET‬לבניית‬
‫אתרי ‪ ,)Web‬את הספרייה ‪ Windows.Forms‬השומרת בתוכה את כל‬
‫הפונקציות הבסיסיות של חלונות‪ ,‬ואת ‪ ,System.Net‬האחראית על תקשורת‪.‬‬
‫אלו היו דוגמאות בודדות בלבד‪ ,‬וככל שאדם ירבה להתעמק ב‪ ,.NET‬הוא יגלה‬
‫עד כמה אינסופית ועשירה היא הספריה הזאת‪.‬‬
‫תכונות נוספות הן תמיכה מובנית ב‪ ,XML, Web Services-‬ועוד‪.‬‬
‫לכל הרכיבים האלו ביחד קוראים ה‪.".NET Framework"-‬‬
‫ניתן לסכם את המבנה של ה‪ Framework‬בתרשים הבא‪:‬‬
‫בתחתית התרשים‪ ,‬נמצאת מערכת ההפעלה‪ ,‬שלמען האמת‪ ,‬יכולה להיות כל מערכת הפעלה‪.‬‬
‫מעליה‪ ,‬יש את ה‪ .CLR-‬כאמור‪ ,‬שכבה זו אחראית על ה"תקשורת" עם מערכת ההפעלה‪.‬‬
‫במילים אחרות‪ ,‬היא החוליה המקשרת בין תוכנת ה‪ .NET‬שלנו‪ ,‬לבין מערכת ההפעלה‪.‬‬
‫מעליה‪ ,‬באדום‪ ,‬נמצאים כל הרכיבים של ה‪ - Class Library-‬ביניהם ‪ ASP.NET‬ו‪.ADO.NET-‬‬
‫לאחר מכן‪ ,‬בכחול‪ ,‬נמצאות השפות שאיתן אנחנו כותבים את האפליקציות שלנו‪ .‬שפות אלו‬
‫חייבות לענות על דרישותיה של ה‪ .CLR-‬דרישות אלו נקראות ה‪ ,CLS-‬כמובא למעלה‪.‬‬
‫הקדמה ל‪ASP.NET-‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫ניתן לראות ב‪ ASP.NET-‬כמעין ממשיכה של ‪ ASP‬הקלאסי‪ .‬אולם‪ ,‬הדבר היחיד‬
‫המשותף שיש לשתי הטכנולוגיות הללו‪ ,‬הוא המטרה ‪ -‬שתיהן טכנולוגיות צד‬
‫שרת שמייצרות ‪ HTML‬ללקוח‪ .‬אבל פה בערך נגמר הדמיון‪ ,‬ומתחיל השוני‪.‬‬
‫‪ ASP.NET‬מציגה קונספציה ומודל שונה לגמרי מזה של ‪ ASP‬קלאסית‪ .‬למודל‬
‫קוראים ‪ ,WebForms‬והוא מציג גישה שלפיה השרת בעצם מודע לפקדים שעד‬
‫עתה טופלו ע"י הלקוח‪ .‬לדוגמא‪ ,‬ב‪ ASP-‬קלאסית השרת לא היה מודע כלל וכלל‬
‫לקיומו של תיבת‪-‬טקסט מסוימת‪ ,‬וה"תקשורת" עמה הייתה רק דרך משתני‬
‫‪( form‬או ‪ .)QueryString‬ב‪ ASP.NET-‬השרת מודע לקיומו של תיבת‪-‬הטקסט‬
‫הנ"ל‪ ,‬והוא זה שדואג לתרגם אותה ל‪ HTML-‬בהתאם‪ .‬השרת הפך להיות‬
‫ל"שרת חכם"‪ ,‬שיודע מה יש בלקוח‪ ,‬לעומת "שרת עיוור" שאין לו מושג מה קורה‬
‫בלקוח‪ .‬מודל זה אולי ייראה קצת מעוות ולא‪-‬נכון בתחילה‪ ,‬אך עם הזמן‪ ,‬ולאחר‬
‫לימוד של המודל‪ ,‬ניתן יהיה להבין את הרעיון שעומד מאחורי התפיסה הזאת‪.‬‬
‫‪ ASP.NET‬היא חלק מה‪ - .net Framework-‬וזה אומר שיש לה מאחוריה את כל‬
‫ה‪ Class Library-‬של ‪ ,.NET‬ניתן לכתוב אותה בכל שפה שמתאימה ל‪.NET‬‬
‫(‪ VisualBasic.net, C#, C++, JScript.net‬ועוד)‪ ,‬והיא עוברת הידור לפני‬
‫הפעלתה (כלומר המחשב צריך לתרגם אותה ל‪ ,IL-‬ולאחר מכן לשפת מכונה)‪,‬‬
‫בניגוד ל‪ ASP-‬קלאסית‪ ,‬שבה השתמשנו בשפות סקריפט שאינן מתהדרות‪ .‬זה‬
‫יתרון עצום‪ ,‬כיוון שעכשיו ניתן לכתוב גם אפליקציות "כבדות" יחסית‪ ,‬והן מורצות‬
‫ממש על ה‪ ,CLR-‬במקום אינטרפרטציה על מנוע ה‪ ASP-‬הרגיל‪.‬‬
‫המשך ‪...ASP.NET‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ ASP.NET‬היא לא שפת תכנות אלא טכנולוגיה שמשתמשת בשפות תכנות‬
‫קיימות‪ .‬זוהי סביבת עבודה שבנויה על ה ‪ .NET -‬ומשמשת לבניית‬
‫אפליקציות ‪Web‬יות‪.‬‬
‫בטכנולוגיה זו כל דבר הוא אובייקט ‪ .‬כאשר אובייקט הוא מופע של מחלקה‬
‫כלשהי המאגדת תחתיה משתנים‪ ,‬מאפיינים ופונקציות המשמשים להפעלת‬
‫והשמשת האובייקט‪.‬‬
‫טכנולוגיה זו מכילה אובייקטים מוכנים שמכילים מתודות המאפשרות את‬
‫הפונקציונאליות שלהם‪.‬‬
‫בדומה ל‪ ASP -‬ששם היו אובייקטים‪:‬‬
‫‪ Response‬ו – ‪ Request‬לדוגמא שאפשרו העברת אינפורמציה מהשרת‬
‫ללקוח או מהלקוח לשרת בעזרת מתודות שהם מכילים‪.‬‬
‫( תוכן שמועבר ללקוח (‪Response.Write‬‬
‫כמו‪:‬‬
‫יתרונות ‪:ASP.NET‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫פחות קוד – יש פקדים מובנים המקצרים את תהליך הכתיבה‪.‬‬
‫הקוד מקומפל (מהודר)‪ ,‬לאחר שהוא קומפל פעם אחת הוא נשמר במאגר‪ ,‬כך‬
‫שבפעם הבאה שיקראו לדף הוא יילקח מהמאגר‪( .‬ביצועים טובים יותר)‬
‫הפעלת אירועים בצד השרת‪.‬‬
‫שימוש קל יותר ברכיבים – ניתן לכתוב בשפות שונות תומכות ‪ .NET‬ועל כן‬
‫הכתיבה עשירה ופשוטה יותר מאשר שימוש בשפות סקריפטים‪.‬‬
‫קיימת הפרדה של קוד ‪ HTML‬מקוד ‪ – ASP‬המסמך הופך להיות מובנה יותר –‬
‫וניתן לעבוד במקביל על הדברים‪ :‬עיצוב )‪ (UI‬ותכנות‬
‫)‪.(Code Behind‬‬
‫לא מתבססת על סקריפטים בצד הלקוח ולכן לא תלויה בסוג הדפדפן או‬
‫בפלטפורמה‪ .‬ולכן ניתן לפתח ‪ Web Form‬אחד שיכול להיות מוצג בכל רכיב שיש‬
‫לו גישה לאינטרנט ודפדפן ‪.Web‬‬
‫קיימת התאמה אישית ללקוח – יש פקדי שרת )‪ (Web Controls‬אשר כותבים קוד‬
‫מותאם לדפדפן שקרא להם‪.‬‬
‫שילוב טוב יותר עם ‪ ADO.NET .XML‬תומך ב‪ XML -‬ועל כן לא רק רכיבי ‪com‬‬
‫יוכלו לקרוא את המידע המועבר‪.‬‬
‫תכונות ניהול ואבטחה‪.‬‬
‫איתור באגים קל יותר‪.‬‬
‫שחקנים ראשיים‪:‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ – )PWS( IIS‬קונפיגורציה של שרת אינטרנט‪ ,‬המכיל קובץ ‪ aspx.dll‬שהוא‬
‫המנוע שמריץ אפליקציות ‪Web‬יות‪.‬‬
‫‪ IIS 5.0‬ומעלה יש תמיכה ב‪.NET -‬‬
‫‪ TCP/IP‬פרוטוקול ההתקשרות‪.‬‬
‫‪ -HTTP‬פרוטוקול המגדיר את סוג החבילות שעוברות ברשת‪.‬‬
‫קוד בצד לקוח ‪ – JavaScript -‬בדיקות בצד הלקוח‪ ,‬נתמך בכל הדפדפנים‪.‬‬
‫‪ Jscript‬של ‪ – VBScript ,MS‬לא נתמך ב‪Netscape -‬‬
‫קוד בצד שרת – ‪ VBScript‬כי האינטראקציה יותר טובה עם ה‪( IIS -‬גם‬
‫‪ . )JavaScript‬בכל שפה שהיא ‪.NET‬‬
‫כתובת ‪ IP‬של שרת מקומי – ‪localhost  127.0.0.1‬‬
‫שרת ה‪ IIS -‬מכיר את כל מה שנמצא בתיקייה ‪ Inetpub/wwwroot‬ולכן‬
‫ניתן לפנות אליהם דרך ה‪.localhost -‬‬
‫ניתן גם לפנות לתיקיות שלא נמצאות בתיקיה זו אם בוצע להן מיפוי לתיקיות‬
‫וירטואליות – מה שיוצר עותק בשרת ה‪ , IIS -‬אבל הכתובת שתוקלד תהא‬
‫אחרת‪.‬‬
‫‪ – ASP.NET Web Forms‬חלק מה – ‪ , Web Application‬מספקים דרך‬
‫קלה לבניית אתרי ‪ Web‬דינמיים‪.‬‬
‫איך מריצים קבצי ‪?ASP.NET‬‬
‫כדי שניתן יהיה להריץ דפי ‪ ,ASP.NET‬חובה להתקין את ה‪..NET Framework-‬‬
‫כמו כן‪ ,‬יש צורך בשרת ‪ - HTTP‬עדיף ‪ .IIS‬קרוב לוודאי ש‪ ASP.NET-‬לא ירוץ על‬
‫‪. PWS‬‬
‫באמצעות אילו כלים כותבים ב‪?ASP.NET-‬‬
‫ניתן לכתוב ‪( ASP.NET‬או כל תוכנית אחרת של ‪ ).NET‬בעזרת כל עורך טקסט‬
‫פשוט ‪.‬‬
‫אולם‪ ,‬ניתן לכתוב גם ב‪ - ASP.NET Webmatrix-‬כלי חינמי מבית היוצר של‬
‫מיקרוסופט‪ .‬כמו כן‪ ,‬בשביל מקצוענות של ממש‪ ,‬מומלץ להשתמש ב‪Visual -‬‬
‫‪.Studio.NET‬‬
Visual Studio .NET IDE
IDE = Integrated Development Environment

‫ יחיד ללא תלות בשפה או בסוג האפליקציה‬IDE ‫ מספקת‬Microsoft
.‫שמפתחים‬
:‫היררכית תיקיות וקבצים‬
Solution




Project…
Project


Web Form
Web Form
:IDE -‫קומפוננטות ב‬
)HTML ‫ או‬Design( Editor/Browser
Solution Explorer
Properties
Dynamic Help
Task List
Server Explorer
Toolbox
Object Browser









‫‪Web Application Files‬‬
‫‪‬‬
‫‪– Solution Files‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ – .sln‬מגדיר את כל הפרוייקטים ב‪ solution -‬ומגדיר אינפורמציה גלובלית לכולם‪.‬‬
‫‪(Solution User Option) – .suo‬‬
‫שומר הגדרות שביצע המשתמש – כמו ‪tast ,breakpoints‬‬
‫‪– Project Files‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ASP.NET Web Form – .aspx‬‬
‫‪ – code behind page – .aspx.cs‬פונקציונליות‬
‫‪Web Service – .asmx‬‬
‫‪ – Global.asax‬קובץ שמכיל את כל המשתנים הגלובליים וה‪event -‬ים ‪ ,‬כמו מה‬
‫לעשות כשהאפליקציה עולה או יורדת‪.‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ :ApplicationOnStart‬ליצור ‪ connection‬ל‪ ,DB -‬לטעון ערכים מקובץ‪...,‬‬
‫‪ – ApplicationOnEnd‬לכתוב מונה מס' כניסות לקובץ‪.‬‬
‫‪ – Web.config‬הגדרות קונפיגורציה שה – ‪ CLR‬קוראת והגדרות שהאפליקציה‬
‫קוראת‪.‬‬
‫‪‬‬
‫דוגמא‪ :‬הגדרת משתני ‪ session‬האם נשמרים בתור ‪ cookies‬או באופן אחר‪ ,‬הגדרוןת‬
‫‪ autentication‬לגבי האפליקציה‪.‬‬
‫‪‬‬
‫‪Project Assembly‬‬
‫‪‬‬
‫‪‬‬
‫‪ – Projectname.dll‬מקבץ את כל קבצי ה‪ , code behind -‬גפי ה‪,ASP.NET-‬‬
‫תמונות ועוד שקיימים בפרוייקט‪ .‬כולם מקןמפלים לקובץ ‪ assembly‬אחד‬
‫שכתוב ב‪ .MSIL -‬ונשמר בתקיית ‪ bin‬של הפרוייקט‪.‬‬
‫‪ CLR‬יכול להפעיל רק קוד שמוכל ב‪ ,assembly -‬לכן גם דפי ה‪ ASP -‬מוכלים ב‪-‬‬
‫‪ assemblies‬שנוצרים באופן דינמי כאשר יש בקשה לדף‪.‬‬
‫‪ – assemblyInfo‬שומר אינפורמציה כללית עבור ה‪ ,assembly -‬כולל גירסאות‬
‫ותכונות‪.‬‬
‫צעדים ראשונים‬
,‫ בפרט‬ASP.NET ‫ ומהו‬,‫ בכלל‬.NET ‫לאחר שיש לנו מושג פחות או יותר מהי‬
,‫ הדף הראשון שלנו יורכב מאמרה פשוטה‬.‫אפשר להתחיל לכתוב קצת קוד‬
‫ שלנו יציג‬ASP.NET-‫ שאותה דף ה‬,"Hello World” ‫ הלא היא‬,‫וידועה‬
.‫באלגנטיות על המסך‬
:‫ זה נראה ככה‬,‫בכל אופן‬
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<%@Page Language="C#"%>
<script runat="server">
void Page_Load(object sender, EventArgs e) {
myLabel.Text = "Hello World!";
}
</script>
<html>
<head>
<title>My first ASP.NET page</title>
</head>
<body>
<asp:Label runat="server" id="myLabel"></asp:Label>
</body>
</html>

‫עכשיו ננתח קצת את הענינים‪:‬‬
‫את דף ה‪ ASP.NET-‬נהוג‪ ,‬בגדול‪ ,‬לחלק לשלושה חלקים עיקריים‪:‬‬
‫‪ .1‬ה‪ .@Page Directive-‬זוהי תמיד השורה הראשונה בכל עמוד ‪ .ASP.NET‬שורה זו מגדירה מאפיינים של‬
‫העמוד שלנו‪ ,‬כגון שפה (כמו בדוגמא)‪ ,‬האם להשתמש ב‪ ,Sessions-‬האם לשמור ‪ Viewstate‬ועוד הגדרות‬
‫שונות‪.‬‬
‫‪ .2‬קוד צד‪-‬השרת של הדף‪ .‬קוד זה יופיע בדרך כלל בקובץ נפרד או בראש הדף‪ ,‬בין תגיות‬
‫<"‪ >script runat="server‬ו‪ .>/script<-‬המאפיין "‪ runat="server‬אומר שהקוד הבא שייך לשרת‪ ,‬ועל‬
‫‪" ASP.NET‬לקרוא" אותו‪ .‬מאפיין זה הוא מוטיב חוזר ב‪ ,ASP.NET-‬שאומר לשרת‪ ,‬שפקדים מסוימים נגישים‬
‫בצד השרת (כמו ‪ ,asp:Label‬כפי שנראה בהמשך)‪ .‬כפי שניתן לראות בקוד‪ ,‬מוגדרת בו מתודה (פונקציה)‪,‬‬
‫שרצה ב‪ ,Page_Load-‬כלומר‪ ,‬כשהדף נטען‪ .‬כל פעם שמשתמש יבקש את הדף הנ"ל מהשרת‪ ,‬מתודה זאת‬
‫תרוץ‪ .‬בדוגמא שלפנינו‪ ,‬אנחנו נותנים למאפיין טקסט של ה‪( label-‬פקד שבעצם אחראי על פלט)‪ ,‬שהוגדר‬
‫בהמשך‪ ,‬את הטקסט "!‪Hello World".‬‬
‫‪ .3‬ה‪ .HTML-‬בחלק השלישי אנחנו כותבים את ה‪ HTML-‬עצמו‪ ,‬בשילוב עם פקדי צד שרת‪ .‬בחלק זה של‬
‫הדף אנחנו מגדירים את המבנה של הדף‪ ,‬ואת העיצוב‪/‬מראה שלו‪ .‬בדוגמא שלנו‪ ,‬הגדרנו פקד צד‪-‬שרת‬
‫(תזכורת‪ :‬פקד צד שרת הוא פקד שהשרת מודע לקיומו) מסוג ‪ .label‬פקד ‪ label‬דומה מאוד ל‪ label‬של‬
‫‪ - Visual Basic 6‬הוא אחראי בעיקר על פלט‪ .‬ישנם עוד סוגי פקדים כגון ‪( textbox‬שמציג תיבת טקסט)‪ ,‬ו‪-‬‬
‫‪( DropDownList‬שמציג ‪ .)SELECT‬לפני שליחתם אל הלקוח‪ ,‬פקדים אלו עוברים תרגום ל‪ HTML-‬רגיל‪,‬‬
‫בהתאם לסוג הדפדפן של הלקוח‪.‬‬
‫חלוקה משולשת זאת מאפשרת הפרדה אמיתית של קוד מעיצוב ותוכן‪ ,‬ופוטרת אותנו מ"קוד הספגטי"‪,‬‬
‫שאיתו היינו מסתבכים ב‪ ASP-‬קלאסי‪.‬‬
:‫ והפעם רואים באופן ברור יותר את הקשר בין השרת ללקוח‬,‫עוד דוגמא היא זו‬
<%@Page Language="C#"%>
<script runat="server">
void btnApply_Click(object sender, EventArgs e) {
lblHello.Text = "Hello, " + myTextbox.Text;
}
</script>
<html>
<head>
<title>Customised message</title>
</head>
<body>
<form runat="server">
Please write your name here:
<asp:TextBox runat="server" id="myTextbox" /><br />
<asp:Button runat="server" id="btnApply"
text="Show message" OnClick="btnApply_Click" /><br />
<br />
<asp:Label runat="server" id="lblHello" />
</form>
</body>
</html>
‫בדוגמא זו‪ ,‬המשתמש כותב את שמו בתיבת‪-‬טקסט‪ ,‬ובלחיצה על כפתור מופיעה‬
‫הודעה‪ ,‬לפי השם שהוכנס‪.‬‬
‫הפעם אנחנו מגדירים פקדים מהסוג ‪ ,TextBox‬שמכיל טקסט פשוט; ‪ ,Button‬שבעת‬
‫לחיצה עליו יוצג בפקד אחר על הטופס ‪ -‬מסוג ‪ - Label‬טקסט דינאמי‪.‬‬
‫כדי לטפל בלחיצה‪ ,‬ישנה פונקציה מיוחדת‪ ,‬המטפלת באירוע (בדוגמא הנ"ל ‪ -‬אירוע‬
‫לחיצה)‪ .‬לפקדים שונים יש אירועים המתאימים לתפקודם‪ ,‬והם מאפשרים להתאים‬
‫את התפקוד שלהם לצרכי האפליקציה‪ .‬למשל‪ ,‬ניתן לבצע בדיקות אימות לערכים‬
‫שהוכנסו בעת לחיצה על כפתור השליחה של טופס‪.‬‬
‫בהגדרת הכפתור הוספנו את המאפיין ‪ ,OnClick‬וערכו הוא שם הפונקציה שמטפלת‬
‫באירוע הלחיצה עליו‪ .‬בפונקציה הנ"ל‪ ,btnApply_Click ,‬מעודכן הטקסט שמופיע על‬
‫ה‪ .Label-‬הטקסט המוצג כולל הודעת ברכה אישית‪ ,‬המשתמשת בטקסט מתוך פקד‬
‫תיבת‪-‬הטקסט‪.‬‬
‫מה קורה כשהלקוח מבקש דף ‪ASP.NET‬‬
‫מהשרת?‬
‫‪‬‬
‫‪‬‬
‫כמו ב‪ ASP-‬קלאסי‪ ,‬הלקוח בעצם מבקש את הדף מ‪ .IIS-‬לאחר מכן‪IIS ,‬‬
‫מריץ את ה‪ ISAPI Filter-‬של ‪( ASP.NET‬בדיוק כמו שהוא מריץ את ה‪-‬‬
‫‪ ISAPI‬של ‪ ,)ASP‬ה‪ ISAPI-‬הזה מריץ את ה‪ ,FrameWork -‬ואת ה‪-‬‬
‫‪ ,ASP.NET Runtime‬שבעצם עושים את עיקר עיבוד עמוד ה‪.ASPX-‬‬
‫סדר הקריאות‬
‫בהתחלה‪ ASP.NET ,‬קוראת את קובץ ה‪ ,ASPX-‬ויוצרת את ה‪Control-‬‬
‫‪ ,Tree‬שזהו "עץ הפקדים" שבדף שלנו‪ .‬בשלב זה‪ ASP.NET ,‬עוברת באופן‬
‫רקורסיבי על קובץ ה‪ ,ASPX-‬ועל התגיות שבו‪ ,‬כדי לקרוא למחלקות‬
‫המתאימות לפקדים המסוימים‪ .‬לדוגמא ‪ -‬אם היא נתקלת בתגית‬
‫<"‪ ,>asp:textbox runat="server‬היא קוראת למחלקה ‪ ,TextBox‬יוצרת‬
‫‪( instance‬מופע) שלה‪ ,‬ומוסיפה אותה לרשימת הפקדים של הדף‪.‬‬
‫לאחר מכן‪ ,‬מתבצעת ‪ ,Page_Init‬במידה והוגדרה פונקציה כזאת בקוד‬
‫שלנו‪ ,‬ואחריה‪ ,‬מתבצעת טעינה ועיבוד של ה‪( ViewState-‬עוד על ה‪-‬‬
‫‪ - ViewState‬בהמשך)‪ .‬לאחר הטעינה והעיבוד של ה‪,ViewState-‬‬
‫הפונקציה ‪ Page_Load‬נקראת‪ ,‬במידה והוגדרה‪.‬‬
‫לאחר ‪ ,Page_Load‬מטפלי האירועים השונים נקראים בשלב זה ירוצו‬
‫פונקציות כמו ‪ Button_click‬או ‪,DropDownList_SelectedIndexChange‬‬
‫שנקראות במקרה שבהם הלקוח לחץ על כפתור‪ ,‬או שינה ‪ index‬של‬
‫‪ DropDown‬מסוים‪.‬‬
‫לאחר מכן‪ Page_PreRender ,‬נקראת‪ ,‬במידה ויש כזו בקוד שלנו‪ .‬פונקציה זו‬
‫היא מקום טוב לשים כל מיני פעולות שכדאי שיתרחשו ממש לפני יצירת ה‪-‬‬
‫‪ HTML‬הסופי שנשלח ללקוח‪ .‬מיקרוסופט ממליצה שפה נשים קוד שמוסיף קוד‬
‫צד‪-‬לקוח (‪ )Javascript‬לדף שלנו‪ .‬אחרי ‪ ,PreRender‬ה‪ASP.NET Runtime-‬‬
‫עובר על כל הפקדים שהוגדרו בדף שלנו‪ ,‬ומתרגם אותם ל‪( HTML-‬זה נעשה‬
‫ע"י קריאה למתודה ‪ ,Render‬שחייבת להימצא בכל פקד)‪.‬‬
‫לבסוף‪ ,‬ה‪ Runtime-‬קורא ל‪( Page_Unload-‬במידה ויש כזה)‪ ,‬ושולח את ה‪-‬‬
‫‪ HTML‬הסופי ללקוח‪.‬‬
‫דוגמאות‬
‫נבדוק כיצד מתבצעות הדוגמאות שנתּנו בעמוד הקודם‪.‬‬
‫בדוגמא הראשונה מוגדרת ‪ label‬על הדף‪ .‬הפונקציה ‪ Page_Load‬נקראת אחרי‬
‫שה‪ label-‬הוספה לרשימת הפקדים בדף‪ ,‬ומעדכנת את הטקסט המופיע עליה‪.‬‬
‫אין דברים נוספים שעל השרת לעבד‪ ,‬ולכן קוד ‪ HTML‬מיוצר ונשלח ללקוח‪.‬‬
‫בדוגמא השניה‪ ,‬המצב מסובך יותר‪ .‬ישנה תיבת‪-‬טקסט‪ ,‬כפתור עם אירוע‬
‫המתבצע בעת לחיצה‪ ,‬ו‪.label-‬‬
‫במצב ההתחלתי‪ ,‬מיוצר הדף כך שתיבת הטקסט וה‪ label-‬ריקות‪ .‬אולם‪ ,‬בעת‬
‫לחיצה על הכפתור‪ ,‬הדף נשלח מחדש לעצמו (פעולה זו נקראת ‪,)postback‬‬
‫כאשר הערך של תיבת הטקסט נשמר ב‪ .ViewState-‬הפעם‪ ,‬יש מטפל‪-‬אירוע‬
‫שצריך להתבצע‪ ,‬והוא משנה את ערך הטקסט של ה‪ ,label-‬בהתאם לערך תיבת‬
‫הטקסט‪ .‬מפה ההמשך הוא כמו בדוגמא הקודמת‪ :‬קוד ‪ HTML‬מיוצר‪ ,‬ונשלח‬
‫ללקוח‪.‬‬
‫יצירת ‪-Web Form‬‬
‫הפונקציונלאיות של ‪ Web Form‬מוגדרת ע"י ‪ 3‬רמות של מאפיינים‪:‬‬
‫‪ :Page‬הגרות גלובליות‬
‫‪.1‬‬
‫‪ :Body‬איך הדף יוצג‬
‫‪.2‬‬
‫‪ :Form‬איך קבוצת פקדים תעובד‬
‫‪.3‬‬
‫‪– PAGE‬‬
‫‪‬‬
‫>”‪<%@ page language=“ “ codebehind = “*.aspx.cs” smartNavigation = “true‬‬
‫מגדיר תכונות ספציפיות של העמוד שיהיו בשימוש ה‪ Parser -‬וה‪ Compiler -‬של‬
‫‪ASP.NET‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ – Language‬מגדיר את שפת ב"מ שבה יכתבו סקריפטים בדף‪.‬‬
‫‪ – Codebehind‬מגדיר את הקובץ שמכיל את הלוגיקה שתומכת בטופס (נוצר אוטומטית)‪.‬‬
‫‪ – smartNavigation‬מאפשר לדפדפן לעדכן רק את האזור שהשתנה בטופס‪.‬‬
‫‪‬‬
‫‪– BODY‬‬
‫>‪<body ms_positioning = “GridLayout”>……..</body‬‬
‫מגדיר איך פקדים וטקסט יוצבו בדף‪.‬‬
‫‪‬‬
‫‪– ms_positioning‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ – GridLayout‬במקום מוחלט ע"י קורדינטות אבסולוטיות ‪ ,‬מוסיף מאפייני ‪DHTML‬‬
‫(‪)Position, Left, Top, Z-Index‬‬
‫‪ – FlowLayout‬הפקדים מתווספים אחד אחרי השני‪.‬‬
‫‪– FORM‬‬
‫>‪<form id=“” method=“” runat=“”>…………..</form‬‬
‫מגדיר איך קבוצת פקדים תעובד‪.‬‬
‫‪‬‬
‫‪‬‬
‫‪ – id‬זיהוי חד חד ערכי ע"י השרת‬
‫‪– Method‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫”‪ – “post‬זוגות של ‪ name/value‬שיועברו בחבילת ה‪HTTP -‬‬
‫”‪ – “get‬מידע מועבר ע"י ‪ query string‬ב‪( URL -‬עד ‪ 1024‬ביט)‬
‫”‪ – Runat=“server‬מגדיר את מיקום יצירת הפקדים‪ ,‬הארועים מבוצעים‬
‫בשרת ‪ ,‬מעביר אינפורמציה חזרה לשרת ‪ ,‬יחיד בטופס‪.‬‬
‫פקדים ‪Controls -‬‬
‫‪‬‬
‫‪HTML Controls‬‬
‫‪‬‬
‫‪‬‬
‫‪ – Client Side‬פקדים רגילים של ‪ ,HTML‬רצים בצד הלקוח‬
‫בלבד‪ ,‬ולא עוברים אף עיבוד בצד השרת‪.‬‬
‫‪– Server Side‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫סינטקטית נרשמים כמו פקדי ‪ HTML‬רגילים אך עם תוספת ‪runat‬‬
‫”‪= “server‬‬
‫השרת מייצר עבורם תמיד אותו קוד ‪ HTML‬ללא תלות בדפדפן‬
‫חייבים להופיע בתוך >‪<form runat=…> </form‬‬
‫מוגדרים ב‪System.Web.UI.HtmlControls : namespace -‬‬
‫בשימוש אם הפקד צריך להריץ קוד גם בצד הלקוח וגם בצד השרת‬
‫ע"י הגדרת ה‪: event -‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪OnClick‬‬
‫‪OnServerClick‬‬
‫קלים להמרה מפקדי ‪ HTML‬הקלאסיים‪.‬‬
‫‪‬‬
‫‪Web Server Controls‬‬
‫‪ ‬אירועים מורצים תמיד בצד השרת ונוצרים על ידו‪.‬‬
‫‪ ‬השרת מייצר עבורם קוד שתלוי בדפדפן שביקש‬
‫את הדף‪.‬‬
‫‪ ‬אוסף של פקדים מיוחדים‪.‬‬
‫‪ ‬בשימוש אם האפליקציה תוצג במס' סוגי דפדפנים‪.‬‬
‫‪ ‬לא יפעלו אם ה‪ runat = “server” -‬לא קיים‪.‬‬
‫‪ ‬כולם מוגדרים ב‪:namespace -‬‬
‫‪System.Web.UI.WebControls‬‬
‫‪ASP.NET Server Controls‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫קומפוננטות שרצות בשרת ומייצרות את ה‪ UI -‬ופונקציות נוספות‪ .‬בשימוש‬
‫בדפי ‪ ASP.NET‬ובקובצי ‪.code behind‬‬
‫>‪<asp:Button id=“…” runat=“server” text=“submit”/‬‬
‫מאפיין ‪ runat‬שמציין שהלוגיקה רצה בשרת‪.‬‬
‫פקדים אלו מתבססים על אותה מחלקה ולכן חולקים תכונות (מאפיינים)‬
‫משותפות – ‪text, width, backColor,…..‬‬
‫פונקציונליות הפקד – מגדירים מה לבצע ב‪ event -‬מסויים‪.‬‬
‫פקדי ‪ HTML‬מסורתיים הם ‪ – stateless‬חוזרים להגדרות ברירת מחדל‪,‬‬
‫בעוד שעבור פקדי שרת מצב התצוגה וקלט המשתמשים נשמרים‬
‫אוטומטית‪.‬‬
‫עבורם נוצר בצד השרת קוד ‪ HTML‬מסויים עבור הדפדפן שביקש את הדף‪.‬‬
‫(לדוגמא אם הדפדפן תומך ב‪ script -‬או לא)‬
‫סוגים של ‪Server Controls‬‬
‫ישנם מס' סוגים זמינים ב‪ ,ASP.NET -‬חלקם דומים לפקדי ‪ HTML‬מסורתיים‬
‫ואחדים חדשים‪.‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪– Intrinsic Controls‬‬
‫בדומה לפקדי ‪ HTML‬פשוטים‪listbox, button, textbox :‬‬
‫‪– Validation Controls‬‬
‫בדיקת קלט משתמש‬
‫‪– Rich Controls‬‬
‫פקדים מורכבים‪ ,‬לדוגמא‪Calander :‬‬
‫‪– List Bound Controls‬‬
‫יכולים להציג רשימה של מידע‪ ,‬מאפשרים למיין‪ ,‬לערוך וכו'‬
‫דוגמאות לפקדים שקולים‬

HTML Button:
<input type=“button” value=“HTML Control”>

HTML Server Control Button:
<input type=“button” value=“HTML Server Control”
id=“button1” runat=“server”>

Web Server Control Button:
<asp:button id=“button1” runat=“server”
text=“Web Server Control”>
Intrinsic Web Server Controls
Web server
control
HTML control
equivalent
<asp:button>
<input type=submit>
<asp:checkbox>
<input type=checkbox>
<asp:hyperlink>
<a href=“…”> </a>
<asp:image>
<img src=“…”>
<asp:linkButton>
Web server control
function
‫יצירת לחצן ששולח בקשה לשרת‬
‫ שניתן לבחור‬check box ‫יצירת‬
.‫ע"י קליק‬
HTML ‫יצירת היפר קישור לדף‬
‫יצירת אזור שבשימוש להצגת‬
.‫תמונה‬
‫יצירת לחצן לקישור‬
<asp:label>
<span> </span>
<asp:listbox>
<select> </select>
<asp:imagebutton
>
<input type=image>
‫יצירת תווית טקסט שמשתמשים‬
.‫לא יכולים לשנות‬
.‫יצירת רשימת בחירה‬
‫יוצר לחצן שעליו תופיע תמונה‬
.‫במקום טקסט‬
Web server
control
HTML control equivalent
<asp:panel>
<div> </div>
<asp:radiobutton>
<input type=radiobutton>
<asp:table>
<table>
<asp:textbox>
<input type=text>
</table>
Web server control
function
.‫יצירת מיכלית של פקדים‬
.‫יצירת לחצן רדיו‬
.‫יצירת טבלה‬
.‫יצירת תיבת טקסט‬
‫‪Validation Controls‬‬
‫‪Function‬‬
‫דורש הקלט יתאים לקלט אחר או לערך‬
‫קיים‪.‬‬
‫‪Control‬‬
‫‪CompareValidator‬‬
‫דורש הקלט יתאים לתנאי מסוים‪.‬‬
‫(לדוגמא מס' זוגי וכו')‬
‫‪CustomValidator‬‬
‫דורש שהקלט יהיה בתחום מסוים‪.‬‬
‫‪RangeValidator‬‬
‫דורש שהקלט יתאים לפורמט מסוים‪.‬‬
‫‪RegularExpressionValidator‬‬
‫דורש שהמשתמש יכניס ערך לשדה‪.‬‬
‫‪RequiredFieldValidator‬‬
‫אוסף את כל הודעות השגיאה של כל‬
‫הפקדים בשביל הצגה מרוכזת‪.‬‬
‫‪ValidationSummary‬‬
‫‪Rich Controls‬‬
‫‪Function‬‬
‫מציג סידרת תמונות אקראית או מוגדרת‪.‬‬
‫מציג יומן גרפי שבו משתמשים יכולים‬
‫לבחור תאריך‪.‬‬
‫‪Control‬‬
‫‪AdRotator‬‬
‫‪Calendar‬‬
‫‪List-Bound Controls‬‬
‫‪Function‬‬
‫מציג מידע כעמודת לחצני סימון‪.‬‬
‫מציג את הרשומות במספר דרכים‪ ,‬לפי‬
‫הגדרה‪.‬‬
‫‪Control‬‬
‫‪CheckBoxList‬‬
‫‪Repeater‬‬
‫מציג את הרשומות בטבלה‪.‬‬
‫‪DataList‬‬
‫כמו ‪ ,DataList‬עם אפשרויות מיון ועריכה‪.‬‬
‫‪DataGrid‬‬
‫מציג את המידע בתפריט של פקד נפתח‪.‬‬
‫‪DropDownList‬‬
‫מציג את המידע בחלון‪.‬‬
‫מציג את המידע כעמודת כפתורי רדיו‪.‬‬
‫‪ListBox‬‬
‫‪RadioButtonList‬‬
‫איך נשמר המידע‬
‫ב‪? Web Server Control -‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫כמו כל טכנולוגיה שמבוססת ‪ HTTP‬ה‪ Web Forms -‬הם ‪. Stateless‬‬
‫כלומר‪ ,‬השרת לא שומר אף אינפורמציה על בקשות קודמות‪.‬‬
‫‪ ASP.NET Web Forms‬מטפלים בבעיה זו של שמירת המצב של‬
‫‪ Web Server Control‬ע"י הוספת פקד חבוי ששמו ‪ _VIEWSTATE‬ששומר‬
‫את מצב הפקדים ב‪.Web Forms -‬‬
‫פקד זה מתווסף לטופס שבצד השרת כשמציינים את התגית‬
‫>”‪<form runat=“server‬‬
‫>‪</form‬‬
‫והוא שומר מצב רק של הפקדים שבתגית‪.‬‬
‫(יתרון‪ :‬התוכניתן מתרכז בעיצוב הדף ולא בבניה של מתודות לשמירת מצב‬
‫הדף)‬
‫הגדרות הדף נשארות קונסיסטנטיות מבקשה אחת לאחרת‪.‬‬
ViewState - ‫ ל‬Enable -‫ ו‬Disable
.‫ שומר את מצב התצוגה של הפקדים בטופס‬web Form ,‫כב"מ‬
‫ יכול להאט את‬View State -‫עבור טופס עם מספר רב של פקדים גודל ה‬
.‫הביצועים בצורה משמעותית‬
‫ רק לפקדים‬Enable -‫ ו‬Page -‫ ברמת ה‬Disable ‫בכדי להגביר את הביצועים נבצע‬
.‫מסוימים‬
:Disable
<%@ page EnableViewState=“False”…….>
:‫ לפקד‬Enable
<asp:list id=“ListName” EnableViewState=“true” runat=“server”/>



