Web Services ASP.NET כתב: אקת'ם חאג' יחיא ליווי מקצועי : ארז קלר

Web Services ASP.NET כתב: אקת'ם חאג' יחיא ליווי מקצועי : ארז קלר

מבוא ל- ASP.NET . יצירת טפסי Web . הפרדה בין קוד לרכיבי תצוגה – Code Behind. טיפול באירועים. קובץ קונפיגורציה – Web.Config. פקדים. פקדים מותאמים אישית. שמירת מצב (State) .

מבוא ל- ASP.NET מאפייני ASP.NET
טכנולוגיה זו הינה חלק מה- Microsoft .NET Framework, ולכן יכולה להשתמש בכל רכיבי ה-Class Library של NET.. מיועדת לעבודה בצד השרת. הדפים שנוצרים מתורגמים בעזרת מנוע מיוחד המותקן בצד השרת ומוחזרים ללקוח כדפי HTML. כמו כל טכנולוגיות .NET גם ASP.NET היא OOP .

מבוא ל- ASP.NET מאפייני ASP.NET - המשך
ASP.NET אינה שפת תכנות אלא טכנולוגיה שמשתמשת במספר שפות תכנות כמו C#, VB.NET J#, JSCRIPT.NET וכו... לכתיבת קוד בשפות תכנות יש יתרון גדול על כתיבת קוד בשפות סקריפטים כמו JScript ו' VBScript.

מבוא ל- ASP.NET מאפייני ASP.NET – המשך
ב- ASP.NET קוד ה- HTML מופרד מהקוד הלוגי של הדף (Code Behind), הפרדת הקוד מהמראה הוויזואלי של הדף מהווה יתרון עצום, עליו נדבר בהמשך. ב- ASP הקלאסית היו 5 אובייקטים, עליהם התבסס קוד ה- Script , ב- ASP.NET ישנם למעלה מ מחלקות מוכנות לשימוש. טכנולוגיית ASP.NET היא לא רק טכנולוגיה ליצירת אתרי אינטרנט, אלא, מכילה גם את שירותי הרשת (Web Services) באמצעותם יישומים יכולים לקבל שירותים דרך הרשת. ASP.NET מכילה פקדי שרת (Web Controls), שמפשטים את העבודה ומתאימים את הקוד לדפדפן שקרא להם ומוכרים על ידי השרת, הפעלת אירועים מתבצעת בצד השרת.

מבוא ל- ASP.NET מאפייני ASP.NET – המשך
מגדירה קבצי קונפיגורציה (mashine.config ו' web.config) אשר מכילים את ההגדרות של האפליקציה או חלקים ממנה. יותר יציבה ומאובטחת. שילוב טוב יותר עם XML ו-ADO.NET . איתור באגים קל יותר.

מבוא ל- ASP.NET מבנה אפליקציית ASP.NET
.aspx – ASP.NET Web Form .aspx.cs – code behind page – פונקציונליות . Global.asax – קובץ שמכיל את כל המשתנים הגלובליים והאירועים ברמת האפליקציה ,לדוגמה: מה יתבצע כאשר האפליקציה עולה או יורדת. Web.config – הגדרות קונפיגורציה.

דף aspx מכיל שלושה חלקים עיקריים: הנחיית הדף (page directive): הגדרות מאפייני הדף. קוד צד-לקוח וקוד צד-שרת : קוד המופעל על ידי הלקוח (דפדפן) למשל JScript והקוד שרץ בצד השרת (IIS). HTML ופקדי השרת: מגדיר את מראה הדף על ידי פקדי HTML או פקדי שרת (שהם חידוש משמעותי ב- ASP.NET)

הקובץ שמכיל את קוד צד-השרת
מבוא ל- ASP.NET מבנה אפליקציית ASP.NET הנחיית הדף (Page directive) מרכיב חשוב בדף aspx. מספק הנחיות טיפול בדף ל- Parser ול- Compiler. מוגדר בראש הדף בין התגיות : התגית <% . דוגמה: Page language="c#" Codebehind="WebForm1.aspx.cs" AutoEventWireup="false“ Inherits="WebApplication1.WebForm1" %> הגדרת שפה התכנות הקובץ שמכיל את קוד צד-השרת לטיפול באירוע הדף המחלקה הממומשת ב- Code Behind

קוד צד-לקוח (Client Side) וקוד צד-שרת (Server Side) דפי aspx יכולים להכיל קוד שרץ בצד השרת וקוד שרץ בצד הלקוח. קוד שרץ בצד לקוח יכול להגדיר אלמנטים עיצוביים (שינוי צבע רקע של פקד בזמן שהעכבר עובר מעליו), בדיקת תקינות קלט משתמש וכו'. תפקידו של קוד שרץ בצד שרת הוא לטפל באירועי הפקדים ואירועי היישום. יתרונותיו של קוד בצד שרת : הקוד מוסתר מהלקוח, מקומפל, יכול לגשת למשאבי השרת, יכול להשתמש בכל מרכיבי .NET

מבוא ל- ASP.NET מבנה אפליקציית ASP.NET קוד צד-לקוח - דוגמה
ניתן להוסיף את קטע הקוד הבא בין תגיות ה- Head של הדף: קוד צד שרת נכתב ב- Jscript או ב- VBScript . <script language="javascript"> function Form1_onmousemove() { document.bgColor="c5c5ff"; } </script>

מבוא ל- ASP.NET מבנה אפליקציית ASP.NET קוד צד שרת
קוד צד שרת ניתן לכתוב בדף aspx או בדף נפרד המכונה code behind. לדוגמה: public class WebForm1 : System.Web.UI.Page { … private void Button1_Click(object sender, System.EventArgs e) int num1=int.Parse(TextBox1.Text); int num2=int.Parse(TextBox2.Text); Label1.Text=(num1+num2).ToString(); } ...

מבוא ל- ASP.NET מבנה אפליקציית ASP.NET דף aspx מורכב משני קבצים:
MyPage.aspx – כתוב בפורמט HTML . MyPage.aspx.cs – כתוב בשפת .NET כלשהיא. בדף aspx מוגדר העיצוב/המראה של האתר, מכיל הגדרות של פקדי HTML ופקדי שרת. כל הפקדים חייבים להופיע בין התגיות. . . </form> <form>. כמו כן , בדף זה ניתן לכתוב את קוד צד הלקוח. דף aspx.cs מכונה Code Behind מטפל באירועי הפקדים ואירועי היישום בצד שרת.

פקדי שרת מוגדרים באמצעות תגיות מיוחדות, לדוגמה: <asp:TextBox id="TextBox1" runat="server"> <asp:TextBox/> בעת החזרת הדף ללקוח הם מתורגמים לתגיות HTML סטנדרטיות : <input type="text" id="TextBox1" />

מבוא ל- ASP.NET מבנה אפליקציית ASP.NET דוגמה: MyPage.aspx
Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %> <html xmlns=" > <head runat="server"> <title>Untitled Page</title> </head> <body> <form id="form1" runat="server"> <asp:Label ID="Label1" runat="server" Text="Label"></asp:Label> <asp:TextBox ID="TextBox1" runat="server" OnTextChanged="TextBox1_TextChanged"> </asp:TextBox> <asp:Button ID="Button1" runat="server" OnClick="Button1_Click" Text="Button" /> </form> </body> </html>

מבוא ל- ASP.NET מבנה אפליקציית ASP.NET דוגמה : MyPage.aspx.cs
public partial class _Default : System.Web.UI.Page { protected void Page_Load(object sender, EventArgs e) } protected void Button1_Click(object sender, EventArgs e) Label1.Text = TextBox1.Text; טיפול באירוע פקד בצד שרת

מבוא ל- ASP.NET מודל ההרצה (Request\Response) התהליך :
מודל ההרצה מתאר מצב שבו הלקוח מבקש דף באמצעות שליחת בקשה לשרת, השרת מגיב ומספק את הדף המבוקש ללקוח. התהליך : הלקוח שולח בקשה (Request) לשרת. השרת בודק את סיומת הקובץ, אם מדובר בסיומת מסוג htm או ,htmlהוא שולף את הקובץ המבוקש ומחזיר אותו מיידית ללקוח. אם מדובר בסיומת מסוג aspx, (זה מה שמעניין אותנו בשלב זה( הבקשה עוברת תהליך עיבוד ולאחר מכן המידע מועבר ללקוח.

מבוא ל- ASP.NET דפדפן שרת מודל ההרצה (Request\Response)
תהליך הבקשה/תגובה: דפדפן שרת שליחת בקשה לשרת עיבוד הבקשה יצירת דף HTML שליחת דף HTML לדפדפן הצגת הדף בניית בקשה

מבוא ל- ASP.NET מודל ההרצה (Request\Response)
כאשר השרת מזהה בקשה עם סיומת aspx הוא מעביר את הבקשה מיד ל"מנוע" ASP.NET. מנוע ה- ASP.NET מבצע אינטרפטציה לשפת הביניים (IL או MSIL) וממיר אותה לשפת מכונה (Native Code). ה-CLR שומר את שפת המכונה של הדף. אחרי שהקוד עבר הידור מתחיל שלב קישור קוד המקור ,תרגום פקדי השרת לתגיות HTML ועיבוד אירועי המערכת. בסוף ASP.NET מתאימה את הקוד לסוג הדפדפן שבקש את הדף ושולחת אליו קובץ HTML.

מבוא ל- ASP.NET מבוא ל- ASP.NET מודל ההרצה (Request\Response)
בקשת הדף בפעם הראשונה Server Client בקשה לדף aspx קבלת HTML MSIL NATIVE CODE INTERPRETER

מבוא ל- ASP.NET מודל ההרצה (Request\Response)
כאשר הלקוח מבקש את הדף בפעם השנייה, ה- CLR בודק אם היה שינוי בקוד. אם כן asp.net תבצע אינרפטציה מחדש לדף. אם בבקשה השניה לא היה שינוי בקוד, asp.net לא תבצע את האינרפטציה וזמן החזרת הדף ללקוח יקטן בצורה משמעותית.

X X מבוא ל- ASP.NET מודל ההרצה (Request\Response) בקשת הדף בפעם השנייה
Server Client בקשה לדף aspx קבלת HTML X MSIL NATIVE CODE X INTERPRETER

יצירת טפסי Web דפי aspx הם קבצי טקסט הכתובים בפורמט HTML.
דפי aspx מכילים טופס WEB (Web Form) אחד ויחיד. בטופס WEB מעצבים את הדף על ידי הצבת פקדים. הם מוצגים כמסמכי HTML בדפדפן. אפשר לכתוב אותם בכל עורך טקסט רגיל כמו למשל בפנקס הרשימות. כדי שהשרת ידע שמדובר בטופס aspx, חייבים לתת לו את הסיומת aspx.

יצירת טפסי Web ישנן שני דרכים ליצירת טפסי Web:
כתיבת ידנית של קוד בעורך טקסט פשוט כמו פנקס הרשימות. שימוש בסביבות עבודה ותוכנות מתוחכמות כמו Visual Studio .Net. עדיף להשתמש בסביבת הפיתוח, מספקת כלים גראפיים שמקלים על תהליך העיצוב של הטופס - What You See Is What You Get (WYSIWYG)

יצירת טפסי Web כתיבה בעזרת פנקס הרשימות כתיבת הקוד הבא פנקס הרשימות :
Page language="c#" %> <HTML> <HEAD> <title>Test page</title> </HEAD> <body> <form id="Form1" method="post" runat="server"> <asp:Label id="Label1" runat="server"> hello world </asp:Label> </form> </body> </HTML>

יצירת טפסי Web כתיבה בעזרת פנקס הרשימות - המשך
שמור את הקובץ בשם test.aspx על השרת המקומי במחשב שלך. השרת המקומי נמצא בדרך כלל בכונן C בתיקיה: c:/Inetpub/wwwroot, במידה והוא נמצא בכונן אחר, שנה את השם שלו בהתאם. הפעל את הדפדפן וכתוב את שם הקובץ וכתובת השרת המקומי בכתובת ה- URL. קוד זה יציג את המשפט "hello world”.

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

יצירת טפסי Web יצירת דף באמצעות Visual Studio.NET
יצירת פרויקט חדש מסוג ASP.NET WebApplication, והגדרת שם לפרוייקט.

יצירת טפסי Web יצירת דף באמצעות Visual Studio.NET - המשך
לחיצה על OK מציגה את העורך הגראפי (Designer) של VS.NET.

יצירת טפסי Web יצירת דף באמצעות Visual Studio.NET – המשך
בחלון ב- SolutionExplorer מופיעים מרכיבי הפרוייקט,נתעלם מכולם ונתמקד בקובץ WebForm1.aspx. זהו קובץ שנוצר אוטומטית בעת יצירת הפרוייקט. ניתן להשתמש בו, לשנות לו את השם או למחוק אותו. הקובץ מכיל טופס אחד כמו כל קבצי ה- aspx . ניתן להוסיף לפרוייקט קבצי aspx נוספים.

הוספת קובץ aspx לפרוייקט: לחיצה ימנית על שם הפרויקט ב- Solution Explorer . בחירת Add ומהתפריט שנפתח בוחרים Add Web Form.

הוספת קובץ aspx לפרוייקט - המשך: בחלון שנפתח משנים את שם ברירת המחדל של הקובץ ל-MyFirstWebForm.aspx.

הוספת קובץ aspx לפרוייקט - המשך: כאשר נלחץ על Open נקבל טופס Web חדש. כעת ניתן לגרור לטופס החדש שנוצר פקדים.

הוספת פקדים לטופס: נגרור תיבת טקסט (TextBox) וכפתור (Button) מארגז הכלים שנמצא בצד שמאל של הטופס ונציב אותם בטופס.

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

הוספת פקדים לטופס: מקליקים הקלקה כפולה עם העכבר על הכפתור ובחלון שנפתח נכתוב את הקוד הבא (המסומן בכחול): private void Button1_Click(object sender, System.EventArgs e) { TextBox1.Text="hello word"; } החזרה לטופס העיצוב מתבצעת באמצעות התווית View Designer (התווית השנייה משמאל) או באמצעות SHIFT+F7.

Code Behind דף aspx מורכב מרכיבי תצוגה המגדירים את חזות הטופס וקוד המטפל באירועי הפקדים. רכיבי התצוגה מוגדרים באמצעות קוד HTML . הטיפול באירועים מתבצע באמצעות שפת .NET כלשהיא (C#, VB.NET וכו') ישנן שלוש שיטות להוספת קוד ל- Web Form: Mixed Code: הקוד ותגיות ה- HTML נמצאים באותו קובץ ומעורבים זה בזה. Inline Code: הקוד ותגיות ה- HTML נמצאים באותו קובץ אבל מופרדים אחד מהשני באמצעות התגית <SCRIPT>. Code Behind: הקוד ותגיות ה- HTML נמצאים בקבצים נפרדים.

Code Behind Code Behind הוא אחת האפשרויות החדשות ב- ASP.NET, פותחה על מנת להפריד את קוד המקור מקוד ה- HTML. חלום רטוב של מפתחי ה- ASP הקלאסי. מגדיר קובץ נפרד מקובץ ה- aspx לצורך טיפול באירועי הפקדים בטופס. על פי טכניקה זו עיצוב הדף נקבע בקובץ aspx ונכתב בפורמט HTML , הטיפול באירועים מתבצע בקובץ נפרד ששמו זהה לשם קובץ ה- aspx אולם בתוספת סיומת תקנית של השפה בה הוא נכתב ( cs או vb). לדוגמה : עיצוב הטופס נקבע בקובץ MyPage.aspx והקוד המטפל באירועי הפקדים נכתב בקובץ MyPage.aspx.cs .

Code Behind השוואה בין קוד שנמצא בתוך הקובץ לקוד שנמצא בנפרד מהקובץ (Code Behind). Code Behind Single File <tags> Code <tags> Code Form1.aspx Form1.aspx Form1.aspx.cs

Code Behind יתרונות מפתחים (developers) ומעצבים (Designers) יכולים לעבוד בנפרד. המעצב מתמקד בעיצוב הוויזואלי של הדף, בזמן שהמפתח מתמקד בכתיבת הקוד בלבד. אחרי הקומפילציה ה- Code Behind הופך לקובץ MSIL עם הסיומת dll ותוכנו מוסתר. קריא וברור יותר. תחזוקה קלה יותר, שינוי הקוד אינו משפיע על האלמנטים הויזואליים, ושינוי מראה הדף אינו משפיע על הקוד. הקבצים קטנים ומסודרים יותר. הקוד יכול להכתב בכל שפות הדוט.נט.

Code Behind שני הקבצים, דף ה- aspx ודף ה- code behind חייבים להיות מקושרים אחד לשני. קישור שני הדפים נעשה באמצעות שנקראת תגית הנחיית הדף (page directive). אחרי קישור הקבצים הם יעבדו ביחד כיחידה אחת. קובץ ה- Code Behind WForm1.aspx Page language="c#" Codebehind="WForm1.aspx.cs" Inherits="WebApp1.WForm1" %>

Code Behind WebForm1.aspx WebForm1.aspx.cs

Code Behind בסיום הכתיבה המהדר מקמפל את כל קבצי ה- Code Behind לקובץ dll אשר מותקן בספריה Bin שבעצמה נמצאת בספריה הוירטואלית. כאשר הלקוח מבקש דף aspx (Request), ה-CLR מבצע אינרפטציה ל-dll מריץ אותו ומקשר אותו לדף ה- aspx המתאים, רק לאחר מכן מנוע ה- ASP.NET מסוגל לייצר את ה- HTML ולהחזיר אותו ללקוח (Response).

Code- behind class file
Response Page Class Instantiate, process and render Gen’d Page Class File Generate Instantiate Parse ASPX Engine File Request Code- behind class file

טיפול באירועים האירוע Page_Load . . .
הוא מתרחש רק אחרי אתחול הדף ויצירת פקדי השרת, כדי ש- ASP.NET תוכל לטפל באירועים שלהם. תפקידו לבצע איתחולים לדף ולפקדים. private void Page_Load(object sender,System.EventArgs e) { . . . }

טיפול באירועים האירוע Page_Load - המשך Page_Init Page_Load
Page_Unload Control events Textbox1_Changed Button1_Click Page_Init Change Events Action Events Page is disposed

טיפול באירועים Page.IsPostBack
בכל בקשה (גם בבקשה חוזרת של אותו הדף) נוצר דף חדש. האירוע Page_Load מתרחש בכל טעינה של הדף, לכן הקוד שנמצא באירוע הזה מופעל כל פעם מחדש. בקשה חוזרת של אותו הדף מכונה (Round Trip). לעיתים נרצה לבצע איתחולים רק בטעינה הראשונה של הדף ולהימנע מהם בבקשות חוזרות של אותו הדף. בדף מוגדר מאפיין בוליאני בשם IsPostBack, ASP.NET משתמשת במאפיין זה על מנת לבדוק אם הוא נדרש בפעם הראשונה או לא (Round Trip). כאשר הלקוח מבקש את הדף בפעם הראשונה, המאפיין IsPostBack יקבל את הערך false. מהבקשה השניה ואילך ערכו true.

טיפול באירועים Page.IsPostBack - המשך
נשתמש בו באירוע Page_Load בצורה הבאה: private void Page_Load(object sender,System.EventArgs e) { if (!Page.IsPostBack) // הקוד מתבצע רק כאשר הדף נשלח בפעם הראשונה } // הקוד מתבצע בכל פעם שהדף נשלח

טיפול באירועים Page.IsPostBack - המשך דוגמה: נניח שקיים הדף הבא:
המכיל פקד ListBox ופקד Button .

טיפול באירועים Page.IsPostBack – המשך
באירוע Page_Load מאתחלים את הפקד בערכים הבאים: private void Page_Load(object sender, System.EventArgs e) { ListBox1.Items.Add("Shoshana"); ListBox1.Items.Add("Zelda"); ListBox1.Items.Add("Yerachmiel"); ListBox1.Items.Add("Zrubavel"); } בכל לחיצה על הלחצן Button הדף נשלח חזרה לשרת.

טיפול באירועים Page.IsPostBack – המשך בבקשה הראשונה של הדף יוצגו
בפקד הערכים הבאים: בבקשה השניה של הדף יוצגו בפקד הערכים הבאים:

טיפול באירועים Page.IsPostBack – המשך
תופעה זו מתרחשת משום שבכל בקשה מתרחש האירוע Load אשר מוסיף לפקד את רשימת הערכים. על מנת להימנע מכך נוסיף את המאפיין Page.IsPostBack: private void Page_Load(object sender, System.EventArgs e) { if(!Page.IsPostBack) ListBox1.Items.Add("Shoshana"); ListBox1.Items.Add("Zelda"); ListBox1.Items.Add("Yerachmiel"); ListBox1.Items.Add("Zrubavel"); }

טיפול באירועים אירועי פקדים לדוגמה:
הפיתוח ב- ASP.NET הוא Event Driven . אירועים מתרחשים כתגובה לפעילות משתמשים על הפקדים. כדוגמה: לחיצה על כפתור, שינוי תוכן תיבת הטקסט, בחירת פריט מתוך תיבה משולבת וכו... . כל אירוע ניתן לקשר למתודה המבוצעת בעת התרחשות האירוע, המתודה המטפלות באירועי פקדים מכונות Event handler. המתודות הללו מוגדרת בקובץ ה- Code Behind ומורצות רק בשרת. לדוגמה: private void Button1_Click(object sender, System.EventArgs e) { }

טיפול באירועים אירועי פקדים - המשך למתודות Event handler יש מבנה דומה.
הכותרת מורכבת משם הפקד והאירוע שהתרחש, לדוגמה: Button1_Click, ListBox1_SelectedIndexChanged, TextBox1_TextChanged המתודות יקבלו שני פרמטרים: System.EventArgs e , object sender. sender - מציין איזה פקד יצר את האירוע. e - מכיל מידע נוסף לצורך הטיפול באירוע.

טיפול באירועים אירועי פקדים - המשך
לכל פקד מציג מספר אירועים, את האירועים שהפקדים מציגים ניתן לראות בחלון של מאפייני הפקד (Properties Window). כדי לראות את האירועים נלחץ על תווית ה- Events (צורה של ברק בצבע צהוב) רשימת האירועים של הפקד Button :

טיפול באירועים אירועי פקדים - המשך אירועי הפקדים מתבצעים רק בשרת.
לכל פקדי השרת מוגדרים מספר אירועים בנוסף לחמשת האירועים שהם יורשים מהמחלקה Control : Init Load PreRender Unload DataBinding

האירועים מתרחשים בדפדפן הלקוח ומטופלים בשרת. שרת לקוח הודעת אירוע אירוע תגובה event handler

קישור האירוע עם הקוד שמתרחש בשרת כתגובה לאירוע מתבצע באמצעותdelegates . ה-delegates הוא אובייקט המכיל מצביעים למתודות. Visual Studio.NET מבצע בעצמו את תהליך הקישור בין אירוע הפקד לבין הקוד המטפל בו בצד שרת. דוגמה: קישור בין האירוע Page.Load ו- Button.Click לבין המתודות המטפלות בהן (Event Handlers). this.Button1.Click += new System.EventHandler(this.Button1_Click); this.Load += new System.EventHandler(this.Page_Load);

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

טיפול באירועים אירועי המערכת בGlobal.ASAX - המשך
נועד בעיקר לטיפול באירועי Session ו- Application. קובץ זה מקומפל ביחד עם קבצי ה- Code Behind ל- dll, אי אפשר להפעיל אותו ישירות מהדפדפן. Global.aspx מאפשר שליטה על אירועים שהתרחשו ברמת האפליקציה ולא ברמת הדף. קובץ זה זמין לכל הדפים באפליקציה, לכן כל שינוי בו מחייב אתחול מחדש של האפליקציה. האתחול מתבצע ברקע בלי שהמשתמש ירגיש.

תיאור האירוע מתרחש פעם אחת בעת הפעלת אפליקציית ASP.NET. Application_Start() מתרחש פעם אחת בעת סיום אפליקציית ASP.NET. Application_End() מתרחש בכל פעם ש- Session חדש מתחיל (בעת הבקשה ראשונה של הלקוח - HTTP Request). Session_Start() מתרחש בכל פעם ש- Session מסתיים (למשל כאשר הלקוח סוגר את הדפדפן). Session_End()

protected static int activeUsers;
טיפול באירועים אירועי המערכת בGlobal.ASAX - המשך דוגמה: מעקב אחר מספר הגולשים באתר. בדוגמה נשתמש באירועי המערכת הבאים: Application_Start, Session_Start ו- Session_End. 1 - נגדיר ב- Global.asax משתנה סטטי מסוג int שימנה את מספר המבקרים באתר: protected static int activeUsers;

טיפול באירועים אירועי המערכת בGlobal.ASAX - המשך דוגמה – המשך:
2 - נגדיר מאפיין שיחזיר לנו את מספר המבקרים לצורך הצגתם בטופס האינטרנט בעת הצורך. מספר המבקרים מאוחסן במשתנה activeUsers שהגדרנו קודם. static int ActiveUsers { get return activeUsers; }

דוגמה – המשך : 3 - באירוע Application_Start (מתרחש כאשר האפליקציה מתחילה), נאתחל את מספר המבקרים ל- 0. כמובן שאפשר להוסיף הגדרות אחרות כמו למשל מספר המבקרים ביום אחד או מספר הביקורים בכל הדפים או כל הגדרה נחוצה אחרת. protected void Application_Start(Object sender, EventArgs e) { activeUsers = 0; }

טיפול באירועים אירועי המערכת בGlobal.ASAX - המשך דוגמה – המשך :
4- באירוע Session_Start, כלומר בעת כניסת הלקוח לאתר נעלה את המונה באחד. כדי לחסום את הגישה לאירוע למשתמש בודד בכל פעם נשתמש במתודות Application.Lock() ו- Application.UnLock() . חשוב לעשות זאת כדי למנוע התנגשויות בעת הכניסה של יותר ממשתמש אחד בו בעת. protected void Session_Start(Object sender, EventArgs e) { Application.Lock(); activeUsers ++; Application.UnLock(); }

5 - באירוע Session_End, כלומר בעת שהלקוח עוזב את האתר נחסיר מהמונה אחד. נשתמש במתודות Application.Lock() ו' Application.UnLock() מאותן סיבות שהזכרנו קודם. protected void Session_End(Object sender, EventArgs e) { Application.Lock(); activeUsers --; Application.UnLock(); }

6 – על מנת לצפות במספר המשתמשים נוסיף את הקוד הבא לאחד מדפי ה- aspx : private void Page_Load(object sender, System.EventArgs e) { Label1.Text = Global.Counter.ToString(); }

Web.Config קובץ הקונפיגורציה הינו קובץ טקסט בפורמט XML סטנדרטי שמכיל את הגדרות התצורה של האפליקציה. אחד החידושים ב- ASP.NET. אפשר לתעד את התוכן שלו:  אפשר לפתוח ולעדכן את הקובץ בכל עורך טקסט רגיל. יכול לשמור הגדרות לדף בודד,לתיקיה שלמה או לכל האפליקציה. הוא אופציונאלי ולא חייב להימצא באפליקציה.

Web.Config קובץ הקונפיגורציה ממוקם בתיקיית השורש של האפליקציה.
אפשר ליצור מספר קבצי קונפיגורציה באפליקציה אחת, אבל בתיקיות שונות.

Web.Config דוגמא פשוטה לקובץ Web.Config.
<?xml version="1.0" encoding="UTF-8" ?> <configuration> <system.web> <authentication mode="Forms"> <forms name="appNameAuth" loginUrl="login.aspx" timeout="20"> </forms> </authentication> <authorization> <deny users="?" /> </authorization> </system.web> </configuration>

Web.Config קובץ קונפיגורציה, מדוע?
תסריט, יישום ASP.NET נעזר במסד נתונים Access על מנת לקרוא ולשמור נתונים. על מנת לעבוד עם מסד הנתונים יש להגדיר מחרוזת חיבור (Connection String), מחרוזת החיבור הוגדרה בקוד, הפרוייקט קומפל והותקן בספרייה וירטואלית בשרת אינטרנט. עברו חלפו הימים , האתר נעשה פופולארי ומסד הנתונים לא מצליח לעמוד בקצב, יש להחליפו במסד נתונים חזק יותר כמו SQL Server . מחרוזת החיבור של SQL Server שונה משל Access ולכן נאלצנו לחזור לקוד המקור לשנות את מחרוזת החיבור , לקמפל מחדש ולהתקין מחדש את היישום בשרת האינטרנט.

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

Web.Config תוכן הקובץ מאפשר שמירת מאפייני האפליקציה ע"י המאפיין appSettings , עליו נדבר בהמשך . לדוגמה: מחרוזת החיבור (ConnectionString) . אפשר לשמור את נתוני משתמשי המערכת (אם מספרם קטן) באמצעות האלמנט credential. אבטחה (Security): במקום לכתוב קוד בכל דף מאובטח, אפשר לעשות זאת בקובץ. ניתן לאבטח תיקיות ואפילו האתר כולו. <location path="admin"> <system.web> <authorization> <deny users="?" /> </authorization> </system.web> </location>

Web.Config תוכן הקובץ – המשך
דפי שגיאה מותאמים אישית : שגיאה באתר עלולה להציג מידע רגיש, שלא נרצה שהמשתמש יראה. לכן עדיף להוביל את המשתמש בעת הופעת השגיאה לדף שגיאות אישי משלנו. טיפול בגלובליזציה (Globalization): קובץ הקונפיגורציה מאפשר טיפול בתאריכים, שפות ולאומים שונים. דוגמא לעבודה עם התאריך והשפה העברית: <customErrors mode="On" > <error statusCode="404" redirect="PageNotFoundError.aspx"/> <error statusCode="500" redirect="MyAppCustError.aspx"/> </customErrors> <globalization requestEncoding=windows-1255 responseEncoding=windows-1255 culture=he-il />

Web.Config תוכן הקובץ – המשך
טיפול ב- Session, זמן הפקיעה של האובייקט מוגדר 20 דקות כברירת המחדל, אפשר לשנות הגדרה זו ע"י שינוי המאפיין timeout. אפשר להגביל את גודל הקבצים שנשלחים ע"י המשתמש ואת משך הזמן לקבלתם. וכך נוכל למנוע מהמשתמשים בעלי כוונות זדוניות מלהפציץ את האתר בקבצים. ערך ברירת המחדל הוא 4mb . <configuration> <system.web> <sessionState timeout="15" /> </system.web> </configuration> <httpRuntime maxRequestLength="1100" executionTimeout="90"/>

Web.Config שמירת מידע לקובץ קונפיגורציה
אחד הדרכים לשמירת מידע בקובץ הקונפיגורציה היא באמצעות האלמנט appSetting המאפשר לשמור מידע מותאם אישית. האלמנט appSetting> > מוגדר באמצעות זוג מפתח-ערך (key-value) התכונה הראשונה תשמש כמפתח ראשי והשניה תציב ערך לאותו מפתח. באמצעות המפתח נוכל לגשת לערך שלו מכל דף באפליקציה.

Web.Config שמירת מידע לקובץ קונפיגורציה – המשך
דוגמא לשמירת ערך בקובץ הקונפיגורציה : <appSettings> <add key="fName" value="MyFirstName"/> <add key="lName" value="MyLastName"/> <add key="conString" value="Provider=Microsoft.Jet.OLEDB.4.0 ; Data Source=c:\\inetpub\\wwwroot\\Test\\MyDB.mdb" /> </appSettings>

Web.Config קריאת מידע מקובץ קונפיגורציה
כדי לקרוא מידע מקובץ הקונפיגורציה, צריכים להוסיף את מרחב השמות (namespace) System.Configuration. המחלקה ConfigurationSettings ששייכת למרחב השמות הנ"ל מכילה מאפיין בשם AppSettings , מאפיין זה יודע לפנות לקובץ הקונפיגורציה ולקרוא ערכים: דוגמה: ConfigurationSettings.AppSettings[“המפתח"]; המפתח שיצרנו בקובץ Web.config txtFName.Text=ConfigurationSettings.AppSettings["fName"]; txtLName.Text=ConfigurationSettings.AppSettings["lName"];

Web.Config הקשר היררכי בין קבצי קונפיגורציה
ברמת השרת (IIS) מוגדר קובץ קונפיגורציה הנקרא machine.config ,קובץ זה מותקן בעת התקנת .NET Framework ומכיל הגדרות גלובאליות המשותפות לכל יישומי ASP.NET המותקנות השרת. קובץ הקונפיגורציה Web.Config מקבל את הגדרות ברירת המחדל שלו מ- Machine.Config . במידה ובאפליקציה לא מוגדר Web.Config, היישום מקבל את ההגדרות ישירות מ- Machine.Config . במידה וביישום מוגדר Web.Config הוא יהיה זמין ליישום ולכל היישומים בתת הספריות. SubDir RootDir web.config זמין גם לתקיות אלה

Web.Config Web Server הקשר היררכי בין קבצי קונפיגורציה - המשך
קובץ קונפיגורציה דורס את ההגדרות הקיימות בקובץ הקונפיגורציה הנמצא בספריה שמעליו, וקובץ הקונפיגורציה בספריית השורש דורס את ההגדרות המוגדרות ב- Machine.Config . IIS wwwroot Sub Dir machine.config Web.Config Web.Config Web Server

פקדים פקדי שרת Html Server Controls
Html Controls או פקדי HTML הם קבוצה של פקדים בסיסיים שנתמכים ע"י שפת HTML, לדוגמה : Input, Textarea, Options וכו... הם פשוטים ולא דורשים משאבים גדולים במיוחד. כברירת מחדל פקדים אלו פועלים רק בצד הלקוח (Client Side). ניתן להפוך אותם גם לפקדי צד השרת (HTML Server control). כפקדי צד שרת ניתן לעבוד עימם גם בצד לקוח וגם בצד שרת.

פקדים פקדי שרת Html Server Controls – המשך <input type="text">
על מנת להפוך פקד HTML רגיל לפקד שרת יש ללחוץ על הפקד עם הלחצן הימני בעכבר, מהתפריט בוחרים באפשרות Run as Server Control. או לחילופין להוסיף את המאפיין runat="server" להגדרת הפקד בדף ה- HTML . Html Control: <input type="text"> Html Server Controls <input type="text" runat=“server”>

פקדים פקדי שרת Html Server Controls – המשך
תומכים במנגנון התכנות המונחה אירועים (הן בצד לקוח והן בצד שרת). פקדים אלו נמצאים תחת מרחב השמות (namespace) System.Web.UI.HtmlControls.

פקדים פקדי שרת Web Server Controls
סידרה של פקדים שפותחו במיוחד לעבודה בסביבת ASP.NET ,מכונים גם Controls ASP.NET Web Form . לפקדים יש מאפיינים, אירועים ומתודות שאפשר לעבוד איתם בזמן הריצה. לפני כל פקד מסוג זה נמצא את התגית : <asp:> פקדים אלו נמצאים תחת מרחב השמות (namespace) System.Web.UI.WebControls לא מוכרים על ידי הדפדפנים , אלא מתורגמים לפקדי HTML רגילים, השרת מייצר עבורם קוד שתלוי בדפדפן שביקש את הדף. .

פקדים פקדי שרת Web Server Controls
כולם יורשים מאותה מחלקה, ולכן יש להם מאפיינים משותפים, כמו width, Height, BackColor וכו' פקדי HTML מסורתיים הם stateless – חוזרים להגדרות ברירת מחדל, בעוד שעבור פקדי שרת מצב התצוגה וקלט המשתמשים נשמרים אוטומטית באמצעות אובייקט הנקרא ViewState . חייבים להיות מוגדרים כ- " runat = server” , אחרת לא יפעלו. אירועים מורצים רק בצד השרת, לא מוכרים בצד לקוח. מכילים אוסף של פקדים מיוחדים שלא קיימים ב- HTML , כגון: Calendar, DataGrid, AdRotator, ImageButton וכו' .

פקדים פקדי שרת השוואה בין סוגי הפקדים. תיבת טקסט כ- Html Control:
<input type="text“ /> תיבת טקסט כ- HTML Server Control : <input type="text“ id=“mytext” runat=“server” /> תיבת טקסט כ- Web Server Control : <asp:TexBox id=“mytext” runat=“server” />

פקדים פקדי שרת השוואה בין סוגי הפקדים.
בעורך הגראפי Html Control ו-Web Server Control נראים אותו דבר למעט של- Web Server Control נוסף חץ ירוק קטן בפינה השמאלית העליונה. Html Server Control Html Control

פקדים הפקדים הסטנדרטיים- TextBox תפקידו לאפשר קבלת קלט מהמשתמש.
משמש גם להצגת נתונים, אם כי לשימוש זה יש תחליפים. המשתמש יכול לערוך את הטקסט, להעתיק, להדביק, לגזור או לבחור טקסט שבתוך הפקד. אפשר למנוע את העריכה של הטקסט ע"י שינוי ערך המאפיין ReadOnly ל- true. כברירת המחדל של TextBox אפשר להכניס עד תווים, ניתן להגביל מספר תווים זה לפחות (MaxLength) או להגדילו עד 32 KB של טקסט (MultiLine TextMode =).

פקדים הפקדים הסטנדרטיים- TextBox- המשך דוגמא ל- TextBox בעורך הגראפי:
בעורך ה- HTML : <asp:TextBox id="TextBox1“ runat="server"> TextBox </asp:TextBox> בדפדפן : >input name="TextBox1" type="text" id="TextBox1”/>

פקדים הפקדים הסטנדרטיים- TextBox - המשך מאפיינים חשובים מאפיין
צבע הרקע Backcolor סוג הגופן Font גובה הפקד Height מספר התווים המקסימאלי שהפקד יכול לקבל MaxLength למניעת העריכה ReadOnly הטקסט שמופיע מעל הפקד Text הצורה בה יוצג הטקסט TextMode הצגה או הסתרה של הפקד Visible רוחב הפקד Width

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

פקדים הפקדים הסטנדרטיים – Label – המשך דוגמה ל- Label בעורך הגראפי:
בעורך ה- HTML : <asp:Label id="Label1" runat="server">Label</asp:Label> בדפדפן: <span id="Label1">Label</span>

פקדים הפקדים הסטנדרטיים – Label – המשך מאפיינים חשובים תיאור מאפיין
צבע הרקע Backcolor סוג המסגרת BorderStyle עובה המסגרת BorderWidth סוג הגופן Font צבע הטקסט ForeColor גובה הפקד Height הטקסט שמופיע מעל הפקד Text הצגה או הסתרה של הפקד Visible רוחב הפקד Width

פקדים הפקדים הסטנדרטיים – Button
פקד פקודה, הקלקה על פקד זה פירושה "ריצה" מיידית לשרת (Postback) . בשרת יופעל אירוע שהוגדר מראש.

פקדים הפקדים הסטנדרטיים – Button – המשך דוגמא לשימוש בעורך הגראפי:
בדף HTML : <asp:Button id="Button1" runat="server" Text="Button"> </asp:Button> בדפדפן: <input type="submit" name="Button1" value="Button" id="Button1" />

פקדים הפקדים הסטנדרטיים – Button – המשך מאפיינים חשובים תיאור מאפיין
צבע הרקע Backcolor סוג המסגרת BorderStyle עובה המסגרת BorderWidth מעביר ערך זה בעת אירוע הלחיצה CommandName העברת מידע נוסף בעת אירוע הלחיצה CommandArgument גובה הפקד Height הטקסט שמופיע מעל הפקד Text הצגה או הסתרה של הפקד Visible רוחב הפקד Width

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

פקדים פקדי רשימה – DropDownList - המשך מצב סגור: מצב פתוח:

פקדים פקדי רשימה – DropDownList - המשך מאפיינים חשובים תיאור מאפיין
האם לשלוח את הטופס לשרת אחרי בחירת פריט מהרשימה AutoPostBack DataSet איבר של מקור הנתונים למשל טבלה מה' DataMember DataSet מקור הנתונים למשל DataSource למשל השדה של הטבלה DataTextField ערך של שדה הנתונים DataValueField אוסף הפריטים של הפקד Items המספר הסידורי של הפריט שנבחר SelectedIndex מאפשר בחירה של ערך אחד או יותר מפריטי הרשימה SelectionMode ערך הפריט הנבחר SelectedValue

פקדים פקדי רשימה – ListBox
מאפשר בחירה של פריט אחד או יותר מתוך רשימה של פריטים המוגדרים מראש. רשימת הפריטים גלויה כל הזמן. שימושי כאשר צריכים לאפשר למשתמש בחירה של ערך אחד או יותר מתוך סידרת ערכים. הוספת הפריטים לפקד יכולה להתבצע בזמן עיצוב או בזמן ריצה: בזמן העיצוב: באמצעות המאפיין Items של הפקד. בזמן הריצה: באמצעות המתודה Add.

פקדים פקדי רשימה – ListBox - המשך מאפיינים חשובים תיאור מאפיין
האם לשלוח את הטופס לשרת אחרי בחירת פריט מהרשימה AutoPostBack DataSet איבר של מקור הנתונים למשל טבלה מה' DataMember DataSet מקור הנתונים למשל DataSource למשל השדה של הטבלה DataTextField ערך של שדה הנתונים DataValueField אוסף הפריטים של הפקד Items המספר הסידורי של הפריט שנבחר SelectedIndex מאפשר בחירה של ערך אחד או יותר מפריטי הרשימה SelectionMode ערך הפריט הנבחר SelectedValue

פקדים המאפיין AutoPostBack
כברירת מחדל הטופס חוזר לשרת (Postback) רק כאשר המשתמש לוחץ על Button . בפקדים ListBox, DropDownBox מוגדר האירוע SelectedIndexChanged המופעל כאשר המשתמש בוחר ערך מתוך רשימת ערכים, בפקד TextBox מוגדר האירוע TextChanged המופעל כאשר הפקד מאבד פוקוס לאחר שהמשתמש הקליד בו דבר מה. כברירת מחדל, שלושת אירועים אלו נשמרים בצד לקוח עד שהמשתמש מקליק על Button . בהקלקה הטופס נשלח לשרת ושם מבוצעים כל אותם אירועים. האירועים מבוצעים על פי סדר הוספת הפקדים לטופס בזמן עיצוב.

פקדים המאפיין AutoPostBack – המשך לדוגמה:
נציב בטופס את הפקדים הבאים על פי הסדר : DropDownList, ListBox ו- TextBox . נוסיף עוד פקד Button שתפקידו לשלוח את הטופס לשרת, ועוד פקד ListBox בו נרשום את האירועים שהתרחשו בטופס.

פקדים המאפיין AutoPostBack – המשך הטיפול באירועים:
private void Button1_Click( ) { lstEventList.Items.Add("Button1_Click"); } private void ListBox1_SelectedIndexChanged( ) lstEventList.Items.Add("ListBox1_SelectedIndexChanged"); private void TextBox1_TextChanged( ) lstEventList.Items.Add("TextBox1_TextChanged"); private void DropDownList1_SelectedIndexChanged( ) lstEventList.Items.Add("DropDownList1_SelectedIndexChanged");

פקדים המאפיין AutoPostBack – המשך דוגמה – המשך :
מריצים את האפליקציה, בוחרים ערכים ל- ListBox, DropDownList ול- TextBox , מקליקים על ה- Button , הטופס מורץ לשרת , והתוצאה המתקבלת היא :

פקדים המאפיין AutoPostBack – המשך
לעיתים נרצה לבצע "ריצה" מיידית לשרת כאשר המשתמש בוחר ערך מפקדי DropDownList , ListBox או מקליד מידע ב- TextBox. כדי שפקדים אלו יבצעו Postback , יש להגדיר את המאפיין AutoPostBack כשווה true . כאשר AutoPostBack=true הפקד "רץ" לשרת מבלי לחכות ל-Button.Click .

פקדים המאפיין AutoPostBack – המשך דוגמה – המשך :
משנים לפקדים ListBox1, DropDownList ול- TextBox את המאפיין AutoPostBack ל- true . ומריצים פעם נוספת.

בחירת ערך ב- DropDownList
פקדים המאפיין AutoPostBack – המשך דוגמה – המשך : בחירת ערך ב- ListBox בחירת ערך ב- DropDownList בחירת ערך ב- TextBox

פקדים פקדי בחירה - CheckBox
מאפשר למשתמש אפשרות בחירה באחד משני מצבים: true או false . סימון הפקד מציין true, ואי סימונו מציין false . ערך ברירת המחדל של המאפיין Checked הוא false. לעיתים קרובות משתמשים בפקד זה כאשר נדרש לאפשר למשתמש אפשרויות בחירה רבות, או המשתמש צריך לענות על שאלה שהתשובה שלה היא כן או לא בלבד. בכל לחיצה על הפקד ערך המאפיין Checked מתחלף. גם לפקד זה מוגדר המאפיין AutoPostBack .

פקדים פקדי בחירה – CheckBox - המשך דוגמה ל- CheckBox בעורך הגראפי:
בעורך ה- HTML : <asp:CheckBox id="CheckBox1" runat="server"></asp:CheckBox> בדפדפן: <input id="CheckBox1" type="checkbox" name="CheckBox1" />

פקדים פקדי בחירה – CheckBox – המשך מאפיינים חשובים: תיאור מאפיין
צבע הרקע Backcolor סימון \ אי סימון של הפקד Checked סוג הגופן Font צבע הטקסט ForeColor גובה הפקד Height הטקסט שמופיע מעל הפקד Text הצגת הטקסט מימין או משמאל לפקד TextAlign הצגה או הסתרה של הפקד Visible רוחב הפקד Width

פקדים פקדי בחירה – RadioButton
מאפשר למשתמש לבחור באפשרות אחת בלבד מבין מספר אפשרויות. פקדי RadioButtons מוגדרים בקבוצות, כל פקד בקבוצה מגדיר אפשרות אחת לבחירה. כאשר בוחרים RadioButton אחד מתוך הקבוצה, הוא מקבל את הערך true וכל שאר הפקדים את הערך false. גם לפקד זה מוגדר המאפיין AutoPostBack .

פקדים פקדי בחירה – RadioButton - המשך דוגמה ל- RadioButton
בעורך הגראפי: בעורך ה- HTML : <asp:RadioButton id="RadioButton1" runat="server"> </asp:RadioButton> בדפדפן: <input id="RadioButton1" type="radio" name="RadioButton1" value="RadioButton1" />

פקדים פקדי בחירה – RadioButton - המשך מאפיינים חשובים תיאור מאפיין
צבע הרקע Backcolor סימון \ אי סימון של הפקד Checked סוג הגופן Font צבע הטקסט ForeColor גובה הפקד Height הטקסט שמופיע מעל הפקד Text הצגת הטקסט מימין או משמאל לפקד TextAlign הצגה או הסתרה של הפקד Visible רוחב הפקד Width

פקדים פקדי אימות קלט משתמש
אימות קלט משתמש (Validating User Input) הנו תהליך הבודק האם מידע שהמשתמש הקליד בטופס מתאים לערך הנדרש, לטווח ערכים מוגדר או לתבנית קלט כלשהיא. אימות קלט משתמש מתבצע על ידי השוואה בין קלט מהמשתמש אל מול תבנית קלט נדרשת אשר נקבעה מראש. תבניות הקלט שנקבעו מראש יכולות להגדיר מספר תווים חוקי, שימוש בתווים מסוימים, טווח ערכים לערך שהוקלד או נוסחא מתמטית. לדוגמא: שדה הקולט כתובת אמורה להיות במבנה מוגדר וחוקי . מספר טלפון חייב להכיל רק ספרות ומספר מוגדר וידוע מראש של ספרות.

פקדים פקדי אימות קלט משתמש התהליך :
בדיקת החוקיות מתבצעת גם בצד לקוח וגם בצד שרת על פי תרשים הזרימה הנ"ל: 2 התהליך : קלט המשתמש נבדק בצד לקוח, במידה והקלט אינו תואם לתבנית שהוגדרה מראש, שליחת הטופס לשרת תבוטל ויוצגו סמלי שגיאה. במידה והקלט תואם את התבנית, שליחת הטופס לשרת לא תתעכב. בשרת מתבצעת בדיקה נוספת של הקלט. במידה והקלט אינו תואם לתבנית שהוגדרה מראש, עיבוד הטופס בשרת יבוטל והוא יוחזר ללקוח לתיקון הטעויות. במידה והקלט אומת, השרת יוכל לעבד את הבקשה. 1 3 4 5 6

אימות קלט משתמש מגן על היישום מפני 2 סכנות עיקריות: Spoofing – מתרחש כאשר משתמש מנטרל סקריפטים לולידציה בצד הלקוח (ע"י נטרול קוד בצד הלקוח שמתבמע בעזרת שינוי הדגרות הדפדפן). ב- ASP.NET ולידציה של צד הלקוח מתבצעת תמיד שוב בצד השרת –שם המשתמש לא יכול לשנות או לנטרל קוד. Malicious code – מתרחש כאשר משתמש יכול להוסיף טקסט בלתי מוגבל ל- Web Page דרך פקדי קלט שאין להם ולידציה. משתמש יכול לשלוח טקסט עצום שיתקע את השרת או להכניס כל מחרוזת אפשרית שיכולה להיות גם שאילתה ששולפת מידע כלשהו מה- DB או הוספת הרשאות או יצירת Accounts. אימות הקלט מונע "ריצות" מיותרות של הטופס לשרת.

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

פקדים פקדי אימות קלט משתמש - הרשימה
RequiredFieldValidator – בודק האם הוזן ערך כלשהוא בפקד שחייב לקבל ערך. RangeValidator – בודק האם ערכו של פקד מסויים נמצא בטווח ערכים מוגדר. RegularExpressionValidator – בודק האם מבנה המידע שהוקלד בפקד מתאים לתבנית מוגדרת. CompareValidator – השוואת ערכם של שני פקדים. CustomValidator – מאפשר כתיבת קוד בדיקה מותאם אישית. ValidationSummary – מציג סיכום של כל שגיאות אימות הקלט בדף.

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

פקדים פקדי אימות קלט משתמש – הוספת פקד לטופס
דוגמה לפקדי אימות ב- HTML : <asp:RequiredFieldValidator ID="RequiredFieldValidator1“ runat="server" ControlToValidate="TextBox1" Display="Dynamic" ErrorMessage="Error Message">*</asp:RequiredFieldValidator> <asp:RangeValidator ID="RangeValidator1" runat="server" ControlToValidate="TextBox1" Display="Dynamic" ErrorMessage="RangeValidator" MaximumValue="100" MinimumValue="0" Type="Integer">R</asp:RangeValidator> פקדי האימות מציגים מחרוזת לשגיאה, ולכן מומלץ להציבם בסמוך לפקד אותו הם בודקים.

פקדים פקדי אימות קלט משתמש – RequiredFieldValidator
בודק האם הוזן ערך כלשהוא בפקד שחייב לקבל ערך. האימות לא מתבצע רק לגבי פקד ריק אלא גם על פקד המכיל ערך התחלתי שהמשתמש חייב לשנות. מאפיינים חשובים: תיאור מאפיין השדה שעליו מתבצע האימות CotrolToValidate ההודעה כאשר השדה לא אומת ErrorMessage טקסט שאפשר לאמת (אופציונאלי) InitialValue

פקדים פקדי אימות קלט משתמש – RangeValidator
בודק האם ערכו של פקד מסויים נמצא בטווח ערכים מוגדר. הערך יכול להיות מספרי, תווי, תאריך או מטבע. מאפיינים חשובים: תיאור מאפיין השדה שעליו מתבצע האימות CotrolToValidate ההודעה כאשר השדה לא אומת ErrorMessage הערך המקסימאלי לשדה האימות MaximumValue הערך המינימאלי לשדה האימות MinimumValue סוג הנתונים שצריך לאמת Type

פקדים פקדי אימות קלט משתמש – CompareValidator
השוואת ערכם של שני פקדים. כדי להשוות מול ערכו שלקבוע בוחרים במאפיין ValueToCompare. כדי להשוות לערך שהוזן בפקד אחר בוחרים במאפיין ControlToCompare. מאפיינים חשובים: תיאור מאפיין שדה ההשוואה ControlToCompare השדה שעליו מתבצע האימות CotrolToValidate ההודעה כאשר השדה לא אומת ErrorMessage סוג ההשוואה Operator השוואה לקבוע ValueToCompare סוג הנתונים של הבדיקה Type

פקדים פקדי אימות קלט משתמש - RegularExpressionValidator
בודק האם מבנה המידע שהוקלד בפקד מתאים לתבנית מוגדרת. פקד זה משווה את התווים, הספרות והסימנים שהוקלדו לתבנית מוגדרת, לדוגמא: , מס' טלפון, מיקוד וכו'. מאפיינים חשובים: תיאור מאפיין השדה שעליו מתבצע האימות CotrolToValidate ההודעה כאשר השדה לא אומת ErrorMessage תבנית האימות ValidationExpression

פקדים פקדי אימות קלט משתמש – CustomValidator
מאפשר כתיבת קוד בדיקה מותאם אישית. נשתמש בו כאשר נדרש לכתוב קוד אימות קלט מותאם. כאשר אף אחד מפקדי אימות הקלט האחרים אינם מספקים מענה מתאים, לדוגמה: בדיקת ספרת ביקורת של מספר זהות. מאפיינים חשובים: תיאור מאפיין השדה שעליו מתבצע האימות CotrolToValidate ההודעה כאשר השדה לא אומת ErrorMessage להפעלת קוד האימות OnServerValidate

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

פקדים פקדי אימות קלט משתמש – בדיקות בצד שרת
ניתן להשתמש במאפיין Page.IsValidעל מנת לבדוק בצד שרת האם כל ערכי הפקדים תקינים. המאפיין Page.IsValid יחזיר true רק אם כל פקדי האימות שבעי רצון מקלט המשתמש (מחזירים true ). לדוגמה: protected void Button1_Click(object sender, EventArgs e) { if (Page.IsValid) obj.DoSomething(); }

פקדים פקדי אימות קלט משתמש – בדיקות בצד שרת
במקום לבדוק את כל פקדי האימות כמקשה אחת , ניתן לבדוק פקד פקד : protected void Button1_Click(object sender, EventArgs e) { if (RequiredFieldValidator1.IsValid) obj.DoSomething(); }

פקדים פקדי מכולה - Table
בניית הפקד יכולה להתבצע בזמן העיצוב, אולם כוחו ועוצמתו האמיתיים של הפקד הם בהיותו ניתן לתכנות בזמן הריצה. בעורך הגראפי: בעורך ה- HTML: <asp:Table id="Table1“ runat="server"></asp:Table>

פקדים פקדי מכולה - Table - המשך
כדי להגדיר פקד Table יש ליצור שורות (TableRow) ותאים TableCell)). בעת הפעלת דף האינטרנט הופכות פקודות הפקד Table לתגיות הטבלה המוכרות מ- HTML דהיינו ,table ,tr ו- td מאפיינים חשובים: תיאור מאפיין הצגה-הסתרה של קווי הרשת של הפקד GridLines יישור אופקי לתכולת הפק HorizontalAlignment להוספת שורות ותאים לטבלה Rows

פקדים פקדי מכולה - Table - המשך דוגמה , יצירת טבלה בזמן ריצה:
for (int j=0; j<numrows; j++) { TableRow r = new TableRow(); for (int i=0; i<numcells; i++) TableCell c = new TableCell(); c.BorderWidth = 2; btn = new Button(); btn.Width = 30; btn.Height = 20; btn.Text = (i*j).ToString(); btn.BackColor = Color.Red; c.Controls.Add(btn); r.Cells.Add(c); } Table1.Rows.Add(r);

פקדים פקדי מכולה - Panel דוגמת HTML :
השימוש בו יוצר מראה נפרד וברור לכל קבוצת פקדים. הכלת הפקדים בתוך ה- Panel עוזרת לנו להשתמש בהם כיחידה אחת ולהציגם בצורה מסודרת על הטופס. דוגמת HTML : <asp:panel id="Panel1“ runat="server">Panel</asp:panel>

פקדים פקדי מכולה - Panel - המשך
לעיתים קרובות משתמשים בו כדי להציג או להסתיר קבוצה שלמה של פקדים. הפקד מאוד עוזר בזמן העיצוב. כאשר צריכים להעביר קבוצה של פקדים ממקום אחד בטופס לאחר או למחוק את כל הפקדים באותה קבוצה. כאשר הוא מועבר ללקוח הוא מתורגם ומוצג בדפדפן (explorer) כתגית ה HTML <div>.

פקדים כריכת מידע ASP.NET מציעה לשימוש גלריה של פקדים שמטרתם להציג ישירות מידע הקיים במקור מידע. פקדים אלו מתחברים למקור מידע באמצעות מאפיינים ומציגים אותו בטופס. הם מקושרים למקור המידע ישירות. ASP.NET משלבת את המידע בפקדים אלו באופן אוטומטי. פקדי ה- List-Bound : DropDownList , ListBox , CheckBoxList , RadioButtonList , DataGrid , DataList , Repeater.

פקדים כריכת מידע – DataGrid ב- HTML :
נשתמש בפקד זה כאשר יש צורך להציג נתונים של מקור המידע טבלאי. כברירת מחדל הוא מציג את הנתונים לקריאה בלבד. ניתן להוסיף לא אפשרות בחירת שורה, מחיקת שורה ועריכת שורה. ניתן להוסיף לו פקדים אשר יציגו את המידע כדי שניתן יהיה לערוך אותם. ב- HTML : <asp:DataGrid id="DataGrid1“ runat="server"></asp:DataGrid>

פקדים כריכת מידע – DataGrid כל רשומה מוצגת כשורה וכל שדה מוצג כעמודה.
הפקד מציג בצורה אוטומטית את המידע השמור במקור המידע. כדי לשלוט בהצגת השדות נשנה את ערך המאפיין AutoGenerateColumn ל- false. באמצעות DataGrid נוכל לחלק מידע גדול לעמודים בצורה פשוטה (paging). ניתן למיין את הנתונים בלחיצה על כפתור.

פקדים כריכת מידע – DataGrid - דוגמה הגדרת אובייקט החיבור מחרוזת החיבור
OleDbConnection conn=new OleDbConnection(); OleDbCommand cmd= new OleDbCommand(); ; Data Source=“ ; conn.ConnectionString +=Server.MapPath("school.mdb"); string SqlStr="select * from Student"; cmd.CommandText=SqlStr; cmd.Connection=conn; OleDbDataAdapter da=new OleDbDataAdapter(cmd); DataSet ds = new DataSet(); da.Fill(ds); DataGrid1.DataSource=ds; DataGrid1.DataBind(); מחרוזת החיבור יצירת משפט SQL הגדרת Adapter הגדרת DataSet וטעינתו בטבלה חיבור ה- DataSet ל- DataGrid

פקדים כריכת מידע – DataGrid מאפיינים חשובים: תיאור מאפיין
האם לאפשר חלוקה לדפים AllowPaging האם לאפשר מיון הנתונים AllowSorting שינוי מאפייני עיצוב הפריטים לסירוגין AlternatingItemStyle קובע אם להציג את כל העמודות באופן אוטומטי AutoGenerateColumns שהערך הזה הוא המפתח.DataGrid הודעה ל'' DataKeyField DataSet איבר של מקור הנתונים למשל טבלה מה' DataMember DataSet מקור הנתונים למשל DataSource viewstate האם לשמור את מצב הפקד ב- EnableViewState מספר הפריטים בדף אחד PageSize

פקדים כריכת מידע – DataList ב- HTML
כמו קודמו, מיועד להציג נתונים ממקור מידע טבלאי. מציג את המידע בצורה של תבניות ((Templates שהוגדרו מראש. אפשר להשתמש בו כדי לאפשר למשתמשים שינוי ומחיקת נתונים. אפשר להציג את הנתונים ביותר מעמודה אחת באמצעות המאפיין RepeatColumns. ב- HTML <asp:DataList id="DataList1“ runat="server"> </asp:DataList>

פקדים כריכת מידע – DataList
על מנת להציג את הנתונים חובה להגדיר תבנית אחת לפחות. בדרך כלל משתמשים בתבנית ItemTemplate. התבניות של הפקד DataList: .HeaderTemplate: הכותרת העליונה. ItemTemplate: עיצוב הנתונים. AlternateItemTemplate: עיצוב השורות הזוגיות. SeparatorTemplate: הפרדה בין השורות. FooterTemplate: הכותרת התחתונה. SelectedItemTemplate: עיצוב הפריט הנבחר. EditItemTemplate: עיצוב הפריטים במצב העדכון.

פקדים כריכת מידע – DataList- המשך צעדים בהגדרת הפקד:
גישה למסד נתונים ובניית DataSet המכיל את הנתונים הנדרשים להצגה. קישור ה- DataSet לפקד, בדיוק כמו עם DataGrid : על מנת שהפקד יציג את הנתונים נדרש להגדיר לפחות תבנית אחת. החיוני ביותר הוא להגדיר את התבנית ItemTemplate על מנת לקבוע כיצד יוצגו הנתונים. ניתן לבנות ולהגדיר עוד תבניות, כגון:תבנית להצגת הכותרת העליונה והתחתונה, תבנית המעצבת את שורות הנתונים הזוגיות וכו' . DataSet ds = new DataSet(); oleDbDataAdapter1.Fill(ds); Datalist1.DataSource=ds; Datalist1.DataBind();

פקדים כריכת מידע – DataList- המשך
צעדים בהגדרת הפקד – קביעת תבנית: <asp:datalist id="DataList1" runat="server" RepeatColumns="2" DataKeyField="id"> <ItemTemplate> <asp:LinkButton id="Linkbutton2“ runat="server"> <%# DataBinder.Eval(Container.DataItem, "fName") %> </asp:LinkButton> <%# DataBinder.Eval(Container.DataItem, "lName")%> </ItemTemplate> </asp:datalist> מספר עמודות תצוגה תבנית הצגת הנתונים קישור השדה fName קישור השדה lName

פקדים כריכת מידע – DataList- המשך מאפיינים חשובים: תיאור מאפיין
שינוי מאפייני עיצוב הפריטים לסירוגין AlternatingItemStyle צבע הרקע Backcolor שהערך הזה הוא המפתח.DataGridהודעה ל'' DataKeyField DataSet איבר של מקור הנתונים למשל טבלה מה' DataMember DataSet מקור הנתונים למשל DataSource viewstate האם לשמור את מצב הפקד ב- EnableViewState סוג הגופן Font הצגה\הסתרה של קווי הרשת. GridLines מספר העמודות שצריך להציג. RepeatColumns

פקדים כריכת מידע – Repeater
הוא גם הגמיש ביותר מביניהם, מוגדר באמצעות תגיות HTML. יתרונו שהוא צורך הכי פחות משאבים בעת הצגת הנתונים. ב- HTML - <asp:Repeater id="Repeater1" runat="server"></asp:Repeater>

פקדים כריכת מידע – Repeater - המשך ל- Repeater יש גם חסרונות:
אינו יורש את המחלקה WebControl, לכן הוא לא מכיל את מאפייני עיצוב כמו DataList ו- DataGrid. תוכן העיצוב מוגדר ידנית בעזרת תגיות HTML. דורש כתיבה של קוד מורכב כאשר מעוניינים למיין או לחלק את המידע לעמודים. מוגבל במספר וביכולת האירועים. מכיל פחות תבניות עיצוב.

פקדים כריכת מידע – Repeater - המשך
כמו ב- DataList גם ה- Repeater מוגדר באמצעות תבניות. התבניות של הפקד Repeater: .HeaderTemplate: כותרת העליונה. ItemTemplate: עיצוב הנתונים (חובה להשתמש). AlternateItemTemplate: עיצוב השורות הזוגיות. SeparatorTemplate: הפרדה בין השורות. FooterTemplate: כותרת התחתונה.

פקדים כריכת מידע – Repeater – המשך צעדים בהגדרת הפקד:
גישה למסד נתונים ובניית DataSet המכיל את הנתונים הנדרשים להצגה. קישור ה- DataSet לפקד, בדיוק כמו עם DataGrid : על מנת שהפקד יציג את הנתונים נדרש להגדיר לפחות תבנית אחת. החיוני ביותר הוא להגדיר את התבנית ItemTemplate על מנת לקבוע כיצד יוצגו הנתונים. ניתן לבנות ולהגדיר עוד תבניות, כגון:תבנית להצגת הכותרת העליונה והתחתונה, תבנית המעצבת את שורות הנתונים הזוגיות וכו' . DataSet ds = new DataSet(); oleDbDataAdapter1.Fill(ds); Repeater1.DataSource=ds; Repeater1.DataBind();

פקדים כריכת מידע – Repeater – המשך
צעדים בהגדרת הפקד – קביעת תבנית: תבנית הצגת הנתונים קישור השדה fName <asp:Repeater id="Repeater1" runat="server"> <ItemTemplate> <%# DataBinder.Eval(Container.DataItem, "fName") %> <%# DataBinder.Eval(Container.DataItem, "lName")%> </ItemTemplate> </ asp:Repeater > קישור השדה lName

פקדים כריכת מידע – Repeater – המשך תיאור מאפיין
DataSet איבר של מקור הנתונים למשל טבלה מה' DataMember DataSet מקור הנתונים למשל DataSource Viewstate האם לשמור את מצב הפקד ב- EnableViewState הצגה\הסתרה של הפקד. Visible

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

User Controls הם דפי ASP.NET בעל סיומת .ascx הם פקדי שרת לכל דבר וענין. בנוים מאוסף פקדים. פקדי משתמש בנויים מ-HTML ומקוד בשפת C# (בדיוק כמו דפי aspx). ניתן לגרור אותם כפקדי שרת לתוך טפסי ASP.NET. ניתן לשימוש בכל אחד מדפי היישום. הם לא עומדים בפני עצמם, הם חייבים להיות חלק מדף aspx . מכיוון שהם נחשבים כחלק מה- Web Form, ולא כדף עצמאי הם לא מכילים את התגיות <HEAD> , <BODY> או <FORM>.

פקדים מותאמים אישית User Controls שלבים ביצירת ושימוש בפקד משתמש:
בחלון ה- Solution Explorer מציבים את סמן העכבר מעל שם הפרוייקט, הקלקה ימנית -> Add -> Add Web User Control . לפרוייקט התווסף דף ascx . עיצוב הפקד וכתיבת הקוד המטפל באירועים בדיוק כמו בדפי aspx . גרירתו מתוך חלון ה- Solution Explorer לתוך דף aspx .

כמו שדף aspx מכיל Page Directive המכיל הנחיות שפה , CodeBehind וכו' , דף ascx מכיל Control Directive : Control Language="c#" AutoEventWireup="false" Codebehind="MyControl.ascx.cs" Inherits="WebApplication1.MyControl" TargetSchema=" הדף עצמו מכיל הגדרותHTML : <TABLE cellSpacing="1" cellPadding="1" width="300" border="1" id="Table1"> <TR> <TD> <asp:TextBox id="TextBox1" runat="server"></asp:TextBox> <asp:Button id="Button1" runat="server" Text="Button"></asp:Button> </TD> </TR> . . . </TABLE>

כאשר גוררים User Control לדף aspx מתווסף לדף הגדרת Register , רישום הפקד בדף: Register TagPrefix="uc1" TagName="MyControl" Src="MyControl.ascx"%> הפקד מופיע כפקד מן המניין: <uc1:MyControl id="MyControl1" runat="server"> </uc1:MyControl>

פקדים מותאמים אישית פרויקט Web Control Library
פרויקט המשמש ליצירת פקדי שרת מותאמים אישית עבור טפסי האינטרנט Web Forms.

פרויקט Web Control Library מורכב מ- custom control אחד או יותר. הידור הפרוייקט יוצר קובץ DLL (dynamic link library ). את קובץ ה- DLL שנוצר ניתן להוסיף לארגז הכלים (toolbox) כדי להשתמש בו במספר רב של פרוייקטים. השימוש בפקדים אלו זהה לחלוטין לפקדי שרת אחרים.

על מנת לקבוע את תוכן התצוגה של הפקד יש לממש את המתודה : protected override void Render(HtmlTextWriter output) במתודה נעזר באובייקט מהמחלקה HtmlTextWriter שתפקידו לשלוח פלט ב- HTML לדף ה- HTML שנוצר כתוצאה מעיבוד דף ה- aspx המכיל את ה- Custom Control .

פקדים מותאמים אישית פרויקט Web Control Library לדוגמה:
protected override void Render(HtmlTextWriter output) { if(arr!=null) output.Write(text); output.Write("<table>"); for (int i=0;i<arr.Length;i++) output.Write("<tr>"); output.Write("<td>"); output.Write(arr[i].ToString()); output.Write("</td>"); output.Write("</tr>"); } output.Write("</table>");

שמירת מצב (State) שרת Web הוא חסר מצב (Stateless) , מה שאומר שאחרי יצירת התגובה (Response) השרת אינו שומר שום מידע. כל האובייקטים שהשרת הקצה עבור יצירת התגובה נהרסים, כולל כל המידע שהמשתמש שלח לשרת בבקשה (Request) וכולל כל המידע שהשרת יצר בתהליך העיבוד. ניתן לומר שלאחר העברת התגובה ללקוח השרת מאבד ענין בלקוח, מנתק את התקשורת עימו והורס את כל האובייקטים והמידע הקשורים בו. אולם, לעיתים היישום מעוניין לשמור נתונים קודמים שהיו בדף לפני שליחתם לשרת. לדוגמה: אנו מעוניינים לספור את מספר הבקשות של הלקוח, במידה וערכו של המונה לא יוכל להשמר בין הבקשות, יהיה ערכו שווה תמיד ל-1. לצורך פתרון בעיה זו נוצרו אובייקטים מיוחדים שכל תפקידם לשמור על המידע בין הבקשות.

שמירת מצב (State) שמירת מידע בצד לקוח Cookies Query String ViewState
פותחו מספר שיטות שניתן לחלקם לשני סוגים עיקריים : הראשונה מכילה טכניקות לשמירת המידע בצד הלקוח, השניה מכילה טכניקות לשמירת המידע בצד השרת. שמירת מידע בצד לקוח Cookies Query String ViewState שמירת מידע בצד שרת Application Session Cache

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

עוגיות יכולים לשמור רק מידע טקסטואלי, אם נרצה לאחסן ערך מספרי, נצטרך להמיר אותו לערך טקסטואלי. הלקוח יכול באמצעות הגדרות של הדפדפן למנוע כניסת עוגיות למחשבו ובכך מונע מאיתנו להשתמש בהם. הלקוח יכול למחוק את העוגייה בכל עת. Server Client Request (include Cookies) Response (include Cookies) Cookies

הגדרת זמן פקיעת העוגייה
שמירת מצב (State) שמירת מידע בצד לקוח – Cookies השימוש בעוגיות ב- ASP.NET מתבצע בעזרת המחלקה HttpCookie המוגדרת במרחב השמות System.Web. דוגמה לקוד פשוט ליצירה ושמירת עוגייה בדפדפן: יצירת העוגייה HttpCookie cookie = new HttpCookie("MyCookie"); cookie["Name"] = "MyNameISCookie"; cookie.Expires =DateTime.Now.AddDays(3); Response.Cookies.Add(cookie); הצבת ערך לעוגייה הגדרת זמן פקיעת העוגייה העוגייה אינה נשלחת מיידית אלא היא מצורפת לתגובת השרת. על לפי הקוד העוגייה נשמרת למשך שלושה ימים ואז היא פגת תוקף. לא חובה להגדיר Cookie.Expires , אולם אז העוגייה נשמרת בזיכרון רק עד לסיום ה- Session .

דוגמה לקריאת מידע מהעוגייה: בדיקה האם העוגייה קיימת if (Request.Cookies["MyCookie"] != null) Label1.Text =Request.Cookies["MyCookie"].Value; else Label1.Text ="no cookie"; הצגת ערך העוגייה Label בתוך אם ננסה לקרוא מעוגייה שלא קיימת בדפדפן או שהיא פגת תוקף נקבל הודעת שגיאה, לכן נחוץ לבדוק האם העוגייה קיימת לפני הצגת הערכים שלה.

C:\Documents and Settings\Administrator

שמירת מצב (State) שמירת מידע בצד לקוח – Cookies מאפיינים חשובים: Name
שם העוגייה. Value ערך העוגייה. Values . אוסף הערכים/מפתחות של העוגייה HasKeys מקבל את הערך true אם העוגייה מכילה מפתחות (keys). Domain הדומיין שאליו שייכת העוגייה. Expires תאריך תפוגת העוגייה. Path המסלול אליו מועברת העוגייה.

שמירת מצב (State) שמירת מידע בצד לקוח – Cookies חסרונות:
Cookies נשמרים כקובץ text ולכן אמינותם מוגבלת.

שמירת מצב (State) שמירת מידע בצד לקוח – Query String
Query strings היא דרך מקובלת להעברת מידע בין דפי האינטרנט של אותו היישום. אפשר להעביר נתונים בקלות מדף אחד לאחר אולם כמות המידע המועבר מוגבלת ותלויה בדפדפן. Query Stringמתחילה בסמן השאלה '?' מיד אחרי כתובת ה- URL. Client Server QsTest.aspx?x=5

המידע נשלח לשרת ע"י שרשורו לכתובת ה- URL. המידע מוגדר בזוגות, מפתח ואחריו ערך : ניתן לשלוח יותר מאשר פרמטר בודד, ההפרדה בין הפרמטרים מתבצעת באמצעות הסימן '&' :

הראשונה, העברת פרמטרים שמכילים את המידע ע"י שרשורם לכתובת ה- URL. השניה, שימוש ב- StringBuilder על מנת ליצור את הפרמטרים: Response.Redirect("TestQueryString.aspx?Name=n”); Response.Redirect("TestQueryString.aspx?FName=fn&LName=ln”); StringBuilder qs = new StringBuilder(); qs.Append("TestQueryString.aspx"); qs.Append("?MyStr="); qs.Append("MyName"); qs.Append("&MyInt="); qs.Append(95); Response.Redirect(qs.ToString());

שמירת מצב (State) שמירת מידע בצד לקוח – Query String חסרונות:
כמות התווים מוגבלת על ידי הדפדפן. המידע חשוף, לא ניתן להסתירו, אלא רק להצפינו בעת הצורך. המידע לא נשמר לאחר סיום ה- Session .

שמירת מצב (State) שמירת מידע בצד לקוח – ViewState בעיות:
משתמש רצה להירשם לאתר שמנהל השמת עובדים לחברות הייטק. המשתמש נתבקש למלא את קורות החייו. אחרי כחצי שעה כשסיים את מילוי הטופס, נשם לרווחה ולחץ על כפתור Submit. איתרע מזלו והוא טעה באחד השדות, השרת החזיר לו את הדף עם בקשה שימלא את הפרטיו מחדש! עצוב, כעוס וזעוף הוא . . . בעיות: 1 – חוסר נוחות ללקוח. 2 – העמסת השרת בבדיקות מיותרות. 3 – העמסת נפח תקשורת מיותר

שמירת מצב (State) שמירת מידע בצד לקוח – ViewState
כברירת מחדל, תקשורת אינטרנטית היא חסרת מצב Stateless ולכן המידע של הפקדים הולך לאיבוד כאשר הטופס רץ לשרת. וראה זה פלא, ב- ASP.NET הפקדים שומרים על המידע שלהם באופן אוטומטי לחלוטין. דף aspx משתמש במאפיין ViewState שתפקידו לשמור את הערכים של מאפייני פקדי השרת שנמצאים על ה- WebForm. ניתן לשמור ב- ViewState כל אובייקט אחר , לדוגמה: ViewState[“BckClr”] = “Yellow”; המידע נשמר בדף HTML שנשלח ללקוח בפקד HIDDEN . מכיוון שהמידע נשמר בדף עצמו הוא יאבד כאשר הלקוח יופנה לדף אחר.

שמירת מצב (State) שמירת מידע בצד לקוח – ViewState דוגמה:
הטופס אחרי ההרצה השדה הנסתר ViewState <form name="Form1" method="post" action="WebForm1.aspx" id="Form1"> <input type="hidden" name="__VIEWSTATE" value="dDwtMzM0ODUxNTMwOzs+Qa+5cYHdu9SlrO7i435C3a2T36E=" /> <input type="submit" name="Button1" value="Button" id="Button1" /> <input name="TextBox1" type="text" id="TextBox1" /> </form> ערך השדה הנסתר

EnableViewState = false במידה ולא מעוניינים בשמירת מצב של כל פקדי ה- Form , ניתן להגדיר : EnableViewState = false ב- Page Directive .

דוגמה נוספת המדגימה שימוש ב- ViewState על מנת למנות את מספר ה- Round Trip של טופס מסויים: if(!Page.IsPostBack) ViewState["counter"]=1; else ViewState["counter"]=int.Parse(ViewState["counter"] .ToString())+1; lblCounter.Text=ViewState["counter"].ToString();

ערך ה' _VIEWSTATE נשלח לשרת
PostBack HTML דף ערך ה' _VIEWSTATE נשלח לשרת השדה הנסתר _VIEWSTATE HTML השרת מעבד את הנתונים ומעדכן את ה' ViewState ערך ה' ViewState נשלח בחזרה לשדה הנסתר _VIEWSTATE

שמירת מצב (State) שמירת מידע בצד שרת – Application
האובייקט Application הוא בעצם מופע מהמחלקה System.Web.HTTPApplication . מיועד בעיקר לשמירת נתונים קטנים או בינוניים, לאובייקטים גדולים עדיף להשתמש באובייקט Cache. דוגמא שכיחה לשימוש באובייקט היא הצבת מונה מבקרים (COUNTER) באתר.

Server Client Request Object Response Object Application Object

כדי לשמור מידע חדש נשתמש בהוראה הבאה: דוגמא: אפשר גם: Application[שם האובייקט""]=ערך האובייקט Application["counter"]=0; Application.Add(“מפתח”, ערך האובייקט) Application.Add(“Name”, “MyName”)

TextBox 1.Text=Application["counter"].ToString(); למחיקת האובייקט נשתמש בהוראה: Application.Remove("המפתח"); או : Application[“המפתח”] = null;

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

שמירת מצב (State) שמירת מידע בצד שרת – Application דוגמה:
Application.Lock(); Application["counter"]=int.Parse(Application["counter"]. ToString())+1; Appliction.UnLock();

המידע זמין ליותר מלקוח אחד. Application SERVER Client A Client B Client C

שמירת מצב (State) שמירת מידע בצד שרת – Session
הוא נמחק גם כאשר סוגרים את הדפדפן או כאשר נותנים הוראה למחיקתו.

SERVER Session A Client A Client B Session B Client C Session C

Server Client Request Object Response Object Session Object

שמירת מצב (State) שמירת מידע בצד שרת – Session לדוגמה:
לקוח הנכנס לאתר הבנק שלו מבקש להזדהות (שם משתמש וסיסמה), הנתונים מאומתים מול מסד נתונים ואם ימצאו נכונים הוא יורשה להכנס לאתר ולבצע פעולות. אפליקציה בנקאית תהיה בנויה, מן הסתם, ממספר רב של דפים, במידה ונתוני האימות שלו לא ישמרו הוא יאלץ להקליד אותם בכל דף מחדש, והמערכת תצטרך לאמת אותם בכל בקשה מחדש. אפשר לשמור את המידע בעוגיות, אולם, בעיה, מטעמי אבטחה אסור זה לא הגיוני, העוגיות נשמרות במחשה הלקוח כקבצי טקסט. השימוש ב- Session הוא פיתרון הגיוני יותר.

כדי ליצור אובייקט חדש ולאתחל אותו נשתמש בהוראה: Session.Add("שם האובייקט“, ערך האובייקט); דוגמא : Session.Add("Name","MyName"); או לחלופין: Session[“"שם האובייקט]=ערך האובייקט; Session["Name"]="MyName"; אפשר לשמור לתוכו גם משתנה או אובייקט אחר כמו DataSet.

האובייקט Session יכול לקבל את כל סוגי האובייקטיםאשר עונים על דרישה אחת: האובייקט צריך לתמוך ב- .serialization אזהרה: אם אתה מוסיף אובייקט גדול במיוחד למשל DataSet שמכיל 5000 רשומות, כאשר נכנסים לאתר 100 משתמשים יישמרו בזיכרון 1000 אובייקטים מסוג DataSet שמכילים רשומות !, בזבוז משאבים ענק.

Session.Remove("שם האובייקט"); דוגמא: Session.Remove("Name"); או Session[“Name”] = null; למחיקת כל הערכים של כל אובייקטי ה' Session של המשתמש מהזיכרון נשתמש בהוראה: Session.RemoveAll();

שמירת מצב (State) ASP.NET שמירת מידע בצד שרת – Session
Session לעומת Application ASP.NET Application 1 Session B Session A Session C Application 2 Session B Session A Session C Application 3 Session B Session A Session C

שמירת מצב (State) שמירת מידע בצד שרת – Cache
האובייקט Cache , כמון האובייקט Application , נועד לשמירת מידע המשותף לכל הגולשים באתר. מכיל יכולות מאוד משופרות לעומת Application . Server Client Request Object Response Object Cache Object

שמירת מצב (State) שמירת מידע בצד שרת – Cache
Cache.Insert[“מפתח”] = ערך האובייקט); הכנסת מידע לאובייקט Cache תוך השימוש מתודה Insert: Cache.Insert(“מפתח”,ערך האובייקט); דוגמא: Cache.Insert(“Name”,”MyName”); למחיקת האובייקט נשתמש בהוראה: Cache.Remove(“שם האבייקט"); או Cache[“שם האובייקט”] = null;

שמירת מצב (State) שמירה בצד הלקוח לעומת שמירה בצד השרת Cookies
Viewstate QueryString Request Response Application Session Cache

שמירת מצב (State) השוואה בין הטכניקות השונות טכניקה באיזה רמה
גודל אופטימאלי Cookies הדף קטן Query String Viewstate Application האפליקציה קטן-בינוני Session המשתמש Cache גדול

שמירת מצב (State) מתי להשתמש בכל אחת מהשיטות? טכניקה מתי להשתמש
Cookies לשמירת מידע במחשב הלקוח. Query String URLלהעברת מידע מדף אחד לאחר דרך כתובת ה Viewstate כאשר רוצים לשמור מידע על הדף עצמו. Application כאשר רוצים שהמידע יהיה זמין לכל המשתמשים. Session כאשר רוצים שהמידע יהיה ספציפי למשתמש אחד. Cache לשמירת כמות גדולה של מידע לכל המשתמשים.

ASP.NET כתב : אקת'ם חאג יחיא עריכה מקצועית : ארז קלר www.corner.co.il
יצירת טפסי Web . הפרדה בין קוד לרכיבי תצוגה – Code Behind. טיפול באירועים. קובץ קונפיגורציה – Web.Config. פקדים. פקדים מותאמים אישית. שמירת מצב (State) . כתב : אקת'ם חאג יחיא עריכה מקצועית : ארז קלר

Web Services ASP.NET כתב: אקת'ם חאג' יחיא ליווי מקצועי : ארז קלר

Similar presentations

Presentation on theme: "Web Services ASP.NET כתב: אקת'ם חאג' יחיא ליווי מקצועי : ארז קלר"— Presentation transcript:

Similar presentations

About project

Feedback

Log in

Auth with social network:

Web Services ASP.NET כתב: אקת'ם חאג' יחיא ליווי מקצועי : ארז קלר

Similar presentations

Presentation on theme: "Web Services ASP.NET כתב: אקת'ם חאג' יחיא ליווי מקצועי : ארז קלר"— Presentation transcript:

Similar presentations

About project

Feedback