Visual Basic 6.0 for Programmers

Transcription

‫‪Visual Basic 6‬‬
‫לתוכניתנים‬
‫מאת אילן אמויאל‬
‫כתובת אימייל‪[email protected] :‬‬
‫אתר אינטרנט‪www.kita.co.il :‬‬
‫© כל הזכויות שמורות למחבר‬
‫כתיבה עריכה‪ :‬אילן אמויאל‬
‫אין להעתיק או לשדר בכל אמצעי שהוא ספר זה או קטעים ממנו בכל צורה ובכל אמצעי אלקטרוני‬
‫או מכני‪ ,‬לרבות צילום והקלטה‪ ,‬אמצעי אחסון והפצת מידע ללא צורך באישור מאת המחבר‪.‬‬
‫מותר להפיץ את הספר חינם וללא ביצוע כל שינוי בתוכנו‪ ,‬אך שלא למטרות מסחריות‬
‫תוכן העניינים‬
‫‪11‬‬
‫הקדמה‬
‫אודות שפת ‪11 ............................................................................................................................... VISUAL BASIC‬‬
‫תוכן הספר ‪11 ......................................................................................................................................................‬‬
‫ידע מוקדם ‪11 ......................................................................................................................................................‬‬
‫קו התכניות ‪11 .....................................................................................................................................................‬‬
‫אי ננטילת אחריות‪11 ............................................................................................................................................‬‬
‫זכויות יוצרים וקניין רוחני ‪11 ................................................................................................................................‬‬
‫סוף דבר ‪11 ..........................................................................................................................................................‬‬
‫‪11‬‬
‫שיעור ‪ :1‬סקירה‬
‫אודות ‪13 .......................................................................................................................................VISUAL BASIC‬‬
‫יתרונות הפיתוח ב‪Visual Basic-‬‬
‫חסרונות הפיתוח ב‪Visual Basic-‬‬
‫‪13‬‬
‫‪13‬‬
‫הכרת סביבת הפיתוח המשולבת (‪11 .................................................. )INTEGRATED DEVELOPMENT ENVIRONMENT‬‬
‫תיבת הדו‪-‬שיח ‪New Project‬‬
‫שורת התפריטים‬
‫סרגל הכלים הסטנדרטי של ‪Visual Basic‬‬
‫חלון ה‪Project Explorer-‬‬
‫חלון ה‪Properties-‬‬
‫חלון ה‪Form Layout-‬‬
‫ה‪( Toolbox-‬ארגז הכלים)‬
‫ה‪( Code Editor-‬עורך הקוד)‬
‫שיעור ‪ :2‬טפסים ותפריטים‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫פרוייקט ‪11 ..........................................................................................................................................................‬‬
‫‪11‬‬
‫‪11‬‬
‫‪12‬‬
‫יצירת פרוייקט חדש‬
‫הרצת פרוייקט‬
‫שמירת פרוייקט‬
‫ה‪ FORM-‬הסטנדרטי‪12 .........................................................................................................................................‬‬
‫‪12‬‬
‫‪( Properties‬מאפיינים)‪( Methods ,‬שיטות)‪ ,‬ו‪( Events-‬אירועים)‬
‫‪11‬‬
‫‪ Properties‬של ‪Form‬‬
‫‪11‬‬
‫‪ Methods‬של ‪Form‬‬
‫‪11‬‬
‫‪ Events‬של ‪Form‬‬
‫פונקציות ראשונות ‪11 ...........................................................................................................................................‬‬
‫הפונקציה ‪Print‬‬
‫הפונקציה ‪MsgBox‬‬
‫דוגמה ‪ :1‬התוכנית ‪HelloWorld‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫הוספת הערות לקוד ‪11 ..........................................................................................................................................‬‬
‫‪11‬‬
‫המשך דוגמה ‪1‬‬
‫‪( MDI FORM‬טופס ‪11 ................................................................................................................................. )MDI‬‬
‫‪ Properties‬של ‪MDI Form‬‬
‫‪ Methods‬של ‪MDI Form‬‬
‫‪-3‬‬‫אילן אמויאל © כל הזכויות שמורות‬
‫אין להעתיק‪ ,‬לשדר או להציג את הספר או חלקים ממנו בשום צורה‪.‬‬
‫מותר להפיץ את הספר חינם בשלמותו בלבד אך לא למטרות מסחריות‬
‫‪www.kita.co.il‬‬
‫‪11‬‬
‫‪11‬‬
‫‪( MENUS‬תפריטים) ‪11 ..........................................................................................................................................‬‬
‫‪ Properties‬של ‪Menu‬‬
‫‪ Events‬של ‪Menu‬‬
‫‪11‬‬
‫‪11‬‬
‫עבודה עם צבעים ‪11 ..............................................................................................................................................‬‬
‫הפונקציה ‪QBColor‬‬
‫הפונקציה ‪RGB‬‬
‫אוסף הקבועים ‪ColorConstants‬‬
‫אוסף הקבועים ‪SystemColorConstants‬‬
‫דוגמה ‪ – 1‬התוכנית ‪Colors‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫תרגילים‪31 ..........................................................................................................................................................‬‬
‫שיעור ‪ :1‬הפקדים הסטנדרטיים ‪I‬‬
‫‪13‬‬
‫‪( LABEL‬תווית) ‪31 .................................................................................................................................................‬‬
‫‪31‬‬
‫‪31‬‬
‫‪ Properties‬של ‪Label‬‬
‫‪ Events‬של ‪Label‬‬
‫‪( TEXTBOX‬תיבת טקסט) ‪31 ..................................................................................................................................‬‬
‫‪31‬‬
‫‪ Properties‬של ‪TextBox‬‬
‫‪31‬‬
‫‪ Events‬של ‪TextBox‬‬
‫‪( COMMANDBUTTON‬לחצן פקודה) ‪31 ....................................................................................................................‬‬
‫‪31‬‬
‫‪ Properties‬של ‪CommandButton‬‬
‫‪( HSCROLLBAR‬פס גלילה אופקי) ו‪( VSCROLLBAR-‬פס גלילה אנכי) ‪31 ........................................................................‬‬
‫‪31‬‬
‫‪ Properties‬של פסי גלילה‬
‫‪31‬‬
‫‪ Events‬של פסי גלילה‬
‫פונקציות לעבודה עם מחרוזות ‪31 ...........................................................................................................................‬‬
‫‪31‬‬
‫‪31‬‬
‫‪31‬‬
‫‪31‬‬
‫‪31‬‬
‫‪31‬‬
‫‪31‬‬
‫‪31‬‬
‫‪31‬‬
‫‪31‬‬
‫הפונקציה ‪Len‬‬
‫הפונקציה ‪Val‬‬
‫הפונקציה ‪Str‬‬
‫הפונקציה ‪UCase‬‬
‫הפונקציה ‪LCase‬‬
‫הפונקציות ‪ LTrim ,Trim‬ו‪Rtrim-‬‬
‫הפונקציות ‪ Left ,Mid‬ו‪Right-‬‬
‫האופרטור &‬
‫הקבוע ‪vbCrLf‬‬
‫הפונקציה ‪Asc‬‬
‫התנאי ‪31 ...............................................................................................................................IF...THEN...END IF‬‬
‫תרגילים‪12 ..........................................................................................................................................................‬‬
‫שיעור ‪ :4‬מרכיבי השפה ‪I‬‬
‫‪41‬‬
‫‪( VARIABLES‬משתנים) ו‪( CONSTANTS-‬קבועים) ‪13 ...................................................................................................‬‬
‫‪13‬‬
‫‪11‬‬
‫‪11‬‬
‫סוגי משתנים‬
‫הצהרה על משתנים‬
‫הצהרה על קבועים‬
‫‪( CONTROL STRUCTURES‬מבני בקרה) ‪11 ...............................................................................................................‬‬
‫‪11‬‬
‫המבנה ‪If...Then...Else‬‬
‫‪11‬‬
‫המבנה ‪While...Wend‬‬
‫‪ Visual Basic 6‬לתוכניתנים‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫המבנה ‪Do...Loop‬‬
‫המבנה ‪For...Next‬‬
‫המבנה ‪Select Case‬‬
‫הפונקציות ‪ INPUTBOX ,BEEP‬ו‪12 ................................................................................................................... IIF-‬‬
‫‪12‬‬
‫הפונקציה ‪Beep‬‬
‫‪12‬‬
‫הפונקציה ‪InputBox‬‬
‫‪12‬‬
‫הפונקציה ‪IIf‬‬
‫תרגילים‪11 ..........................................................................................................................................................‬‬
‫שיעור ‪ :3‬הפקדים הסטנדרטיים ‪II‬‬
‫‪31‬‬
‫‪( CHECKBOX‬תיבת סימון) ‪13 ................................................................................................................................‬‬
‫‪13‬‬
‫‪13‬‬
‫‪ Properties‬של ‪CheckBox‬‬
‫‪ Events‬של ‪CheckBox‬‬
‫‪( OPTIONBUTTON‬לחצן אפשרות) ‪13 ......................................................................................................................‬‬
‫‪13‬‬
‫‪ Properties‬של ‪OptionButton‬‬
‫‪( FRAME‬מסגרת) ‪11 ..............................................................................................................................................‬‬
‫‪11‬‬
‫‪ Properties‬של ‪Frame‬‬
‫‪11‬‬
‫‪ Methods‬של ‪Property‬‬
‫‪11‬‬
‫דוגמה ‪ :1‬התוכנית ‪CopyText‬‬
‫‪( LISTBOX‬תיבת רשימה) ‪11 ...................................................................................................................................‬‬
‫‪11‬‬
‫‪ Properties‬של ‪ListBox‬‬
‫‪11‬‬
‫‪ Methods‬של ‪ListBox‬‬
‫‪11‬‬
‫‪ Events‬של ‪ListBox‬‬
‫‪( COMBOBOX‬תיבה משולבת) ‪11 ............................................................................................................................‬‬
‫‪11‬‬
‫‪ Properties‬של ‪ComboBox‬‬
‫‪( LINE‬קו) ו‪( SHAPE-‬צורה) ‪11 ................................................................................................................................‬‬
‫‪11‬‬
‫‪ Properties‬של ‪ Line‬ו‪Shape-‬‬
‫‪( TIMER‬פקד שעון) ‪11 ............................................................................................................................................‬‬
‫‪11‬‬
‫‪ Properties‬של ‪Timer‬‬
‫‪11‬‬
‫‪ Events‬של ‪Timer‬‬
‫‪11‬‬
‫דוגמה ‪StudentCourses – 1‬‬
‫תרגילים‪11 ..........................................................................................................................................................‬‬
‫שיעור ‪ :6‬מרכיבי השפה ‪II‬‬
‫‪63‬‬
‫המילה ‪11 ................................................................................................................................................... WITH‬‬
‫‪( ARRAYS‬מערכים) ‪11 ............................................................................................................................................‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪( One-Dimensional Arrays‬מערכים חד ממדיים)‬
‫‪( Multi-Dimensional Arrays‬מערכים רב ממדיים)‬
‫‪( Dynamic Arrays‬מערכים דינמיים)‬
‫בדיקת גודל מערך בזמן ריצה באמצעות ‪ LBound‬ו‪UBound-‬‬
‫‪( CONTROL ARRAY‬מערכי פקדים) ‪11 .....................................................................................................................‬‬
‫‪11‬‬
‫תרגיל ‪ – 1‬התוכנית ‪CommandBoard‬‬
‫פרוצדורות ב‪12 ............................................................................................................................. VISUAL BASIC-‬‬
‫‪11‬‬
‫רוטינות ופונקציות שלב ‪I‬‬
‫‪11‬‬
‫קריאות לרוטינות ופרוצדורות‬
‫‪11‬‬
‫רוטינות ופרוצדורות שלב ‪II‬‬
‫מודולי קוד סטנדרטיים ‪11 ........................................................................................................................... *.BAS‬‬
‫הפעלת פונקציות מחלון ה‪11 ................................................................................................................IMMEDIATE‬‬
‫‪11‬‬
‫תרגיל ‪ – 1‬הפעלת קוד מחלון ה‪Immediate-‬‬
‫‪( ENUMERATIONS‬אוספי קבועים) ‪11 ......................................................................................................................‬‬
‫‪11‬‬
‫דוגמאות‬
‫‪( USER-DEFINED TYPES‬סוגי נתונים מוגדרים על ידי המשתמש) ‪11 ...........................................................................‬‬
‫‪11‬‬
‫שיעור ‪ :7‬הרצה וניפוי שגיאות‬
‫‪11‬‬
‫חלונות תצוגה שונים לאבחון ‪11 .............................................................................................................................‬‬
‫שלושת המצבים של תוכנית ‪11 ...............................................................................................................................‬‬
‫התפריט ‪( RUN‬הרצה) ‪11 .......................................................................................................................................‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪( Start‬התחל)‬
‫‪( Start With Full Compile‬התחל לאחר קימפול מלא)‬
‫‪( Break‬עבור ל‪)Break Mode-‬‬
‫‪( End‬סיים)‬
‫‪( Restart‬התחל מחדש)‬
‫התפריט ‪( DEBUG‬ניפוי שגיאות) ‪11 .........................................................................................................................‬‬
‫‪11‬‬
‫‪( Step Into‬צעד לתוך)‬
‫‪11‬‬
‫‪( Step Over‬צעד מעבר)‬
‫‪11‬‬
‫‪( Step Out‬צא החוצה)‬
‫‪11‬‬
‫‪( Run To Cursor‬הרץ עד הסמן)‬
‫‪13‬‬
‫‪( Add Watch‬הוספת תצפית)‬
‫‪13‬‬
‫‪( Edit Watch‬ערוך תצפית)‬
‫‪13‬‬
‫‪( Quick Watch‬תצפית מהירה)‬
‫‪11‬‬
‫‪( Toggle Breakpoint‬הפוך מצב של נקודת עצירה)‬
‫‪11‬‬
‫‪( Clear All Breakpoints‬הסר את כל נקודות העצירה)‬
‫‪11‬‬
‫‪( Set Next Statement‬קבע את המשפט הבא לביצוע)‬
‫‪11‬‬
‫‪( Show Next Statement‬הצג את המשפט הבא לביצוע)‬
‫האובייקט ‪11 ........................................................................................................................................... DEBUG‬‬
‫טיפול בשגיאות בקוד התוכנית ‪11 ...........................................................................................................................‬‬
‫האובייקט ‪Err‬‬
‫‪On Error...‬‬
‫‪On Error GoTo line‬‬
‫‪On Error Resume Next‬‬
‫‪On Error GoTo 0‬‬
‫המשפט ‪Resume‬‬
‫הפונקציה ‪Error‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫שיעור ‪ :1‬מבוא לתכנות מבוסס רכיבים ‪11 COMPONENTWARE DEVELOPMENT‬‬
‫תכנות פרוצדורלי לעומת תכנות מונחה עצמים ‪11 .....................................................................................................‬‬
‫‪11‬‬
‫‪11‬‬
‫‪Procedural Programming‬‬
‫‪Object Oriented Programming‬‬
‫‪( EVENT ORIENTED PROGRAMMING‬תכנות מונחה אירועים) ‪11 ...............................................................................‬‬
‫‪11 ............................................................................................................ )COM( COMPONENT OBJECT MODEL‬‬
‫התמיכה של ‪ VISUAL BASIC‬ב‪ OOP-‬ו‪11 ...................................................................................................... COM-‬‬
‫שיעור ‪ :1‬תכנות מונחה עצמים ב‪VISUAL BASIC-‬‬
‫‪17‬‬
‫‪( CLASSES‬מחלקות) ‪11 .........................................................................................................................................‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪11‬‬
‫‪122‬‬
‫‪121‬‬
‫‪121‬‬
‫‪112‬‬
‫‪112‬‬
‫‪111‬‬
‫‪111‬‬
‫‪111‬‬
‫‪ Properties‬של ‪Class Module‬‬
‫‪ Events‬של ‪Class Module‬‬
‫הגדרת משתנים ב‪Class-‬‬
‫הוספת פרוצדורות ל‪Class-‬‬
‫הצהרה על אובייקטים מסוג המחלקה‬
‫‪( Reference Counting‬ספירת התייחסויות)‬
‫תרגיל ‪ – 1‬התוכנית ‪ClassDemo‬‬
‫תרגיל ‪ – 1‬התוכנית ‪RectDemo‬‬
‫תרגיל ‪ – 3‬התוכנית ‪EventDemo‬‬
‫מימוש ‪Interface‬‬
‫אבחון תכונות אובייקט בזמן ריצה‬
‫תרגיל ‪ – 1‬התוכנית ‪ImplementsDemo‬‬
‫‪ Early Binding‬לעומת ‪Late Binding‬‬
‫תרגיל ‪ – 1‬התוכנית ‪Analyzer‬‬
‫הגדרת תכונות של פרוצדורות ב‪111...................................................................................................... INTREFCAE-‬‬
‫‪111‬‬
‫צפייה בתכונות באמצעות ‪Object Browser‬‬
‫‪111‬‬
‫תרגיל ‪ – 1‬צפייה באובייקטים באמצעות ה‪Object Browser-‬‬
‫‪111‬‬
‫צפייה באמצעות היישום ‪OLE VIEW‬‬
‫‪111‬‬
‫תרגיל ‪ OLE View – 1‬לבעלי לב חזק בלבד‬
‫‪111‬‬
‫הגדרת תכונות‬
‫‪( COLLECTIONS‬אוספים) ‪112.................................................................................................................................‬‬
‫‪112‬‬
‫תחביר‬
‫‪111‬‬
‫הלולאה ‪For each ..In .. Next‬‬
‫‪111‬‬
‫תרגיל ‪ – 1‬התוכנית ‪ShapeColl1‬‬
‫‪111‬‬
‫מחלקות ‪ Collection‬מותאמות אישית‬
‫‪111‬‬
‫תרגיל ‪ – 1‬התוכנית ‪ShapeColl2‬‬
‫שיעור ‪ACTIVEX DLL :11‬‬
‫‪113‬‬
‫מושגים ‪131..........................................................................................................................................................‬‬
‫יצירת ‪131..................................................................................................................................... ACTIVEX DLL‬‬
‫יצירת אובייקטים‬
‫הצגת ממשק משתמש‬
‫ניהול קבוצת פרוייקטים במקביל‬
‫תרגיל ‪ – 1‬ספריית הרכיבים ‪SecurityLib‬‬
‫‪( Instancing‬יצירת מופעים)‬
‫תרגיל ‪ – 1‬שינוי המאפיין ‪ Instancing‬במחלקה ‪CLogin‬‬
‫הגדרת כתובות בסיס לרכיבי ‪DLL‬‬
‫תרגיל ‪ – 3‬שינוי כתובת הבסיס לספרייה ‪SecurityLib‬‬
‫טיפול בשגיאות ברכיב‬
‫תרגיל ‪ :1‬ספריית הרכיבים ‪DynamicArray‬‬
‫‪131‬‬
‫‪131‬‬
‫‪131‬‬
‫‪131‬‬
‫‪111‬‬
‫‪111‬‬
‫‪111‬‬
‫‪113‬‬
‫‪113‬‬
‫‪111‬‬
‫שיעור ‪ :11‬כתיבת ‪ STORED PROCEDURES‬ב‪SQL SERVER-‬‬
‫‪141‬‬
‫‪111.................................................................................................................................. STORED PROCEDURES‬‬
‫‪111‬‬
‫‪112‬‬
‫תהליך הביצוע של משפט ‪ SQL‬הנשלח על ידי לקוח‬
‫תהליך הביצוע של בקשה להפעלת ‪ Stored Procedure‬מתוך תוכנית לקוח‬
‫כתיבת ‪ STORED PROCEDURES‬ב‪112................................................................................................ SQL SERVER-‬‬
‫‪112‬‬
‫פרוצדורה פשוטה ללא פרמטרים‬
‫‪111‬‬
‫פרוצדורה המקבלת פרמטרים‬
‫‪111‬‬
‫הגדרת ערך ברירת מחדל לפרמטרים‬
‫‪111‬‬
‫החזרת ערך מפרוצדורה באמצעות משתנה‬
‫‪113‬‬
‫שימוש במשתנים מקומיים‬
‫‪113‬‬
‫יציאה מפרוצדורה באמצעות ‪RETURN‬‬
‫שיעור ‪ACTIVEX DATA OBJECTS :12‬‬
‫‪133‬‬
‫סקירה של טכנולוגיות הגישה לנתונים ‪111...............................................................................................................‬‬
‫‪111‬‬
‫‪111‬‬
‫‪111‬‬
‫‪111‬‬
‫‪111‬‬
‫‪111‬‬
‫‪111‬‬
‫‪111‬‬
‫‪111‬‬
‫‪111‬‬
‫‪111‬‬
‫‪)Open Database Connectivity( ODBC‬‬
‫‪)Data Access Object( DAO‬‬
‫‪)Data Control( DC‬‬
‫‪)Remote Data Object( RDO‬‬
‫‪)Remote Data Control( RDC‬‬
‫‪ODBCDirect‬‬
‫‪OLE DB‬‬
‫‪)ActiveX Data Objects( ADO‬‬
‫‪MSDASQL‬‬
‫‪)ADO Data Control( ADODC‬‬
‫תרגיל ‪NwindDSN– 1‬‬
‫‪111.................................................................................................................... )ACTIVEX DATA OBJECTS( ADO‬‬
‫‪111‬‬
‫‪Data Link‬‬
‫‪111‬‬
‫תרגיל ‪NWind.udl :1‬‬
‫‪112‬‬
‫תרגיל ‪Pubs.udl :3‬‬
‫‪111‬‬
‫תרגיל ‪NWindDSN.udl :1‬‬
‫‪111‬‬
‫האובייקט ‪Connection‬‬
‫‪111‬‬
‫תרגיל ‪ – 1‬התוכנית ‪SimpleConnection‬‬
‫‪111‬‬
‫‪-Event‬ים של אובייקט ‪Connection‬‬
‫‪111‬‬
‫תרגיל ‪ – 1‬התוכנית ‪ConnectWithEvents‬‬
‫האובייקט ‪111...................................................................................................................................RECORDSET‬‬
‫‪111‬‬
‫תרגיל ‪ – 1‬התוכנית ‪DisplayEmployees‬‬
‫‪111‬‬
‫המאפיין ‪CursorType‬‬
‫‪111‬‬
‫תנועה ב‪Recordset-‬‬
‫‪( CURSORS‬סמנים) ‪111..........................................................................................................................................‬‬
‫‪111‬‬
‫המאפיין ‪LockType‬‬
‫‪111‬‬
‫מאפיינים נוספים‬
‫‪111‬‬
‫תרגיל ‪ – 1‬התוכנית ‪NevigateRecords‬‬
‫‪111................................................................................................................................... ADO DATA CONTROL‬‬
‫‪113‬‬
‫‪ Properties‬של ‪ADODC‬‬
‫‪ Methods‬של ‪ADODC‬‬
‫‪ Events‬של ‪ADODC‬‬
‫‪113‬‬
‫‪111‬‬
‫עיצוב הנתונים ‪111................................................................................................................................................‬‬
‫‪StdDataFormats Objects‬‬
‫הערות לגבי ‪Data Bound Controls‬‬
‫שיעור ‪COM+ :11‬‬
‫‪111‬‬
‫‪111‬‬
‫‪113‬‬
‫תרגיל ‪COM+Demo :1‬‬
‫‪111‬‬
‫יצירת רכיבים המותאמים לפעולה תחת ‪111................................................................................................. COM+‬‬
‫המאפיין ‪MTSTransactionMode‬‬
‫האובייקט ‪ObjectContext‬‬
‫תרגיל ‪MTSSample.dll :1‬‬
‫תרגיל ‪ :3‬הוספת ‪ MTSSampleDLL.dll‬ל‪COM+-‬‬
‫תרגיל ‪ :1‬בחינת פעולת ‪ MTSSample.dll‬תחת ‪COM+‬‬
‫תרגיל ‪ :1‬הוספת ‪ Roles‬לאפליקצית ‪COM+‬‬
‫תרגיל ‪ :1‬בדיקת הרשאות מתוך רכיב‬
‫תרגיל ‪ :1‬העברת ‪ ConstructString‬לרכיב‬
‫תרגיל ‪ :1‬קליטת ‪ ConstructString‬מרכיב‬
‫‪111‬‬
‫‪111‬‬
‫‪111‬‬
‫‪111‬‬
‫‪111‬‬
‫‪111‬‬
‫‪111‬‬
‫‪111‬‬
‫‪111‬‬
‫הקדמה‬
‫(הקדמה זו שוכתבה בשנת ‪)2112‬‬
‫אודות שפת‬
‫‪VISUAL BASIC‬‬
‫‪ Visual Basic 6‬היא שפה וטכנולוגיה ותיקה מאוד בשוק מערכות המידע‪ ,‬אשר עדיין נמצאת בשימוש בעיקר במערכות‬
‫שנכתבו לפני הפצת טכנולוגית ‪ dot.NET‬לשוק ע"י ידי מייקרוסופט‪ ,‬בסביבות שנת ‪ .1221‬על מערכות מידע אלה יש להוסיף‬
‫מערכות תוכנה שונות שמאפשרות להרחיב את פעולתן על ידי כתיבת הרחבות באמצעות ‪,Visual Basic for Applications‬‬
‫למשל‪ ,‬תוכנות ‪ Microsoft Office‬השונות‪ ,Autocad ,‬ועוד‪.‬‬
‫אמנם‪ ,‬מאז יציאתה לשוק של טכנולוגית ‪ dot.NET‬על ידי מייקרוסופט‪ ,‬ירד קרנה של ‪ Visual Basic 6‬לשם פיתוח מערכות‬
‫מידע חדשות‪ ,‬אך עדיין יש צורך במפתחים לצורך תחזוקת מערכות קיימות או לשם פיתוח הרחבות למערכות המאפשרות‬
‫זאת על ידי ‪ .Visul Basic for Applications‬לכן‪ ,‬כמתכנת תוכל להיעזר בספר זה כמשאב למידה בשעת הצורך‪ ,‬ואם הנך‬
‫מתכנת מתחיל המתעניין בשפה ובטכנולגית ‪ ,Visual Basic 6‬אין ספק שתוכל להפיק תועלת רבה מספר זה‪.‬‬
‫תוכן הספר‬
‫ספר זה נועד להדריך את המתכנת ברזי שפת ‪ ,Visul Basic 6‬והטכנולוגיות הנלוות אליה תוך שימוש יעיל בשפה וביכולות‬
‫פיתוח מוכווני עצמים עד כמה שהם נתמכים ב‪.Visual Basic 6-‬‬
‫בספר עצמו השתדלתי‪ ,‬עד כמה שניתן‪ ,‬להיות תמציתי ותכליתי‪ ,‬ולתת דוגמאות ברורות אשר מתמקדות בנושא הנלמד ולא‬
‫מתפזרות סביב‪ .‬בכתיבת הדוגמאות השתדלתי שלא להלאות את הקורא בפרטים‪ ,‬אלא להנחות אותו שלב שלב בצעדים‬
‫שעליו להשלים על מנת לסיים את כתיבת הדוגמה‪ .‬את ההסבר על אופן הפעולה של תוכניות הדוגמה הבאתי מיד לאחר כל‬
‫דוגמה‪.‬‬
‫בספר זה עשיתי שימוש יעיל בקורסים אותם העברתי בשעתו בחברות טכנולוגיה‪ ,‬בעיקר לפני יציאתה לשוק של טכנולוגיית‬
‫‪ .dot.NET‬הספר לא הושלם עד תומו (ובעיקר שני הפרקים אחרונים שבספר)‪ ,‬אך את עיקר החומר אפשר לקבל מן הפרקים‬
‫שנכתבו ובוודאי שגם מחיפוש מידע באינטרנט‪.‬‬
‫נושאים נוספים אותם רציתי למצות בספר זה אך לא עשיתי זאת הם‪:‬‬
‫‪ - XML ‬סקירה ושימוש באמצעות ‪Visual Basic‬‬
‫‪Deployment and Maintanance ‬‬
‫‪ ‬גישה ל‪ Win32 API-‬מתוך קוד ‪VB‬‬
‫‪ ‬סקירה של ‪ASP‬‬
‫‪ ‬ניתוח ועיצוב תוכנה‬
‫‪ ‬יצירת ממשקים באמצעות ‪IDL‬‬
‫חשוב לשים לב כי חלק מהנושאים הללו חשובים ביותר לכל מתכנת ‪ Visual Basic‬מקצועי (בעיקר השלושה הראשונים‬
‫שפרטתי)‪ ,‬ולכן אם אתה מוצא את עצמך לומד מספר זה‪ ,‬אני ממליץ לך לחפש חומר אודות הנושאים שלא מיציתי בספר‬
‫באמצעות רשת האינטרנט‪.‬‬
‫ ‪- 11‬‬‫אילן אמויאל © כל הזכויות שמורות‬
‫הקדמה‬
‫ידע מוקדם‬
‫ספר זה מניח כי אתה מתכנת בעל ידע בסיסי בתכנות‪ ,‬בעל יכולת לייצג מספרים בבסיסים בינארי‪ ,‬אוקטאלי והקצאדצימלי‪,‬‬
‫ובעל נסיון בכתיבת קוד בשפה כלשהי‪.‬‬
‫קו התכניות‬
‫קובץ ה‪ Zip-‬המכיל את הספר הזה‪ ,‬מכיל גם ספרייה בשם ‪ Code‬הכולל את קוד המקור של התכניות המובאות כדוגמאות‬
‫בפרקי הספר‪ .‬כמו כן‪ ,‬ספרייה זו כוללת הצעות פתרון לתרגילים המובאים בסופי חלק מהפרקים‪.‬‬
‫אי ננטילת אחריות‬
‫המחבר אינו מתחייב על שלמות המידע שבספר או הפרקים שבו ומידת דיוקם‪.‬‬
‫הקריאה מספר זה והסתמכות על הכתוב בו בכל סוג של יישום היא על אחריותך בלבד‪ .‬אין המחבר יהיה אחראי בכל צורה‬
‫שהיא לכל סוג של נזק שעלול להיגרם כתוצאה משימוש בהוראות והנחיות הכתובות בספר זה‪.‬‬
‫אם בכל זאת החלטת לעשות שימוש בספר זה‪ ,‬שים לב כי עליך לקבל תנאי זה ללא כל סייג וכל נזק אם חלילה ייגרם‪ ,‬הנו על‬
‫אחריותך בלבד‪.‬‬
‫זכויות יוצרים וקניין רוחני‬
‫מחבר הספר שומר לעצמו את זכויות היוצרים של ספר זה‪.‬‬
‫עם זאת כבר אמרו חזל "אין אדם יוצא מן העולם וחצי תאוותו בידו"‪ .‬אם כן‪ ,‬החליט המחבר לאפשר הפצה חופשית‬
‫וחינמית של הספר ללא כל צורך בהרשאה מהמחבר‪ .‬וזאת תחת התנאים הבאים‪:‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫מותר להפיץ את הספר חינם בשלמותו בלבד‪ ,‬ללא הכנסת כל שינוי‪ ,‬גריעת תוכן וכיוצה בזה‪.‬‬
‫הפצת הספר לא תיעשה בשום אופן למטרות מסחריות‪.‬‬
‫בספר זה‪ ,‬ייתכן ומוזכרים מידי פעם סמלים מסחריים של גופים מסחריים שונים‪ .‬יש לציין כי זכויות היוצרים ו‪/‬או הקניין‬
‫הרוחני של המוצרים הללו‪ ,‬כולל שמותיהם וסמליהם בכל מקום בו הם מוזכרים שמורה לבעליהם החוקיים בלבד‪.‬‬
‫סוף דבר‬
‫אני מקווה שספר זה אכן יהיה לך לעזר וישמש אותך היטב בעת הצורך‪ .‬כפי ששימש בעבר את הלומדים ממנו‪.‬‬
‫בברכה‪,‬‬
‫אילן אמויאל‬
‫בשיעור זה‪:‬‬
‫‪ ‬תכיר את יתרונות הפיתוח שב‪Visual Basic-‬‬
‫‪ ‬תכיר רכיבים בסיסיים בסביבת הפיתוח המשולבת של ‪Visual Basic‬‬
‫אודות‬
‫‪‬‬
‫‪‬‬
‫‪VISUAL BASIC‬‬
‫‪ Visual Basic‬היא סביבת פיתוח מבית היוצר של ‪Microsoft‬‬
‫‪ Visual Basic‬כוללת מרכיבי שפה (‪ )Basic‬ומרכיבים גרפיים המאפשרים פיתוח אפליקציות משולב‪.‬‬
‫יתרונות הפיתוח ב ‪Visual Basic -‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫קלות פיתוח‬
‫חזותיות‬
‫מהירות פיתוח‬
‫כלי ‪ Debug‬הנם חלק אינטגרלי מסביבת הפיתוח‬
‫ניתן להפעיל את כלי ה‪ Debug-‬בשילוב עם סביבות פיתוח אחרות‬
‫ניתן להכניס תוספות (‪ )Add-Ins‬לסביבת הפיתוח‬
‫ניתן לנהל מספר פרוייקטים במקביל‪ ,‬תחת קבוצה (‪ )Group‬אחת‬
‫קיימת תמיכה לשימוש ויצריה של רכיבי ‪ActiveX‬‬
‫חסרו נות הפיתוח ב ‪Visual Basic -‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫פיתוח ב‪ Visual Basic-‬פירושו פיתוח אפליקציות לסביבת ‪ Microsoft Windows‬בלבד‬
‫תוכניות הנכתבות ב‪ Visual Basic-‬מהירות פחות מתוכניות הנכתבות בשפת ‪ ,C‬ואינן מתאימות ליישומים‬
‫הדורשים ביצועים מהירים כמו ‪Real Time‬‬
‫תוכנית הנמצאת בשלבי פיתוח ומורצת מתוך ‪ Visual Basic‬רצה כ‪ Thread-‬בתוך ‪ Visual Basic‬ולא כ‪Process-‬‬
‫נפרד‪ .‬המשמעות היא שקריסה של ריצת התוכנית גורמת לקריסת ‪( Visual Basic‬הכוונה לקריסה קריטית ולא‬
‫לשגיאה רגילה)‬
‫פיתוח יישומים מרובי ‪ Threads‬היא משימה לא קלה ב‪Visual Basic-‬‬
‫הכרת סביבת הפיתוח המשולבת (‬
‫‪)ENVIRONMENT‬‬
‫‪INTEGRATED DEVELOPMENT‬‬
‫סביבת הפיתוח של ‪ Visual Basic‬כוללת רכיבים רבים‪ ,‬נכיר את חלקם‪ ,‬חלק אחר שלהם נכיר בהמשך הקורס‪.‬‬
‫תיבת הדו ‪ -‬שיח ‪New Project‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫תיבה זו נפתחת אוטומטית בעת הפעלת ‪ ,Visual Basic‬או בעת בחירת הפריט ‪ New‬מהתפריט ‪File‬‬
‫תיבה זו מאפשרת לבחור פרוייקט חדש מסוגים שונים‬
‫תיבה זו כוללת ‪( Templates‬תבניות) ו‪( Wizards-‬אשפים) המאפשרים קיצור משך הפיתוח‬
‫שורת התפריטים‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫שורת התפריטים של ‪ Visual Basic‬כוללת מספר רב של פריטים‪ ,‬נציג את החשובים שבהם‪:‬‬
‫התפריט ‪ File‬מאפשר יצירת פרוייקטים חדשים‪ ,‬שמירת פרוייקט פתוח‪ ,‬סגירת פרוייקט‪ ,‬קומפילציה (הידור) של‬
‫תוכנית‪ ,‬ועוד‪.‬‬
‫התפריט ‪ Edit‬מאפשר פעולות עריכה שונות כגון‪ ,‬העתקה‪ ,‬גזירה‪ ,‬הדבקה‪ ,‬חיפוש והחלפה אוטומטיים‪ ,‬השלמה‬
‫אוטומטית של מילים שמורות ושמות פונקציות‪ ,‬ועוד‪.‬‬
‫התפריט ‪ View‬שולט בעיקר על אופן התצוגה של ‪ Visual Basic‬ועל רכיבי ה‪ IDE-‬המוצגים‪.‬‬
‫התפריט ‪ Project‬כולל אפשרויות להוספת רכיבים לפרוייקט‪ ,‬והסרה של רכיבים‪ ,‬שליטה על סוג הפרוייקט‬
‫ומאפייניו‪ ,‬ועוד‪.‬‬
‫התפריט ‪ Format‬מאפשר לעצב את הפקדים על הטופס‪.‬‬
‫התפריט ‪ Debug‬מאפשר להריץ ולנפות שגיאות מהתוכנית‪.‬‬
‫התפריט ‪ Run‬מאפשר הרצה‪ ,‬השהייה והפסקה של התוכנית‪.‬‬
‫התפריט ‪ Tools‬מאפשר הוספת שלדי פונקציות‪ ,‬מתודות ומאפיינים לרכיבי קוד בפרוייקט‪ ,‬הוספת תפריטים‬
‫לפרוייקט‪ ,‬כמו גם אפשרויות מתקדמות להגדרת אופן ההתנהגות של ‪.Visual Basic‬‬
‫התפריט ‪ Add-Ins‬מאפשר לצרף תוספות של יצרן צד שלישי לממשק ‪.Visual Basic‬‬
‫התפריט ‪ Window‬מאפשר שליטה על אופן פריסת החלונות בחלון ה‪.IDE-‬‬
‫התפריט ‪ Help‬מאפשר קבלת עזרה‪.‬‬
‫סרגל הכלים הסטנדרטי של ‪Visual Basic‬‬
‫‪ ‬סרגל הכלים הסטנדרטי כולל את אפשרויות התפריט השימושיות ביותר‬
‫‪ ‬ניתן להוסיף סרגלי כלים נוספים לתצוגה ע"י בחירה מתאימה מתוך התפריט ‪ ,View‬או ע"י לחיצה ימנית על‬
‫איזור סרגלי הכלים ובחירה בתפריטים המתאימים‪.‬‬
‫להלן הסבר כללי על פריטי סרגלי הכלים‪ ,‬שחלק לא קטן מהם אתה מכיר‪:‬‬
‫‪‬‬
‫הפריט‬
‫מוסיף פרוייקט נוסף‬
‫‪‬‬
‫הפריט‬
‫מוסיף רכיבים לפרוייקט‬
‫‪‬‬
‫הפריט‬
‫מוסיף תפריטים לתוכנית‬
‫‪‬‬
‫הפריטים‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫הפריט‬
‫מציג מסתיר את ה‪Project Explorer-‬‬
‫‪‬‬
‫הפריט‬
‫מציג‪/‬מסתיר את ה‪Properties Window -‬‬
‫‪‬‬
‫הפריט‬
‫מציג‪/‬מסתיר את ה‪Form Layout Window-‬‬
‫‪‬‬
‫הפריט‬
‫מציג‪/‬מסתיר את ה‪Toolbox-‬‬
‫מאפשרים פתיחה ושמירה של פרוייקט‬
‫מאפשרים גזירה‪ ,‬הדבקה‪ ,‬העתקה‪ ,‬חיפוש והחלפה של טקסט‬
‫מאפשרים ביטול והפעלה מחדש‬
‫מאפשרים הפעלה‪ ,‬השהייה והפסקה של התוכנית‬
‫חלון ה ‪Project Explorer -‬‬
‫‪‬‬
‫‪‬‬
‫בחלון זה רואים את רכיבי הפרוייקט‬
‫כאשר מנהלים מספר פרוייקטים במקביל‪ ,‬רואים אותם ב‪ Project Explorer-‬תחת ‪ Group‬אחד‬
‫חלון ה ‪Properties -‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫חלון ה‪ Properties-‬מציג את מאפייני הרכיב או האובייקט הנבחר‪.‬‬
‫האובייקט הנבחר יכול להיות ‪( Form‬טופס)‪( Control ,‬פקד)‪ ,‬הפרוייקט עצמו‪ ,‬או קבוצת רכיבים‪.‬‬
‫ניתן לצפות במאפיינים בסדר אלפביתי או מסודרים לפי קטגוריות‪.‬‬
‫חלון ה ‪Form Layout -‬‬
‫‪‬‬
‫‪‬‬
‫ב‪ Form Layout-‬ניתן לראות ולקבוע כיצד ייפרסו הטפסים על המסך בעת פתיחתם‬
‫ניתן לקבוע את אופו פריסת הטפסים מחלון זה או מתוך חלון מאפייני הטופס‬
‫ה ‪( Toolbox -‬ארג ז הכל ים)‬
‫‪ ( PictureBox‬תיבת תמונה)‬
‫‪ ( TextBox‬תיבת טקסט)‬
‫‪ ( CommandButton‬לחצן פקודה)‬
‫‪ ( OptionBox‬לחצן אפשרות)‬
‫מצביע לבחירת אובייקט‬
‫‪ ( Label‬תווית)‬
‫‪ ( Frame‬מסגרת)‬
‫‪ ( CheckBox‬תיבת סימון)‬
‫‪ ( ListBox‬תיבת רשימה)‬
‫‪ ( ComboBox‬תיבה משולשבת)‬
‫‪ ( VscrollBar‬פס גלילה אנכי)‬
‫‪ ( HscrollBar‬פס גלילה אופקי)‬
‫‪ ( DriveListBox‬תיבת רשימת הכוננים)‬
‫‪ ( FileListBox‬תיבת רש ימת קבצים)‬
‫‪ ( Line‬קו)‬
‫‪ ( Data‬פקד ‪)Data‬‬
‫‪ ( Timer‬שעון)‬
‫‪ ( DirListBox‬תיבת רשימת ספריות)‬
‫‪ ( Shape‬צורה)‬
‫‪ ( Image‬פקד דמות‪ /‬תמונה)‬
‫‪ ( OLE‬פקד קיצור והטבעה)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫ה‪ ToolBox-‬של ‪ Visual Basic‬מציג במצב התחלתי את הפקדים הסטנדרטיים של ‪Visual Basic‬‬
‫ניתן להוסיף פקדים נוספים ל‪ToolBox-‬‬
‫ניתן לארגן את הפקדים השונים לפי קבוצות‬
‫ה ‪( Code Editor -‬עורך הקוד)‬
‫‪– Procedure‬רשימת פרוצדורות (‪)Events‬‬
‫‪– Object‬רשימת אובייקטים‬
‫‪- Code‬אזור הקוד‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫במרכז המסך ממוקם חלון הקוד – כאן רושמים את שורות הקוד השונות‬
‫התיבה המשולבת (‪ )ComboBox‬משמאל מציגה את רשימת האובייקטים הזמינים לעריכת קוד‬
‫התיבה המשולבת (‪ )ComboBox‬מימין מציגה את רשימת האירועים הזמינים עבור האובייקט‬
‫שיעור ‪ : 2‬טפסים ותפריטים‬
‫‪ ‬תבין מהו פרוייקט ב‪Visual Basic-‬‬
‫‪ ‬תכיר את הפרוייקט מהסוג ‪Standard EXE‬‬
‫‪ ‬תכיר את מבנה החלון בסביבת ‪Microsoft Windows‬‬
‫‪ ‬תבין את המושגים ‪ Methods ,Properties‬ו‪Events-‬‬
‫‪ ‬תכיר את המושגים ‪ Design Time‬ו‪Run Time-‬‬
‫‪ ‬תכיר את שני סוגי ה‪( Forms-‬טפסים) העיקריים ב‪ :Visual Basic-‬טופס רגיל וטופס ‪MDI‬‬
‫‪ ‬תלמד לעבוד עם ‪( Menus‬תפריטים)‬
‫‪ ‬תכיר את הפונקציות ‪ Print‬ו‪MsgBox-‬‬
‫‪ ‬תלמד להוסיף הערות לקוד‬
‫‪ ‬תלמד כיצד ניתן לשלוט על מיקום ופריסת הטפסים ביחס למסך‪ ,‬ביחס לחלון אב‪ ,‬וביחס לחלון ‪MDI‬‬
‫‪ ‬תכיר את סוגי הקבצים המאחסנים את נתוני הפרוייקט ואת נתוני ה‪Forms-‬‬
‫פרוייקט‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫פרוייקט ב‪ Visual Basic-‬הוא אוסף קבצים המאוגדים כקבוצה אחת לשם יצירת תוכנית מסוג כלשהו‬
‫ב‪ Visual Basic-‬ניתן ליצור פרוייקטים מסוגים שונים ולנהל מספר פרוייקטים‬
‫פרוייקט ב‪ Visual Basic-‬מאוחסן בקובץ שהסיומת שלו היא ‪ .*.vbp‬קובץ זה הוא קובץ טקסט המכיל מידע מגוון‬
‫אודות הפרוייקט‬
‫לעתים יש צורך לערוך ידנית את קובץ הפרוייקט‪ .‬למשל‪ ,‬כשמידע מסויים בקובץ שגוי וגורם לבעיות בטעינת‬
‫הפרוייקט‬
‫יצירת פרוייקט חדש‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫בעת הפעלת ‪ Visual Basic‬נפתח באופן אוטומטי חלון ‪New Project‬‬
‫מתוך חלון ה‪ New Project-‬ניתן לבחור את סוג הפרוייקט שרוצים לפתח‬
‫לשם יצירת פרוייקט חלונות סטנדרטי יש לבחור את ‪Standard EXE‬‬
‫ניתן להפעיל את חלון ה‪ New Project-‬גם מתוך התפריט ‪File‬‬
‫הפרוייקט ורכיביו מוצגים בחלון ה‪Project Explorer-‬‬
‫לאחר סימון הפרוייקט ב‪ Project Explorer-‬ניתן לקבוע את שמו ב‪Properties Window-‬‬
‫ניתן לקבוע את שם הפרוייקט ומאפיינים נוספים של הפרוייקט ע"י בחירת ‪ [Project name] Properties...‬מתוך‬
‫התפריט ‪ ,Project‬כאשר ]‪ [Project Name‬הוא שם הפרוייקט שבפיתוח‪ ,‬נכיר את המאפיינים השונים של‬
‫הפרוייקט במהלך הקורס‬
‫הרצת פרוייקט‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫ניתן להריץ את התוכנית שבפיתוח ע"י לחיצה על הכפתור ‪ Start‬או ע"י לחיצה על המקש ‪F5‬‬
‫השלב שבו מפתחים את הפרוייקט‪ ,‬נקרא ‪Design Time‬‬
‫השלב שבו הפרוייקט נמצא במצב ריצה נקרא ‪Run Time‬‬
‫כדי להפסיק (באופן לא מסודר) את ריצת התוכנית שבפיתוח יש ללחוץ על הלחצן ‪Stop‬‬
‫לחיצה על ‪ Stop‬עוצרת באופן מידי את התוכנית תוך דילוג על אירועי הסיום המובנים בתוכנית‬
‫‪Start‬‬
‫‪Stop‬‬
‫שמירת פרוייקט‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ Visual Basic‬שומרת את הפרוייקט במספר קבצי טקסט‬
‫הנתונים אודות הפרוייקט עצמו ומאפייניו מאוחסנים בקובץ שהסיומת שלו היא ‪*.vbp‬‬
‫במקרה הצורך‪ ,‬ניתן לערוך קובץ זה באמצעות ה‪Notepad-‬‬
‫ה‪ FORM-‬הסטנדרטי‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫בעת יצירת פרוייקט מסוג ‪ Standard EXE‬נוסף ‪ Form‬רגיל לפרוייקט‬
‫ניתן להוסיף ‪ Forms‬נוספים ע"י בחירת ‪ Add Form‬מהתפריט ‪Project‬‬
‫טפסים נשמרים בקבצים בעלי הסיומת ‪*.frm‬‬
‫קובץ זה הוא קובץ טקסט הכולל את הקוד השייך לטופס (קוד זה מוצג בעת טעינת הטופס ב‪ ,)Visual Basic-‬כמו‬
‫גם‪ ,‬נתונים נוספים הממוקמים בראש הקובץ‪ ,‬כגון מאפיינים (שגם הם מוצגים בחלון המאפיינים)‬
‫אם קיים צורך‪ ,‬ניתן לערוך קובץ זה ידנית מתוך ה‪Notepad-‬‬
‫מרכיבי ‪Form‬‬
‫‪Maximize/Restore Button‬‬
‫( לחצן הגדלה‪ /‬שחזור)‬
‫‪Minimize Button‬‬
‫( לחצן הקטנה)‬
‫‪ ( Title Bar‬שורת כותרת)‬
‫‪ ( Caption‬כותרת)‬
‫‪ ( Icon‬סמל החלון)‬
‫וה ‪Control Menu-‬‬
‫( תפריט הבקרה)‬
‫‪Close Button‬‬
‫( לחצן סגירה)‬
‫‪Form Grid‬‬
‫( רשת עיצוב –מוצגת‬
‫בזמן הפיתוח בלבד)‬
‫‪ ( Client Area‬אזור הלקוח)‬
‫‪Window Area Border‬‬
‫( גבול אז ור החלון)‬
‫‪( Properties‬מאפיינים)‪( Methods ,‬שיטות)‪ ,‬ו ‪( Events -‬אירועים)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪( Property‬מאפיין) של אובייקט הוא ערך מסוג מסוים הקובע פן מסוים בהתנהגות האובייקט‪ .‬למשל‪ ,‬המאפיין‬
‫‪ Caption‬של ‪ Form‬קובע את הטקסט המופיע בפס הכותרת של הטופס‪.‬‬
‫‪( Method‬שיטה) של אובייקט היא שגרה המופעלת מתוך האובייקט ומשפיע על אופן תפקודו‪ .‬למשל‪ ,‬המתודה‬
‫‪ Move‬של טופס משנה את מיקומו על המסך‪.‬‬
‫‪( Event‬אירוע) של אובייקט הוא שגרה המופעלת בעת התרחשות מסוימת הקשורה באותו אובייקט‪ .‬למשל‪,‬‬
‫האירוע ‪ Load‬של ‪ Form‬מופעל עם טעינת הטופס‪.‬‬
‫לרוב האובייקטים (כולל טפסים ופקדים) קיימים ‪ Methods ,Properties‬ו‪Events-‬‬
‫הכרה של ‪ Methods ,Properties‬ו‪ Events-‬של ‪ Form‬או ‪ ,Control‬חוסכת לימוד חוזר שלהם עבור אובייקטים‬
‫שמכירים לאחר מכן‪ ,‬כיוון שאופן ההתנהגות הוא בדרך שלל זהה‪.‬‬
‫שים לב‪:‬‬
‫בסעיפים הבאים אפרט את חלק ניכר מהמאפיינים‪ ,‬השיטות והאירועים של טופס‪ .‬לעתים קרובות‬
‫המאפיינים‪ ,‬השיטות והאירועים הללו זהים בין אובייקטים שונים‪ ,‬ולכן לא אסביר אותם מחדש כאשר‬
‫אסביר לך אודות אובייקטים נוספים‪ ,‬כגון טופס ‪ CommandButton ,MDI‬וכו'‪ ,‬אלא אם יש הבדל באופן‬
‫פעולתם העקרוני‪.‬‬
‫‪ Properties‬של ‪Form‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ :Name‬השם המוקצה לאובייקט ה‪ ,Form-‬באמצעות שם זה פונים למאפייני ה‪ Form-‬או למתודות שלו‬
‫‪ :BackColor‬קובע את צבע הרקע של ה‪Form-‬‬
‫‪ :BorderStyle‬קובע את סגנון הגבול של הטופס‬
‫‪ :Caption‬קובע את הטקסט המוצג בפס הכוותרת‬
‫‪ :ControlBox‬קובע האם יוצגו תפריטי הבקרה‬
‫‪ :Enabled‬קובע האם ה‪ Form-‬יהיה פעיל או לא (‪ Enabled‬או ‪ Form .)Disabled‬פעיל יכול להגיב לאירועים‬
‫המתרחשים‪ ,‬כגון לחיצת עכבר וכו'‬
‫‪ :FillColor‬צבע המילוי עבור צורות המצוירות באמצעות שגרות גרפיות על גבי ה‪Form-‬‬
‫‪ :FillStyle‬סגנון המילוי (קיימים שמונה סגנונות מילוי שונים‪ - Solid :‬מלא‪ - Transparent ,‬שקוף‪,‬‬
‫‪ - HorizontalLine‬קווקו אנכי‪ ,‬ועוד‪)...‬‬
‫‪ :Font‬סגנון הגופן עבור פעולות גרפיות הכותבות טקסט על גבי ה‪Form-‬‬
‫‪ :ForeColor‬קובע את צבע הקידמה‪ ,‬כלומר‪ ,‬את הצבע באמצעותו יצוירו גבולות הצורות הגרפיות והטקסט‬
‫‪ :Height‬גובה ה‪Form-‬‬
‫‪ :Icon‬סמל הטופס‬
‫‪ :KeyPreview‬קובע האם ה‪ Form-‬יקלוט את אירועי הפקדים שבתוכו לפני שהם מגיבים להם‬
‫‪ :Left‬מיקום נקודת הקצה השמאלית של ה‪Form-‬‬
‫‪ :MaxButton‬קובע האם כפתור ההגדלה שבתפריט הבקרה יהיה פעיל או לא‬
‫‪ :MDIChild‬קובע האם הטופס יהיה טופס בן של טופס ה‪ MDI-‬בתוכנית‬
‫‪ :MinButton‬קובע האם כפתור המזעור בתפריט הבקרה יהיה פעיל‬
‫‪ :Moveable‬קובע האם ה‪ Form-‬יהיה נייד במהלך ריצת התוכנית‬
‫‪ :NegotiateMenus‬קובע האם ה‪ Form-‬ישתף תפריטים של האובייקטים שבתוכו בשורת התפריטים שלו‬
‫‪ :Picture‬הוספת תמונה לרקע של הטופס‬
‫‪ :RightToLeft‬קובע את כיוון הצגת הטקסט‬
‫‪ :ScaleHeight‬גובה אזור הלקוח ב‪ Form-‬לפי יחידות המדידה המצוינת ב‪ScaleMode-‬‬
‫‪ :ScaleLeft‬ערך קצהו השמאלי של אזור הלקוח ב‪Form-‬‬
‫‪ :ScaleMode‬יחידות המדידה לפיהן נמדד אזור הלקוח (ה‪( Client Area-‬ניתן ליצור יחידות מדידה מותאמות‬
‫אישית – ואז לקבוע באופן חופשי את הערכים ‪ ScaleHeight ,ScaleTop ,ScaleLeft‬ו –‪)ScaleWidth‬‬
‫‪ :ScaleTop‬ערך קצהו העליון של אזור הלקוח ב‪Form-‬‬
‫‪ :ScaleWidth‬רוחב אזור הלקוח של ה‪ Form-‬לפי יחידות המדידה שנקבעה ב‪ScaleMode-‬‬
‫‪ :ShowInTaskbar‬קובע האם יוצג סמל התוכנית בשורת המשימות‬
‫‪ :StartUpPosition‬קובע את מיקום ה‪ Form-‬ביחס למסך או לחלון האב‬
‫‪ :Top‬מיקום נקודת הקצה העליונה של ה‪Form-‬‬
‫‪ :Visible‬קובע האם ה‪ Form-‬יהיה נראה (‪ )Visible‬או לא‬
‫‪ :Width‬רוחב ה‪Form-‬‬
‫‪ :WindowState‬קובע את מצבו ההתחלתי של ה‪( Form-‬מוגדל‪/‬מוקטן‪/‬נורמלי)‬
‫‪ Methods‬של ‪Form‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ :Cls‬מנקה ציורים וטקסט שנוספו ל‪ Form-‬בזמן הריצה‬
‫‪ :Hide‬מסתיר את הטופס אך לא פורק (‪ )Unloading‬אותו‬
‫‪ :Move‬משנה את מיקומו ו‪/‬או את גודלו של ה‪Form-‬‬
‫‪ :PopupMenu‬מציג תפריט מוקפץ‬
‫‪ :Refresh‬מרענן את תוכן ה‪ Form-‬כך שיצטייר מחדש‬
‫‪ :SetFocus‬מעביר את ה‪( Focus-‬מיקוד) ל‪Form-‬‬
‫‪ Events‬של ‪Form‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ :Activate‬מתרחש כשה‪ Form-‬הופך להיות פעיל‬
‫‪ :Click‬מתרחש כשלחצן העכבר נלחץ ומשוחרר על גבי ה‪Form-‬‬
‫‪ :DblClick‬מתרחש בעת לחיצה כפולה על הטופס‬
‫‪ :Deactivate‬מתרחש כשה‪ Form-‬הופך ללא פעיל‬
‫‪ :GotFocus‬מתרחש כאשר ה‪ Form-‬מקבל את ה‪( Focus-‬מיקוד)‬
‫‪ :Initialize‬מתרחש בעת אתחול ה‪Form-‬‬
‫‪ :KeyDown‬מתרחש בעת לחיצת מקש‬
‫‪ :KeyPress‬מתרחש לאחר לחיצה ושחרור של מקש‬
‫‪ :KeyUp‬מתרחש לאחר שחרור מקש‬
‫‪ :Load‬מתרחש בעת טעינת ה‪Form-‬‬
‫‪ :LostFocus‬מתרחש בעת איבוד ה‪( Focus-‬מיקוד)‬
‫‪ :MouseDown‬מתרחש בעת לחיצה על אחד הלחצנים בעכבר‬
‫‪ :MouseMove‬מתרחש בעת תזוזת עכבר‬
‫‪ :MouseUp‬מתרחש בעת שחרור אחד הלחצנים בעכבר‬
‫‪ :Paint‬מתרחש בעת ציור תוכן הטופס מחדש‬
‫‪ :QueryUnload‬מתרחש לפני פירוק (‪ )Unloading‬של הטופס‬
‫‪ :Resize‬מתרחש בעת שינוי גודל ה‪Form-‬‬
‫‪ :Terminate‬מתרחש בעת סיום פעולת הטופס‬
‫‪ :Unload‬מתרחש בעת פריקת הטופס‬
‫האירועים ‪ GotFocus ,Deactivate ,Activate ,Unload ,Load ,Terminate ,Initialize‬ו‪ LostFocus-‬ו‪QueryUnload-‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫האירוע ‪ Initialize‬מתרחש בעת יצירת האובייקט בזכרון (תמיד מתרחש לפני ‪ ,)Load‬לאחר ‪ Initialize‬ה‪Form-‬‬
‫קיים כאובייקט אך עדיין לא כחלון‬
‫האירוע ‪ Terminate‬מתרחש בעת שחרור האובייקט מהזכרון (מתרחש תמיד אחרי ‪ ,Unload‬אך אינו מתרחש אם‬
‫התוכנית הסתיימה בצורה לא נורמלית)‬
‫האירוע ‪ Load‬מתרחש בעת טעינת האובייקט מהזכרון והפיכתו לחלון – כלומר בשלב זה‪ ,‬לחלון יש ידית (‪,)hWnd‬‬
‫והפקדים שבו נוצרו ונטענו‬
‫האירוע ‪ Unload‬מתרחש בעת פריקת החלון וכל הפקדים שבו‪ ,‬עם זאת‪ ,‬ה‪ Form-‬עדיין קיים כאובייקט בזכרון‬
‫האירוע ‪ QueryUnload‬מתרחש לפני פריקת (‪ )Unloading‬של ה‪Form-‬‬
‫‪ Activate‬מתרחש בעת מעבר ל‪ Form-‬מטופס אחר באותה התוכנית‬
‫‪ Deactivate‬מתרחש בעת מעבר ל‪ Form-‬אחר באותה התוכנית‬
‫‪ GetFocus‬ו‪ SetFocus-‬מתרחשים בעת קבלה ושחרור של המוקד‪ ,‬בהתאמה‬
‫ארבעת המצבים ש‪ Form-‬יכול להימצא בהם‬
‫קיימים ארבעה מצבים שבהם יכול להימצא ‪:Form‬‬
‫‪ :Created but not loaded ‬ה‪Form -‬נוצר כאובייקט בזכרון אך לא הוטען עדיין כחלון‬
‫‪ :Loaded but not shown ‬ה‪ Form-‬הוטען כחלון אך לא הוצג‬
‫‪ :Shown ‬ה‪ Form-‬הוצג‬
‫‪ :Memory and resources completely reclaimed ‬הזכרון והמשאבים שהוקצו עבור ה‪ Form-‬שוחררו‬
‫במלואם‬
‫‪‬‬
‫הגרף הבא מתאר את סדר התרחשות האירועים הנ"ל בתגובה לפעילויות מסוימות של המשתמש או פונקציות‬
‫שהמתכנת מפעיל‪.‬‬
‫‪Initialize Load Activate GotFocus LostFocus Deactivate QueryUnload Unload Terminate‬‬
‫יצירת ‪ Form‬חדש באמצעות‬
‫המשפט ‪Set...= New ...‬‬
‫שחרור ‪ Form‬באמצעות‬
‫המשפט ‪Set...= Nothing‬‬
‫‪1‬‬
‫‪1‬‬
‫בעת הפעלת הש גרה ‪Load‬‬
‫אירוע ‪ 1‬יתרחש אם הטופס אי נו‬
‫בזיכר ון‪ ,‬אירוע ים ‪ 3‬ו ‪ 4-‬יתרחשו אם‬
‫המאפיי ן ‪ Visible‬שווה ל ‪True-‬‬
‫‪4‬‬
‫בעת הפעלת הש גרה ‪Show‬‬
‫אירוע ‪ 1‬יתרחש א ם הטופס אינ ו‬
‫בזיכר ון‪ ,‬אירוע ‪ 2‬יתרחש אם‬
‫הטופס לא הוטע ן קודם‬
‫‪4‬‬
‫בעת מעבר ל ‪ Form-‬אחר‬
‫באותה התוכנית‪ ,‬או הפעלת‬
‫‪ SetFocus‬על ‪ Form‬אחר באותה‬
‫התוכנ ית‬
‫‪2‬‬
‫בעת מעבר ל ‪ Form-‬מ ‪ Form-‬אחר‬
‫או ע" י הפעלת ‪ SetFocus‬על‬
‫ה ‪Form-‬‬
‫בעת הפעלת הפ ונקציה ‪Unload‬‬
‫אירוע ‪ 3‬יתרחש רק אם אין‬
‫טפסים נוס פים והתוכנית‬
‫‪3‬‬
‫מסתיימת‪,‬או אם הטופס‬
‫משוחרר בצ ורה מפורשת ע"י‬
‫המשפט ‪Set ... = Nothing‬‬
‫‪3‬‬
‫‪2‬‬
‫‪1‬‬
‫‪1‬‬
‫‪2‬‬
‫‪2‬‬
‫‪3‬‬
‫‪2‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫האירועים ‪ Click‬ו‪DblClick-‬‬
‫‪‬‬
‫‪‬‬
‫האירוע ‪ Click‬באובייקט מתרחש לאחר הורדת לחצן עכבר (‪ )MouseDown‬ושחרור אותו לחצן (‪ )MouseUp‬על‬
‫גבי אותו אובייקט‬
‫האירוע ‪ DblClick‬באובייקט מתרחש לאחר הורדת לחצן עכבר שבאה בעקבות האירוע ‪ Click‬תוך פרק זמן הקצר‬
‫או שווה לזה שמוגדר בלוח הבקרה (‪ )Control Panel‬של המערכת‬
‫פונקציות ראשונות‬
‫בסעיף זה נכיר שתי פונקציות ראשונות להצגת הודעה‪ Print :‬ו‪MsgBox-‬‬
‫הפו נקציה ‪Print‬‬
‫‪‬‬
‫‪‬‬
‫הפונקציה ‪ Print‬מדפיסה טקסט על גבי הטופס‬
‫לדוגמה‪:‬‬
‫‪‬‬
‫שורת קוד זו מדפיסה את המחרוזת !‪ Hello, world‬על גבי ה‪Form-‬‬
‫”!‪Print “Hello, world‬‬
‫הפו נקציה ‪MsgBox‬‬
‫‪‬‬
‫‪‬‬
‫הפונקציה ‪ MsgBox‬מציגה תיבת הודעה למשתמש‬
‫‪‬‬
‫שורת קוד זו מציגה תיבת הודעה עם הכיתוב !‪Hello, world‬‬
‫”!‪MsgBox “Hello, world‬‬
‫דוגמה ‪ : 1‬התוכנית ‪HelloWorld‬‬
‫‪‬‬
‫‪‬‬
‫בדוגמה זו ניצור תוכנית המדפיסה את המחרוזת !‪ Hello, world‬על גבי הטופס ובאמצעות תיבת הודעה‬
‫בהדרגה נוסיף פריטים לתוכנית זו‪ ,‬תוך כדי למידה של נושאים נוספים‬
‫שים לב‪:‬‬
‫פעולות שחוזרות על עצמן‪ ,‬כגון יצירת פרוייקט‪ ,‬מתן שם לפרוייקט וכו'‪ ,‬אפרט פעם אחת בדוגמה‬
‫הראשונה שבה נדרשת פעולה זו‪ .‬אם בדוגמאות מתקדמות שכחת כיצד לבצע פעולה זו‪ ,‬חזור לדוגמאות‬
‫הראשונות כדי לרענן את זיכרונך‪.‬‬
‫‪ .1‬צור תוכנית מסוג ‪:Standard EXE‬‬
‫‪ ‬הפעל את ‪( Visual Basic‬אם ‪ Visual Basic‬כבר פתוחה בחר באפשרות ‪ New Project‬מתוך התפריט ‪)File‬‬
‫‪ ‬בחר בפרוייקט ‪ ,Standard EXE‬ולאחר מכן לחץ על ‪OK‬‬
‫‪ .1‬הקצה שם לפרוייקט‪:‬‬
‫‪ ‬בחר באפשרות ‪ Project1 Properties...‬מתוך התפריט ‪Project‬‬
‫‪ ‬בשדה ‪ Project Name‬רשום ‪( HelloWorld‬זהו שם הפרוייקט שבחרתי לפרוייקט זה‪ ,‬כמובן שתוכל לבחור‬
‫בשם אחר אם רצונך בכך)‬
‫‪ .3‬הקצה מאפיינים ל‪:Form-‬‬
‫‪ ‬לחץ על ה‪ Form-‬במקום כלשהו‬
‫‪ ‬מאפייני ה‪ Form-‬צריכים להופיע בחלון המאפיינים (אם אינך רואה את חלון המאפיינים‪ ,‬בחר באפשרות‬
‫‪ Properties Window‬בתפריט ‪ ,View‬או לחץ על ‪)F4‬‬
‫‪ ‬הגדר את המאפיינים הבאים‪:‬‬
‫מאפיין‬
‫‪Name‬‬
‫‪Caption‬‬
‫ערך‬
‫‪FrmHello‬‬
‫‪Hello World Program‬‬
‫‪ .1‬שמור את הפרוייקט‪:‬‬
‫‪ ‬בחר באפשרות ‪ Save Project‬מתוך התפריט ‪File‬‬
‫‪ ‬הקפד ליצור ספרייה נפרדת עבור כל פרוייקט‬
‫‪ ‬שים לב ש‪ Visual Basic-‬מציעה שמות התואמים את‬
‫שמות הפרוייקט והטופס כפי שהקצת להם בתוכנית‬
‫‪ .1‬הוסף קוד‪:‬‬
‫‪ ‬לחץ לחיצה כפולה על הטופס או על‬
‫הלחצן ‪ View Code‬בחלון ה‪Project Explorer-‬‬
‫‪ ‬בחלון ה‪( Code Editor-‬עורך הקוד) בחר ב‪Click-‬‬
‫מתוך רשימת הפרוצדורות הזמינות והקלד את הקוד הבא‪:‬‬
‫‪View Code‬‬
‫()‪Private Sub Form_Click‬‬
‫!"‪Print "Hello, world‬‬
‫‪End Sub‬‬
‫‪ .1‬הרץ את התוכנית ובדוק אותה‪:‬‬
‫‪ ‬לחץ על ‪F5‬‬
‫‪ ‬לחץ לחיצת עבר על ה‪ Form-‬המוצג‪ ,‬אתה צריך לראות את ההודעה ‪ Print‬מוצגת על הטופס‬
‫‪ ‬כל לחיצה נוספת תוסיף שורה נוספת של ההודעה על הטופס‬
‫‪ ‬מזער את החלון והגדל אותו בחזרה – ההודעות נעלמו‬
‫‪ ‬לחץ לחיצה נוספת על הטופס‪ ,‬שוב תיכתב ההודעה !‪ Hello, world‬מיד לאחר השורה האחרונה שבה היא‬
‫נרשמה קודם‬
‫‪ ‬עצור את ריצת התוכנית ע"י סגירת החלון‬
‫‪ .1‬הנחה את הטופס לזכור את תוכנו כתמונת מפת סיביות‪:‬‬
‫‪ ‬שנה את המאפיין ‪ AutoRedraw‬של ‪ frmHello‬לערך ‪True‬‬
‫‪ ‬הרץ ובדוק את התוכנית שוב‪ ,‬שים לב שהפעם לאחר מזעור והגדלה של ה‪ Form-‬תוכנו נשמר‬
‫‪ ‬סיים את ריצת התוכנית‬
‫‪ .1‬הפעלת תיבת הודעה בתגובה ללחיצת מקש‪:‬‬
‫‪ ‬בחלון הקוד בחר ב‪ KeyPress -‬מתוך רשימת הפרוצדורות הזמינות‪ ,‬והקלד את הקוד הבא‪:‬‬
‫)‪Private Sub Form_KeyPress(KeyAscii As Integer‬‬
‫!"‪MsgBox "Hello, world‬‬
‫‪End Sub‬‬
‫‪ .1‬הרץ את התוכנית ובדוק אותה‪:‬‬
‫‪ ‬לאחר הרצת התוכנית לחץ על מקש כלשהו (מבין מקשי האותיות והמספרים)‬
‫‪ ‬צריכה להופיע תיבת הודעה עם המסר ‪!Hello, world‬‬
‫‪ .12‬שמור את התוכנית‪:‬‬
‫‪ ‬שמור את התוכנית ע"י בחירת ‪Save Project‬מתוך תפריט ‪File‬‬
‫‪ ‬בהמשך נשוב למספר שינויים בתוכנית זו‬
‫‪ ‬אם תרצה תוכל לסגור את התוכנית ע"י בחירת ‪ Remove Project‬מתוך התפריט ‪ File‬או ע"י סגירת ‪Visual‬‬
‫‪Basic‬‬
‫הוספת הערות לקוד‬
‫‪‬‬
‫‪‬‬
‫מומלץ להוסיף הערות כדי לשפר את הבנת הקוד‬
‫הערות ב‪ Visual Basic-‬ניתן להוסיף לאחר הסימן ' (גרש בודד)‬
‫המשך דוגמה ‪1‬‬
‫‪ .11‬פתח את התוכנית ‪:HelloWorld‬‬
‫‪ ‬מצא את התוכנית בספרייה שבה שמרת אותה‬
‫‪ ‬הקלק על הקובץ ‪ – HelloWold.vbp‬התוכנית תיפתח אוטומטית באמצעות ‪Visual Basic‬‬
‫‪ .11‬הוסף הערות לקוד‪:‬‬
‫‪ ‬הוסף את ההערות הבאות לקוד (ההערות נצבעות אוטומטית בצבע ירוק)‬
‫()‪Private Sub Form_Click‬‬
‫‪Print "Hello, world!" 'Print the message on the form‬‬
‫‪End Sub‬‬
‫)‪Private Sub Form_KeyPress(KeyAscii As Integer‬‬
‫‪MsgBox "Hello, world!" 'Display a message box to the user‬‬
‫‪End Sub‬‬
‫‪ .13‬מקם את ה‪ Form-‬במרכז המסך‪:‬‬
‫‪ ‬קבע את המאפיין ‪ StartUpPosition‬של ‪ frmHello‬לערך ‪2-CenterScreen‬‬
‫‪ .11‬קבע את גבול החלון כקבוע‪:‬‬
‫‪ ‬שנה את המאפיין ‪ BorderStyle‬של ‪ frmHello‬לערך ‪2-FixedSingle‬‬
‫‪ .11‬הרץ ובדוק את התוכנית‪:‬‬
‫‪ ‬כאשר תריץ את התוכנית‪ ,‬תשים לב כי החלון מוקם במרכז המסך‬
‫‪ ‬נסה לשנות את גודל ה‪ – Form-‬שים לב שזה בלתי אפשרי‬
‫‪( MDI FORM‬טופס ‪)MDI‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ MDI‬הם ראשי התיבות של ‪ – Multiple Document Interface‬ממשק מרובה מסמכים‬
‫לפרוייקט ניתן להוסיף ‪ MDI Form‬אחד לכל היותר‬
‫‪ MDI Form‬הוא ‪ Form‬שיכול להכיל בתוכו מספר ‪-Form‬ים‬
‫במקרה כזה ה‪ MDI Form-‬ייקרא חלון האב של החלונות הכפופים לו‬
‫כדי להפוך ‪ Form‬לטופס השייך לחלון ה‪ MDI-‬יש לנות את המאפיין ‪ MDI Child‬של אותו ‪ Form‬ל‪True-‬‬
‫‪ Properties‬של ‪MDI Form‬‬
‫‪‬‬
‫‪‬‬
‫רוב ה‪ Properties-‬ה‪ Methods-‬וה‪ Events-‬של ‪ MDI Form‬זהים לאלה שבבסעיף ה‪ Form-‬הסטנדרטי‬
‫‪ :AutoShowChildren‬קובע האם חלונות בנים (‪ )MDI Children‬יוצגו באופן אוטומטי בזמן הטעינה‬
‫‪ Methods‬של ‪MDI Form‬‬
‫‪‬‬
‫‪ :Arrange‬מסדר את החלונות הבנים הפתוחים בתוך ה‪MDI Form-‬‬
‫‪( MENUS‬תפריטים)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫ניתן להוסיף תפריטים לטפסים ע"י בחירת ‪ Menu Editor...‬מתפריט ‪Tools‬‬
‫תפריט הוא כמו אובייקט רגיל ב‪ ,Visual Basic-‬ניתן לגשת אל מאפייניו באמצעות שמו‬
‫ניתן להוסיף & לפני אות מסוימת בכותרת תפריט על מנת להפוך אותו למקש מהיר (‪)Accelerator‬‬
‫כדי ליצור קו מפריד בתפריט‪ ,‬יש ליצור פריט שה‪ Caption-‬שלו הוא – (הסימן מינוס)‬
‫‪ Properties‬של ‪Menu‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ :Checked‬קובע האם יוצג הסימן ‪ V‬ליד פריט התפריט‬
‫‪ :NegotiatePosition‬קובע את האופן שבו יסודרו התפריטים על גבי החלון המכיל יחד עם תפריטים‬
‫מאובייקטים שונים‬
‫‪ :Shortcut‬קובע מקשי קיצור עבור פריט התפריט‬
‫‪ :Tag‬מאפשר להצמיד מידע נוסף (מחרוזתי) לאובייקט התפריט‬
‫‪ :WindowList‬קובע אובייקט התפריט ינהל רשימת חלונות (מסוג ‪ )MDI Child‬הפתוחים בתוך ‪MDI Form‬‬
‫‪ :Parent‬ייחוס לחלון האב של התפריט‬
‫‪ Events‬של ‪Menu‬‬
‫‪‬‬
‫‪ :Click‬מתרחש בעת לחיצה על התפריט‬
‫עבודה עם צבעים‬
‫בסעיף זה נכיר מספר פונקציות וקבועים המחזירים ערכים המייצגים צבע‪.‬‬
‫הפו נקציה ‪QBColor‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫פונקציה זו יודעת ליצור ערך המייצג צבע עבור ‪ 11‬צבעים שונים מוגדרים מראש‬
‫פונקציה זו מקבלת אחד מהערכים ‪ 0-15‬ומחזירה ערך המייצג צבע‬
‫)‪Form1.BackColor = QBColor(8‬‬
‫‪‬‬
‫בשורת קוד זו‪ ,‬נקבע צבע הרקע של ‪ Form1‬לצבע ‪( Gary‬אפור)‬
‫הפו נקציה ‪RGB‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫הפונקציה ‪ RGB‬יוצרת צבע מותאם אישית‬
‫הפונקציה מקבלת שלושה ערכים‪ ,‬כל ערך מייצג את רמת מרכיב הצבע – אדום‪ ,‬ירוק או כחול – בצבע התוצאה‬
‫כל מרכיב יכול לנוע החל מהערך ‪ 0‬עד לערך ‪255‬‬
‫יש להפעיל את הפונקציה באופן הבא‪:‬‬
‫)‪RGB(red_value, green_value, blue_value‬‬
‫‪‬‬
‫דוגמה‪:‬‬
‫‪‬‬
‫‪‬‬
‫בשורת קוד זו נקבע צבע הקדמה (צבע הטקס והגבולות של צורות המצויירים ע"י פונקציות גרפיות) לצבע כחול‬
‫טיפים‪:‬‬
‫‪ o‬אם רמת כל צבעים מוגדרת כ‪ 0-‬נוצר צבע שחור‬
‫‪ o‬אם רמת כל צבעים מוגדרת כ‪ 255-‬נוצר צבע לבן‬
‫‪ o‬אם רמת כל צבעים מוגדרת לערך זהה נוצר גוון אפור‬
‫‪ o‬ככל שהערכים גבוהים יותר הצבע בהיר יותר‬
‫)‪Form1.ForeColor = RGB(0, 0, 255‬‬
‫אוסף הקבועים ‪ColorConstants‬‬
‫‪‬‬
‫אוסף קבועים זה מכיל שמונה צבעים מוגדרים מראש‬
‫אוסף הקבועים ‪SystemColorConstants‬‬
‫‪‬‬
‫אוסף של ‪ 25‬קבועים שונים המגדירים צבעים כפי הוגדרו ע"י המשתמש בלוח הבקרה (‪ )Control Panel‬של‬
‫המערכת (למעשה קיימים ‪ 27‬אך שניים מהם זהים)‬
‫דוגמה ‪ – 2‬התוכנית ‪Colors‬‬
‫‪‬‬
‫‪.1‬‬
‫‪.1‬‬
‫‪.3‬‬
‫‪.1‬‬
‫‪.1‬‬
‫‪.1‬‬
‫בדוגמה זו ניצור תוכנית ‪ MDI‬עם שלושה חלונות‪ ,‬ונבצע משחקי צבעים וגרפיקה פשוטים על הטפסים‪ .‬כמו כן‪,‬‬
‫נוסיף תפריטים לתוכנית‬
‫צור תוכנית מסוג ‪Standard EXE‬‬
‫הוסף ‪ Forms‬לפרוייקט‪:‬‬
‫‪ ‬בחר ב‪ Add Form-‬מתוך התפריט ‪Project‬‬
‫‪ ‬מתוך תיבת הדו‪-‬שיח ‪ Add Form‬בחר ב‪( Form-‬הפריט הראשון ברשימה)‬
‫‪ ‬חזור על פעולה זו כך שתוסיף טופס שלישי לתוכנית‬
‫הוסף ‪ MDIForm‬לפרוייקט‪:‬‬
‫‪ ‬בחר ב‪ Add MDI Form-‬מהתפריט ‪Project‬‬
‫‪ ‬מתיבת הדו‪-‬שיח ‪ Add MDI Form‬בחר ב‪MDI Form-‬‬
‫הקצה שמות לפרוייקט ולטפסים‪:‬‬
‫‪ ‬שנה את שמו של הפרוייקט ל‪Colors-‬‬
‫‪ ‬שנה את שמות הטפסים לשמות ‪ frmRGB ,frmQBColors‬ו‪frmSystemColors-‬‬
‫‪ ‬שנה את שם טופס ה‪ MDI-‬ל‪mdiColors-‬‬
‫שמור את הפרוייקט‬
‫הגדר את המאפיינים הבאים‪:‬‬
‫אובייקט‬
‫‪FrmQBColors‬‬
‫‪frmRGB‬‬
‫‪FrmSystemColors‬‬
‫מאפיין‬
‫‪Caption‬‬
‫‪MDIChild‬‬
‫‪Caption‬‬
‫‪Caption‬‬
‫ערך‬
‫‪QBColors‬‬
‫‪True‬‬
‫‪RGB‬‬
‫‪True‬‬
‫‪System Colors‬‬
‫‪True‬‬
‫‪ .1‬שנה את ה‪:Startup Object-‬‬
‫‪ ‬פתח את ‪ Colors Properties...‬מתוך התפריט ‪Project‬‬
‫‪ ‬שנה את האובייקט בשדה ‪ Startup Object:‬כך שיהיה ‪MDIColors‬‬
‫ לתוכניתנים‬Visual Basic 6
:mdiColors ‫ הוסף תפריט לטופס‬.1
‫ מתוך תפריט‬Menu Editor-‫ בח ר ב‬
Tools
&Open ‫ רשום‬Caption ‫ בשדה‬
mnuOpen ‫ רשום‬Name ‫ובשדה‬
Next ‫ לחץ על‬
‫ השדות התרוקנו להזנת הפריט הבא‬
‫ רשום‬Caption ‫ בשדה‬
‫ רשום‬Name ‫ ובשדה‬,QBColos Form
mnuOpenQBColorsForm
‫ השתמש בחץ המופנה כלפי ימין כדי‬
‫להזיח את הפריט הזה מקום אחד‬
‫ כך שיופיע כתת פריט של‬,‫ימינה‬
mnuOpen
‫ הסימן – (מינוס) יוצר הפרדה‬:‫ שים לב‬
‫בתפריטים‬
‫ הוסף את הפריטים המופעים ברשימה‬
‫הבאה כך שהחלון ייראה כמו זה‬
)‫שמופיע כאן (בסוגריים רשומים השמות‬
Caption
Name
&Open mnuOpen
&QBColors Form
&RGB Form
&System Colors Form
E&xit
mnuOpenQBColorsForm
mnuOpenRGBForm
mnuOpenSystemColorsForm
mnuOpenSeparator
mnuOpenExit
:‫ באופן דומה הוסף את התפריטים הבאים‬.1
:frmQBColors ‫ לטופס‬
Caption
Name
&Colors
mnuColors
&Red mnuColorsRed
&Green mnuColorsGreen
&Blue mnuColorsBlue
mnuColorsSeparator1
B&lack mnuColorsBlack
&White mnuColorsWhite
mnuColorsSeparator2
&Quit mnuColorsQuit
- 11 ‫אילן אמויאל © כל הזכויות שמורות‬
.‫ לשדר או להציג את הספר או חלקים ממנו בשום צורה‬,‫אין להעתיק‬
www.kita.co.il
‫ טפסים ותפריטים‬:2 ‫שיעור‬
:frmRGB ‫לטופס‬

:frmSystemColors ‫לטופס‬

Caption
Name
&Colors
mnuColors
&Red mnuColorsRed
&Green mnuColorsGreen
&Blue mnuColorsBlue
mnuColorsSeparator1
&Cyan mnuColorsCyan
&Magenta
mnuColorsMagenta
&Yellow
mnuColorsYellow
mnuColorsSeparator2
&Quit mnuColorsQuit
Caption
Name
&Colors
mnuColors
&Button Face mnuColorsButtonFace
&Tool Tip
mnuColorsToolTip
&Desktop
mnuColorsDesktop
mnuColorsSeparator
&Quit mnuColorsQuit
:‫ הוסף קוד‬.12
:mdiColors ‫ לטופס‬
Private Sub mnuOpenExit_Click)(
Unload Me
End Sub
Private Sub mnuOpenQBColorsForm_Click)(
' Loads and displays frmQBColors
Load frmQBColors
frmQBColors.Show
End Sub
Private Sub mnuOpenRGBForm_Click)(
' Loads and displays frmRGB
Load frmRGB
frmRGB.Show
End Sub
Private Sub mnuOpenSystemColorsForm_Click)(
' Loads and displays frmSystemColors
Load frmSystemColors
frmSystemColors.Show
End Sub
www.kita.co.il
Private Sub mnuWindowArrangeIcons_Click)(
Arrange vbArrangeIcons
End Sub
Private Sub mnuWindowCascade_Click)(
Arrange vbCascade
End Sub
Private Sub mnuWindowTileHorizontally_Click)(
Arrange vbTileHorizontal
End Sub
Private Sub mnuWindowTileVertically_Click)(
Arrange vbTileVertical
End Sub
:frmQBColors ‫לטופס‬
Private Sub mnuColorsBlack_Click)(
BackColor = QBColor(0) ' Black
End Sub
Private Sub mnuColorsBlue_Click)(
BackColor = QBColor(1) ' Blue
End Sub
Private Sub mnuColorsGreen_Click)(
BackColor = QBColor(2) ' Green
End Sub
Private Sub mnuColorsQuit_Click)(
Unload Me
End Sub
Private Sub mnuColorsRed_Click)(
BackColor = QBColor(4) 'Red
End Sub
Private Sub mnuColorsWhite_Click)(
BackColor = QBColor(15) 'white
End Sub
www.kita.co.il

‫ טפסים ותפריטים‬:2 ‫שיעור‬
:frmRGB ‫לטופס‬
Private Sub mnuColorMagenta_Click)(
BackColor = RGB(255, 0, 255) 'Magenta
End Sub
Private Sub mnuColorsBlue_Click)(
BackColor = RGB(0, 0, 255) ' Blue
End Sub
Private Sub mnuColorsCyan_Click)(
BackColor = RGB(0, 255, 255) ' Cyan
End Sub
Private Sub mnuColorsGreen_Click)(
BackColor = RGB(0, 255, 0) ' Green
End Sub
Unload Me
End Sub
Private Sub mnuColorsRed_Click)(
BackColor = RGB(255, 0, 0) ' Red
End Sub
Private Sub mnuColorsYellow_Click)(
BackColor = RGB(255, 255, 0) ' Yellow
End Sub
www.kita.co.il

:frmSystemColors ‫לטופס‬

Private Sub mnuColorsButtonFace_Click)(
BackColor = SystemColorConstants.vbButtonFace
End Sub
Private Sub mnuColorsDesktop_Click)(
BackColor = SystemColorConstants.vbDesktop
End Sub
Unload Me
End Sub
Private Sub mnuColorsToolTip_Click)(
BackColor = SystemColorConstants.vbInfoBackground ' ToolTip background
End Sub
‫ הרץ ובדוק את התוכנית‬.11
www.kita.co.il
‫תרגילים‬
‫‪ .1‬כתוב תוכנית בשם ‪ SimpleColors‬ובה שלושה ‪ .Forms‬קבע צבע רקע שונה לכל ‪ Form‬וטען את ה‪ Form-‬השני‬
‫בעת לחיצה על ה‪ Form‬הראשון‪ ,‬ואת ה‪ Form-‬השלישי בעת לחיצה כפולה על ה‪ Form‬השני‪.‬‬
‫בעת לחיצת מקש על ה‪ Form-‬השלישי ייסגרו של ה‪ Forms-‬ותסתיים התוכנית‪.‬‬
‫‪ .1‬כתוב תוכנית בשם ‪ TraceEvents‬ובה שלושה ‪ Form2 ,Form1 :Forms‬ו‪Form3-‬‬
‫ב‪ Form1-‬הוסף תפריט המאפשר את טעינת ‪ Form2‬ו‪ ,Form3-‬ניקוי ה‪( Form-‬בצע ניקוי באמצעות השגרה ‪)Cls‬‬
‫וכן‪ ,‬אפשרות יציאה מהתוכנית (הסוגרת את כל ה‪ .)Forms-‬כמו כן‪ ,‬בטל את לחצן הסגירה ב‪ Form1-‬כך שניתן‬
‫יהיה לסגור את התוכנית רק באמצעות האופציה המתאימה בתפריט‪ ,‬ולבסוף‪ ,‬הגדר את ‪ AutoRedraw‬ב‪Form1-‬‬
‫כ‪ True-‬ע"מ שתוכן החלון יישמר לאחר הסתרה של חלק ממנו‪.‬‬
‫בכל אחד מה‪ Forms-‬האחרים (‪ Form2‬ו‪ ,)Form3-‬הוסף שורות קוד המדפיסות על גבי ‪ Form1‬את האירוע‬
‫שהתרחש עבור כל אחד מהאירועים הבאים‪,GotFocus ,Unload ,QueryUnload ,Load ,Initialize :‬‬
‫‪ Activate ,LostFocus‬ו‪ .Deactivate-‬כך לדוגמה‪ ,‬באירוע ‪ Activate‬שב‪ Form3-‬תרשום‪:‬‬
‫()‪Private Sub Form_Activate‬‬
‫"‪Form1.Print "Form3: Activate‬‬
‫‪End Sub‬‬
‫תוכל להיעזר בחלון ה‪ Form Layout-‬כדי להגדיר בקלות את מיקומי הטפסים על גבי המסך בעת הרצת התוכנית‪.‬‬
‫לאחר הפעלת התוכנית‪ ,‬עקוב אחר סדר התרחשות ה‪ Events-‬ב‪ Form2-‬ו‪ Form3-‬כפי שהם מודפסים על –‪.Form1‬‬
‫‪ .3‬כתוב תוכנית בשם ‪ ArrangeForms‬עם ‪ MDIForm‬ושלושה ‪ Forms‬רגילים המוגדרים כ‪.MDIChild-‬‬
‫הוסף ל‪ MDIForm-‬תפריט לטעינת הטפסים הללו‪ ,‬וכן תפריט בשם ‪ Window‬המאפשר לפרוס את החלונות שבו‬
‫באופנים שונים‪ ,Cascade ,Tile Vertically ,Tile Horizontally :‬ו‪( Arrange Icons-‬השתמש בשגרה ‪Arrange‬‬
‫של ‪ MDIForm‬לשם כך)‪ .‬כמו כן הגדר את האפשרות ‪ WindowList‬עבור התפריט ‪ Window‬כ‪ True-‬על מנת‬
‫שרשימת ה‪ Forms-‬הפתוחים תוצג בתפריט זה‪( .‬אל תשכח לשנות את ה‪ Startup Object-‬ל‪ MDIForm-‬בהגדרות‬
‫הפרוייקט)‪.‬‬
‫שיעור ‪ : 1‬הפקדים הסטנדרטיים ‪I‬‬
‫‪ ‬תכיר את ה‪ Controls‬הבאים‪:‬‬
‫‪( Label o‬תווית)‬
‫‪( TextBox o‬תיבת טקסט)‬
‫‪( CommandButton o‬לחצן פקודה)‬
‫‪( HScrollBar o‬פס גלילה אופקי)‬
‫‪( VScrollBar o‬פס גלילה אנכי)‬
‫‪ ‬תכיר את הפונקציות הבאות לעבודה עם מחרוזות‪,Mid ,Left ,Right ,Trim ,LTrim ,RTrim ,Str ,Val ,Len :‬‬
‫ו‪Asc-‬‬
‫‪ ‬תלמד לשרשר מחרוזות ולהוסיף מעברי שורה‬
‫‪ ‬תכיר את התנאי ‪If... Then... End If‬‬
‫הערה‬
‫בדרך כלל‪ ,‬אני לא חוזר על ‪ Methods ,Properties‬ו‪ events-‬שהזכרתי בטפסים שפעולתם זהה לאופן‬
‫הפעולה ב‪ Controls-‬שבפרק זה‪ .‬בכל ‪ Control‬אני מציין את ה‪ Methods ,Properties-‬ו‪ Events-‬שלא‬
‫צוינו קודם‪.‬‬
‫‪( LABEL‬תווית)‬
‫‪‬‬
‫‪ Label‬נועד בעיקר להצגת טקסט‪ ,‬בד"כ בצמוד לפקדים אחרים‬
‫‪ Properties‬של ‪Label‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ :Alignment‬קובע את סוג יישור הטקסט בתוך ה‪Label-‬‬
‫‪ :Appearance‬קובע את אופן התצוגה של ה‪( Label-‬אפקטים תלת ממדיים או ללא אפקטים תלת ממדיים)‬
‫‪ :AutoSize‬קובע האם גודל ה‪ Label-‬ישתנה באופן אוטומטי בהתאם לתוכן‬
‫‪ :BackStyle‬קובע את סגנון הרקע (‪ – Transparent‬שקוף‪ ,‬או ‪ – Opaque‬אטום‪ ,‬לא שקוף)‬
‫‪ :Caption‬טקסט התוכן המוצג ב‪Label-‬‬
‫‪ :Container‬קובע את ה‪ Container Control‬של ה‪ Control Container( Label‬הוא ‪ Control‬מכולה‪ ,‬כלומר‬
‫‪ Control‬המסוגל להכיל בתוכו פקדים אחרים‪ .‬מהפקדים הסטנדרטיים‪ PicutreBox ,‬ו‪ Frame-‬הם ה ‪Control‬‬
‫‪ Containers‬היחידים)‬
‫‪ :Index‬מספרו הסידורי של ה‪ Label-‬אם הוא שייך למערך של ‪Labels‬‬
‫‪ :RightToLeft‬קובע את כיוון קריאת הטקסט‬
‫‪ :TabIndex‬קובע את מיקומו הסידורי של ה‪ Label-‬בסדר מעבר הטאב‬
‫‪ :Tag‬מאפשר להצמיד מידע נוסף ל‪Label-‬‬
‫‪ :ToolTipText‬טקסט עזרה המוצג כאשר סמן העכבר ממוקם מעל ה‪Label-‬‬
‫‪ :UseMnemonic‬קובע האם להתייחס לתו & כתו המאפשר הגדרת מאיץ מקלדת או להציגו כמו שהוא‬
‫‪ :WordWrap‬קובע האם לאשר גלישת טקסט הארוך מרוחב ה‪Label-‬‬
‫‪ Events‬של ‪Label‬‬
‫‪‬‬
‫‪ :Change‬מתרחש כאשר משתנה תוכן ה‪Label-‬‬
‫‪( TEXTBOX‬תיבת טקסט)‬
‫‪‬‬
‫השימוש הנפוץ ב‪ TextBox-‬הוא לקבלת קלט מהמשתמש‬
‫‪ Properties‬של ‪TextBox‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ :HideSelection‬קובע האם טקסט מסומן יישאר מואר כאשר הפוקוס עובר ל‪ Control-‬אחר‬
‫‪ :Locked‬קובע האם ה‪ TextBox-‬יכול לקבל פעולות עריכה‬
‫‪ :MaxLength‬קובע את המספר המקסימלי של תווים בניתן להזין ל‪ 0( TextBox-‬מציין אי הגבלה)‬
‫‪ :MultiLine‬קובע אם ה‪ TextBox-‬יכול להיות מרובה שורות‬
‫‪ :PasswordChar‬קובע איזה תו יחליף את התו המוקלד (בתצוגה בלבד) במקרה שה‪ TextBox-‬משמש לקבלת‬
‫סיסמה‬
‫‪ :ScrollBars‬קובע אילו פסי גלילה יופיעו ב‪TextBox-‬‬
‫‪ :TabStop‬קובע אם סדר מעבר הטאב יפעל גם על ה‪TextBox-‬‬
‫‪ :Text‬מכיל את הטקסט הנמצא ב‪TextBox-‬‬
‫‪ Events‬של ‪TextBox‬‬
‫‪‬‬
‫‪‬‬
‫‪ :Change‬מתרחש בכל פעם שהטקסט שונה (לאחר שהשינוי הוצג ב‪)TextBox-‬‬
‫‪ :KeyPress‬מתרחש בעת לחיצה על מקש ‪( ASCII‬אות או מספר) לפני הצגת התו ב‪.TextBox-‬‬
‫‪( COMMANDBUTTON‬לחצן פקודה)‬
‫‪‬‬
‫שימושו הנפוץ של ‪ CommandButton‬הוא לאפשר למשתמש פעולה מסוימת המשויכת ל‪.CommandButton-‬‬
‫לפיכך‪ ,‬בדרך כלל‪ ,‬מגיבים לאירוע ‪ Click‬ב‪CommanButton-‬‬
‫‪ Properties‬של ‪CommandButton‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ :Cancel‬קובע אם ה‪ CommandButton‬ידמה לחיצה עליו בתגובה ללחיצה על המקש ‪Escape‬‬
‫‪ :Default‬קובע אם ה‪ CommandButton-‬ידמה לחיצה עליו בתגובה ללחיצה על המקש ‪)Return( Enter‬‬
‫‪ :DisablePicture‬קובע איזה תמונה תוצג על גבי ה‪ CommandButton-‬כאשר הוא במצד ‪ ,Disable‬כלומר‪ ,‬כאשר‬
‫המאפיין ‪ Enabled‬שווה ל‪( False-‬יש לוודא שהמאפיין ‪ Style‬של ה ‪ CommandButton‬יהיה ‪)Graphical‬‬
‫‪ :DownPicture‬קובע איזו תמונה תוצג על גבי הלחצן בזמן לחיצה עליו (שוב‪ ,‬ה‪ Style-‬של ה‪CommandButton-‬‬
‫צריך להיות ‪ True‬בכדי שמאפיין זה יפעל)‬
‫‪ :Enabled‬קובע האם הלחצן יאופשר או לא (זהו אחד המאפיינים השימושיים ביותר של ‪)CommandButton‬‬
‫‪ :MaskColor‬מאפשר להגדיר איזה צבע בתמונה יהיה שקוף (יש להגדיר גם ‪ UseMaskColor‬כ‪ True-‬כדי‬
‫שמאפיין זה יפעל)‬
‫‪ :Picute‬קובע איזו תמונה תוצג על גבי הלחצן במצב רגיל‪.‬‬
‫‪ :Style‬קובע את סגנון הלחצן‪ – Standard .‬מציג רק טקסט ו‪ – Graphical-‬משתמש גם בתמונות המוגדרות‪.‬‬
‫‪ :UseMaskColor‬קובע האם ה‪ CommandButton-‬ישתמש בצבע המוגדר במאפיין ‪ MaskColor‬כצבע שקוף‪.‬‬
‫‪( HSCROLLBAR‬פס גלילה אופקי) ו‪( VSCROLLBAR-‬פס גלילה אנכי)‬
‫‪‬‬
‫פסי גלילה מאפשרים גלילת טקסט‪ ,‬תמונות וכו'‪ ,‬וזהו בדרך כלל שימושם העיקרי‬
‫‪ Properties‬של פסי גל ילה‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ :LargeChange‬קובע את גודל הקפיצה כאשר לחצן העכבר לוחץ במקום כלשהו בין ה‪ Bar-‬לבין אחד החצים‪ ,‬או‬
‫כאשר נלחץ אחד מהמקשים ‪ PageUp‬או ‪PageDown‬‬
‫‪ :Max‬מגדיר את הערך המקסימלי (הקצה הימני בפס אופקי או הקצה התחתון בפס אנכי) של פס הגלילה‬
‫‪ :Min‬מגדיר את הערך המינימלי של פס הגלילה (אם ‪ Min‬גדול מ‪ Max-‬פס הגלילה משנה את כיוון התקדמותו‬
‫מימין לשמאל בפס אופקי‪ ,‬ומלמטה כלפי מעלה בפס אנכי)‬
‫‪ :SmallChange‬מגדיר את גודל הצעד הקטן עבור התקדמות ה‪Bar-‬‬
‫‪ Events‬של פסי גלילה‬
‫‪‬‬
‫‪‬‬
‫‪ :Change‬מתרחש בעת שינוי בערכו של פס הגלילה‪.‬‬
‫‪ :Scroll‬מתרחש בעת גרירת ה‪ Bar-‬שעל פס הגלילה באמצעות העכבר‪.‬‬
‫פונקציות לעבודה עם מחרוזות‬
‫‪‬‬
‫בסעיף זה תכיר מספר פונקציות לעבודה עם מחרוזות‬
‫הפו נקציה ‪Len‬‬
‫‪‬‬
‫‪‬‬
‫הפונקציה ‪ Len‬מאפשרת למצוא את אורכה של מחרוזת‬
‫‪‬‬
‫בשורת קוד זו‪ ,‬הפונקציה ‪ Len‬את המספר ‪ 13‬שהוא אורך המחרוזת !‪Hello,world‬‬
‫)”!‪Len(“Hello ,world‬‬
‫הפו נקציה ‪Val‬‬
‫‪‬‬
‫‪‬‬
‫הפונקציה ‪ Val‬מחזירה את הערך הנומרי של מחרוזת‬
‫‪‬‬
‫בשורת קוד זו‪ ,‬מוחזר הערך ‪ 12‬ע"י הפונקציה ‪Val‬‬
‫)”‪Val(“12abc‬‬
‫הפו נקציה ‪Str‬‬
‫‪‬‬
‫‪‬‬
‫הפונקציה ‪ Str‬יוצרת מחרוזת הזהה לערך נומרי המועבר לה‬
‫‪‬‬
‫פונקציה זו יוצרת את המחרוזת “‪”12.45‬‬
‫)‪Str(12.45‬‬
‫הפו נקציה ‪UCase‬‬
‫‪‬‬
‫‪‬‬
‫הפונקציה ‪ UCase‬מקבלת מחרוזת ומחזירה את אותה המחרוזת לאחר הפיכת האותיות הקטנות במחרוזת‬
‫לאותיות גדולות‬
‫)"‪something 4 u...‬‬
‫‪‬‬
‫שורת קוד זו מחזירה את המחרוזת "‪"I HAVE SOMTHING 4 U...‬‬
‫‪UCase("I have‬‬
‫הפו נקציה ‪LCase‬‬
‫‪‬‬
‫‪‬‬
‫הפונקציה ‪ LCase‬מקבלת מחרוזת ומחזירה את אותה המחרוזת לאחר הפיכת האותיות הגדולות במחרוזת‬
‫לאותיות קטנות‬
‫)"?‪LCase("HOW R u 2 dayyYy...‬‬
‫‪‬‬
‫שורת קוד זו מחזירה את המחרוזת "?‪"how r u 2 dayyyy...‬‬
‫הפו נקצ יות ‪ LTri m , Trim‬ו ‪Rtrim -‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫הפונקציה ‪ RTrim‬מעתיקה מחרוזת חדשה ממחרוזת נתונה‪ ,‬תוך הסרת כל הרווחים הנמצאים בקצה הימני של‬
‫המחרוזת‪.‬‬
‫הפונקציה ‪ LTrim‬מעתיקה מחרוזת חדשה ממחרוזת נתונה‪ ,‬תוך הסרת כל הרווחים הנמצאים בקצה השמאלי של‬
‫המחרוזת‪.‬‬
‫הפונקציה ‪ Trim‬מעתיקה מחרוזת חדשה ממחרוזת נתונה‪ ,‬תוך הסרת כל הרווחים שבקצות המחרוזת‪.‬‬
‫)“‬
‫‪‬‬
‫פונקציה זו תחזיר את המחרוזת “‬
‫‪How r u‬‬
‫‪How r u‬‬
‫‪Hello‬‬
‫“( ‪LTrim‬‬
‫‪“Hello‬‬
‫הפו נקצ יות ‪ Left , Mid‬ו ‪Right -‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫הפונקציה ‪ Left‬יוצרת תת מחרוזת שמאלית באורך נתון ממחרוזת נתונה‬
‫הפונקציה ‪ Right‬יוצרת תת מחרוזת ימנית באורך נתון ממחרוזת נתונה‬
‫הפונקציה ‪ Mid‬יוצרת תת מחרוזת המתחילה במיקום נתון‪ ,‬ובאורך נתון מתוך מחרוזת נתונה‪.‬‬
‫דוגמאות‪:‬‬
‫(‪Right("Hello ,world!",6‬‬
‫‪‬‬
‫שורת קוד זו מחזירה את המחרוזת ‪!world‬‬
‫‪‬‬
‫שורת קוד זו מחזירה את המחרוזת ‪Hell‬‬
‫‪‬‬
‫שורת קוד זו מחזירה את המחרוזת ‪wor‬‬
‫(‪Left("Hello ,world!",4‬‬
‫(‪Mid("Hello ,world!",8,3‬‬
‫האופרטור &‬
‫‪‬‬
‫‪‬‬
‫האופרטור & מאפשר לשרשר מחרוזות‬
‫‪‬‬
‫שור זו הופכת למחרוזת “‪”Ilan Amoyal‬‬
‫‪‬‬
‫בשורת קוד זו‪ ,‬לתוך ה‪ txtOut-‬מוזנת המחרוזת המשורשרת מ‪ txtInput1-‬ו‪txtInput2-‬‬
‫”‪“Ilan” & “ “ & “Amoyal‬‬
‫‪txtOut.Text = txtInput1.Text & txtInput2.Text‬‬
‫הקבוע ‪vbCrLf‬‬
‫‪‬‬
‫‪‬‬
‫הקבוע ‪ vbCrLf‬מייצג את תו מעבר השורה‬
‫”!‪Text1.Text = Text1.Text & vbCrLf & “Hello, world‬‬
‫‪‬‬
‫שורת קוד זו מוסיפה מעבר שורה ל‪ Text1-‬ומיד לאחר מכן משרשרת את המחרוזת “‪”!Hello, world‬‬
‫הפו נקציה ‪Asc‬‬
‫‪‬‬
‫‪‬‬
‫מחזירה את ערכו ה‪ ASCII-‬של התו במחרוזת נתונה‬
‫)”‪Asc(“a‬‬
‫בשורת קוד זו‪ ,‬הפונקציה ‪ Asc‬מחזירה את הערך ‪ ,97‬שזהו ערכו של התו “‪ ”a‬לפי טבלת ה‪ASCII-‬‬
‫)"‪Asc("Goal‬‬
‫בשורת קוד זו הפונקציה ‪ Asc‬מחזריה את ‪ ,71‬שזהו ערכו ה‪ ASCII‬של התו ‪( G‬התו הראשון במחרוזת)‬
‫התנאי‬
‫‪IF...THEN...END IF‬‬
‫‪‬‬
‫תחביר התנאי הוא כדלקמן‪:‬‬
‫‪‬‬
‫התנאי (‪ )condition‬יכול להיות מורכב מהקשרים ‪ And‬ו‪/‬או ‪Or‬‬
‫‪If condition Then‬‬
‫‪do_somthing‬‬
‫‪End If‬‬
‫‪ .1‬כתוב תוכנית בשם ‪ Focuses‬ובה ארבעה ‪ .CommandButtons‬ליצה על ה‪ CommandButton-‬הראשון יעביר את‬
‫ה‪ Focus-‬ל‪ CommandButton-‬השני‪ .‬לחיצה על השני תעביר את ה‪ Focus-‬לשילישי‪ ,‬לחיצה על השלישי תעביר את‬
‫ה‪ Focus-‬לרביעי‪ ,‬ולחיצה על הרביעי תעביר את ה‪ ,Focus-‬חזרה‪ ,‬ל‪ CommandButton‬הראשון‪.‬‬
‫כל ‪ CommandButton‬בעת קבלת ה‪ ,Focus-‬ידפיס על גבי ה‪ Form-‬את שמו (‪( )Name‬לאחר ניקוי התוכן הקודם‬
‫של ה‪ ,)Form-‬וכמו כן‪ ,‬יעדכן את כותרת (‪ )Caption‬החלון כך שתהיה זהה לכותרתו (‪.)Caption‬‬
‫‪ .1‬כתוב תוכנית בשם ‪ ThreeColors‬ובה שלושה ‪ CommandButtons‬עם הכיתובים ‪ Green ,Red‬ו‪ .Blue-‬לחיצה על‬
‫אחד הפקדים תשנה את צבע הרקע של ה‪ ,Form-‬ותעדכן את כותרת ה‪ Form-‬בהתאם‪.‬‬
‫‪ .3‬כתוב תוכנית בשם ‪ Concatenate‬ונח בה שלושה פקדי ‪ TextBox‬ו‪ CommandButton-‬אחד‪.‬‬
‫סמוך ל‪ TextBox-‬הראשון מקם ‪ Label‬עם הכיתוב “‪ .”Input1‬סמוך ל‪ TextBox-‬השני מקם ‪ Label‬עם הכיתוב‬
‫“‪ ”Input2‬וליד השלישי מקם ‪ Label‬עם הכיתוב “‪ .”Output‬כמו כן‪ ,‬נעל את ה‪ TextBox-‬השלישי מפני עריכה‪.‬‬
‫לחיצה על ה‪ CommanButton-‬תשרשר את שתי המחרוזות שבשני פקדי ה‪.TextBoxes-‬‬
‫‪ .1‬כתוב תוכנית זהה לקודמת בשם ‪ Concatenate2‬עם השינויים הבאים‪:‬‬
‫ה‪ CommandButton-‬יהיה ‪.Default‬‬
‫יוכנס מעבר שורה בין שתי המחרוזות המשורשרות‪.‬‬
‫לאחר השרשור‪ ,‬ימחקו תכני תיבות הקלט וה‪ Focus-‬יוחזר לתיבת הקלט הראשונה‪.‬‬
‫‪ .1‬כתוב תוכנית בשם ‪ .TextBoxCopy‬על ה‪ Form -‬הנח שני פקדי ‪ TextBox‬האחד לקלט (‪ )Input‬והשני‬
‫לפלט (‪ .)Output‬התוכנית צריכה להעתיק את המחרוזת המוזנת כקלט ב‪ TextBox-‬הראשון אל ה‪ TextBox-‬של‬
‫הפלט‪ .‬כל העתקה תיכנס לשורה חדשה בפלט מבלי למחוק את השורות הקודמות‪.‬‬
‫בתוכנית זו הוסף שלושה ‪ .CommandButtons‬אחד להעתקה (זה יהיה פקד ה‪ ,)Default-‬שני לניקוי תיבת הפלט‪,‬‬
‫ושלישי לסגירת התוכנית (זה יהיה פקד ה‪.)Escape-‬‬
‫לאחר העתקת הטקסט‪ ,‬יש להחזיר את ה‪ Focus-‬לתיבת הקלט תוך סימון הטקסט הרשום בה‪.‬‬
‫‪ .1‬כתוב תוכנית בשם ‪ ,DigitTextBox‬שתכלול ‪ TextBox‬שיאפשר קלט של ספרות‪ ,‬מקש ‪ ,Backspace‬ומקש ‪Enter‬‬
‫למעבר שורה‪ .‬בנוסף הנח שני ‪ ,CommandButtons‬האחד לניקוי ה‪ TextBox-‬והשני ליציאה (שיהיה מקש ה‪-‬‬
‫‪ Escape‬בתוכנית)‪.‬‬
‫‪ .1‬כתוב תוכנית בשם ‪:SlideColors‬‬
‫ב‪ Form-‬הנח שלושה ‪ ScrollBars‬והגדר את הטווח שלהם מ‪ 2-‬עד ‪ .111‬כמו כן‪ ,‬הנח ‪ Label‬על הטופס‪.‬‬
‫בעת שינוי ערכו של אחד מה‪ ScrollBars-‬יש לעדכן את צבע הרקע של ה‪ Label-‬באמצעות הפונקציה ‪ ,RGB‬כך‬
‫שה‪ ScrollBar-‬הראשון יהווה את המרכיב ‪ Red‬בפונקציה‪ ,‬ה‪ ScrollBar-‬השני יהווה את מרכיב ה‪Green-‬‬
‫בפונקציה‪ ,‬וה‪ ScrollBar-‬השלישי יהווה את מרכיב ה‪ Blue-‬בפונקציה‪.‬‬
‫צור ממשק נוח למשתמש תוך שימוש ב‪ Labels-‬לפי הצורך‪.‬‬
‫‪ .1‬צור תוכנית זהה לתוכנית הקודמת בשם ‪ SlideColors2‬תוך הוספת השיפורים הבאים‪:‬‬
‫דאג לכך שבזמן שהתוכנית עולה‪ ,‬צבע ה‪ Label-‬יהיה תואם לערכים שב‪ScrollBars-‬‬
‫בסמוך לכל ‪ ScrollBar‬תוצב תיבת טקסט שתשקף את הערך שב‪ScrollBar-‬‬
‫צבע הרקע של כל ‪ TextBox‬יהיה צבע המרכי שאותו הוא מייצג‪.‬‬
‫כמו כן‪ ,‬נעל את תיבות טקסט אלו‬
‫ה‪ LargeChange-‬של ה‪ ScrollBar-‬יהיה ‪10‬‬
‫שיעור ‪ : 4‬מרכיבי השפה ‪I‬‬
‫‪ ‬תלמד להצהיר על משתנים ועל קבועים ותכיר את סוגם‬
‫‪ ‬תבין את ההבדל בין משתנה מקומי בפרוצדורה או פונקציה לבין משתנה משותף במודול‬
‫‪ ‬תבין את ההבדלים בין ‪ Public Dim‬ו‪ Private-‬בהקשר של הצהרות משתנים‬
‫‪ ‬תכיר את מבני הבקרה הקיימים ב‪Visual Basic-‬‬
‫‪ ‬תכיר את הפונקציות ‪ Beep ,InputBox‬ו‪IIf-‬‬
‫‪( VARIABLES‬משתנים) ו‪( CONSTANTS-‬קבועים)‬
‫בסעיף זה נסקור את‪:‬‬
‫‪ ‬סוגי המשתנים ב‪Visual Basic-‬‬
‫‪ ‬אופן ההצהרה על משתנים‬
‫‪ ‬אזורי הצהרה שונים במודול‬
‫‪ ‬הסתרה או חשיפה של משתנים באמצעות המילים ‪ Private‬או ‪( Public‬הרשאות גישה)‬
‫סוג י משתנים‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫ב‪ Visual Basic-‬קיימים סוגי משתנים לאחסון מספרים שלמים‪ ,‬מספרים ממשיים (עם נקודה צפה) וכן מחרוזות‬
‫וטיפוסים נוספים‪.‬‬
‫למספר סוגים ישנם תווים מיוחדים להצהרה משתנים (‪ ,)Type-declaration character‬תווים אלו הנם שריד של‬
‫הגרסאות המוקדמות של ‪ .Visual Basic‬לסוגי הנתונים החדשים (למשל ‪ Byte‬ו‪ )Boolean-‬מעצבי ‪Visual Basic‬‬
‫לא הקצו תווים מיוחדים (כנראה כיוון שזה רעיון גרוע מלכתחילה)‪ ,‬בכל אופן עדיף להשתמש בהצהרה ברורה ולא‬
‫בתווי הצהרה‬
‫הסוג ‪ Variant‬הוא סוג כללי המאפשר להכיל בתוכו את כל סוגי המשתנים (מלבד מחרוזות בגודל קבוע)‬
‫הסוג ‪ Variant‬מאפשר טיפול גמיש מאוד בנתונים‪ ,‬וכן פעילות אוטומציה בין יישומים שונים‬
‫בטבלה הבאה מפורטים סוגי המשתנים השימושיים ביותר‪:‬‬
‫סוג‬
‫גודל אחסון בזכרון‬
‫תחום ערכים‬
‫תו הצהרה‬
‫‪Byte‬‬
‫‪Boolean‬‬
‫‪Integer‬‬
‫‪Long‬‬
‫בית אחד‬
‫‪ 2‬בתים‬
‫‪4 bytes‬‬
‫‪Single‬‬
‫(מספר ממשי ברמת‬
‫דיוק בודדת)‬
‫‪ 0‬עד ‪255‬‬
‫‪ True‬או ‪False‬‬
‫‪ -32,768‬עד ‪32,767‬‬
‫‪-2,147,483,648‬‬
‫עד‬
‫‪1,111,113,111‬‬
‫בתחום השלילי‪:‬‬
‫‪-3.402823E38‬‬
‫עד‬
‫‪E-451.121111‬‬‫בתחום החיובי‪:‬‬
‫‪1.401298E-45‬‬
‫עד‬
‫‪E383.121113‬‬
‫אין‬
‫אין‬
‫‪( %‬אחוז)‬
‫&‬
‫(אמפרסנד)‬
‫! (סימן‬
‫קריאה)‬
‫סוג‬
‫גודל אחסון בזכרון‬
‫תחום ערכים‬
‫תו הצהרה‬
‫‪Double‬‬
‫(מספר ממשי ברמת‬
‫דיוק כפולה)‬
‫‪Date‬‬
‫‪Object‬‬
‫‪( String‬בגודל‬
‫משתנה)‬
‫‪( String‬בגודל קבוע)‬
‫‪ 10‬בתים ‪ +‬אורך‬
‫המחרוזת‬
‫כאורך המחרוזת‬
‫בתחום השלילי‪:‬‬
‫‪-1.79769313486231E308‬‬
‫עד‬
‫‪E-3241.11211111111111‬‬‫בתחום החיובי‪:‬‬
‫‪E-3241.11211111111111‬‬
‫עד‬
‫‪E3081.11111313111131‬‬
‫‪ 1‬לינואר שנת ‪100‬‬
‫עד‬
‫ה‪ 31-‬לדצמבר שנת ‪1111‬‬
‫הפנייה כלשהי לאובייקט‬
‫‪ 0‬עד ‪ 2‬מיליארד (בערך)‬
‫‪( #‬סולמית)‬
‫אין‬
‫‪( $‬דולר)‬
‫‪ 1‬עד ‪( 65,400‬בערך)‬
‫‪( $‬דולר)‬
‫‪( Variant‬עם‬
‫מספרים)‬
‫‪( Variant‬עם תווים)‬
‫‪ 16‬בתים‬
‫‪ 11‬בתים ‪ +‬אורך‬
‫המחרוזת‬
‫אין‬
‫כל ערך מספרי עד מקסימום לתחום‬
‫המספרים מסוג ‪Double‬‬
‫אורך זהה כשל מחרוזת בגודל משתנה‬
‫הצהרה על משתנים‬
‫‪‬‬
‫ניתן להצהיר על משתנים במקומות שונים בתוכנית‪:‬‬
‫‪ o‬ברמת המודול (חלק ה‪)General-‬‬
‫‪ o‬בתוך פרוצדורה או פונקציה‬
‫תחביר ההצהרה על משתנים הוא‪:‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ Dim‬זוהי המילה המורה ל‪ Visual Basic-‬להקצות מקום אחסון למשתנה‬
‫בתוך פרוצדורה או פונקציה חייבים להשתמש במילה ‪Dim‬‬
‫ברמת המודול ניתן להשתמש במילים ‪ Public‬או ‪ Private‬במקום ‪:Dim‬‬
‫‪( Public o‬ציבורי)‪ :‬מאפשר גישה למשתנה לקטעי קוד הנמצאים במודולים אחרים‬
‫‪( Private o‬פרטי)‪ :‬מאפשר גישה למשתנה אך ורק לפרוצדורות והפונקציות הרשומות בתוך אותו מודול בו‬
‫הוצהר המשתנה‬
‫‪ o‬אם משתמשים ב‪ ,Dim-‬ההחלטה אם המשתנה יהיה ‪ Private‬או ‪ Public‬במודול תלויה בסוג שלו‪ .‬למשל‪,‬‬
‫עבור ‪( Form‬שהוא למעשה ‪ )Class Module‬ברירת המחדל היא ‪Private‬‬
‫‪ :varname‬זהו שם המשתנה‬
‫‪ :Type‬זהו סוג המשתנה‪ ,‬אם לא מצוין הסוג המשתנה יהיה מסוג ‪( Variant‬אלא אם נעשה שימוש ב‪DefType-‬‬
‫במודול – נושא זה לא נדון בקורס)‬
‫ניתן להצהיר על ‪ Strings‬באורך קבוע באמצעות שימוש בסימן *‬
‫‪‬‬
‫]‪Dim varname [As type‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ - nGrade‬משתנה ‪Integer‬‬
‫‪‬‬
‫‪ - strFirstName‬משתנה ‪String‬‬
‫‪‬‬
‫‪ - m_strLName‬משתנה ‪ String‬באורך קבוע של ‪ 20‬תווים‬
‫‪‬‬
‫‪ - lBillGatesSalary‬משתנה מסוג ‪Long‬‬
‫‪‬‬
‫‪ – nStage‬משתנה מסוג ‪Integer‬‬
‫‪Dim nGrade As Integer‬‬
‫‪Private strFirstName As String‬‬
‫‪Private m_strLName As String * 20‬‬
‫‪Public lBillGatesSalary As Long‬‬
‫‪Dim nStage%‬‬
‫הצהרה על קבועים‬
‫‪‬‬
‫‪‬‬
‫ניתן להצהיר על קבועים במקומות שונים בתוכנית‪:‬‬
‫‪ o‬ברמת המודול (חלק ה‪)General-‬‬
‫‪ o‬בתוך פרוצדורה או פונקציה‬
‫תחביר ההצהרה על קבועים הוא‪:‬‬
‫‪[Private | Public] Const constname [As type] = expression‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫המילה ‪ Const‬משמשת להצהרת קבועים‬
‫קבועים על פי ברירת המחדל הם מסוג ‪ Private‬אלא אם נרשם ‪ Public‬במפורש‬
‫ב‪ Class Module-‬לסוגיו השונים (‪ Form‬הוא דוגמה ל‪)Class Module-‬לא ניתן להצהיר על קבועים כ‪Public-‬‬
‫(‪ Class Modules‬נלמד בהמשך הקורס)‬
‫ניתן להצהיר על ‪ Consts‬גם בתוך פונקציות ופרוצדורות‪ ,‬אך הם אינם קיימים מחוץ לפונקציות או פרוצדורות‬
‫אלה‬
‫‪‬‬
‫קבוע ‪ Double‬המאותחל לערך ‪17‬‬
‫‪‬‬
‫קבוע ‪ String‬המאותחל לערך “‪"Sales‬‬
‫‪‬‬
‫קבוע ‪ Long‬המאותחל לערך ‪4405‬‬
‫‪cdTaxPercentage As Double = 17#‬‬
‫"‪Private Const cstrDepartment = "Sales‬‬
‫‪Public const clErrNumber as Long = 4405‬‬
‫‪( CONTROL STRUCTURES‬מבני בקרה)‬
‫בסעיף זה נכיר את מבני הבקרה השונים הקיימים ב‪ Visual Basic-‬בכלל זה נכיר את צוות רישום התנאי השונות‪ ,‬מבני‬
‫לולאה ומבנה רב ברירות (‪)Case‬‬
‫המבנה ‪If...Then...Else‬‬
‫צורה ראשונה‬
‫]‪If condition Then [statements] [Else elsestatements‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ condition‬הוא התנאי‬
‫‪ statements‬הן המשפטים שיתבצעו אם התנאי מתקיים (אם יש מספר משפטים‪ ,‬יש להפריד בניהם באמצעות‬
‫נקודה‪-‬פסיק)‬
‫‪ :elsestatements‬אלו הם המשפטים שיתבצעו אם התנאי לא מתקיים (אם יש מספר משפטים‪ ,‬יש להפריד בניהם‬
‫באמצעות נקודתיים)‬
‫דוגמה ‪:1‬‬
‫"‪If nGrade > 90 Then MsgBox "Very good!" Else MsgBox "OK‬‬
‫‪‬‬
‫דוגמה ‪:1‬‬
‫"‪If nAge >= 18 And nAge <= 21 Then Print "Army": Print "You are Great‬‬
‫צורה שניה‬
‫‪If condition Then‬‬
‫]‪[statements‬‬
‫‪condition-n Then‬‬
‫‪[ElseIf‬‬
‫‪[else if statements]...‬‬
‫‪[Else‬‬
‫]]‪[else statements‬‬
‫‪End If‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫בצורה זו ניתן ליצור מספר הסתעפויות אפשריות‬
‫ניתן לרשום בלוק משפטים לביצוע עבור כל תנאי‬
‫אין חובה לכלול את חלקי ה‪ ElseIf-‬או ה‪ Else-‬אך יש להקפיד לרשום ‪ End If‬בסוף המבנה‬
‫‪If nAge < 13 Then‬‬
‫"‪Print "Child‬‬
‫‪ElseIf nAge < 18 Then‬‬
‫"‪Print "Teenager‬‬
‫‪ElseIf nAge < 22 Then‬‬
‫"‪Print "Soldier‬‬
‫‪Else‬‬
‫"‪Print "Big-Boy‬‬
‫‪End If‬‬
‫המ בנה ‪While...Wend‬‬
‫‪‬‬
‫תחביר המבנה הוא‪:‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ condition‬הוא התנאי הנבדק‬
‫‪ statements‬הם המשפטים המבוצעים אם התנאי הוא ‪True‬‬
‫טיפ‪ :‬עדיף להשתמש בלולאה ‪ Do...Loop‬כיוון שהיא גמישה יותר‬
‫‪While condition‬‬
‫‪Wend‬‬
‫‪Dim nCounter As Integer‬‬
‫‪nCounter = 1‬‬
‫‪While nCounter < 10‬‬
‫)‪Print "Now counter is equal to " & str(nCounter‬‬
‫‪Wend‬‬
‫המבנה ‪Do...Loop‬‬
‫צורה ראשונה‬
‫]‪Do [{While | Until} condition‬‬
‫[‪[statements‬‬
‫[‪[Exit Do‬‬
‫[‪[statements‬‬
‫‪Loop‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ condition‬הוא התנאי הנבדק‬
‫‪ While‬משמעותו – "כל עוד התנאי מתקיים"‬
‫‪ Until‬משמעותו – "עד אשר יתקיים התנאי"‬
‫המשפטים יבוצעו אם התנאי בכללותו יתקיים (כולל ה‪ While-‬או ה‪)Until-‬‬
‫בצורה זו התנאי נבדק לפני הכניסה ללולאה‪ ,‬כך שאפשר שהלולאה לא תתבצע כלל‬
‫ניתן לצאת בכל שלב מהלולאה ע"י ‪( Exit Do‬מה שלא ניתן לעשות ב‪While...Wend-‬‬
‫צורה שניה‬
‫‪Do‬‬
‫]‪[Exit Do‬‬
‫]‪Loop [{While | Until} condition‬‬
‫‪‬‬
‫‪‬‬
‫השוני היחידי בין צורת רישום זו לקודמת‪ ,‬הוא בכך שגוף הלולאה במקרה זה מתבצע פעם אחת לפחות (כיוון‬
‫שהתנאי נבדק רק בסיום הלולאה)‬
‫‪Dim strBoard As String‬‬
‫‪Dim nColomns As Integer, nRows As Integer‬‬
‫‪Const cnMaxColomns As Integer = 10, cnMaxRows As Integer = 10‬‬
‫‪nRows = 1‬‬
‫‪Do While nRows <= cnMaxRows‬‬
‫‪nColomns = 1‬‬
‫‪Do While nColomns <= cnMaxColomns‬‬
‫)" \‪strBoard = strBoard & Format(nRows * nColomns, "000‬‬
‫‪nColomns = nColomns + 1‬‬
‫‪Loop‬‬
‫‪strBoard = strBoard & vbCrLf‬‬
‫‪nRows = nRows + 1‬‬
‫‪Loop‬‬
‫‪MsgBox strBoard‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫קטע קוד זה יוצר מחרוזת הכוללת רווחים ומעברי שורות‪ ,‬ואשר מאחסנת בתוכה את לוח הכפל‬
‫שים לב לשימוש בפונקציה ‪( Format‬תוכל לקבל עזרה אודות פונקציה זו במערכת העזרה של ‪)Visual Basic‬‬
‫קטע קוד זה משתמש בשתי לולאות ‪ Do...Loop‬מקוננות לשם ביצוע המשימה‬
‫בסוף פירמוט המחרוזת‪ ,‬מוצגת המחרוזת ע"י הפונקציה ‪MsgBox‬‬
‫המבנה ‪For...Next‬‬
‫‪‬‬
‫תחביר המבנה‪:‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫הלולאה ‪ For‬מאפשרת ביצוע נוח של בלוק פקודות מספר קבוע של פעמים‬
‫‪ counter = start‬זוהי פעולת האתחול של מונה הלולאה‬
‫‪ end‬הוא הערך הסופי של מונה הלולאה‬
‫‪ step‬זהו ערך הקפיצה של מונה הלולאה לאחר כל איטרציה (ניתן לקבוע ערך שלילי ל‪ Step-‬כך שמונה הלולאה‬
‫יקבל ערכים הולכים וקטנים)‬
‫]‪For counter = start To end [Step step‬‬
‫]‪[Exit For‬‬
‫]‪Next [counter‬‬
‫‪‬‬
‫‪Dim i As Integer‬‬
‫‪For i = 1 To 5‬‬
‫)‪Print "The number is: " & str(i‬‬
‫‪Next‬‬
‫המבנ ה ‪Select Case‬‬
‫‪‬‬
‫‪‬‬
‫המבנה ‪ Select...Case‬הוא מבנה רב ברירות המאפשר בחירת בלוק לביצוע‪ ,‬ע"פ בדיקת ערכו של משתנה מסוים‬
‫תחביר‪:‬‬
‫‪Select Case testexpression‬‬
‫‪[Case expressionlist-n‬‬
‫‪[statements-n]] ...‬‬
‫‪[Case Else‬‬
‫]]‪[elsestatements‬‬
‫‪End Select‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ textexpression‬הוא המשתנה שערכו נבחן‬
‫‪ expressionlist‬זוהי רשימת ערכים‪ ,‬שאם המשתנה הנבחן שווה לאחד מהערכים שברשימה‪ ,‬אותו בלוק השייך ל‪-‬‬
‫‪ Case‬זה יתבצע‬
‫‪ – elsestatements‬יתבע בכל מקרה אחר‪ ,‬כלומר אם לא נמצא ערך מתאים ברשימות הערכים השונות‬
‫ניתן להשתמש בביטוי ‪ val1 To val2‬כדי ליצור טווח ערכים‬
‫ניתן להשתמש בביטוי ‪ Is comparison‬כדי להפעיל בדיקת ערך בתוך ‪Select‬‬
‫‪Dim nAge As Integer‬‬
‫))"‪nAge = Val(InputBox("Enter an age‬‬
‫‪Select Case nAge‬‬
‫‪Case 1‬‬
‫"‪MsgBox "One year old‬‬
‫‪Case 2‬‬
‫"‪MsgBox "Two years old‬‬
‫‪Case 3, 4, 5, 6‬‬
‫"!‪MsgBox "Well, growing‬‬
‫‪Case 7 To 13‬‬
‫"!‪MsgBox "Not a child anymore‬‬
‫‪Case 14, 15, Is < 19‬‬
‫"?‪MsgBox "A stupid teenager‬‬
‫‪Case Else‬‬
‫"!‪MsgBox "Well, very big‬‬
‫‪End Select‬‬
‫‪‬‬
‫‪‬‬
‫בקטע קוד זה מוצג ‪ Message‬שונה על‪-‬פי המספר שהזין המשתמש‪.‬‬
‫תיאור הפונקציה ‪ InputBox‬מובא בסעיף הבא‬
‫הפונקציות ‪,BEEP‬‬
‫‪ INPUTBOX‬ו‪IIF-‬‬
‫הפו נקציה ‪Beep‬‬
‫‪‬‬
‫‪‬‬
‫הפונקציה ‪ Beep‬משמיעה צפצוף מרמקול המחשב‬
‫‪Beep‬‬
‫הפו נקציה ‪InputBox‬‬
‫‪‬‬
‫‪‬‬
‫הפונקציה ‪ InputBox‬מציגה הודעה למשתמש‪ ,‬ומאפשרת לו להזין נתונים בתיבה מתאימה‬
‫תחביר הפקודה‪:‬‬
‫‪InputBox(prompt[, title] [, default] [, xpos] [, ypos] [, helpfile,‬‬
‫)]‪context‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ Prompt‬הוא ההודעה למשתמש‬
‫‪ Title‬הוא כותרת ההודעה‬
‫‪ default‬הוא המחרוזת שתוצג עם הפעלת ה‪InputBox-‬‬
‫‪ xpos‬ו‪ ypos-‬מגדירים את מיקום ה‪ InputBox-‬במסך‬
‫‪ helpfile‬ו‪ context-‬מאפשרים הפעלת מערכת עזרה בתגובה ללחיצה על ‪F1‬‬
‫הפונקציה מחזירה ‪ String‬כך שיהיה צורך בהמרות במקרה של בקשרה להזנת מספר מצד המשתמש‬
‫)"‪strGender = InputBox("Enter your gender", "Gender", "Male‬‬
‫‪‬‬
‫בהפעלת שורת קוד זו‪ Visual Basic ,‬מציגה את החלון הבא‪:‬‬
‫הפו נקציה ‪IIf‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫פונקציה זו מאפשר בדיקת תנאי‪ ,‬והחזרת ערך אחד מתוך שניים נתונים בהתאם לבדיקה‬
‫פונקציה זו דומה בפעולתה לאופרטו ? בשפת ‪C‬‬
‫)‪IIf(expr, truepart, falsepart‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ expr‬הוא הביטוי המוערך‬
‫‪ truepart‬יתבצע‪ ,‬והערך שלו יוחזר ע"י הפונקציה אם התוצאה של ‪ expr‬היא ‪True‬‬
‫‪ falsepart‬יתבצע‪ ,‬והערך שלו יוחזר ע"י הפונקציה אם התוצאה של ‪ expr‬היא ‪False‬‬
‫הפונקציה מפעילה בכל מקרה את הפקודות הרשומות ב‪ truepart-‬וב‪elsepart-‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫קטע קוד זה מציג ‪ InputBox‬למשתמש וקולט ממשנו מספר‬
‫הפונקציה ‪ IIf‬מכניסה למחרוזת ‪ strAge‬את הערך המתאים לפי בדיקת התנאי ‪nAge = 5‬‬
‫לבסוף מוצגת הודעה למשתמש‬
‫‪Dim nAge As Integer, strAge As String‬‬
‫)"‪nAge = InputBox("Enter an age", "Age‬‬
‫)"‪strAge = IIf(nAge = 5, "The age is five", "The age is not five‬‬
‫‪MsgBox strAge‬‬
‫‪ .1‬צור תוכנית בשם ‪ ControlStructures‬המציגה למשתמש בקשה להזנת מספר בין ‪ 0‬ל‪ 2-‬באמצעות הפונקציה‬
‫‪ ,InputBox‬ובהתאם למספר שהוזן יוצג ‪ MsgBox‬למשתמש‪.‬‬
‫מקם על ה‪ Form-‬שלושה ‪ CommandButtons‬וכתוב את הנדרש בשלוש צורות‪:‬‬
‫תוך שימוש ב‪ ,If...Then...Else-‬בתגובה ל‪ Click-‬על ה‪ CommandButton-‬הראשון‬
‫א‪.‬‬
‫תוך שימוש ב‪ Select...Case-‬בתגובה ל‪ Click-‬על ה‪ CommandButton-‬השני‬
‫ב‪.‬‬
‫תוך שימוש בפונקציה ‪ IIf‬בתגובה ל‪ Click-‬על ה‪ CommandButton-‬השלישי‬
‫ג‪.‬‬
‫‪ .1‬כתוב תוכנית בשם ‪ .PrintSequence‬מקם על טופס ‪ TextBox‬אחד ו‪ .CommandButton-‬בעת לחיצה על‬
‫ה‪ CommandButton-‬יש להציג על ‪ Label‬שיונח על הטופס את רצף המספרים המתחיל ב‪ 0-‬עד המספר שהוזן ע"י‬
‫המשתמש לתוך ה‪.TextBox-‬‬
‫‪ .3‬כתוב תוכנית בשם ‪ .MultipleBoard‬לחיצה על ‪ CommandButton‬שימוקם על הטופס‪ ,‬ידפיס על גבי ‪Label‬‬
‫שימוקם בטופס את לוח הכפל במימדים ‪ 10X10‬בתוספת כותרות‪.‬‬
‫‪ .1‬כתוב תוכנית בשם ‪ ProcessInputs‬הקולטת מהמשתמש מספים בעזרת ‪ InputBox‬עד אשר המשתמש מזין ‪ 0‬או‬
‫מחרוזת ריקה‪ .‬התוכנית תציג על גבי הטופס את סכום המספרים‪ ,‬מכפלתם (אין לכפול כמובן ב‪ 0-‬האחרון)‪ ,‬ואת‬
‫ממוצע המספרים‪.‬‬
‫שיעור ‪ : 3‬הפקדים הסטנדרטיים ‪II‬‬
‫‪ ‬תכיר את ה‪ Controls-‬הבאים‪:‬‬
‫‪( CheckBox o‬תיבת סימון)‬
‫‪( OptionButton o‬תיבת אפשרות)‬
‫‪( Frame o‬מסגרת)‬
‫‪( ListBox o‬תיבת רשימה)‬
‫‪( ComboBox o‬תיבה משולבת)‬
‫‪( Line o‬קו)‬
‫‪( Shape o‬צורה)‬
‫‪( Timer o‬שעון)‬
‫‪ ‬תכיר שיטה לניהול ממשק המשתמש באמצעות ‪Timer‬‬
‫‪( CHECKBOX‬תיבת סימון)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ CheckBox‬שימושי כאשר יש צורך בבחירת אחת שתי אפשרויות "כן" או "לא"‪" ,‬אמת" או "שקר"‪" ,‬מלא" או‬
‫"ריק" וכו'‬
‫ישנה אפשרות שלישית הנקראת ‪ ,Grayed‬היא משמשת בעיקר לתיאור מצב לא מוגדר או חלקי (תוכל לעיין למשל‬
‫התוכנית ההוספה וההסרה של פריטי ‪ Windows‬מתוך ה‪ ,Control Panel-‬שם ‪ Grayed‬מסמל בחירה חלקית של‬
‫התת קבוצה)‬
‫המעבר בין שני המצבים הראשונים הוא אוטומטי‪ .‬כדי להפוך את התיבה ל‪ Grayed-‬יש לנהל זאת מתוך הקוד‬
‫‪ Properties‬של ‪CheckBox‬‬
‫‪‬‬
‫‪‬‬
‫‪ DownPicture ,DisablePicture‬ו‪ :Picture-‬מגדירים תמונות למצבים שונים של ה‪ CheckBox-‬במקרה שה‪-‬‬
‫‪ Style‬של ה‪ CheckBox-‬מוגדר כ‪Graphical-‬‬
‫‪ :Value‬מכיל את אחד משלושה ערכים שבאוסף הקבועים ‪vbUnchecked ,vbChecked – CheckBoxConstants‬‬
‫ו‪vbGrayed-‬‬
‫‪ Events‬של ‪CheckBox‬‬
‫‪‬‬
‫‪ :Click‬מתרחש בעת לחיצת עכבר או מקש הרווח‪ ,‬המשנה את ערך ה‪CheckBox-‬‬
‫‪( OPTIONBUTTON‬לחצן אפשרות)‬
‫‪‬‬
‫תוכל להשתמש ב‪ OptionButton-‬במסגרת קבוצת אפשרויות שרק אחת מהן יכולה להיות מסומנת בזמן נתון‬
‫‪ Properties‬של ‪OptionButton‬‬
‫‪‬‬
‫‪ :Value‬מכיל את ערך ה‪ OptionButton-‬שהוא ‪True‬או ‪False‬‬
‫‪( FRAME‬מסגרת)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫באמצעות ‪ Frame‬תוכל לקבץ מספר ‪ Controls‬תחת קבוצה אחת‬
‫‪ Frame‬הוא פקד מסוג ‪Container‬‬
‫שתי תכונות עיקריות מאפיינות ‪:Containers‬‬
‫‪ o‬אם משנים את מיקומו של ה‪ Frame-‬כל ה‪ Child Controls-‬שבתוכו זזים יחד איתו‬
‫‪ o‬כאשר ה‪ Frame-‬נמצא במצב ‪ Disabled‬כל ה‪ Child Controls-‬שבו גם הם ‪Disabled‬‬
‫‪ Properties‬של ‪Frame‬‬
‫‪‬‬
‫‪ :Enabled‬הוא המאפיין היותר חשוב של ה‪ ,Frame-‬אם ערכו שווה ל‪ False-‬כל ה‪ Controls-‬שבו הופכים ללא‬
‫זמינים‬
‫‪ Methods‬של ‪Property‬‬
‫‪‬‬
‫‪ :Move‬הוא ‪ Method‬חשוב ב‪ ,Frame-‬כיוון ששימוש נכון בו יכול לאפשר מיקום מהיר של קבוצת ‪Controls‬‬
‫דוגמה ‪ : 1‬התוכנית ‪CopyText‬‬
‫‪ ‬בתוכנית זו תיצור טופס עם שני ‪ .TextBoxes‬לחיצה על ‪ CommandButton‬יעתיק את תוכני ה‪TextBoxes-‬‬
‫לתיבה שלישית‪ .‬ליד כל תיבת טקסט יופיע ‪ CheckBox‬שיקבע האם יש להעתיק את אותו הטקס לפלט‪ .‬בנוסף‪,‬‬
‫יוצבו על התיבה שני ‪ OptionButtons‬הבוררים בין רווח (‪ )Space‬לבין מעבר שורה (‪ )New line‬כמפריד בין תיבות‬
‫הטקסט‪.‬‬
‫‪ ‬בתוכנית זו נבצע אתחול של ערכי ה‪ Controls-‬השונים בשלב ה‪ Load-‬של הטופס‪.‬‬
‫‪ .1‬צור פרוייקט חדש מסוג ‪ ,Standard EXE‬ושמור אותו‪:‬‬
‫‪ ‬הקצה לפרוייקט את השם ‪ CopyText‬ולטופס ‪frmCopyText‬‬
‫‪ ‬שמור את הפרוייקט‬
‫‪ .1‬הוסף ‪ Controls‬לטופס‪:‬‬
‫‪ ‬הוסף את ה‪ Controls‬הבאים ומקם אותם ע"פ הציור שלפניך‪:‬‬
‫‪ o‬שני ‪ lblInput1:Labels‬ו‪lblInput2-‬‬
‫‪ o‬שני ‪ chkIncludeText1 :CheckBoxes‬ו‪chkIncludeText2-‬‬
‫‪ o‬שני ‪ optSeparateBySpace :OptionButtons‬ו‪optSeparateByNewLine-‬‬
‫‪ CommandButon o‬אחד‪cmdCopyTexts :‬‬
‫‪ o‬שלושה ‪ txtInput2 ,txtInput1 :TextBoxes‬ו‪txtOutput-‬‬
‫‪ ‬מקם את ה‪ Controls-‬כך שהטופס ייראה כמו בציור הבא‬
‫‪ ‬הקצה להם שמות כפי שמוצג בציור הבא‬
‫‪ ‬קבע את סדר מעבר הטאב כך שיהיה לפי סדר המספרים המוקפים במלבן בציור הבא‬
0
4
1
2
5
3
6
7
8
9
:‫ הגדר את המאפיינים הבאים‬.3
‫ערך‬
1-Fixed Single
CenterScreen–2
True
‫מאפיין‬
BorderStyle
StartUpPosition
Default
frmCopyText
cmdCopyTexts
:‫ הוסף קוד לטופס‬.1
Load ‫ בתגובה לאירוע‬,‫ השונים‬Controls-‫ קוד זה מאתחל את הטקסט בכותרת הטופס ועל גבי ה‬
Controls-‫ קוד זה מאתחל את ערכי ה‬,‫ בנוסף‬
Private Sub Form_Load()
' Initialize the form caption
frmCopyText.Caption = "Copy Text"
' Initialize the labels caption
lblInput1.Caption = "Input &1"
lblInput2.Caption = "Input &2"
' Clear the text boxes
txtInput1.Text = ""
txtInput2.Text = ""
txtOutput.Text = ""
' Initialize the check boxes
chkIncludeText1.Caption = "Copy to output"
chkIncludeText1.Value = vbChecked
chkIncludeText2.Caption = "Copy to output"
chkIncludeText2.Value = vbChecked
www.kita.co.il
II ‫ הפקדים הסטנדרטיים‬:3 ‫שיעור‬
' Initialize the option buttons
optSeparateByNewLine.Caption = "Separate by a &new-line"
optSeparateBySpace.Caption = "Separate by a &space"
optSeparateBySpace = True
' Initialize the command button
cmdCopyTexts.Caption = "&Copy texts to output"
End Sub
cmdCopyTexts ‫ הקוד הבא פועל בתגובה ללחיצה על הלחצן‬
Private Sub cmdCopyTexts_Click()
' Copy first input text only if chkInputText1 is checked
If chkIncludeText1.Value = vbChecked Then
txtOutput.Text = txtOutput.Text & txtInput1.Text
End If
' Copy space or new-line only if txtOutput is not empty
If txtOutput.Text <> "" Then
' Determines which option button is checked and copy new-line
' or space accordingly
If optSeparateByNewLine.Value = True Then
txtOutput.Text = txtOutput.Text & vbCrLf
Else
txtOutput.Text = txtOutput.Text & " "
End If
End If
' Copy second text only if chkInputText2 is checked
If chkIncludeText2.Value = vbChecked Then
txtOutput.Text = txtOutput.Text & txtInput2.Text
End If
' Prepare the output text box to the next copy
If txtOutput.Text <> "" Then
txtOutput.Text = txtOutput.Text & vbCrLf
End If
' Bring the focus back to input1
txtInput1.SelStart = 0
txtInput1.SelLength = Len(txtInput1.Text)
txtInput1.SetFocus
End Sub
‫ הרץ את התוכנית ובדוק את פעולתה‬.1
www.kita.co.il
‫‪( LISTBOX‬תיבת רשימה)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫תיבת רשימה מאפשרת להציג למשתמש רשימת מחרוזות‬
‫המשתמש יכול לגלול את רשימת הערכים כלפי מטה או מעלה‬
‫האינדקסים של פריט ה‪ ListBox‬נעים בין ‪ 0‬ל‪( n  1 -‬כשאר ‪ n‬הוא מספר הפריטים ברשימה)‬
‫‪ Properties‬ש ל ‪ListBox‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ :Columns‬קובע אם ה‪ ListBox‬יציג את התוכן בטור אחד ( ‪ ) Columns  0‬או במספר טורים ( ‪ ) Colums  1‬עם‬
‫פס גלילה אופקי‬
‫‪ :IntegralHeight‬קובע אם ה‪ ListBox-‬יתאים את גובהו כך שמחרוזות יוצגו בשלמות‬
‫‪ :ItemDate‬מערך שלמים מסוג ‪ Long‬המאפשר לצרף מידע נוסף לפריטי ה‪ ListBox-‬כך שלכל מחרוזת ניתן יהיה‬
‫להצמיד ערך מספרי לשימוש פנימי כלשהו של התוכנית‬
‫‪ :List‬מערך מחרוזות המכיל בתוכו את תוכן ה‪ListBox‬‬
‫‪ :ListCount‬מחזיר את מספר הפריטים ב‪ListBox‬‬
‫‪ :ListIndex‬מחזיר את האינדקס של הפריט הנבחר ‪( -‬במקרה של ‪ ListBox‬ללא ‪ ,MultiSelect‬או את הפריט‬
‫שנמצא בפוקוס (בין אם הוא נבחר או לא) כאשר ‪ MultiSelect‬שווה ל‪ 1‬או ‪1‬‬
‫‪ :MultiSelect‬קובע האם יהיה ניתן לבחור מספר פריטים ברשימה במקביל‬
‫‪ :NewIndex‬מחזיר את האינדקס של הפריט האחרון שנוסף לרשימה‬
‫‪ :SelCount‬מחזיר את מספר הפריטים הנבחרים ברשימה‬
‫‪ :Selected‬מאפיין זה מקבל כפרמטר אינדקס של פריט‪ ,‬ומחזיר ערך בוליאני הקובע האם הפריט נבחר או לא‪.‬‬
‫מאפיין זה שימושי במקרה של ‪ .MultiSelect‬כמו כן‪ ,‬ניתן לקבוע בעזרת מאפיין זה האם פריט ייבחר או לא‪.‬‬
‫‪ :Sorted‬קובע אם האלמנטים ברשימה ימוינו באופן אוטומטי‬
‫‪ :Style‬קובע את סגנון ה‪( ListBox-‬רגיל או עם ‪)CheckBoxes‬‬
‫‪ :TopMost‬מאפשר לקבוע איזה פריט יוצג בראש הרשימה‬
‫‪ Methods‬של ‪ListBox‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ :AddItem‬מאפר להוסיף פריטים לרשימה בזמן ריצה‬
‫‪ :Clear‬מנקה את התוכן של ה‪ListBox-‬‬
‫‪ :Refresh‬מרענן את תצוגת ה‪ListBox‬‬
‫‪ :RemoveItem‬מסיר פריט מהרשימה‬
‫‪ Events‬של ‪ListBox‬‬
‫‪‬‬
‫‪‬‬
‫‪ :ItemCheck‬מתרחש כאשר המשתמש מסמן ‪ V‬ב‪ CheckBox-‬המוצמד לפריט רשימה (רלוונטי כאשר המאפיין‬
‫‪ Style‬שווה ל‪)checkbox‬‬
‫‪ :Scroll‬מתרחש כאשר המשתמש גולל את הרשימה או כאשר המתכנת גולל את הרשימה ע"י שימוש במאפיין‬
‫‪TopIndex‬‬
‫‪( COMBOBOX‬תיבה משולבת)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ ComboBox‬הוא שילוב של ‪ TextBox‬ו‪ListBox-‬‬
‫כל ה‪( Properties‬מלבד ‪ ,)Style‬ה‪ Methods‬וה‪ Events‬שך ‪ ComboBox Control‬זהים לאלו של ‪TextBox‬‬
‫וה ‪ ListBox‬והתנהגותם זהה גם כן‪.‬‬
‫‪ Style‬הוא המאפיין היחיד ששונה ב‪ComboBox-‬‬
‫‪ Properties‬של ‪ComboBox‬‬
‫‪‬‬
‫‪ :Style‬קובע את סגנון ה‪:ComboBox‬‬
‫‪ :Dropdown Combo o‬כולל ‪ TextBox‬ורשימה נפתחת‪ .‬המשתמש יכול לבחור ערך מהרשימה או‬
‫להקליד את הערך בעצמו‬
‫‪ :Simple Combo o‬כולל ‪ TextBox‬ורשימה לא נפתחת‪ .‬המשתמש יכול לבחור את הרשימה בעצמו או‬
‫להקליד את הערך‬
‫‪ :Dropdown List o‬כולל רשימה נפתחת בלבד‪ .‬המשתמש יכול לבחור ערך מהרשימה בלבד‪.‬‬
‫‪( LINE‬קו) ו‪( SHAPE-‬צורה)‬
‫‪‬‬
‫‪‬‬
‫‪ Line‬ו‪ Shape-‬הם פקדים המאפשרים להוסיף קווים שונים וצורות לטופס ללא שימוש בפונקציות גרפיקה לשם‬
‫כך‬
‫ל‪ Line-‬ול‪ Shape‬אין ‪Events‬‬
‫‪ Properties‬של ‪ Line‬ו ‪Shape -‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ Width ,Top ,Left‬ו‪( Height-‬ב‪ :)Shape‬מגדירים את גודל ומיקום המלבן החוסם את הצורה‬
‫‪( Y2 ,Y1 ,X2 ,X1‬ב‪ :)Line-‬מגדירים את נקודות הקצה של הישר‬
‫חשוב לשים לב למאפייני הצבע והרקע של ‪ Line‬ו‪ Shape-‬כי מעבר לשימוש גרפי בצורות אלו‪ ,‬אין להם שימושים‬
‫רבים‬
‫‪( TIMER‬פקד שעון)‬
‫‪‬‬
‫‪‬‬
‫‪ Timer‬משמש לשיגור אירוע כל זמן נתון‪.‬‬
‫‪ Timer‬הוא מסוג הפקדים שלא נראים ב‪( Run Time-‬זמן ריצה)‬
‫‪ Properties‬של ‪Timer‬‬
‫‪‬‬
‫‪‬‬
‫‪ :Enabled‬קובע האם השעון פעיל וכתוצאה מכך משגר אירוע כל זמן נתון‬
‫‪ :Interval‬קובע את המרווח במילי שניות בין שיגור אירוע אחד לשני‬
‫‪ Events‬של ‪Timer‬‬
‫‪‬‬
‫‪ :Timer‬מתרחש כל ‪ Interval‬מילי שניות (בתנאי שה‪ Timer-‬נמצא במצב ‪)Enabled‬‬
‫דוגמ ה ‪StudentCourses – 2‬‬
‫‪ ‬בתוכנית זו נאפשר למשתמש לשבץ תלמידים לקורסים‪ ,‬ולהוסיף את השיבוצים ל‪ListBox-‬‬
‫‪ ‬המשתמש יוכל גם להסיר שורות שהכניס או את כולן תוך שימוש ב‪ CommandButton-‬שיוצב לשם כך‬
‫‪ ‬בתוכנית זו נשתמש ב‪ Timer-‬שינהל את ממשק‬
‫‪ .1‬צור פרוייקט חדש מסוג ‪ ,Standard EXE‬ושמור אותו‪:‬‬
‫‪ ‬הקצה לפרוייקט את השם ‪ StudentCourses‬ולטופס ‪frmStudentCourses‬‬
‫‪ .1‬הוסף ‪ Controls‬לטופס‪:‬‬
‫‪ ‬הוסף את ה‪ Controls‬הבאים ומקם אותם ע"פ הציור שלפניך‪:‬‬
‫‪ o‬שלושה ‪ lblCourse ,lblStudents :Labels‬ו‪lblStudentToCourse-‬‬
‫‪ o‬שני ‪ cboStudents :ComboBoxes‬ו‪cboCourses-‬‬
‫‪ o‬שלושה ‪ cmdQuit ,cmdAdd :CommandButtons‬ו‪cmdDelete-‬‬
‫‪ ListBox o‬אחד‪lstStudentToCourse :‬‬
‫‪ CheckBox o‬אחד‪chkDeleteAll :‬‬
‫‪ Timer o‬אחד‪tmrUUUpdate :‬‬
‫‪ o‬שלושה ‪ txtInput2 ,txtInput1 :TextBoxes‬ו‪txtOutput-‬‬
‫‪ ‬מקם את ה‪ Controls-‬כך שהטופס ייראה כמו בציור‬
‫‪ ‬הקצה להם שמות כפי שמוצג בציור‬
‫‪ ‬קבע את סדר מעבר הטאב כך שיהיה לפי סדר המספרים המוקפים במלבן בציור‬
‫‪ ‬תוכל להשתמש בקווים כדי להפריד חלקים בטופס באופן וויזואלי‬
‫‪0‬‬
‫‪5‬‬
‫‪6‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫‪7‬‬
‫‪8‬‬
‫‪9‬‬
‫‪ .3‬הגדר את המאפיינים הבאים‪:‬‬
‫‪frmStudentCourses‬‬
‫‪lblStudents‬‬
‫‪cboStudents‬‬
‫‪lblCourses‬‬
‫‪cboCourses‬‬
‫‪lblStudentToCourses‬‬
‫‪lstStudentToCourse‬‬
‫מאפיין‬
‫‪BorderStyle‬‬
‫‪StartUpPosition‬‬
‫‪Autosize‬‬
‫‪Style‬‬
‫‪Style‬‬
‫‪Sort‬‬
‫ערך‬
‫‪1-Fixed Single‬‬
‫‪2 - CenterScreen‬‬
‫‪True‬‬
‫‪1 - Dropdown combo‬‬
‫‪True‬‬
‫‪2 - Dropdown List‬‬
‫‪True‬‬
‫‪True‬‬
1 - Checkbox
True
True
20
Style
Default
Cancel
Interval
cmdAdd
cmdQuit
tmrUIUpdate
:‫הוסף קוד לטופס‬
:‫ הקוד הבא מצהיר על משתנים וקבועים‬
‫ בדיקת משתנה זה‬.ListBox-‫ נועד לספור את מספר הפריטים שיש להסיר מה‬m_nCheckCounter ‫ המשתנה‬
ListBox-‫ בתוך ה‬Check ‫ בתגובה לסימון או ביטול סימון של‬chkDeleteAll ‫מקילה על שינוי מראה הלחצן‬
.‫ מתעדכן בהתאם‬lstStudentToCourse-‫ כל הסימונים בתוך ה‬chkDeleteAll-‫ במקרה של שינוי הסימון ב‬
‫ כדי לאפשר‬m_nCheckedSource ‫ בתוכנית זו נעשה שימוש במשתנה הגלובלי‬,‫כיוון שנוצרת תגובה מעגלית‬
‫ לבדוק האם מקור השינוי היה פעולת משתמש או פעולת‬lstStudentToCourse-‫בקוד התגובה לסימון שורה ב‬
.‫ שאז אין לבצע מאומה‬,‫השמה מתוך הקוד‬
‫ הקבועים הופכים את התוכנית לקריאה יותר‬
Dim m_nCheckCount As Integer
Dim m_nCheckedSource As Integer
Const CHECK_SOURCE_USER As Integer = 0
Const CHECK_SOURCE_CODE As Integer = 1
:‫ הקוד הבא מאתחל את הפקדים השונים ואת המשתנים‬
' Initializing lblStudets
lblstudents.Caption = "&Students"
' Initializing cboStudents
cboStudents.Clear
cboStudents.AddItem "John Degweed"
cboStudents.AddItem "Erick E"
cboStudents.AddItem "Michel de Hey"
cboStudents.AddItem "Paul Okenfold"
cboStudents.AddItem "Dimmitri"
cboStudents.AddItem "Tiesto"
cboStudents.AddItem "Josh Wink"
cboStudents.AddItem "Terry Francis"
cboStudents.AddItem "Ferry Corsten"
' Initializing lblCourses
lblCourses.Caption = "&Courses"
' Initializing cboCourses
cboCourses.Clear
cboCourses.AddItem "Advanced DJ Techniqs"
cboCourses.AddItem "Using guitar loops in the Mix"
cboCourses.AddItem "Synthisizer - Advance Topics"
cboCourses.AddItem "Synthisizer - Fundamentals"
cboCourses.AddItem "Extarcting Loops"
' Initializing cmdAdd
cmdAdd.Caption = "&Add to list"
www.kita.co.il
' Initializing cmdQuit
cmdQuit.Caption = "&Quit"
' Initializing lblStudentsToCourses
lblStudentToCourse.Caption = "Student to course"
' Initializing lstStudentToCourse
lstStudentToCourse.Clear
' Initializing chkDeleteAll
chkDeleteAll.Caption = "Delete &all rows"
' Initializing cmdDelete
cmdDelete.Caption = "&Delete"
' Other initializations
m_nCheckCount = 0
m_nCheckedSource = CHECK_SOURCE_USER
End Sub
cmdQuit ‫ או לחיצה על‬cmdAdd ‫ להלן קוד השגרות לתגובה בעת לחיצה על‬
‫ להזנת ערך חדש‬cboStudent-‫ הפוקוס מוחזר ל‬,‫ לאחר הוספת השורה לרשימה‬
Private Sub cmdAdd_Click()
Dim strRow As String
strRow = cboStudents.Text & ": " & cboCourses.Text
lstStudentToCourse.AddItem strRow
cboStudents.SelStart = 0
cboStudents.SelLength = Len(cboStudents.Text)
cboStudents.SetFocus
End Sub
Private Sub cmdQuit_Click()
Unload Me
End Sub
cmdDelete ‫ הקוד הבא מופעל בתגובה ללחיצה על‬
‫ היא מבצעת איטרציה על פריטי‬,‫ אחרת‬Clear-‫ אם יש להסיר את כל הפריטים מהרשימה השגרה משתמשת ב‬
‫הרשימה בכדי לבדוק אלו מהם מסומנים למחיקה‬
chkDeleteAll ‫ ומבטלת את הסימון שליד‬m_nCheckCount ‫ השגרה מאפסת את המונה‬,‫ בסיום‬
Private Sub cmdDelete_Click()
Dim i As Integer
' Check whether to remove all items
If chkDeleteAll.Value = vbChecked Then
lstStudentToCourse.Clear ' Use Clear to emove all items
Else
' Remove only the checked items
i = 0
Do While i <= (lstStudentToCourse.ListCount - 1)
If lstStudentToCourse.Selected(i) = True Then
www.kita.co.il
lstStudentToCourse.RemoveItem (i)
Else
i = i + 1
End If
Loop
End If
' Reset the "Delete all" - CheckBox and the
' Checked-Items counter (m_nCheckCount)
chkDeleteAll.Value = vbUnchecked
m_nCheckCount = 0
End Sub
lstStudentToCourse ‫ הקוד הבא בתגובה לסימון שורה ברשימה‬
‫ אזי מתבצע דילוג על שאר הקוד כדי למנוע תגובה‬,chkDeleteAll ‫ אם האירוע התרחש בגלל לחיצה על‬
‫מעגלית‬
m_nCheckCount ‫ בהתאם לכך הוא מעדכן את‬.‫ הקוד בודק אם נוסף סימון או הוסר‬
chkDeleteAll-‫ ובהתאם לערך זה מותאם הסימון ב‬m_nCheckCount ‫ לאחר מכן נבדק ערכו של‬
Private Sub lstStudentToCourse_ItemCheck(Item As Integer)
Dim nCheckedCount As Integer, i As Integer
' Process this code only if the Checked or Unchecked operation
' was invoked by the user and not the code inside chkDeleteAll
If m_nCheckedSource = CHECK_SOURCE_USER Then
m_nCheckCount = m_nCheckCount + _
IIf(lstStudentToCourse.Selected(Item), 1, -1)
If m_nCheckCount = 0 Then
chkDeleteAll.Value = vbUnchecked
ElseIf m_nCheckCount = lstStudentToCourse.ListCount Then
chkDeleteAll.Value = vbChecked
Else
chkDeleteAll.Value = vbGrayed
End If
End If
End Sub
‫ מילי שניות‬12 ‫ מופעל כל‬,‫ קטע הקוד הבא‬
‫ בקוד זה נבדק מצב מרכיבים שונים בטופס ובהתאם לכך מעודכן ממשק המשתמש‬
cboCourses-‫ ו‬cboStudents-‫ מאופשר רק אם קיים טקסט ב‬cmdAdd ‫ הלחצן‬
lstStudentToCourse-‫ מאופשר רק אם ישנם פריטים ב‬chkDeleteAll 
2-‫ גדול מ‬m_nCheckCount ‫ מאפשר רק אם‬cmdDeleteAll ‫ הלחצן‬
Private Sub tmrUIUpdate_Timer()
' Enable the "Add to list" command only if there is text in
' cboStudents as well as in cboCourses
cmdAdd.Enabled = cboCourses.Text <> "" And cboStudents.Text <> ""
www.kita.co.il
' Enable the "Delete All" - CheckBox
only if there are
' items in the list
chkDeleteAll.Enabled = lstStudentToCourse.ListCount > 0
' Enable cmdDelete only if the number of the checked items
' is greater than 0
cmdDelete.Enabled = m_nCheckCount > 0
End Sub
:‫ הפעל את התוכנית ובדוק את פעולה‬.1
‫ בתגובה לשינוי תכני הרשימות השונות‬User Interface-‫ שים לב לעדכון ה‬
‫ מאופשר רק אם יש סימון כלשהו ברשימה‬Delete-‫ שים לב ש‬
www.kita.co.il
‫‪ .1‬כתוב תוכנית בשם ‪ .DayAndColor‬מקם על טופס ‪ Frame‬ובתוכו שבעה ‪ OptionButtons‬עם הכותרות ‪,Sunday‬‬
‫‪ Monday‬וכו'‪ .‬כמו כן מקם על הטופס שלושה ‪ CheckBoxes‬עם הכותרות ‪ Green ,Red‬ו‪ .Blue-‬במקום ריק‬
‫בטופס מקם ‪ .Label‬בעת בחירת אחד הימים ב‪ OptionButtons-‬יש לשנות את הטקסט הכתוב ב‪ .Label-‬בעת‬
‫לחצה על ‪ CheckBox‬של צבע‪ ,‬יש להוסיף המרכיב שלו לצבע הטופס או להסיר מרכיב זה מצבע הטופס בהתאם‬
‫לערך ה‪ .CheckBox-‬כך למשל‪ ,‬אם צבע הטופס הוא אדום )‪ RGB(255, 0, 0‬לאחר לחיצה על ה‪CheckBox-‬‬
‫הירוק יתוסף המרכיב שלו לצבע וכתוצאה מכך תקבל צבע צהוב ()‪ ,RGB(255, 255, 0‬לחיצה נוספת על ‪Green‬‬
‫תסיר את המרכיב והרקע ישוב להיות אדום‪.‬‬
‫‪ .1‬כתוב תוכנית בשם ‪ .FulfilListBox‬בתוכנית הוסף על טופס את ה‪ Controls-‬הבאים‪:‬‬
‫‪( TextBox‬עם ‪ Label‬מתאים ככותרת)‪ ListBox ,‬ושלושה ‪.CommandButtons‬‬
‫בעת לחיצה (‪ )Click‬על ה‪ CommandButton-‬הראשון יתוסף הטקסט שהוזן לתוך ה‪ TextBox-‬ה‪ListBox-‬‬
‫(ה‪ CommandButton-‬הזה יהי ‪ .)Default‬אם לא קיים טקסט בתוך ה‪ ,TextBox-‬לא יתבצע מאומה‪ .‬לאחר‬
‫ההוספה יוחזר הפוקוס ל‪ TextBox-‬ויסומן הקטע שבתוכו‪.‬‬
‫בעת לחיצה על ה‪ CommandButton-‬השני ימחק הפריט המסומן ברשימה‪.‬‬
‫‪ CommandButton‬שלישי ישמש ליציאה ויקבל את המאפיין ‪.Cancel‬‬
‫כמו כן‪ ,‬בעת לחיצה כפולה (‪ )Double Click‬על שורה בתוך ה‪ ListBox-‬יוצג ‪ Message Box‬טקסט פריט שנבחר‪.‬‬
‫‪ .3‬צור תוכנית בשם ‪.SumListData‬‬
‫בטופס מקם את ה‪ Controls-‬הבאים‪:‬‬
‫שני ‪ TextBoxes‬עם ‪ Labels‬מתאימים שכותרת הראשון היא "‪ "Name‬וכותרת השני היא "‪."Additional Value‬‬
‫שני ‪ CommandButtons‬שכותרת הראשון היא ‪ Insert‬וכותרת השני היא ‪.Sum‬‬
‫‪ ListBox‬אחד‪.‬‬
‫בעת לחיצה על ‪ Insert‬יוזן ל‪ ListBox-‬המידע שני ה‪ .TextBoxes-‬כאשר ה‪ Additional Data-‬הוא מידע המוכנס‬
‫ל‪ .ItemData-‬אם המשתמש לא הזין דבר לשדה ‪ Name‬אזי לא תתבצע ההכנסה‪ .‬אם רק השדה ‪Additional Data‬‬
‫חסר‪ ,‬ערך ברירת המחדל יהיה ‪ .1‬לאחר ההוספה יוחזר הפוקוס לתיבה ‪ Name‬ויסומן בה הטקסט לשם החלפה‪.‬‬
‫בעת לחיצה על הלחצן ‪ Sum‬יחושב סכום כל מאפייני ה‪ ItemData-‬הצמודיפ לפריטי הרשימה‪ ,‬ותוצג למשתמש‬
‫הודעה מתאימה‪.‬‬
‫שיעור ‪ : 6‬מרכיבי השפה ‪II‬‬
‫‪ ‬תכיר את המילה ‪With‬‬
‫‪ ‬תלמד איך ליצור מערכים חד ממדיים‪ ,‬רב ממדיים ומערכים דינמיים‬
‫‪ ‬תלמד ליצור ‪( Control Arrays‬מערכים של פקדים)‬
‫‪ ‬תלמד לכתוב רוטינות ופונקציות‬
‫‪ ‬תכיר צורות העברה שונות של פרמטרים לרוטינה ופונקציה‬
‫‪ ‬תבין מהם משתנים מקומיים‪ ,‬משתנים גלובליים ומשתנים סטטיים‬
‫‪ ‬תבין מהי פרוצדורה סטטית‬
‫‪ ‬תלמד ליצור פרוצדורה עם מספר פרמטרים משתנה‬
‫‪ ‬תלמד לעבוד עם מודולי קוד (*‪)bas.‬‬
‫‪ ‬תלמד כיצד להפעיל קוד מחלון ה‪Immediate-‬‬
‫‪ ‬תלמד ליצור רשימות קבועים באמצעות המשפט ‪Enum...End Enum‬‬
‫‪ ‬תלמד להגדיר סוגי משתנים חדשים (‪)User Defined Type‬‬
‫המילה‬
‫‪‬‬
‫‪‬‬
‫‪WITH‬‬
‫לעתים יש צורך להגדיר מספר גדול של מאפיינים של אובייקט‬
‫כדי לקצר את זמן הכתיבה וכדי להפוך את הקוד מובן יותר אפשר להשתמש בתבנית הכתיבה הבאה‪:‬‬
‫‪With object‬‬
‫‪.property1 = value1‬‬
‫‪.property2 = value2‬‬
‫‪...‬‬
‫‪End With‬‬
‫‪( ARRAYS‬מערכים)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫מערך הוא רצף של משתנים מאותו הסוג הממוקמים ברצף בזכרון‬
‫ב‪ Visual Basic-‬ניתן להצהיר על מערכים חד ממדיים‪ ,‬רב ממדיים‪ ,‬ומערכים דינמיים‬
‫הפנייה לאיבר במערך ב‪ Visual Basic-‬מתבצעת על‪-‬ידי רישום אינדקס האיבר בתוך סוגריים עגולים‬
‫כאשר הפנייה היא לאיבר במערך רב ממדי‪ ,‬יש להפריד בין אינדקסים ברמות שונות באמצעות פסיקים‬
‫הצהרה תוך שימוש במילים ‪ Dim Private ,Public‬או ‪ ,Static‬זהה באופן ובמשמעות שלה להצהרה על משתנים‬
‫רגילים‬
‫‪( One-Dimensional Arrays‬מערכים חד ממדיים)‬
‫‪‬‬
‫הצהרה על מערך חד ממדי יכולה להתבצע בשתי צורות‪ ,‬הצורה הראשונה היא‪:‬‬
‫‪Dim arr_name(upper_index) As Type‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ arr_name‬הוא שם המערך‬
‫‪ upper_index‬הוא האינדקס של האיבר האחרון במערך‬
‫‪ Type‬הוא סוג האיברים במערך‬
‫‪‬‬
‫הצורה השניה היא‪:‬‬
‫‪‬‬
‫‪‬‬
‫השוני בצורה זו‪ ,‬הוא בכך שאתה מגדיר את האינדקס התחתון ואת האינדקס העליון שיהוו את גבולות המערך‬
‫מותר להשתמש גם במספרים שליליים עבור האינדקסים‬
‫‪Dim arr_name(lower_index To upper_index) As Type‬‬
‫המשפט ‪Option Base‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫אם לא מצוין האינדקס התחתון של המערך‪ ,‬ברירת המחדל היא ‪2‬‬
‫כדי לשנות זאת ניתן להשתמש במשפט ‪ Option Base 1‬בתחילת מודול הקוד‪ ,‬במקרה זה‪ ,‬האינדקס התחתון של‬
‫מערכים שיוצהרו בצורה הראשונה יהיה ‪1‬‬
‫ניתן להשתמש גם במשפט ‪ ,Option Base 0‬אך זוהי ברירת המחדל‬
‫‪( Multi-Dimensional Arrays‬מערכים רב ממד יים)‬
‫‪‬‬
‫ההצהרה על מערכים רב ממדיים דומה למערכים חד ממדיים‪ ,‬אלא שיש להפריד בפסיקים בין הגדרת טווחי‬
‫האינדקסים של כל ממד‪ ,‬באופן הבא‪:‬‬
‫‪Dim arr_name(lower_index1 To upper_index1, lower_index2 To‬‬
‫‪upper_index2,...) As Type‬‬
‫‪‬‬
‫טווחי האינדקסים של ממד במערך יכולים להיות מוצהרים כמו בצורה הראשונה שהוצגה עבור מערכים חד‬
‫ממדיים‪ .‬במקרה זה‪ ,‬האינדקס התחתון יהיה ‪ 2‬אלא אם הוגדר ‪ Option Base 1‬בתחילת הקובץ‬
‫‪( Dynamic Arrays‬מערכים די נמיים)‬
‫‪‬‬
‫כדי להצהיר על מערך דינמי‪ ,‬יש להצהיר עליו מלכתחילה ללא גודל מוגדר‪ ,‬באופן הבא‪:‬‬
‫‪Dim arr_name() As Type‬‬
‫‪‬‬
‫באמצעות המילה ‪ ReDim‬ניתן לשנות את גודל המערך במהלך ריצת התוכנית‪ ,‬באופן הבא‪:‬‬
‫]‪ReDim [Preserve] (lower_index1 To upper_index1, ...) [As Type‬‬
‫‪ ‬ניתן לשנות את מספר הממדים במערך‪ ,‬את גודל כל ממד‬
‫‪ ‬את סוג האיברים במערך ניתן רק אם המערך מאוחסן בתוך משתנה מסוג ‪Variant‬‬
‫‪ ‬אם משתמשים במילה ‪ Preserve‬גודלו משתנה תוך שמירת תוכנו הקודם‬
‫‪ ‬בעת שימוש במילה ‪ Preserve‬לא ניתן לשנות את סוג האיברים במערך‪ ,‬כמו גם את גבולו התחתון של המערך‬
‫‪ ‬בעת שימוש במילה ‪ Preserve‬בעת שינוי גודלו של מערך רב ממדי‪ ,‬ניתן לשנות רק את אינדקסים של הממד‬
‫האחרון במערך‬
‫אזהרה‪ :‬השימוש במילה ‪ ReDim‬יכול לשמש גם כהצהרה על משתנה‪ .‬משמעות הדבר היא שגם אם כתוב בראש‬
‫המודול המשפט ‪ ,Option Explicit‬והשתמשת ב‪ ReDim-‬יחד עם שם משתנה שלא הוצהר בראש המודול‪ ,‬לא‬
‫תקבל שגיאת קומפילציה ואותו מערך אכן ייוצר באופן מקומי‪.‬‬
‫בדיקת גודל מע רך ב זמן ריצה באמצעות ‪ LBound‬ו ‪UBound -‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫מתעורר צורך לעתים קרובות לדעת מהו הגבול התחתון (האינדקס התחתון) של מערך‪ ,‬כמו גם גבולו העליון‪ .‬צורך‬
‫זה הופך לקריטי כשעוסקים בכתיבת קוד גנרי‪ ,‬כמו גם תוך עבודה עם מערכים דינמיים‬
‫הפונקציה ‪ )Lower Bound( LBound‬מחזירה את האינדקס התחתון של מערך‬
‫הפונקציה ‪ )Upper Bound( UBound‬מחזירה את האינדקס העליון של המערך‬
‫דוגמה ‪1‬‬
‫‪Dim m_nArr(9) As Integer‬‬
‫‪‬‬
‫פקודה זו מצהירה על מערך שהאינדקס הראשון שלו הוא ‪ 0‬והאחרון הוא ‪ .9‬סה"כ ‪ 10‬איברים‬
‫‪Option Base 1‬‬
‫‪...‬‬
‫‪...‬‬
‫‪Dim m_nArr(9) As Integer‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫שורות קוד אלו זו מצהירה על מערך שהאינדקס הראשון שלו הוא ‪ 1‬והאחרון הוא ‪ .9‬סה"כ ‪ 9‬איברים‬
‫שים לב שהמשפט ‪ Option Base‬יכול להופיע רק פעם אחת בתחילת המודול (לפני כל הפונקציות או ההצהרות על‬
‫מערכים)‬
‫משפט ‪ Option Base‬משפיע רק על מערכים שנוצרו בתוך המודול בו נרשם המשפט‬
‫‪Dim TicTacToe(1 To 3, 1 To 3) As Boolean‬‬
‫‪‬‬
‫בשורת קוד זו מוצהר מערך דו ממדי בשם ‪ ,TicTacToe‬שהאינדקסים בשני הממדים שלו נעים בין ‪ 1‬ל‪( 3-‬כולל)‬
‫‪‬‬
‫בדוגמה זו הנח ששורות הקוד מתבצעות בסדר כרונולוגי מהמשפט הראשון לאחרון‪.‬‬
‫‪Dim dyn_arr() As Integer‬‬
‫‪‬‬
‫בשורת קוד זו מוצהר מערך דינמי בשם ‪ dyn_arr‬מסוג ‪Integer‬‬
‫‪‬‬
‫בשורת קוד זו קובעים מחדש את ממדי המערך ‪ ,dyn_arr‬כך שיכיל ממד אחד שהאינדקסים שלו נעים בין ‪ 5‬ל‪1-‬‬
‫)‪ReDim dyn_arr(5 To 9‬‬
‫)‪ReDim dyn_arr(3 To 10‬‬
‫‪‬‬
‫שורת קוד זו משנה שוב את ממדי המערך כך שיכיל ממד אחד שהאינדקסים שבו נעים בין ‪ 3‬ל‪12-‬‬
‫)‪ReDim Preserve dyn_arr(3 To 12‬‬
‫‪‬‬
‫‪‬‬
‫שורת קוד זו מגדירה שוב את ממדי המערך תוך שמירה על הערכים המאוחסנים בו‪ .‬בשורה שזו משתנה האינדקס‬
‫ל‪11-‬‬
‫ניסיון להריץ את שורת הקוד הבאה יגרום לשגיאה‪:‬‬
‫)‪ReDim Preserve dyn_arr(-2 To 20‬‬
‫‪‬‬
‫שורת קוד זו מנסה (אך לא יכולה) להשתמש במילה ‪ Preserve‬תוך שינוי האינדקס התחתון של המערך‬
‫)‪ReDim dyn_arr(-2 To 7, 11‬‬
‫‪‬‬
‫‪‬‬
‫בשורת קוד זו משנים שוב את ממדי המערך כך שיכיל שני ממדים‪ ,‬כאשר האינדקסים בממד הראשון נעים בין –‪2‬‬
‫ל‪ ,1-‬והאינדקסים בממד השני נעים בין ‪ ( 2‬או ‪ 1‬אם הוגדר ‪ 1 Option Base‬בראש המודול) ל‪11-‬‬
‫ניסיון להריץ את שורת הקוד הבאה ייתקל בשגיאה‪:‬‬
‫‪ReDim dyn_arr(-2 To 7, 13) As Long‬‬
‫‪‬‬
‫לא ניתן לשנות סוג של מערך‬
‫‪‬‬
‫‪‬‬
‫בדוגמה זו תראה כיצד ניתן לשנות את סוג המערך‬
‫תחילה יש להצהיר על משתנה רגיל מסוג ‪:Variant‬‬
‫‪‬‬
‫‪‬‬
‫שים לב שזהו משתנה רגיל (אין סוגריים ריקים בהצהרה)‬
‫לאחר מכן תוכל לשנות את גודל המערך ואת סוגו כל אימת שתרצה בכך‪:‬‬
‫‪Dim dyn_arr as Variant‬‬
‫‪ReDim dyn_arr(3 To 5, 6 To 7) As Long‬‬
‫‪‬‬
‫לא תוכל לשנות את סוג המערך אם השתמשת במילה ‪Preserve‬‬
‫‪( CONTROL ARRAY‬מערכי פקדים)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫כפי שניתן ליצור מערכי משתנים מסוגים בסיסיים וסוגים המוגדרים ע"י המשתמש‪ ,‬כך ניתן ליצור ‪Control‬‬
‫‪( Arrays‬מערכי פקדים)‬
‫לכל סוגי הפקדים (בדוק זאת!!!) קיים מאפיין בשם ‪Index‬‬
‫ב‪ Control Array-‬כל הפקדים חייבים להיות מאותו הסוג ובעלי אותו שם‬
‫האינדקס של כל פקד במערך נקבע באמצעות המאפיין ‪Index‬‬
‫גישה לפקד בודד מתוך ‪Control Array‬‬
‫‪‬‬
‫כדי לגשת לפקד מסוים במערך יש לציין את האינדקס שלו באופן הבא‪:‬‬
‫‪ControlArrayName(desire_index).property = ...‬‬
‫או‬
‫‪ControlArrayName.Item(desire_index).property = ...‬‬
‫בדיקת גודל המערך וגבולותיו‬
‫‪‬‬
‫ניתן לקבוע את גודל ה‪ Control Array-‬באמצעות הפונקציה ‪ ,Count‬באופן הבא‪:‬‬
‫‪ControlArrayName.Count‬‬
‫‪‬‬
‫ניתן לקבוע את האינדקס התחתון ב‪ Control Array-‬באמצעות הפונקציה ‪ ,LBound‬באופן הבא‪:‬‬
‫‪ControlArrayName.LBound...‬‬
‫‪‬‬
‫ניתן לקבוע את גבולו העליון של ה‪ Control Array-‬באמצעות הפונקציה ‪ ,UBound‬באופן הבא‪:‬‬
‫‪ControlArrayName.UBound...‬‬
‫אירועים של פקדים השייכים ל‪Control Array-‬‬
‫‪‬‬
‫‪‬‬
‫הפרמטר הראשון בשגרות אירוע של ‪ ,Control Array‬הוא האינדקס של הפקד במערך עבורו שוגרה ההודעה‬
‫מבנה כללי של שגרת אירוע עבור ‪ ControlArray‬הוא כדלקמן‪:‬‬
‫‪Private Sub ControlArrayName_EventName(Index As Integer, .....all other‬‬
‫)‪parameters in the event...‬‬
‫שלבי יצירת ‪Control Array‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫ליצירת ‪ Control Array‬ישנן כמה דרכים‪ ,‬אתאר כאן שתיים‪:‬‬
‫הדרך הראשונה והפשוטה היא ליצור פקד אחד‪ ,‬להגדיר לו את השם והמאפיינים הנדרשים ולאחר מכן להעתיק‬
‫אותו (‪ )Ctrl+C‬ולהדביק אותו (‪ Visual Basic .)Ctrl+V‬תשאל אותך האם אתה מעוניין ליצור מערך פקדים אשר‬
‫את הבקשה‪ ,‬והמערך ייוצר‪.‬‬
‫דרך שניה היא להגדיר באופן ידני את שמות הפקדים ואת האינדקס שלהם כך ששמות הפקדים יהיו זהים‪ ,‬ולכל‬
‫אחד מהם יוקצה אינדקס ייחודי‬
‫יצירת פקדים בזמן ריצה‬
‫‪‬‬
‫‪‬‬
‫כדי ליצור פקדים בזמן ריצה עליך ליצור ‪ Control Array‬שיש בו לפחות איבר אחד בזמן עיצוב התוכנית‬
‫בזמן ריצת התוכנית תוכל להשתמש במתודה ‪ Load‬כדי לטעון פקדים נוספים באופן הבא‪:‬‬
‫)‪Load arr_name(new_index‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫תקבל שגיאה אם תנסה ליצור פקד חדש עם אינדקס שכבר תפוס ע"י פקד אחר באותו המערך‬
‫הקפד להגדיר את מאפייני הפקד מיד לאחר שנוצר‬
‫כדי להסיר פקד בזמן ריצה‪ ,‬השתמש במתודה ‪ Unload‬באופן הבא‪:‬‬
‫)‪Unload arr_name(index_to_remove‬‬
‫‪‬‬
‫לא תוכל להסיר פקדים שנוצרו בזמן עיצוב‪ ,‬אלא רק פקדים שנוצרו באמצעות קריאה קודמת ל‪Load-‬‬
Com mandBoard ‫ – התוכנ ית‬1 ‫תרגיל‬
‫בדוגמה זו אמחיש לך כיצד ניתן ליצור פקדים בזמן ריצה‬
‫ ונמקם אותם על גבי הטופס הראשי של התוכנית‬Runtime-‫בתוכנית זו נטען פקדים ב‬
,‫ ותסיר אותו מהטופס (אלא אם מדובר בפקד הראשון‬,‫לחיצה על אחד הפקדים תציג הודעה עם מספר הפקד‬
)Design time-‫כלומר זה שמוקם על הטופס ב‬
:Standard EXE ‫צור תוכנית‬
frmCommandBoard ‫ ולטופס את השם‬,CommandBoard ‫ הקצה לפרוייקט את השם‬
‫ שמור את התוכנית‬
:‫הוסף פקד לטופס‬
cmdBoard ‫ על גבי הטופס והקצה לו את השם‬CommandButton ‫ הצב פקד מסוג‬
:‫הגדר את המאפיינים הבאים‬
‫ערך‬
‫מאפיין‬
1-Fixed Single
BorderStyle
frmCommandBoard
2 - CenterScreen
StartUpPosition
0 - User
ScaleMode
0
ScaleLeft
0
ScaleTop
3
ScaleWidth
3
ScaleHeight
0
Index
cmdBoard
:Control Array-‫ נוסיף פעולות אתחול ויצירה של ה‬,‫ של הטופס‬Load ‫ לאירוע‬
Dim i As Integer
' Initialize the caption
Me.Caption = "Command Board"
' Reposition the first control
With cmdBoard(0)
.Caption = "&0"
.Left = 0
.Top = 0
.Width = 1
.Height = 1
.Visible = True
End With
' Load the controls from 2 to 9 (th first is already on the form)
' Then, reposition the loaded controls
For i = 1 To 8
Load cmdBoard(i)
www.kita.co.il



.1
.1
.3
.1
‫)‪With cmdBoard(i‬‬
‫))‪.Caption = "&" & Trim(Str(i‬‬
‫‪.Left = i Mod 3‬‬
‫‪.Top = i \ 3‬‬
‫‪.Width = 1‬‬
‫‪.Height = 1‬‬
‫‪.Visible = True‬‬
‫‪End With‬‬
‫‪Next i‬‬
‫‪End Sub‬‬
‫‪ ‬שים לב‪ ,‬לאחר טעינת כל פקד השתמשנו ב‪ With-‬כדי להגדיר קבוצת מאפיינים שלו‪ .‬צורת רישום כזו נוחה‬
‫ומובנת‬
‫‪ ‬יש להגדיר את המאפיין ‪ Visible‬ל‪ True-‬כדי שהפקד הנטען יוצג על פני הטופס‬
‫‪ ‬הכותרות של הפקדים הוגרו לפי האינדקס שלהם לצורך הנוחות‬
‫‪ ‬כשרוצים להכניס קו תחתון מתחת למספר (מאיץ מקלדת באמצעות ‪ ,)ALT‬משתמשים בתו המוכר &‬
‫(אמפרסנד)‬
‫‪ ‬הפונקציה ‪ Str‬הממירה מספר למחרוזת מוסיפה רווח בתחילת המחרוזת כאשר המספר הוא חיובי‪ ,‬וסימן –‬
‫(מינוס) כאשר המספר הוא שלילי‪ .‬כדי להסיר רווח זה ניתן להשתמש בפונקציה ‪Trim‬‬
‫‪ .1‬הוסף קוד לטופס‪:‬‬
‫‪ ‬הקוד הבא פועל בתגובה לאירוע ‪ Click‬של הפקדים במערך‬
‫‪ ‬אם הפקד שנלחץ אינו הראשון (אינדקס ‪ 0‬שאותו אסור להסיר באמצעות ‪ ,)Unload‬מוסר הפקד באמצעות‬
‫‪:Unload‬‬
‫)‪Private Sub cmdBoard_Click(Index As Integer‬‬
‫‪' Remove the Command only if it isn't the first (index = 0) command‬‬
‫)‪If Index <> 0 Then Unload cmdBoard(Index‬‬
‫‪End Sub‬‬
‫‪ .1‬הרץ ובדוק את פעולת התוכנית‬
‫פרוצדורות‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫ב‪VISUAL BASIC-‬‬
‫כמו בכל שפת תכנות‪ ,‬גם ב‪ Visual Basic-‬ניתן לכתוב פרוצדורות קוד‬
‫פרוצדורות ב‪ Visual Basic-‬מגיעות אלינו בארבעה טעמים‪:‬‬
‫‪ – Sub Routines o‬רוטינות‬
‫‪ - Functions o‬פונקציות‬
‫‪ – Properties o‬מאפיינים‬
‫‪ - Events o‬אירועים‬
‫את השניים הראשונים תכיר בשיעור זה‪ .‬יצירת מאפיינים ואירועים תכיר בשיעור העוסק במחלקות‬
‫רוטי נות ופו נקצ יות שלב ‪I‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫רוטינה ב‪ Visual Basic-‬אינה מחזירה ערך‪ ,‬לעומת פונקציה המחזירה ערך‬
‫לרוטינות ופונקציות ניתן להעביר פרמטרים בשתי צורות‪:‬‬
‫‪ - By Value o‬על ידי ערך‬
‫‪ – By Reference o‬על ידיד ייחוס‬
‫‪ o‬קיימים היבטים נוספים הנוגעים להעברת פרמטרים‪ ,‬נכיר אותם בהמשך‬
‫העברת פרמטר ‪ By Value‬יוצרת העתק למשתנה והעתק זה נמצא בידי הרוטינה או הפונקציה‬
‫העברת פרמטר ‪ By Reference‬גורמת למשתנה המקורי להיות נגיש על ידי הרוטינה או הפונקציה‬
‫תחביר רוטינות ופונקציות‬
‫‪‬‬
‫תחביר רוטינה הוא‪:‬‬
‫‪‬‬
‫תחביר פונקציה הוא‪:‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ SubName‬הוא שם הרוטינה ו‪ FunctionName-‬הוא שם הפונקציה‬
‫‪ parameters‬הוא רשימת הפרמטרים המועברים לרוטינה או לפונקציה‪ .‬בהמשך נראה כיצד מעבירים פרמטרים‪.‬‬
‫‪ Public‬הופך את הרוטינה או הפונקציה לציבורית‪ ,‬כלומר נגישה על ידי קוד ממודולי קוד אחרים בפרוייקט‬
‫ניתן להשתמש במילה ‪ Private‬במקום המילה ‪ ,Public‬ואז הרוטינה או הפונקציה הופכת לפרטית באותו מודול‬
‫קוד‪ ,‬ולא תהיה אליה גישה ממודולים אחרים‬
‫‪ Public‬היא הרשאת ברירת המחדל עבור פרוצדורות קוד‬
‫‪ Type‬הוא סוג הערך המוחזר על ידי הפונקציה‪ .‬אם לא צוין במפורש‪ ,‬הסוג הוא ‪Variant‬‬
‫‪ – ReturnValue‬כשרוצים להחזיר ערך מפונקציה יש לבצע השמה לשם הפונקציה‬
‫)‪Public Sub SubName(parameters‬‬
‫‪...‬‬
‫‪End Sub‬‬
‫‪Public Function FunctionName(parameters) As Type‬‬
‫‪...‬‬
‫‪FunctionName = ReturnValue‬‬
‫‪End Function‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫רשימת פרמטרים‬
‫‪‬‬
‫רישום הפרמטרים שהפרוצדורה מקבלת מתבצע באופן הבא‪:‬‬
‫‪[ByVal | ByRef] parameter1 As Type, [ByVal | ByRef] parameter2 As‬‬
‫‪Type...‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ parameter1‬ו‪ parameter2-‬הם שמות הפרמטרים‬
‫‪ Type‬הוא סוג הערך של הפרמטר‪ .‬אם לא צוין במפורש‪ ,‬סוג הפרמטר הוא ‪Variant‬‬
‫‪ ByVal‬או ‪ ByRef‬קובעים את האופן שבו יועבר הפרמטר לפונקציה‪ .‬האפשרויות הן‪:‬‬
‫‪ – ByVal o‬על ידי ערך‬
‫‪ – ByRef o‬על ידי ייחוס‬
‫‪ o‬אם לא צויין במפורש‪ ,‬ברירת המחדל היא ‪ByRef‬‬
‫מערכים ניתן להעביר‪ ByRef‬בלבד‬
‫יציאה מרוטינה או פונקציה‬
‫‪‬‬
‫ניתן לצאת בכל שלב מתוך רוטינה או פונקציה על ידי שימוש במשפטים‪:‬‬
‫‪ – Exit Sub o‬ליציאה מרוטינה‬
‫‪ – Exit Function o‬ליציאה מפונקציה‬
‫משתנים מקומיים‪ ,‬גלובליים וסטטיים‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫ניתן להצהיר על משתנים בתוך פרוצדורות קוד באמצעות המילים ‪ Dim‬או ‪ Static‬בלבד‬
‫הצהרה על משתנים בתוך פרוצדורה אינה יכולה להתבצע באמצעות המילים ‪ Public‬או ‪Private‬‬
‫משתנים המוצהרים בתוך פרוצדורת קוד נקראים משתנים מקומיים‬
‫משתנים מקומיים זמינים אך ורק לקטע הקוד התחום בתוך הרוטינה או הפונקציה‬
‫משתנים מקומיים מתחילים את חייהם עם תחילת הפרוצדורה ומשוחררים מהזיכרון עם סיום הפרוצדורה‬
‫משתנים המוצהרים בראש מודול נקראים משתנים גלובליים‬
‫משתנים גלובליים זמינים לכל הרוטינות והפרוצדורות באותו מודול‬
‫משתנים גלובליים מתחילים את חייהם בתחילת חייו של מודול הקוד ומסיימים את חייהם בסיום חייו של מודול‬
‫הקוד (במקרה של מודול *‪ bas.‬מדובר בתחילת התוכנית ובסיומה‪ .‬מודול ‪ *.bas‬יילמד בהמשך)‬
‫משתנים המוצהרים בפרוצדורה באמצעות המילה ‪ Static‬נקראים משתנים סטטיים‬
‫משתנים סטטיים נשמרים בזכרון גם לאחר שהפרוצדורה מסיימת את פעולתה‪ ,‬וערכם נשמר עד להפעלה הבאה‬
‫של הפרוצדורה‪ .‬במילים אחרות‪ ,‬משתנים סטטיים שומרים על ערכם בין שתי קריאות סמוכות לפרוצדורה‪.‬‬
‫)(‪Public Sub Hello‬‬
‫"!‪MsgBox "Hello, world‬‬
‫‪End Sub‬‬
‫‪‬‬
‫‪‬‬
‫פרוצדורה זו מציגה ‪ Message Box‬עם ההודעה "!‪"Hello, world‬‬
‫שים לב שהיה ניתן להימנע מהשימוש במילה ‪ Public‬כיוון שזוהי ברירת המחדל‬
‫)‪Public Sub DispSum(ByVal a As Integer, ByVal b As Integer‬‬
‫)‪MsgBox Str(a + b‬‬
‫‪End Sub‬‬
‫‪‬‬
‫רוטינה זו מציגה ב‪ Message Box-‬את סכומם של שני מספרים המועברים אליה‬
‫)‪Public Sub Swap(ByRef var1 As Variant, ByRef var2 As Variant‬‬
‫‪Dim varTmp As Variant‬‬
‫‪varTmp = var1‬‬
‫‪var1 = var2‬‬
‫‪var2 = varTmp‬‬
‫‪End Sub‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫הרוטינה ‪ Swap‬מחליפה בין התכנים של שני משתנים המועברים אליה‬
‫כיוון שהפרמטרים מוצהרים כ‪ ,Variant-‬ניתן להפעיל רוטינה זו על כל הסוגים הבסיסיים של ‪Visual Basic‬‬
‫שים לב שניתן היה להימנע מהשימוש במילה ‪ ByRef‬כיוון שזוהי ברירת המחדל‬
‫‪Public Function GiveMe5() As Integer‬‬
‫‪GiveMe5 = 5‬‬
‫‪‬‬
‫פונקציה זו מחזירה ‪ 5‬למי שקרא לה (‪)Caller‬‬
‫‪Public Function Factorial(ByVal n As Byte) As Long‬‬
‫‪Dim lRes As Long‬‬
‫‪lRes = 1‬‬
‫‪Do While n > 0‬‬
‫‪lRes = lRes * n‬‬
‫‪n = n - 1‬‬
‫‪Loop‬‬
‫‪Factorial = lRes‬‬
‫פונקציה זו מחשבת את העצרת של מספר המועבר אליה‬
‫‪ ‬שים לב לשימוש בפרמטר ‪( n‬הפרמטר המועבר לפונקציה)‪ .‬שינוי הפרמטר במהלך הפונקציה לא משפיע על המקור‪,‬‬
‫כיוון שהפרמטר מועבר ‪ ,ByVal‬כלומר בפונקציה נעשה שימוש בהעתק של המשתנה המועבר‪.‬‬
‫‪Public Function FindBigger(ByRef arr() As Integer) As Integer‬‬
‫‪Dim l As Integer, u As Integer‬‬
‫‪Dim bigger As Integer‬‬
‫)‪l = LBound(arr‬‬
‫)‪u = UBound(arr‬‬
‫‪bigger = l‬‬
‫‪Do While l <= u‬‬
‫‪If arr(l) > arr(bigger) Then bigger = l‬‬
‫‪l = l + 1‬‬
‫‪Loop‬‬
‫‪FindBigger = bigger‬‬
‫‪‬‬
‫‪‬‬
‫פונקציה זו מקבלת מערך של ‪ Integers‬ומחזירה את האינדקס של האיבר הגדול במערך‬
‫הפונקציה סורקת את המערך החל מאינדקס האיבר הראשון (‪ )LBound‬עד לאינדקס האיבר האחרון (‪)UBound‬‬
‫‪Public Function SumCalls() As Integer‬‬
‫‪Static nCalls As Integer‬‬
‫‪nCalls = nCalls + 1‬‬
‫‪SumCalls = nCalls‬‬
‫‪‬‬
‫‪‬‬
‫בדוגמה זו ‪ SumCalls‬היא פונקציה המחזירה את מספר הקריאות שהתבצעו אליה עד כולל הקריאה האחרונה‬
‫המשתנה ‪ nCalls‬מוצהר כסטטי‪ ,‬לכן הוא מאותחל ל‪ 2-‬פעם אחת (בקריאה הראשונה)‪ ,‬ובכל קריאה נוספת הוא‬
‫שומר על ערכו הקודם‬
‫קריאות לרוטינות ופרוצדורות‬
‫]‪[Call] name [argumentlist‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫ניתן לקרוא לרוטינות או פונקציות באמצעות המילה ‪Call‬‬
‫השימוש במילה ‪ Call‬הוא אופציונלי‪ ,‬ולרוב לא משתמשים בו‬
‫אם נעשה שימוש במילה ‪ ,Call‬יש לתחום בתוך סוגריים ארגומנטים המועברים לרוטינה או לפונקציה‬
‫כאשר קוראים לרוטינה ללא שימוש במילה ‪ ,Call‬אין לתחום בסוגריים את הארגומנטים‬
‫אם משתמשים בערך המוחזר של פונקציה‪ ,‬יש לתחום בסוגריים את הארגומנטים המועברים לפונקציה‬
‫דוגמאות לקריאה לפרוצדורת‬
‫‪Call Hello‬‬
‫‪‬‬
‫בשורת קוד זו נקראת הרוטינה ‪Hello‬‬
‫‪‬‬
‫‪‬‬
‫בשורת קוד זו מתבצעת קריאה לרוטינה ‪ ,Swap‬ומועברים אליה הפרמטרים ‪ a‬ו‪b-‬‬
‫באופן דומה ניתן היה לרשום‪:‬‬
‫‪‬‬
‫בשורת קוד זו‪ ,‬המבצעת קריאה לפונקציה ‪ ,Factorial‬והערך המוחזר ממנה מושם למשתנה ‪res‬‬
‫)‪Call Swap(a, b‬‬
‫‪Swap a, b‬‬
‫)‪res = Factorial(8‬‬
‫רוטי נות ופרוצדורות שלב ‪II‬‬
‫פרוצדורות סטטיות‬
‫‪‬‬
‫ניתן להפוך פרוצדורה לסטטית על ידי הוספת המילה ‪ Static‬לאחר המילה ‪ Public‬או ‪ Private‬ולפני שם‬
‫הפרוצדורה‪ ,‬כלומר‪:‬‬
‫]‪[Public | Private] Static ProcedureName(arglist) [As Type‬‬
‫‪‬‬
‫פרוצדורה סטטית היא פרוצדורה שכל המשתנים שבה שומרים על ערכם בין הקריאות השונות לפרוצדורה‬
‫‪named-arguments‬‬
‫‪‬‬
‫‪‬‬
‫בעת קריאה לפונקציה ניתן לציין לאיזה פרמטר פורמלי מיועד כל ארגומנט אקטואלי שמעבירים‪ ,‬תוך שימוש‬
‫באופרטור ‪( =:‬נקודתיים ושווה)‬
‫כך לדוגמה‪ ,‬אם מוצהרת הפונקציה הבאה‪:‬‬
‫‪Public Function Div(ByVal Num1 As Double, ByVal Num2 As Double) As‬‬
‫‪Double‬‬
‫‪‬‬
‫ונרצה לחשב את הביטוי ‪ , 3.12 8  2‬נוכל לקרוא לפונקציה בשתי צורות‪:‬‬
‫)‪res = Div(8, 2‬‬
‫או‬
‫)‪res = Div(Num2 = 2, Num1 = 8‬‬
‫‪ParamArray‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ ParamArray‬דומה לאופרטור ‪( ...‬שלוש נקודות) בשפת ‪ ,C‬בהקשר של פרמטרים לפונקציות‬
‫‪ ParamArray‬מאפשר להעביר מספר משתנה של פרמטרים לפרוצדורה‬
‫‪ ParamArray‬חייב להופיע בסוף רשימת הפרמטרים‬
‫לפרוצדורה שהפרמטר האחרון שלה הוא מסוג ‪ ,ParamArray‬ניתן לקרוא עם מספר משתנה של פרמטרים (חוץ‬
‫מהפרמטרים שהם חובה כמובן)‬
‫בתוך הפרוצדורה‪ ,‬הגישה לפרמטרים המועברים נעשית בצורה שבה ניגשים לאיברי מערך‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫אי אפשר להשתמש במילים ‪ ByVal‬או ‪ ByRef‬יחד עם ‪ParamArray‬‬
‫ברשימת הפרמטרים לא יכולים להיות יחד ‪ ParamArray‬ופרמטרים אופציונליים (נלמד בסעיף הבא)‬
‫תחביר השימוש ב‪ ParamArray-‬הוא כדלקמן‪:‬‬
‫‪......(arg1 As Type, arg2 As Type, ..., ParamArray other_pamaters())....‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫מילת המפתח היא ‪ParamArray‬‬
‫)(‪ other_paramaters‬זהו שם המערך (במקרה זה) כפי שיוכר בפרוצדורה‬
‫בהמשך תראה דוגמה לשימוש ב‪ParamArray-‬‬
‫פרמטרים אופציונליים‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫ניתן להגדיר פרמטרים מסוימים של פרוצדורה כאופציונליים‪ ,‬כלומר פרמטרים שאין חובה להעביר לפרוצדורה‬
‫ניתן להשתמש בפונקציה ‪ IsMissing‬כדי לבחון אם פרמטר (מסוג ‪ Variant‬בלבד) הועבר לפונקציה‬
‫ניתן להגדיר ערכי ברירת מחדל עבור פרמטרים אופציונליים‬
‫כאשר משתמשים בפרמטר אופציונלי כל הפרמטרים שאחריו חייבים גם הם להיות אופציונליים‬
‫התחביר לפרמטרים אופציונליים הוא כדלקמן‪:‬‬
‫‪...(...,Optional [ByVal | ByRef] arg As Type [= DefaultValue],...‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫מילת המפתח היא ‪Optional‬‬
‫ניתן להמשיך ולהשתמש ב‪ ByRef-‬או ‪ByVal‬‬
‫‪ Type‬הוא סוג הפרמטר שלו מצפה הפרוצדורה‬
‫‪ DefaultValue‬הוא חלק רשות המגדיר את ערך הפרמטר במקרה שלא הועבר לפרוצדורה‬
‫יצירת שלד פרוצדורה באמצעות ‪ Add Procedure‬מהתפריט ‪Tools‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫ניתן ליצור תבנית פרוצדורות מכל הטעמים (רוטינות‪ ,‬פונקציות‪ ,‬מאפיינים ואירועים)‬
‫באמצעות ה‪Add Procedure... :Wizard-‬‬
‫לשם פתיחת ה‪ Wizard‬עליך להיות בחלון הקוד של אחד מהמודולים בתוכנית‪ .‬ואז מתוך התפריט ‪ Tools‬בחר‬
‫ב‪...Add Procedure-‬‬
‫אפשרויות הבחירה הן‪ Property ,P Function ,Sub :‬ו‪Procedure-‬‬
‫אפשרויות הגישה הן ‪ Public‬או ‪Private‬‬
‫אם תסמן את האפשרות ‪ All Local variables as Static‬ה‪ Wizard-‬ייצור עבורך פרוצדורה סטטית‬
‫_ ‪Public Function Mult(ByVal Num1 As Double,‬‬
‫_ ‪ByVal Num2 As Double,‬‬
‫‪ParamArray AdditionalNums()) As Double‬‬
‫‪Dim res As Double‬‬
‫‪Dim l As Integer, u As Integer‬‬
‫)‪l = LBound(AdditionalNums‬‬
‫)‪u = UBound(AdditionalNums‬‬
‫‪res = Num1 * Num2‬‬
‫)‪res = res * AdditionalNums(l‬‬
‫‪l = l + 1‬‬
‫‪Loop‬‬
‫‪Mult = res‬‬
‫‪‬‬
‫לפונקציה זו ישנם שני פרמטרים שהם חובה‪ Num1 :‬ו‪Num2-‬‬
‫‪‬‬
‫ניתן להעביר פרמטרים נוספים לפונקציה ואז תחושב המכפלה של כל המספרים‬
‫_ ‪Public Function Div(Optional ByVal Num1 As Double = 1#,‬‬
‫‪Optional ByVal Num2 As Double = 1#) As Double‬‬
‫‪If Num2 = 0# Then Exit Function ' Num2 must be non-zero‬‬
‫‪Div = Num1 / Num2‬‬
‫‪‬‬
‫‪‬‬
‫פונקציה זו מחזירה את מנת החלוקה של ‪ Num1‬ב‪Num2-‬‬
‫אם לא מועבר אחד מהמספרים‪ ,‬ערך ברירת המחדל שלו יהיה ‪1.0‬‬
‫מודולי קוד סטנדרטיים‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫מודולי הקוד ב‪ Visual Basic-‬מתחלקים לשתי קבוצות עיקריות‪:‬‬
‫‪Class Modules o‬‬
‫‪Standard Modules o‬‬
‫מודולי מחלקה (‪ )Class Modules‬יילמדו בהמשך‪ ,‬טפסים לדוגמה הם סוג של מודול מחלקה‬
‫מודול סטנדרטי יכול להכיל פונקציות ומשתנים גלובליים שיהיו זמינים לכל האובייקטים ביישום‬
‫ניתן לכלול משתנים ופונקציות שיהיו זמינים לפונקציות שבמודול בלבד על ידי שימוש במילה ‪Private‬‬
‫כדי להוסיף מודול יש לבחור ‪ Add Module‬מתוך התפריט ‪Project‬‬
‫הפעלת פונקציות מחלון‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪*.BAS‬‬
‫ה‪IMMEDIATE‬‬
‫חלון ה‪ Immediate-‬הוא אחד ממרכיבי מערכת ניפוי השגיאות (‪ )Debugger‬של ‪( Visual Basic‬נושא יילמד‬
‫בשיעור הבא)‬
‫חלון ה‪ ,Immediate-‬כשמו‪ ,‬מאפשר לבצע פעולות באופן מידי‬
‫ניתן להריץ פונקציות ורוטינות באמצעות חלון ה‪ Immediate-‬מבלי להריץ את התוכנית כולה‬
‫כמובן שגם במהלך התוכנית ניתן לבחון ערכי משתנים ופונקציות בתוכנית‪ ,‬אך נושא זה יידון בפירוט בפרק הבא‬
‫כדי להציג ערך המוחזר על ידי פונקציה בחלון ה‪ ,Immediate‬יש להקדים את הסימן? (סימן שאלה) – כמובן שיש‬
‫לתחום בסוגריים את הארגומנטים המועברים לפונקציה‬
‫כדי להציג את חלון ה‪ Immediate-‬ניתן לבחור ‪ Immediate window‬מהתפריט ‪ ,View‬או לחילופין להפעיל את‬
‫צירוף המקשים ‪Ctrl+G‬‬
‫תרגיל ‪ – 2‬הפעלת קוד מחלון ה ‪Immediate -‬‬
‫‪ ‬בתרגיל זה תכתוב במודול סטנדרטי קוד המוצג בדוגמאות הקודמות‪ ,‬ותריץ אותו דרך חלון ה‪Immediate-‬‬
‫‪ .1‬צור תוכנית ‪:Standard EXE‬‬
‫‪ ‬הסר מהתוכנית את הטופס‪:‬‬
‫‪ o‬לחץ לחיצה ימנית על שם הטופס ב‪( Project Explorer-‬אם אינך רואה את ה‪ Project Explorer-‬בחר‬
‫אותו מהתפריט ‪)View‬‬
‫‪ o‬מהתפריט המוקפץ בחר ב‪Remove Form1-‬‬
‫‪ ‬הוסף מודול לפרוייקט‪:‬‬
‫‪ o‬בחר באפשרות ‪ Add Module‬מהתפריט ‪Project‬‬
‫‪ o‬בחר ב‪ Module-‬ולחץ על ‪Open‬‬
‫‪ ‬הקצה לפרוייקט את השם ‪ ModuleAndImmediate‬ו‪-‬למודול הקצה את השם ‪modProcedures‬‬
‫‪ .1‬הצג את חלון ה‪:Immediate-‬‬
‫‪ ‬וודא שחלון ה‪ Immediate-‬מוצג אם אינך רואה אותו לחץ על ‪Ctrl+G‬‬
‫‪ .3‬בחן את הרוטינה ‪ MsgBox‬מתוך חלון ה‪:Immediate-‬‬
‫‪ ‬הקלד בחלון ה‪ Immediate-‬את הקוד הבא‪:‬‬
‫"!‪MsgBox "Hello, world‬‬
‫‪ ‬ברגע שתלחץ על ‪ Enter‬חלון ה‪ Message Box-‬יופיע‬
‫‪ ‬נסה לשנות את הפרמטרים האחרים ברוטינה ובחן את השפעתם על אופן הצגת ה‪Message Box-‬‬
‫‪ .1‬בחן את הפונקציה ‪ Left‬של ‪:Visual Basic‬‬
‫‪ ‬הקלד את שורת הקוד הבאה בחלון ה‪:Immediate-‬‬
‫)‪?Left ("Hello, world!",4‬‬
‫‪ ‬שים לב לסימן השאלה בתחילת השורה‪ ,‬ולסוגריים המקיים את הארגומנטים‬
‫‪ ‬הארגומנטים מטרתם להנחות את ‪ Visual Basic‬שברצוננו להשתמש בערך המוחזר מהפונקציה‬
‫‪ ‬סימן השאלה מטרתו להנחות את ‪ Visual Basic‬להציג את הערך המוחזר בחלון ה‪Immediate-‬‬
‫‪ .1‬הוסף פונקציה ל‪:Module-‬‬
‫‪ ‬כתוב את הפונקציה ‪ Sum‬המוצגת להלן‪ ,‬בחלון ה‪:Module-‬‬
‫_ ‪Public Function Divide(ByVal a As Double,‬‬
‫‪Optional ByVal b As Double = 2#) As Double‬‬
‫‪Divide = a / b‬‬
‫‪ .1‬בחן את הפונקציה מחלון ה‪:Immediate-‬‬
‫‪ ‬הקלד את שורת הקוד הבאה בחלון ה‪:Immediate‬‬
‫)‪?Divide(3,6‬‬
‫‪‬‬
‫‪‬‬
‫אתה צריך לקבל את התוצאה ‪( 2.1‬האפס לא מוצג)‬
‫הקלד את שורת הקוד הבאה בחלון ה‪:Immediate-‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫בשורת קוד זו השתמשת ב‪named arguments-‬‬
‫אתה צריך לקבל ‪2‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫במקרה זה‪ ,‬חסר הארגומנט השני‪ ,‬לפיכך הפונקציה משתמשת בערך ברירת המחדל שקבעת לה‬
‫אתה צריך לקבל ‪4‬‬
‫)‪?Divide(b:=3, a:=6‬‬
‫)‪?Divide(8‬‬
‫)‪?Divide(7, 0‬‬
‫‪‬‬
‫אתה אמור לקבל ששגיאת חלוקה ב‪ 2-‬על ידי סביבת הפיתוח‬
‫‪( ENUMERATIONS‬אוספי קבועים)‬
‫‪‬‬
‫‪‬‬
‫בדומה למילת המפתח ‪ enum‬בשפת ‪ ,C‬קיימת המילה ‪ Enum‬ב‪Visual Basic-‬‬
‫‪ Enum‬מאפשרת ליצור אוסף קבועים המאוגדים תחת שם אחד באופן הבא‪:‬‬
‫‪[Public | Private] Enum name‬‬
‫]‪membername [= constantexpression‬‬
‫]‪membername [= constantexpression‬‬
‫‪...‬‬
‫‪End Enum‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ Public‬או ‪ Private‬קובעים לאילו חלקי קוד בתוכנית ה‪ Enum-‬יהיה מוכר‬
‫‪ name‬הנו השם שבחרת ל‪Enum-‬‬
‫‪ membername‬הנו שם קבוע בתוך ה‪Enum-‬‬
‫‪ constantexpression‬הנו ערך קבוע שמוקצה עבור ה‪membername-‬‬
‫אם לא מגדירים ערך קבוע עבור פריט בתוך ‪ Enum‬אז ערכו נקבע לפי הכלל הבא‪:‬‬
‫‪ o‬אם זהו הפריט הראשון ב‪ Enum-‬ערכו יהיה ‪0‬‬
‫‪ o‬עבור של פריט (שאינו הפריט הראשון) ערכו יהיה גדול ב‪ 1-‬מערך נפריט הקודם‬
‫לא ניתן לשנות את ערכו של פריט ב‪ Enum-‬במהלך התוכנית‬
‫לאחר שהוגדר ‪ ,Enum‬ניתן להשתמש בו לשם הצהרת משתנים‪ ,‬פרמטרים של פרוצדורות וערכים מוחזרים של‬
‫פונקציות‬
‫‪Public Enum AgeCategoriesConstants‬‬
‫‪acChild‬‬
‫‪acYoung‬‬
‫‪acAdult‬‬
‫‪acOld‬‬
‫‪End Enum‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫ב‪ Enum-‬זה מוצהרים ארבעה קבועים‬
‫ערכו של ‪ acChild‬הוא ‪ ,0‬של ‪ acYoung‬הוא ‪ 1‬וכן הלאה‬
‫בהנחה שרוצים להשים את הקבוע ‪ acChild‬למשתנה ‪ ,nAge‬אפשר לבצע זאת בשתי צורות‪:‬‬
‫‪nAge = acChild‬‬
‫או‬
‫‪nAge = AgeCategoriesConstants.acChild‬‬
‫‪‬‬
‫הצורה השניה נוחה כאשר יש התנגשות שמות עם קבוע אחר‬
‫‪( USER-DEFINED TYPES‬סוגי נתונים מוגדרים על ידי המשתמש)‬
‫‪‬‬
‫‪‬‬
‫ניתן ליצור סוגי נתונים מורכבים (כמו ‪ Struct‬בשפת ‪ )C‬באמצעות המילה ‪Type‬‬
‫התחביר הוא כדלקמן‪:‬‬
‫‪[Public | Private] Type varname‬‬
‫‪elementname [(subscript)] As type‬‬
‫‪elementname [(subscript)] As type‬‬
‫‪...‬‬
‫‪End Type‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ Public‬או ‪ Private‬מגדירים את טווח ההכרה (‪ )Scope‬של הסוג החדש‬
‫‪ varname‬הוא שם הסוג החדש שמוגדר על ידי ‪Type‬‬
‫‪ elementname‬הוא שם אלמנט בתוך הסוג החדש‬
‫אלמנט יכול להיות גם מערך חד ממדי או רב ממדי‪ ,‬ואז יש להשתמש ב‪ subscript-‬כדי להגדיר את ממדיו‬
‫כל אחד מהאנלמטים בתוך הסוג החדש צריך להיות מסוג (‪ )type‬מוכר באותו שלב‬
‫כדי לגשת לאלמט בתוך משתנה מהסוג החדש‪ ,‬יש להשתמש בסימן ‪( .‬נקודה)‬
‫‪Public Type Point‬‬
‫‪x As Integer‬‬
‫‪y As Integer‬‬
‫‪‬‬
‫בשורות קוד אלו הוגדר סוג חדש בשם ‪ Point‬שיש לו שני שדות‪ x :‬ו‪y-‬‬
‫‪‬‬
‫בשורות קוד אלו הוגדר סוג חדש בשם ‪ ,Rectangle‬ובו שני שדות‪ ptTopLeft :‬ו‪ ptBottomRight-‬מסוג ‪Point‬‬
‫שהוגדר קודם‬
‫‪Public Type Rectangle‬‬
‫‪ptTopLeft As Point‬‬
‫‪ptBottomRight As Point‬‬
‫‪Public Type Scribble‬‬
‫‪ptArr(100) As Point‬‬
‫בדוגמה זו הוגדר סוג חדש בשם ‪( Scribble‬שרבוט) המכיל מערך מסוג ‪ Point‬בגודל ‪100‬‬
‫שיעור ‪ : 7‬הרצה וניפוי שגיאות‬
‫‪ ‬תכיר את אפשרויות ההרצה השונות‬
‫‪ ‬תכיר את מרכיבי סביבת הפיתוח המאפשרים ניפוי שגיאות ב‪Visual Basic-‬‬
‫‪ ‬תבין מהם שלושת המצבים‪ Run Time ,Design Tine :‬ו‪Break Mode-‬‬
‫‪ ‬תכיר את האובייקט ‪Debug‬‬
‫‪ ‬תכיר את המשפט ‪ On Error...‬המיועד לטיפול בשגיאות‬
‫חלונות תצוגה שונים לאבחון‬
‫‪‬‬
‫מתוך התפריט ‪ View‬ישנן ארבע תצוגות מעניינות‪ ,‬העשויות לסייע באבחון שגיאות בתוכנית‪:‬‬
‫‪ :Immediate Window o‬בנוסף לאפשרויות שהוזכרו בשיעור הקודם‪ ,‬ניתן להעביר לחלון ה‪Immediate-‬‬
‫פלט מהאובייקט ‪( Debug‬נדון בהמשך שיעור זה)‬
‫‪ :Locals Window o‬מאפשר לצפות במשתנים מקומיים בפרוצדורה‬
‫‪ :Watch Window o‬מאפשר לצפות במשתנים שנוספו לחלון ה‪( Watch-‬נדון בהמשך)‬
‫‪ :Call Stack o‬מציג את מצב הקריאות לפרוצדורות במחסנית‪ .‬חלון זה מציג את שרשרת הקריאות‬
‫לפרוצדורות עד לנקודה מסוימת בתוכנית‪.‬‬
‫שלושת המצבים של תוכנית‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ :Design Time‬שהו השלב שבו התוכנית נמצאת בעיצוב‪ ,‬המילים אחרות‪ ,‬השלב שבו אתה מניח פקדים על‬
‫טפסים‪ ,‬כותב קוד אך עדיין לא מבצע אותו קרוי ‪Design Time‬‬
‫‪ :Run Time‬זהו המצב שבו שורות הקוד שבתוכנית שלך מתחילות להתבצע‬
‫‪ :Break Mode‬שהו מצב שבו מושהית התוכנית (לא מפסקת כי אם מושהית)‬
‫התפריט ‪( RUN‬הרצה)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫ב‪ Visual Basic-‬קיימות מספר אפשרויות להרצה‬
‫האפשרויות השונות כלולות בתפריט ‪Run‬‬
‫הפעלת אפשרות להרצה מעבירה את התוכנית למצב ‪Run Time‬‬
‫‪( Start‬התחל)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ Start‬היא צורת ההרצה השכיחה‬
‫ניתן להפעיל את ‪ Start‬בשלושה אופנים‪:‬‬
‫‪ o‬לבחור ‪ Start‬מהתפריט ‪Run‬‬
‫‪ o‬ללחוץ על הכפתור המתאים בסרגל הכלים‬
‫‪ o‬להפעיל את צירוף המקשים ‪Ctrl+F5‬‬
‫בעת הרצה עם ‪ Start‬לא מבוצע קימפול של התוכנית‬
‫‪( Start With Full Compile‬התחל לאחר קימפול מלא)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ Start With Full Compile‬מבצע קימפול לפני ההרצה‬
‫הרצה כזו מומלצת לשם גילוי שגיאות כבר בזמן הקימפול‪ ,‬למשל משתנים שלא מוצהרים‬
‫ניתן להפעיל אפשרות זו מתפריט ‪ Run‬או על ידי צירוף המקשים ‪Ctrl+F5‬‬
‫‪( Break‬עבור ל ‪) Break Mode -‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ Break‬מאפשר לבצע מעבר ממצב ריצה למצב ‪Break‬‬
‫אפשרות זו שימושית כשרוצים לעבור במצב מסוים לשלב ‪Debug‬‬
‫אפשר להפעיל את ‪ Break‬בשלוש צורות‪:‬‬
‫‪ o‬בחירת ‪ Break‬מהתפריט ‪Run‬‬
‫‪ o‬בחירת הכפתור המתאים בסרגל הכלים‬
‫‪ o‬הפעלת צירוף המקשים ‪Ctrl+Break‬‬
‫האפשרות האחרונה (צירוף המקשים ‪ )Ctrl+Break‬שימושית המיוחד כשנכנסים למצב שסרגלי הכלים‬
‫והתפריטים לא נגישים‪ :‬למשל בלולאות אינסופיות‪ ,‬או כשאר מופיע ‪ Message Box‬מודאלי‬
‫‪( End‬סיים)‬
‫‪‬‬
‫‪‬‬
‫‪ End‬מסיים את פעולת התוכנית‬
‫ניתן להפעיל את ‪ End‬מהתפריט ‪ Run‬או מסרגל הכלים‬
‫‪( Restart‬התחל מחדש)‬
‫‪‬‬
‫‪‬‬
‫‪ Restart‬מאפשר להפעיל מחדש את התוכנית‬
‫ניתן לבחור ב‪ Restart‬מהתפריט ‪ Run‬או להפעיל את צירף המקשים ‪Shift+F5‬‬
‫התפריט ‪( DEBUG‬ניפוי שגיאות)‬
‫‪‬‬
‫‪‬‬
‫התפריט ‪ Debug‬מאפשר לבצע כמעט כל דבר אפשרי בזמן ריצת התוכנית לשם ביצוע אבחון של התוכנית‬
‫אפשרויות ה‪ Debug-‬כלולות תחת תפריט ‪Debug‬‬
‫‪( Step Into‬צעד לתוך)‬
‫‪‬‬
‫‪‬‬
‫אפשרות זו יכולה לפעול במספר צורות‪:‬‬
‫‪ o‬אם התוכנית נמצאת ב‪ ,Design Time-‬התוכנית תתחיל לרוץ ותעבור מיד למצב של ‪ Break Mode‬כאשר‬
‫יש שליטה על כל צעד וצעד בתוכנית‬
‫‪ o‬אם התוכנית עומדת להפעיל פרוצדורה הכתובה בתוכנית‪ ,‬תתבצע כניסה לתוך הפרוצדורה‬
‫ניתן להפעיל אפשרות זו מהתפריט ‪ Debug‬או באמצעות ‪[F8‬‬
‫‪( Step Over‬צעד מעבר)‬
‫‪‬‬
‫‪‬‬
‫אפשרות זו פועלת כמו ‪ Step Into‬אלה שבמקרה שהתוכנית קוראת לפרוצדורה‪ ,‬לא תתבצע כניסה לתוך‬
‫לפרוצדורה‬
‫ניתן להפעיל אפשרות זו מתוך התפריט ‪ Debug‬או על ידי הצירוף ‪Shift+F8‬‬
‫‪( Step Out‬צא החוצה)‬
‫‪‬‬
‫‪‬‬
‫מצבע יציאה מפרוצדורה פנימית לחיצונית‬
‫ניתן להפעיל אפשרות זו מתוך התפריט ‪ Debug‬או על ידי ‪Ctrl+Shift+F8‬‬
‫‪( Run To Cursor‬הרץ עד הסמן)‬
‫‪‬‬
‫‪‬‬
‫אפשרות זו מריצה את התוכנית עד אשר שורת הביצוע מגיעה למיקומו של הסמן ואז התוכנית עוברת ל‪Break -‬‬
‫‪Mode‬‬
‫ניתן להפעיל אפשרות זו מתוך התפריט ‪ Debug‬או באמצעות הצירוף ‪Ctrl+F8‬‬
‫‪( Add Watch‬הוספת תצפית)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫באמצעות ‪ Watch‬אפשר לעקוב אחר ערכו של משתנה במהלך ריצת התוכנית‬
‫ניתן להוסיף ‪ Watch‬מהתפריט ‪Debug‬‬
‫הבחירה ב‪ Add Watch-‬פותחת את התיבה ‪ Add Watch‬המוצגת להלן‪:‬‬
‫‪‬‬
‫‪‬‬
‫ב‪ Expression-‬רושמים את הביטוי שאחריו רוצים לעקוב‬
‫‪ Module ,Procedure‬ו‪ Project-‬מגדירים את מיקומו של הביטוי מבין כל הפרוייקטים המודולים והפרוצדורות‬
‫שנמצאים בעריכה‬
‫‪ Watch Type‬מגדיר את הפעולה שברצוננו לבצע‪:‬‬
‫‪ :Watch Expression o‬מציג את ערכו של הביטוי בכל נקודת זמן בתוכנית (אם הביטוי אינו קיים באותו‬
‫שלב‪ ,‬תוצג לידו ההודעה ‪)Out Of Context‬‬
‫‪ :Break When Value Is True o‬מעביר את התוכנית ל‪ Break Mode-‬ברגע שהביטוי הוא ‪True‬‬
‫‪ :Break When Value Changes o‬מעביר את התוכנית ל‪ Break Mode-‬כאשר ערך הביטוי משתנה‬
‫‪‬‬
‫‪( Edit Watch‬ערוך תצפ ית)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫מאפשר לשנות הגדרות ‪Watch‬‬
‫תיבת הדו שיח הנפתחת דומה מאוד לזו של ‪ ,Add Watch‬אלא שגם קיימת האפשרות למחוק ‪Watch‬‬
‫כדי להפעיל אפשרות זו יש לבחור אותה מהתפריט ‪ Debug‬או להפעיל את צירוף המקשים ‪Ctrl+W‬‬
‫‪( Quick Watch‬תצפית מהירה)‬
‫‪‬‬
‫‪‬‬
‫אפשרות זו מאפשרת לבצע תצפית מיידית על ערכו של משתנה‬
‫כדי להפעיל אפשרות זו יש‪:‬‬
‫‪ o‬לבחור ביטוי בחלון הקוד‬
‫‪ o‬להפעיל את האפשרות מהתפריט ‪ Debug‬או על ידי צירוף המקשים ‪Shift+F9‬‬
‫‪‬‬
‫החלון הנפתח בתגובה הוא‪:‬‬
‫‪‬‬
‫‪ :Context‬מתאר את מיקום הביטוי בתוך מרחב העבודה של ‪ ,Visual Basic‬כלומר את הנתיב לפרוצדורה שבא‬
‫ממוקם הביטוי הנבחן (שם פרוייקט‪ ,‬שם מודול‪ ,‬שם פרוצדורה וכו')‬
‫‪ :Expression‬זהו הביטוי הנצפה‬
‫‪ :Value‬זהו ערכו של המשתנה‪ .‬אם המשתנה לא קיים באותו רגע‪ ,‬תוצג ההודעה ‪Out of context‬‬
‫‪‬‬
‫‪‬‬
‫‪( Toggle Breakpoint‬הפוך מצב של נקודת עצירה)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ Breakpoint‬היא נקודת עצירה הממוקמת במשפט מסוים בתוכנית‬
‫תוכנית רצה עוברת ל‪ Break Mode-‬בעת הגיעה ל‪Breakpoint-‬‬
‫לחצן זה הוא דו מצבי‪ ,‬כלומר מוסיף או מנקה ‪Breakpoint‬‬
‫‪ Breakpoint‬מוצג באמצעות נקודה אדומה בחלון הקוד‬
‫כדי להוסיף או להסיר ‪ Breakpoint‬יש לבחור את האפשרות מהתפריט ‪ ,Debug‬או מסרגל הכלים או על ידי המקש‬
‫‪ ,F9‬או לחיצה על העיגול האדום במסמל ‪ Breakpoint‬בחלון הקוד‬
‫‪( Clear All Breakpoi nts‬הסר את כל נקודות העצירה)‬
‫‪‬‬
‫‪‬‬
‫אפשרות זו מסירה את כל נקודת העצירה שמוקמו בקוד‬
‫ניתן להפעיל אפשרות זו מהתפריט ‪ Debug‬או על ידי הצירוף ‪Ctrl+Shift+F9‬‬
‫‪( Set Next Statement‬קבע את המשפט הבא לביצוע)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ Next Statement‬הנו הביטוי הבא שאמור להתבצע לאחר הביטוי הנוכחי‬
‫במצב ‪ ,Break Mode‬הביטוי הבא לביצוע מוצג באמצעות חץ צהוב‬
‫בעת הרצה ב‪ Break Mode-‬ניתן לשנות את הביטוי הבא שיבוצע בשתי צורות‪:‬‬
‫‪ o‬יש להציב את הסמן במשט שאליו נרצה שהתוכנית תעבור בשלב הבא‪ ,‬ואז יש לבחור באפשרות ‪Set Next‬‬
‫‪ Statement‬מתוך התפריט ‪ Debug‬או להפעיל את הצירוף ‪Ctrl + F9‬‬
‫‪ o‬ניתן לגרור את החץ הצהוב את השורה שרוצים שתהפוך למשפט הבא לביצוע‬
‫יש לשים לב כי המשפט הבא לביצוע חייב להיות באותה הפרוצדורה‬
‫‪( Show Next St atement‬הצג את המשפט הבא לביצוע)‬
‫‪‬‬
‫‪‬‬
‫אפשרות זו מעבירה את סמן הטקסט אל המשפט הבא לביצוע‬
‫ניתן לבחור באפשרות זו מתוך התפריט ‪Debug‬‬
‫האובייקט‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪DEBUG‬‬
‫האובייקט ‪ Debug‬הוא אובייקט של סביבת ‪Visual Basic‬‬
‫לאובייקט ‪ Debug‬יש שתי מתודות‪:‬‬
‫‪ o‬המתודה ‪ Print‬מוציאה פלט לחלון ה‪Immediate-‬‬
‫‪ o‬המתודה ‪ Assert‬בוחנת ביטוי בוליאני‪ ,‬ואם הוא ‪ False‬עוצרת את מהלך התוכנית באותה הנקודה‬
‫כל הפעולות המבוצעות בעזרת האובייקט ‪ Debug‬מתקמפלות רק בשלב הפיתוח‪ ,‬כאשר יוצרים את קובץ הריצה‬
‫באמצעות הפריט ‪ Make‬מהתפריט‪ ,File‬קטעי הקוד הקוראים לאובייקט ‪ Debug‬לא מתקמפלים‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫נניח כי אנו רוצים לכתוב פונקציה בשם ‪ SumUpTo‬המקבלת מספר אי שלילי שלם ומחשבת את סכום כל‬
‫המספרים מ‪ 0-‬עד לאותו מספר (כולל)‬
‫נוכל לוודא שהמספר שהועבר הוא אי שלילי באמצעות ‪Debug.Assert‬‬
‫נוכל להדפיס נתונים לחלון ה‪ Immediate-‬באמצעות ‪Debug.Print‬‬
‫‪Public Function SumUpTo(ByVal n As Integer) As Integer‬‬
‫‪Dim res As Integer‬‬
‫_ & " ‪Debug.Print "The input for SumUpTo is :‬‬
‫‪Trim(Str(n)) ' Print to the immediate‬‬
‫‪Debug.Assert n >= 0 ' Allow only non-negative arguments‬‬
‫‪res = 0‬‬
‫‪Do While n > 0‬‬
‫‪res = res + n‬‬
‫‪n = n - 1‬‬
‫‪Loop‬‬
‫‪SumUpTo = res‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫הרצת קוד זה גורמת להדפסת הערך המועבר לפונקציה לחלון ה‪Immediate-‬‬
‫אם מועבר ערך שלילי‪ ,‬ההרצה מושהית על ידי המשפט ‪ ,Debug.Assert‬במקרה כזה נוכל להיעזר ב‪Call Stack-‬‬
‫כדי לדעת מאיזו פרוצדורה התבצעה קריאה לפונקציה זו‬
‫כאמור‪ ,‬קטעי הקוד הללו מקומפלים ורצים רק בשלב הפיתוח ולא במוצר המוגמר‬
‫טיפול בשגיאות בקוד התוכנית‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫אובייקטים של ‪ Visual Basic‬מטפלים בשגיאות בסגנון ה‪Exception Handling-‬‬
‫פונקציות המיובאות מ‪ DLL-‬רגילים מחזירים ערך המצביע בדרך כלל על הצלחה או כשלון של הקיאה‬
‫כשאר מפעילים פונקציות מ‪ DLL-‬רגילים (שים לב שהכוונה ל‪ DLL-‬שונים מאלו שתלמד לבנות בשיעורים אודות‬
‫‪ )ActiveX‬בודקים את הערך המוחזר כדי לזהות שגיאה‬
‫כאשר מפעילים קוד סטנדרטי של ‪ Visual Basic‬יש ללכוד חריגים באמצעות המשפט ‪On Error‬‬
‫שים לב‪ ,‬חריג שלא טופל יגרום לקריסת התוכנית אצל המשתמש‪ ,‬לפיכך יש לטפל בכל בחריגים האפשריים‬
‫האובייקט ‪Err‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫בזמן התרחשות שגיאה‪ ,‬הנתונים אודות השגיאה מאוחסנים באובייקט ‪Err‬‬
‫בזמן לכידת שגיאה יש לבחון את האובייקט ‪Err‬‬
‫האובייקט ‪ Debug‬מאפשר להעביר שגיאה החוצה לקוד הקורה לפונקציה‬
‫המאפיינים והמתודות של האובייקט ‪ Err‬הם‪:‬‬
‫‪ :Number o‬מספר השגיאה שהתרחשה‬
‫‪ :Description o‬תיאור מילולי של השגיאה‬
‫‪ :Source o‬זוהי מחרוזת המכילה את המקור לשגיאה שהתרחשה‪ ,‬למשל שם המחלקה שיצרה את השגיאה‬
‫(הנושא מחלקות נלמד בהמשך הקורס)‬
‫‪ :LastDLLError o‬מחזיר את קוד השגיאה האחרון שנוצר ב‪( DLL-‬רגיל) שהתבצעה אליו קריאה‪ .‬ערך זה‬
‫המצוי ב‪ LastDLLError-‬שקול לקריאה ‪ GetLastError‬מתוך ‪Windows API‬‬
‫‪ :HelpFile o‬מכיל את הנתיב לקובץ עזרה הקשור לשגיאה שהתאלשה‬
‫‪ :HelpContext o‬מכיל את זיהוי הנושא בקובץ העזרה‬
‫‪ :Clear o‬מתודה זו מנקה את האובייקט ‪ .Err‬מומלץ לבצע זאת לאחר ששגיאה טופלה‬
‫‪ :Raise o‬מתודה זו מאפשרת לעורר שגיאה‪ .‬משתמשים במתודה זו בעיקר בתכנות רכיבים חדשים (הנושא‬
‫נדון בשיעורים אודות ‪)ActiveX‬‬
‫‪On Error...‬‬
‫‪‬‬
‫המשפט ‪ On Error‬בא בשלושה טעמים‪:‬‬
‫‪On Error GoTo line o‬‬
‫‪On Error Resume Next o‬‬
‫‪On Error GoTo 0 o‬‬
‫‪On Error GoTo line‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫משפט זה מעביר את הביצוע לשורה המצוינת במילה ‪ line‬כאשר שגיאה מתרחשת‬
‫כדי לציין שורה יש להשתמש ב‪ Labels-‬או במספרי שורות‬
‫‪ o‬כדי לציין ‪ Label‬יש לרשום שם חוקי עם נקודתיים בתחילת שורה‬
‫‪ o‬ניתן להשתמש במספרי שורות בקוד ‪ ,Visual Basic‬אך זוהי שיטה ישנה המתאימה לימי הביניים‪ .‬בכל‬
‫אופן‪ ,‬מספר חייב להופיע בתחילת השורה‬
‫חשוב למקם משפט יציאה מהפרוצדורה‪ Exit Sub :‬או ‪ Exit Function‬לפני קוד הטיפול בשגיאות‪ ,‬על מנת שהוא‬
‫לא יתבצע כאשר הקוד בוצע בהצלחה‬
‫‪Public Function Div(ByVal Num1 As Double,‬‬
‫‪ByVal Num2 As Double) As Double‬‬
‫‪On Error GoTo Err_Handler‬‬
‫‪Exit Function‬‬
‫‪Err_Handler:‬‬
‫‪MsgBox "The following error occured: " & Err.Description‬‬
‫פונקציה זו מחלקת שני מספרים‬
‫‪ ‬אם תתרחש שגיאה (למשל שגיאת חלוקה ב‪ )0-‬תועבר השליטה לקוד שאחרי התווית ‪Err_Handler‬‬
‫‪ ‬קוד הטיפול פשוט מציג הודעה עם תיאור השגיאה שהתרחשה‬
‫‪‬‬
‫‪‬‬
‫שים לב שלפני התווית יש יציאה מפונקציה‪ ,‬כדי למנוע את ביצוע הקוד אם לא התרחשה שגיאה‬
‫אין צורך לקרוא למתודה ‪ ,Err.Clear‬כיוון שהאובייקט ‪ Err‬מתנקה אוטומטית בעת יציאה מפונקציה‬
‫‪‬‬
‫משפט זה מעביר את הקוד לביצוע לשורה הבאה שלאחר השגיאה‬
‫‪On Error GoTo 0‬‬
‫‪‬‬
‫‪‬‬
‫משפט זה מכבה (‪ )Turn Off‬טיפול בשגיאות שהוגדר‪ ,‬כלומר אם התבצעה קריאה ל‪ On Error GoTo line-‬או‬
‫ל‪ On Error Resume Next-‬הם יבוטלו‬
‫טוב להשתמש במשפט זה אם רוצים לטפל באופן שונה בשגיאות המתרחשות במקומות שונים בקוד‬
‫המשפט ‪Resume‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫המשפט ‪ Resume‬מאפשר להמשיך את ביצוע התוכנית בשורה מסוימת לאחר טיפול בשגיאה שהתרחשה‬
‫קיימות שלוש אפשרויות‪:‬‬
‫‪ :Resume o‬מחזיר את הביצוע לשורה ממנה התרחשה השגיאה‬
‫‪ Resume Next o‬מעביר את הביצוע לשורה שאחרי השורה שבה התרחשה השגיאה‬
‫‪ :Resume line o‬מעביר את הביצוע לשורה המצוינת על ידי תווית או מספר שורה (כמובן שהשורה חייבת‬
‫להיות באותה פרוצדורה)‬
‫לאחר קריאה ל‪ Resume-‬האובייקט ‪ Err‬מתנקה אוטומטית‬
‫_ ‪Public Function Div(ByVal Num1 As Double,‬‬
‫‪ByVal Num2 As Double) As Double‬‬
‫‪Debug.Print Err.Number, Err.Description‬‬
‫‪Exit Function‬‬
‫‪Num2 = 1#‬‬
‫‪Resume‬‬
‫‪‬‬
‫דוגמה זו זהה לקודמת‪ ,‬אלא שכאן בקוד הטיפול משנים את ערכו של ‪ Num2‬ל‪ 1-‬ומחזירים את הביצוע לשורה‬
‫שיצרה את השגיאה‪ ,‬כך נמנעים מחלוקה ב‪0-‬‬
‫הפו נקציה ‪Error‬‬
‫‪‬‬
‫הפונקציה ‪ Error‬מאפשרת לקבל תיאור של שגיאה לפי המספר שלה‬
‫שיעור ‪ : 1‬מבוא לתכנות מבוסס רכיבים ‪Componentware Development‬‬
‫‪ ‬תבין את ההבדלים בין ‪( Procedural Programming‬תכנות פרוצדורלי) לבין ‪Object Oriented Programming‬‬
‫(תכנות מונחה עצמים ‪)OOP‬‬
‫‪ ‬תבין מהו ‪( Event Oriented Programming‬תכנות מונחה אירועים)‬
‫‪ ‬תבין את עקרונות ‪COM‬‬
‫‪ ‬תבין מהם ‪( COM Interfaces‬ממשקי ‪ ,)COM‬ואת הצורך בהם‬
‫‪ ‬תלמד אודות התמיכה של ‪ Visual Basic‬בתכנות מונחה עצמים‪ ,‬תכנות מונחה אירועים ותכנות רכיבים‬
‫‪ ‬תהיה מוכן להרטיב את הרגליים בשיעור הבא העוסק בתכנות מונחה עצמים ב‪Visual Basic-‬‬
‫תכנות פרוצדורלי לעומת תכנות מונחה עצמים‬
‫מבדילים בין שני סוגים עיקריים של שפות תכנות‪:‬‬
‫‪Procedural Languages ‬‬
‫‪Object Oriented Programming Languages ‬‬
‫‪Procedural Prog ramming‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫מרכז העצבים בתכנות פרוצדורלי הנם הפונקציות והרוטינות‬
‫הגדרה של סוגי נתונים חדשים בתכנות פרוצדורלי אפשרית‪ ,‬אך במקביל יש לכתוב פרוצדורות המסוגלות לטפל‬
‫בסוגים החדשים‬
‫סוג נתונים מוגדרים על ידי המשתמש יכולים להכיל בתוכם משתנים מכל הסוגים המוכרים עד לנקודה בה הם‬
‫הוגדרו‬
‫סוגי נתונים מוגדרים על ידי המשתמש אינם יכולים להכיל בתוכם פונקציות‬
‫בתכנות פרוצדורלי‪ ,‬המשתנים והפרוצדורות חיים בנפרד‬
‫בדרך כלל משתמשים ב‪( Modular Programming-‬תכנות מודולרי) כדי ליצור איזושהי רמה של הסתרת מידע‪.‬‬
‫‪ Modular Programming‬משמעותו היא שהקוד מרוכז במודולי קוד (המקבילים למודולים סטנדרטיים ב‪Visual -‬‬
‫‪ ,)Basic‬ובאופן זה ניתן להסתיר משתנים מסוימים שאין צורך שייראו מחוץ למודול‪ .‬מודול הנו קובץ בודד של‬
‫קוד‪.‬‬
‫דוגמה‬
‫‪ ‬נמחיש את ההיבטים הללו של תכנות פרוצדורלי באמצעות יישום פשוט בשפת ‪ C‬וב‪ Visual Basic-‬תוך שימוש‬
‫במגבלות התכנות הפרוצדורלי‬
‫‪ ‬נכתוב תוכנית המנהלת רשימה של ‪ 20‬עובדים ומאפשרת את הפונקציונליות הבאה‪:‬‬
‫‪ o‬הוספת רשומת עובד (עד ‪ 20‬עובדים‪ ,‬כאמור)‬
‫‪ o‬הדפסת פרטי העובדים‬
‫הגדרת סוג הנתונים‪:‬‬
‫‪ ‬בשלב הראשון נגדיר סוג נתונים חדש בשם ‪ Worker‬שיכיל את השדות ‪ Address ,Name ,ID‬ו‪Phone-‬‬
‫‪ ‬בשפת ‪ C‬היינו מגדירים זאת כך‪:‬‬
‫>‪#include <stddef.h‬‬
‫>‪#include <tchar.h‬‬
‫‪20‬‬
‫‪100‬‬
‫‪#define SIZE_NAME‬‬
‫‪#define SIZE_ADDRESS‬‬
Componentware Development ‫ מבוא לתכנות מבוסס רכיבים‬:1 ‫שיעור‬
#define SIZE_PHONE
20
typedef struct tagWorker
{
long ID;
TCHAR Name[SIZE_NAME];
TCHAR Address[SIZE_ADDRESS];
TCHAR Phone[SIZE_PHONE];
} Worker;
:‫ נוכל להשתמש בהגדרה הבאה‬Visual Basic-‫ב‬

Public Const SIZE_NAME As Integer = 20
Public Const SIZE_ADDRESS As Integer = 100
Public Const SIZE_PHONE As Integer = 20
Public Type Worker
ID As Long
Name As String * SIZE_NAME
Address As String * SIZE_ADDRESS
Phone As String * SIZE_PHONE
End Type
:‫ כתיבת פרוצדורות‬.1
Worker ‫ בשלב השני נרצה לכתוב פונקציה המזינה נתונים לרשומה מסוג‬
:‫ היינו כותבים זאת כך‬C ‫ בשפת‬
void SetWorkerData(Worker *pWorker, long id, _TCHAR *name,
_TCHAR *address, _TCHAR *phone)
{
pWorker->ID = id;
_tcsncpy(pWorker->Name, name, sizeof(pWorker->Name));
_tcsncpy(pWorker->Address, address, sizeof(pWorker->Address));
_tcsncpy(pWorker->Phone, phone, sizeof(pWorker->Phone));
}
:‫ ניתן לרשום רוטינה דומה באופן הבא‬Visual Basic-‫ב‬
Public Sub SetWorkerData(ByRef pWorker As Worker, _
ByVal nID As Long, _
ByRef strName As String, _
ByRef strAddress As String, _
ByRef strPhone As String)
pWorker.ID = nID
pWorker.Name = strName
pWorker.Address = strAddress
pWorker.Phone = strPhone
End Sub
www.kita.co.il
‫‪‬‬
‫‪‬‬
‫לבסוף נכתוב פונקציה המדפיסה את מערך העובדים‬
‫בשפת ‪ C‬אפשר לכתוב אותה באופן הבא‪:‬‬
‫‪void PrintWorkerData(FILE *out, Worker *pWorker,‬‬
‫)‪size_t nWorkers‬‬
‫{‬
‫;‪size_t i‬‬
‫)‪for(i = 0; i < nWorkers; i++‬‬
‫{‬
‫‪_ftprintf(out,‬‬
‫"‪_T("ID: %ld\n‬‬
‫"‪"Name: %s\n‬‬
‫"‪"Address: %s\n‬‬
‫‪"Phone: %s\n\n"),‬‬
‫‪(pWorker + i)->ID,‬‬
‫‪(pWorker + i)->Name,‬‬
‫‪(pWorker + i)->Address,‬‬
‫;)‪(pWorker + i)->Phone‬‬
‫}‬
‫}‬
‫‪‬‬
‫וב‪ Visual Basic-‬הרוטינה הבאה תהיה טובה מספיק‪:‬‬
‫_ ‪Public Sub PrintWorkerData(ByRef out As TextBox,‬‬
‫_ ‪ByRef pWorker() As Worker,‬‬
‫)‪ByVal nWorkers As Integer‬‬
‫‪Dim i As Integer‬‬
‫‪For i = 0 To nWorkers - 1‬‬
‫_ & ‪out.Text = out.Text‬‬
‫_ & ‪"ID: " & Str(pWorker(i).ID) & vbCrLf‬‬
‫_ & ‪"Name: " & pWorker(i).Name & vbCrLf‬‬
‫_ & ‪"Address: " & pWorker(i).Address & vbCrLf‬‬
‫‪"Phone: " & pWorker(i).Phone & vbCrLf & vbCrLf‬‬
‫‪Next‬‬
‫‪End Sub‬‬
‫‪ .1‬כתיבת תוכנית דוגמה‪:‬‬
‫‪ ‬ניתן להמשיך ולכתוב תוכנית המדגימה את השימוש בסוג הנתונים החדש‪ ,‬אך את זאת אני משאיר לך‬
‫כתרגיל‪ .‬בכל מקרה תוכל למצוא את תוכניות הדוגמה (ב‪ C-‬וב‪ )Visual Basic-‬בדיסק‪.‬‬
‫מסקנה‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫מעיון בקוד הדוגמה‪ ,‬קל להבחין שישנה הפרדה בין הפרוצדורות לבין הנתונים‬
‫כדי להפעיל פונקציה על משתנה מסוג ‪ Worker‬יש להעביר אותו כפרמטר לפונקציה‬
‫היה יותר נוח לו יכולנו לרשום‪:‬‬
‫)‪pWorker(i).SetData(....‬‬
‫בדיוק כפי שאנו רושמים כשאנחנו קוראים למשל למתודה ‪ Show‬של ‪ ,Form‬אך זה כבר עניין ל‪OOP-‬‬
‫שיעור ‪ :1‬מבוא לתכנות מבוסס רכיבים ‪Componentware Development‬‬
‫‪Object Oriented Programming‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫בתכנות מונחה עצמים מגדירים סוגי נתונים חדשים באמצעות ‪( Class‬מחלקה) ולא באמצעות ‪( Type‬או ‪Struct‬‬
‫בשפת ‪)C‬‬
‫במחלקות אורזים יחד משתנים ופרוצדורות‪ .‬באופן כזה יוצרים יחידה לוגית אחת הכוללת משתנים ומתודות‬
‫הפועלות על המשתנים הללו‬
‫משתנים של מחלקה קרויים ‪ ,member variables‬ומתודות של מחלקה קרויות ‪member methods‬‬
‫אובייקטים הם מופעים (‪ )Instances‬של מחלקות‪ .‬כלומר משתנים המוצהרים בתוכנית מסוג מחלקה מסוימת הנם‬
‫אובייקטים של המחלקה‬
‫כאשר יש להפעיל מתודה של אובייקט‪ ,‬אין צורך להעביר את האובייקט למתודה (כפי שראינו בדוגמה הקודמת)‪.‬‬
‫המתודה היא חלק פנימי של האובייקט כך שהפעלת המתודה נעשית באמצעות האובייקט עצמו‬
‫בתכנות מונחה עצמים קיימים שלושה רעיונות מרכזיים‪:‬‬
‫‪( Encapsulation o‬כמיסה)‬
‫‪( Inheritance o‬הורשה)‬
‫‪( Polymorphism o‬רב צורתיות)‬
‫‪( Encapsulation‬כמיסה)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫כמיסה היא היכולת של מחלקה להסתיר ‪ members‬מסוימים‪ ,‬ולחשוף אחרים‬
‫ה‪ members-‬החשופים של מחלקה קרויים ה‪( Interface-‬ממשק) של המחלקה‬
‫רעיון הכמיסה הנו רעיון מרכזי ב‪ OOP-‬כיוון שבעזרת כמיסה ניתן למנוע מקוד לא מורשה לגשת ל‪members-‬‬
‫פרטיים באובייקט‪ .‬כך לדוגמה‪ ,‬לא תרצה שיוזן מספר זיהוי שאינו חוקי ל‪ member-‬של אובייקט המאחסן מספר‬
‫תעודת זיהוי‪ .‬כיוון שכך‪ ,‬מומלץ להפוך את כל ה‪ member variables-‬של מחלקה לפרטיים (עד כמה שהדבר ניתן)‪,‬‬
‫ובמקביל‪ ,‬לאפשר גישה אליהם באמצעות ‪ member methods‬שייכתבו כך שלא יפרו את כללי הארגון (אלא אם‬
‫אתה חתרן בלתי נלאה)‬
‫מחלקה המעונינת להסתיר ‪ members‬אך במקביל לאפשר גישה ל‪ members-‬הללו למחלקות ספציפיות תוכלנה‬
‫לעשות זאת על ידי הגדרת המחלקות הללו כ‪( Friends-‬כך נעשה הדבר בשפת ‪)C++‬‬
‫ב‪ Visual Basic-‬הרעיון בבסיסו דומה‪ ,‬אך קיים שוני מסוים‪ :‬ב‪ Visual Basic-‬הגדרת ‪ members‬כ‪Fiends-‬‬
‫הופכת אותם לציבוריים עבור כל הקוד שבפרוייקט (מחלקות ומודולים רגילים) ‪ ,‬אך לא נגישים לקוד מפרוייקטים‬
‫אחרים‬
‫‪ Friends‬פוגעים ברעיון הכמיסה‪ ,‬ולפיכך מומלץ שלא להשתמש בהם אלא במקרים מיוחדים מאוד‬
‫‪( Inheritance‬הורשה)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫הורשה היא היכולת של מחלקה לרשת תכונות ממחלקה אחרת‬
‫המחלקה היורשת קרויה מחלקה נגזרת (‪ ,)Subclass‬והמחלקה המורישה קרויה מחלקת בסיס (‪)Superclass‬‬
‫הורשה מתבטאת בשני היבטים‪:‬‬
‫‪ o‬הורשת ממשק‬
‫‪ o‬הורשת מימוש‬
‫הורשת ממשק מתבטאת בהורשת שמות המאפיינים והמתודות ממחלקת הבסיס למחלקה הנגזרת‬
‫הורשת מימוש מתבטאת שהורשת מימוש המתודות והמאפיינים ממחלקת הבסיס למחלקה הנגזרת‬
‫הורשה הנה המפתח לשימוש חוזר בקוד – שפות מונחות עצמים מחויבות לתמוך שהורשה (ממשק ומימוש)‬
‫השימוש בהורשה צריך להתבצע בעת זיהוי יחסי אב‪-‬בן בין מחלקות‪ .‬ניתן להיעזר בתבנית ‪ ClassX‬הוא סוג של‬
‫‪ ClassY‬כדי לזהות יחסי הורשה‪ ,‬כאשר ‪ ClassX‬היא המחלקה הנגזרת ו‪ ClassY-‬היא מחלקת הבסיס‪ .‬לדוגמה‪:‬‬
‫‪ o‬דוגמה נכונה‪ :‬מלבן הוא צורה‬
‫‪ o‬דוגמה נכונה‪ :‬מנהל הוא סוג של עובד‬
‫‪ o‬דוגמה לא נכונה‪ :‬מכונית היא ארבע דלתות‪ ,‬מנוע‪ ,‬שלדה‪...‬‬
‫נכון להגיד‪ :‬מכונית מכילה ארבע דלתות‪ ,‬מנוע‪ ,‬שלדה‪...‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫צריך להיזהר שלא ליפול למלכודת הטמונה בבלבול שבין יחסי הורשה (‪ )Inheritance‬לבין יחסי‬
‫הכלה (‪)Containment‬‬
‫‪( Multiple Inheritance‬הורשה מרובה) היא היכולת לרשת ממספר מחלקות בו זמנית‬
‫שפות מונחות עצמים תומכות בהורשה מרובה במידה כזו או אחרת‪ C++ .‬למשל מאפשר הורשה מרובה מלאה‪,‬‬
‫‪ Java‬מאפשרת הורשה מלאה ממחלקה אחת והורשה של ממשקים נוספים‪ Visual Basic .‬מאפשרת מימוש‬
‫ממשקים בלבד (חיה מוזרה שדומה להורשת ממשקים)‬
‫דוגמאות להורשה מרובה‪:‬‬
‫‪ o‬דוגמה נכונה‪ :‬רכב אמפיבי הוא רכב יבשתי וגם רכב ימי‬
‫‪ o‬דוגמה לא נכונה‪ ComboBox :‬הוא גם ‪ TextBox‬והוא גם ‪ListBox‬‬
‫נכון יהיה להגיד‪ ComboBox :‬מכיל בתוכו ‪ TextBox‬ו‪ListBox-‬‬
‫‪( Ploymorphism‬רב צורתיות)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ Polymorphism‬הוא היכולת של אובייקט ללבוש צורות שונות‪ ,‬או במילים אחרות לתפעל את אותו ‪member‬‬
‫באופנים שונים‬
‫‪ Polymorphism‬נובע מהשימוש בהורשה‬
‫קל יותר להבין מהו ‪ Polymorphism‬באמצעות דוגמה‪:‬‬
‫נניח שברצוננו ליצור תוכנית גרפית פשוטה המאפשרת ציור של שלוש צורות‪( Line :‬קו)‪( Rectangle ,‬מלבן)‬
‫ו‪( Ellipse-‬אליפסה)‪ .‬ברור שנרצה לאחסן את הצורות באמצעות מבנה נתונים מסוים‪ .‬הבעיה הראשונה שתתעורר‬
‫היא שלא נוכל להשתמש במבנה נתונים הכולל מצביעים מסוג ‪-Line‬ים‪ ,‬למשל‪ ,‬לאחסון ‪-Rectangle‬ים או‬
‫‪-Ellipse‬ות‪ .‬כדי לפתור בעיה זו נגדיר את כל המחלקות הללו כנגזרות של מחלקה מופשטת בשם ‪ .Shape‬היררכית‬
‫המחלקות תיראה‪ ,‬אם כן‪ ,‬כמו בציור הבא (כאשר החץ משמעותו "יורש מ‪:)"...‬‬
‫‪Shape‬‬
‫‪Ellipse‬‬
‫‪Rectangle‬‬
‫‪Line‬‬
‫את הבעיה הראשונה פתרנו‪ ,‬כיוון שבשפות מונחות עצמים מצביע למחלקת בסיס (במקרה זה ‪ )Shape‬יכול להצביע‬
‫לסוגים נגזרים (במקרה זה ‪ Rectangle ,Line‬ו‪ .)Ellipse-‬כלומר סוג המצביע במבנה הנתונים יהיה מסוג ‪.Shape‬‬
‫הבעיה השניה שמתעוררת היא‪ ,‬כיצד נבצע סריקה על כל האובייקטים במבנה הנתונים לצורך ביצוע פעולה כלשהי‬
‫(למשל ציור על המסך)‪ ,‬הבעיה נובעת מכך שבפועל כל תא במבנה מצביע לסוג נתונים לא ידוע (‪Rectangle ,Line‬‬
‫או ‪ .)Ellipse‬בעיה זו אינה בעיה כלל ועיקר‪ ,‬כיוון שנוכל להשתמש במצביע מחלקת בסיס כדי לבצע סריקה במבנה‬
‫הנתונים ובאמצעות מצביע זה נפעיל את המתודה הרצויה‪ .‬השאלה הנשאלת כעת היא איזו מתודה בדיוק תופעל‪,‬‬
‫האם זו של המחלקה ‪ Shape‬ממנה מוגדרים המצביעים במבנה הנתונים‪ ,‬או אולי המתודה של האובייקט המוצבע‬
‫בפועל‪ ,‬כאשר זה יכול להיות שונה בין תא לתא במבנה הנתונים‪ .‬התשובה היא שתופעל המתודה של סוג הנתונים‬
‫המוצבע בפועל ולא המתודה של סוג המצביע‪ .‬זהו ‪ Polymorphism‬במיטבו‪.‬‬
‫כדי להשלים את התמונה‪ ,‬ובכדי להפוך את העניין למוחשי יותר‪ ,‬נגדיר מתודות המשותפות לכל הצורות כחלק‬
‫מהממשק של ‪ .Shape‬מתודות לדוגמה יהיו ‪ .Move ,Paint‬מתודות אלו עוברות בירושה לכל אחת מהמחלקות‬
‫הנגזרות (כלומר ‪ Rectangle ,Line‬ו‪ )Ellipse-‬ומקבלות בכל מחלקה משמעות שונה‪ .‬כך למשל‪ Paint ,‬עבור ‪Line‬‬
‫פירושו שימוש בפונקציות מערכת היודעות לצייר קווים על גבי המסך‪ Paint .‬עבור ‪ Rectangle‬ימומש באמצעות‬
‫קריאה לפונקציה מערכת המתמחה בציור מלבנים‪ .‬היררכית המחלקות אם כן תיראה כך‪:‬‬
‫‪Shape‬‬
‫)(‪Paint‬‬
‫)(‪Move‬‬
‫‪...‬‬
‫‪Ellipse‬‬
‫)(‪Paint‬‬
‫{‬
‫)(‪Paint‬‬
‫{‬
‫מימוש המתאים לציור מלבן‬
‫מימוש המתאים לציור אליפסה‬
‫}‬
‫)(‪Move‬‬
‫{‬
‫מימוש המתאים להזזת אליפסה‬
‫‪Line‬‬
‫)(‪Paint‬‬
‫{‬
‫מימוש המתאים לציור קו‬
‫}‬
‫)(‪Move‬‬
‫{‬
‫מימוש המתאים להזזת מלבן‬
‫{‬
‫‪...‬‬
‫}‬
‫)(‪Move‬‬
‫{‬
‫מימוש המתאים להזזת לקו‬
‫{‬
‫‪...‬‬
‫{‬
‫‪...‬‬
‫כעת נניח שברשותנו מערך של ‪-Shape‬ים שכל תא בו מצביע על צורה מסוג כלשהו‪:‬‬
‫‪Shape‬‬
‫‪Line‬‬
‫]‪[0‬‬
‫]‪[1‬‬
‫‪Line‬‬
‫]‪[2‬‬
‫‪Ellipse‬‬
‫]‪[3‬‬
‫]‪[4‬‬
‫‪Ellipse‬‬
‫]‪[5‬‬
‫כעת נוכל להצהיר על משתנה מסוג ‪ Shape‬ולבצע סריקה על המערך‪ .‬מתוך המצביע הזה נפיל את המתודה ‪.Print‬‬
‫מה שיופעל למעשה אלו הן המתודות של האובייקטים המוצבעים‪ ,‬ובאופן יותר ספציפי עבור האיבר עם האינדקס‬
‫]‪ ,[0‬תופעל המתודה ‪ Paint‬של ‪ ,Line‬עבור האיבר עם האינדקס ]‪ [1‬תופעל המתודה ‪ Print‬של ‪ ,Rectangle‬וכן‬
‫הלאה‪.‬‬
‫‪( EVENT ORIENTED PROGRAMMING‬תכנות מונחה אירועים)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫בתוכנות מונחה אירועים זרימת התוכנית מונחית על פי האירועים המתרחשים‬
‫ב‪ Visual Basic-‬למשל‪ ,‬מוכרים לך האירועים ‪ Click,MouseDown‬וכו'‪ .‬קוד הנכתב הפרוצדורות האירועים הללו‬
‫יופעל בתגובה לאירועי המשתמש‪.‬‬
‫לכל אירוע יש שני צדדים‪ :‬הצד המעורר את האירוע והצד המגיב לאירוע‪ .‬לדוגמה האירוע ‪ MouseMove‬צדו‬
‫האחד היא מערכת ההפעלה היוזמת את האירוע בתגובה לתזוזת כבר מצד המשתמש‪ ,‬והצד השני היא התוכנית‬
‫שלך המגיבה לאירוע‪.‬‬
‫אירועים אינם קשורים בהכרח לפעולות משתמש‪ ,‬למשל האירוע ‪ DataArrival‬של פקד ‪ Winsock‬מתרחש בכל‬
‫פעם שמידע מגיע למחשב המקומי ממחשב אחר ברשת‬
‫‪)COM( COMPONENT OBJECT MODEL‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ COM‬מאפשר להתמודד טוב יותר עם הבעיות והאתגרים הבאים‪:‬‬
‫‪ o‬פיתוח תוכניות מודולריות ברמה הבינרית‪:‬‬
‫כתיבת רכיבי קוד בשפות שונות מעלה בעיות של תאימות בינרית בין רכיבי הקוד‬
‫לעתים יש רצון וצורך לשפר פונקציונליות של תוכנה מסוימת‪ .‬פעולה מהסוג הזה כרוכה בדרך כלל‬
‫בהחלפת התוכנה כולה‪ .‬לצורך ההדגמה‪ ,‬נניח שברשותך מעבד תמלילים מדהים שבדיקת האיות שלו‬
‫זוועתית‪ .‬היה נחמד לו יכולת לרכוש רכיב בדיקת איות מחברה צד ג' ולשלב אותו כחלק אינטגרלי של‬
‫מעבד התמלילים‪.‬‬
‫‪ o‬שימוש חוזר ברכיבים ותאימות גרסאות רכיבים‪:‬‬
‫יישומי תוכנה בסדר גודל בינוני ומעלה הופכים קשים לפיתוח ולתחזוק‪ .‬לעתים תכופות מוצאים עצמם‬
‫מתכנתים משתמשים בפונקציונליות שפותחה זה מכבר עבור תוכנה אחרת‪ .‬הבעיה העיקרית היא‪ ,‬שמאוד‬
‫מסוכן לשנות מחלקות‪ ,‬או להוסיף פונקציונליות למחלקות בשל פגיעה לא צפויה במחלקות אחרות‬
‫הנגזרות או משתמשות במחלקה הספציפית‪.‬‬
‫‪ o‬שקיפות בהפעלת רכיב שרת ללא קשר למיקומו ביחס לרכיב הלקוח‪:‬‬
‫רכיבים הפועלים מול רכיבים אחרים‪ ,‬מושפעים ממיקום הרכיב ביחס אליהם‪ ,‬כלומר‪ ,‬האם הרכיב מצוי‬
‫באותו מרחב כתובות (אותו ‪ ,)Process‬או במרחב כתובות שונה באותו מחשב (‪ Process‬שונה באותו‬
‫מחשב)‪ ,‬או אולי במחשב אחר ברחבי הרשת‪ .‬ברור שפניה לרכיב המצוי במחשב אחר ברחבי הרשת שונה‬
‫בתכלית מפניה לרכיב המצוי תחת אותו מרחב כתובות‪ ,‬שכן פניה לרכיב ברשת כרוכה בהעברת מסרים‬
‫בפרוטוקולים שונים ומשונים וכו'‪ .‬היית מאושר לו יכולת להפעיל רכיב מרוחק בדיוק באותו האופן בו‬
‫אתה מפעיל רכיב מקומי וכל משימת ההתקשרות דרך הרשת‪ ,‬או חציית מרחבי כתובות הייתה נופלת על‬
‫כתפי מישהו אחר (ביל גייטס‪ ,‬למשל)‪.‬‬
‫‪ COM‬מגדיר תקנים לפיתוח רכיבים‪ :‬באמצעות ממשקים סטנדרטיים שרכיבי ‪ COM‬אמורים לתמוך בהם‪ .‬אפשר‬
‫להגיד ש‪ COM-‬הוא הדבק שבין רכיבים‬
‫כתיבת רכיבים בהתאם ל ספציפיקצית ‪ COM‬מאפשרת שימוש חוזר ברמה בינרית‪ ,‬ללא תלות בשפות שבהם‬
‫נכתבו הרכיבים‪ .‬היתרון הנובע מכך הוא שניתן לפתח רכיב בשפה מסוימת המתאימה ביותר לפיתוח אותו רכיב‬
‫ואז אפשר יהיה להשתמש בו בשפות שונות‬
‫התמיכה הקיימת במערכת ההפעלה עבור ‪ COM‬מאפשרת לבצע את ההתחברות בין רכיבים‪ .‬כדי להבהיר את‬
‫העניין המעורפל הזה אשתמש באנלוגיה ובסוגריים ארשום את ההקבלה‪:‬‬
‫נניח שישנם שלושה אנשים איש א' (רכיב א)‪ ,‬איש קשר (מערכת ‪ COM‬הבנויה כחלק אינטגרלי ממערכת ההפעלה)‬
‫ואיש ב' (רכיב ב)‪ .‬בין איש א'(רכיב א') לאיש ב' (רכיב ב') נמצא קיר‪ ,‬כך שאף אחד מהם לא יודע האם השני קיים‬
‫או לא‪ .‬כדי לברר זאת שואל איש א' (רכיב א') את איש הקשר (מערכת ‪ )COM‬האם איש ב' (רכיב ב') נמצא והאם‬
‫הוא יודע לדבר בשפה שלנו (‪ )COM‬התשובה תהיה חיובית (נניח שהיא חיובית) ובשלב זה יקשר איש הקשר‬
‫(מערכת ‪ )COM‬בין איש א' (רכיב א') לאיש ב' (רכיב ב') ויעזוב אותם לנפשם‪ .‬מכאן והלאה איש א' (רכיב א') ואיש‬
‫ב' (רכיב ב') ידברו בניהם – ימצאו או לא ימצאו עניין משותף (‪ )Interface‬זהו עניינם‪.‬‬
‫רכיב מאפר גישה אליו על ידי חשיפת ממשק (‪ )Interface‬שדרכו יוכלו לקוחות להתחבר אליו‪ .‬נניח למשל שאתה‬
‫מעוניין לפתח רכיב לביצוע חישובים מתמטיים מסובכים‪ ,‬וודאי תחשוף ממשק המאפשר ביצוע חישובים‬
‫סטטיסטיים (יתכן שתקרה לו ‪)IStatistics‬‬
‫לקוחות של רכיבים מפרסמים בדרך כלל את הממשק לו הם מצפים בבואם להתקשר עם רכיב ‪ ,COM‬פרסום זה‬
‫מטרתו היא לאפשר פיתוח רכיבים מתמחים על‪-‬ידי חברות שונות ובכך לאפשר תחרות "הרכיב הטוב ביותר"‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ COM‬אוסר על מפתחי רכיבים לשנות ממשק שכבר פורסם והופץ למשתמשים‪ .‬שינוי מסוג עלול לגרום לקריסתם‬
‫של תוכניות לקוח שהשתמשו ברכיב בגרסאותיו הקודמות‪ .‬אם הממשק שיצרת דורש שינוי ושיפור‪ ,‬פשוט צור‬
‫ממשק חדש שיכיל את הפונקציונליות הנדרשת‪ ,‬והשאר את הממשק הקודם ללא שינוי‪ .‬שים לב שלא אמרתי‬
‫שאינך יכול לשנות את המימוש הפנימי של הרכיבים‪ ,‬תוכל לעשות זאת כל אימת שתחפוץ בכך‪ ,‬על כל פנים זכור‬
‫שהרכיבים שלך מתקשרים באמצעות הממשקים שיצרת עבורם לכן היזהר לפני ביצוע שינויים כלשהם‪.‬‬
‫רכבי ‪ COM‬יש משלושה סוגים עיקריים‪:‬‬
‫‪( In Process o‬תוך תהליכי) – רכיב ‪ COM‬הפועל החלק מתוכנית הלקוח (בתוך מרחב כתובות הזכרון של‬
‫תוכנית הלקוח)‬
‫‪( Out of Process o‬חוץ תהליכי) – רכיב המופעל כתוכנית נפרדת‪ ,‬וכתוצאה מכך מוקצים עבורו מרחב‬
‫כתובות נפרד‪.‬‬
‫‪( Remote o‬מרוחק) – זהו רכיב ‪ COM‬הממוקם במחשב אחר ברחבי הרשת‬
‫‪ COM‬משתדל להסתיר ממך את פרטי ההתקשרות עם הרכיב‪ ,‬כך שפנייה לרכיב ברחבי הרשת תהיה זהה לפנייה‬
‫לרכיב תוך תהליכי‬
‫‪ )DCOM( Distributed COM‬היא טכנולוגיה המאפשרת הפעלת רכיבים מרוחקים ברחבי הרשת‪ ,‬תוך הסתרת‬
‫פרטי‬
‫‪ ActiveX‬זהי טכנולוגיה המבוססת על ‪COM‬‬
‫התמיכה של‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ VISUAL BASIC‬ב‪ OOP-‬ו‪COM-‬‬
‫‪ Visual Basic‬תומכת ב‪ Encapsulation-‬וב‪Polymorphism-‬‬
‫‪ ,Visual Basic‬למרבה הצער‪ ,‬איננה תומכת בהורשה‬
‫‪ Visual Basic‬תומכת בהורשת ממשקים (יותר מדויק להגיד‪ :‬מימוש ממשקים‪ ,‬אך נושא זה יידון בפירוט בשיעור‬
‫הבא)‬
‫כיוון ש‪ Visual Basic-‬אינה תומכת בהורשה‪ ,‬לא יהיה נכון לקרוא לה שפה מונחית עצמים טהורה‬
‫‪ Visual Basic‬תומכת בתכנות מונחה אירועים‪ .‬כלומר תוכל להגיב לאירועים‪ ,‬כמו גם לכתוב אירועים משלך‬
‫לרכיבים חדשים שאתה מפתח‬
‫רכיבי ‪ ActiveX‬של ‪Visual Basic‬‬
‫ב‪ Visual Basic-‬תוכל ליצור רכיבי ‪ ActiveX‬מהסוגים הבאים‪:‬‬
‫‪ – ActiveX DLL o‬רכיב קוד היכול להכיל גם אלמנטים של ממשק‬
‫‪ – ActiveX EXE o‬תוכניות המאפשרות התקשרות אליהם באמצעות ‪COM‬‬
‫‪ – ActiveX Controls o‬פקדים חדשים הנוצרים ומותאמים על‪-‬ידי המשתמש‬
‫ב‪ Visual Basic-‬יצירת הממשקים בהם תומך הרכיב נעשית באופן אוטומטי‪ .‬עם זאת‪ ,‬תוכל ליצור ממשקים‬
‫ריקים (ללא מימוש) באמצעות ‪ )Interface Definition Language( IDL‬ולממש אותם בשפות שונות‬
‫‪ Visual Basic‬מקילה באופן דרמטי את קלות פיתוח הרכיבים‪ .‬בשפות אחרות (‪ C++‬למשל‪ ,‬שלא לדבר על ‪ C‬ששם‬
‫לא תמצא את הידיים ואת הרגליים) תמצא את עצמך מתעסק עם ממשקים לסידור נתונים לפני שליחה ‪,IMarshal‬‬
‫רישום רכיבים לקבלת הודעות (‪ ,)IConnectionPointContainters‬שלא לדבר על ‪MTA Model ,STA Model‬‬
‫‪ Single Apartment Model‬ששם הבלבול הופך לצל שלך‪.‬‬
‫תשמח לשמוע שרכיבים שאתה מפתח ב‪ Visual Basic-‬נגישים מסביבות אחרות התומכות ב‪( ActiveX-‬למשל‬
‫‪)MFC‬‬
‫שיעור ‪ : 1‬תכנות מונחה עצמים ב ‪Visual Basic-‬‬
‫‪ ‬תלמד כיצד ליצור מחלקות ב‪Visual Basic-‬‬
‫‪ ‬תלמד להוסיף‪ ,‬פרוצדורות מכל הסוגים (‪ Properties ,Functions ,Sub‬ו‪ )Events-‬למחלקות‬
‫‪ ‬תלמד מהו ‪( Interface‬ממשק) וכיצד ניתן לממש ‪-Interface‬ים ב‪Visual Basic-‬‬
‫‪ ‬תלמד את הצורות השונות בהן ניתן להשתמש באובייקטים בתוכנית‬
‫‪ ‬תבין מהו ‪Reference Counting‬‬
‫‪ ‬תבין את ההבדל בין ‪ Early Binding‬ל‪Late Binding-‬‬
‫‪ ‬תלמד מהו ‪( Collection‬אוסף)‪ ,‬כיצד תוכל ליצור ‪-Collection‬ים משלך וכיצד לסרוק ‪Collection‬‬
‫‪( CLASSES‬מחלקות)‬
‫‪‬‬
‫ליצירת מחלקות ב‪ Visual Basic-‬יש להשתמש ב‪Class Module-‬‬
‫‪ Properties‬של ‪Class Modul e‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ :Name‬מגדיר את שם המחלקה‬
‫‪ :DataBindingBehavior‬קובע האם האובייקט יכול להיכרך סביב נתונים (נושא זה נדון בהמשך הקורס)‬
‫‪ :DataSourceBehavior‬קובע האם האובייקט יכול לשמש כמקור נתונים (גם נושא זה נדון בהמשך הקורס)‬
‫‪ Events‬של ‪Class Module‬‬
‫‪‬‬
‫‪‬‬
‫‪ :Initialize‬מתעורר בכל פעם שנוצר אובייקט חדש מסוג ה‪ Class-‬שלך‬
‫‪ :Terminate‬מתעורר בכל פעם באובייקט מסוג ה‪ Class-‬שלך משתחרר מהזיכרון‬
‫הגדרת משתנים ב ‪Class -‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫ניתן להגדיר משתנים בתוך ‪ Class Module‬בדיוק כפי שמצהירים עליהם במודול רגיל‬
‫הרשאות הגישה האפשריות עבור הצהרת משתנים‪:‬‬
‫‪ :Private o‬משתנה פרטי‬
‫‪ :Public o‬מתשתנה ציבורי‬
‫ברירת המחדל היא ‪ ,Private‬כלומר הצהרה באמצעות ‪ Dim‬זהה להצהרה באמצעות ‪Private‬‬
‫מומלץ להסתיר את המשתנים באמצעות המילה ‪ Private‬ולאפשר גישה אליהם באמצעות ‪ Properties‬מתאימים‬
‫בלבד‪ .‬באופן כזה אתה שומר על עקרון ה‪ Encapsulation-‬בתכנות מונחה עצמים‬
‫הוספת פרוצדורות ל ‪Class -‬‬
‫‪‬‬
‫‪‬‬
‫הרשאות הגישה האפשריות עבור פרוצדורות של ‪ Class‬הן‪:‬‬
‫‪ :Private o‬הפרוצדורה היא לשימוש פנימי בלבד של ה‪Class-‬‬
‫‪ :Public o‬הפרוצדורה נגישה מקוד חיצוני‬
‫‪ :Friend o‬הפרוצדורה נגישה מקוד חיצוני בתנאי שמדובר באותו פרוייקט‪ .‬עבור תוכניות לקוח מפרויקטים‬
‫אחרים‪ ,‬פרוצדורת ‪ Friend‬תהיה בדיוק כמו ‪Private‬‬
‫בשיעור הבא תיצור ספריות רכיבים הניתנות לשימוש מתוכניות חיצוניות‬
‫שיעור ‪ :1‬תכנות מונחה עצמים ב‪Visual Basic-‬‬
‫‪( Properties‬מאפיינים)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ Properties‬של ‪ Class‬הם פרוצדורות שמטרתן לאתחל משתנים בתוך ה‪Class-‬‬
‫היתרון בשימוש במאפיינים ‪ Properties‬הוא בכך שניתן לאתחל משתנים באמצעות הסימן = (שווה) ולהפוך בכך‬
‫את הקוד לקראי יותר‬
‫‪ Properties‬באים בשלוש צורות‪:‬‬
‫‪ :Property Let o‬מאפשר העברת ערכים ל‪ Class-‬לשם ביצוע פעולות אתחול למשתנים מסוגים בסיסיים‬
‫‪ :Property Set o‬מאפשר העברת אובייקטים ל‪ Class-‬לשם ביצוע פעולות אתחול לאובייקטים פנימיים‬
‫‪ :Property Get o‬מאפשר לאחזר ערך מהמחלקה (כלומר לבצע השמה מהמחלקה למשתנה הנמצא בחוץ)‬
‫בדוגמאות שבהמשך תראה את השימוש ב‪Properties-‬‬
‫‪( Sub‬רוטינות) ו‪( Functions-‬פונקציות)‬
‫‪‬‬
‫ניתן להוסיף ל‪ Class-‬רוטינות ופונקציות בדיוק כפי שהיית מוסיף למודולי הקוד שהכרת עד כה‬
‫‪( Events‬אירועים)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫בדיוק כפי שקיימים ‪ Events‬ל‪ Labels ,CommandButton-‬ואובייקטים וויזואליים (וגם לא וויזואליים)‪ ,‬תוכל גם‬
‫אתה להוסיף ‪ Events‬ל‪ Class-‬שאתה יוצר‬
‫כדי להוסיף ‪ Event‬יש להצהיר עליו בחלק ב‪ General-‬של הקוד‪ ,‬כולל הפרמטרים שה‪ Event-‬מקבל‬
‫כדי לעורר (‪ Event )To Fire‬יש להשתמש במילה ‪RaiseEvent‬‬
‫תוכל להעביר פרמטרים ‪ ByRef‬ולהשתמש בערך שלהם לאחר שהמשתמש ב‪ Class-‬שלך סיים את הטיפול בהם‪,‬‬
‫ובכך לאפשר למשתמש במחלקה להעביר מידע ל‪ Class‬שלך אודות האופן שבו הוא רוצה שה‪ Class-‬שלך יתנהג‬
‫(בדוגמאות שבהמשך עניין זה יובהר)‬
‫הצהרה על אובי יקטים מסוג המחלקה‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫כדי להבחין בין משתנים מסוגים בסיסיים לבין משתנים מסוגים של מחלקות משתמשים במילה אובייקט כדי‬
‫לתאר מופע (‪ )Instance‬של מחלקה‬
‫כדי ליצור אובייקטים יש להשתמש במילה ‪New‬‬
‫כדי לשחרר אובייקט מהזיכרון (יותר מדויק יהיה להגיד להפחית את ה‪ Reference Counting‬שלו‪ ,‬אך נדון בכך‬
‫בהמשך) משתמשים במילה ‪Nothing‬‬
‫ביצוע פעולות של השמת אובייקט מתבצעות באמצעות המילה ‪Set‬‬
‫עליך להבחין בין האובייקט עצמו (הנמצא בזיכרון) לבין המשתנה באמצעותו אתה ניגש לאובייקט‪ .‬משתנה זה‬
‫מאפשר לך להתייחס (‪ )Reference‬לאובייקט‬
‫אם לאובייקט מסוים יש אירועים ניתן להצהיר עליו תוך שימוש במילה ‪ WithEvents‬כדי להפוך את האירועים‬
‫שלו לזמינים עבור הלקוח (עניין זה יובהר בדוגמאות שבהמשך)‬
‫‪Dim prs As New CPerson‬‬
‫‪‬‬
‫בדוגמה זו הוצהר משתנה ייחוס בשם ‪ prs‬מהמחלקה ‪ CPerson‬ואותחל באובייקט חדש בזכרות באמצעות המילה‬
‫‪New‬‬
‫‪Dim prs As CPerson‬‬
‫‪Set prs = New CPerson‬‬
‫‪‬‬
‫שתי שורות קוד אלו זהות להצהרה בדוגמה הקודמת‬
‫‪‬‬
‫קיימים הבדלים מהותיים באופן ההתנהגות של אובייקט המוצהר כמו בדוגמה ‪ 1‬לבין אובייקט המוצהר כמו‬
‫בדוגמה ‪ ,1‬כפי שמפורט להלן‪:‬‬
‫‪ o‬אובייקט המוצהר כמו בדוגמה ‪ ,1‬אינו נוצר בפועל אלא רק כאשר אתה ניגש למאפיין או פונקציה שלו‪.‬‬
‫אובייקט המוצהר כמו בדוגמה ‪ 2‬נוצר בעת הקריאה ל‪New-‬‬
‫‪ o‬אובייקט המוצהר כמו בדוגמה ‪ 1‬הוא אובייקט בטוח יותר‪ ,‬כיוון שמובטח לך שאם תשחרר את‬
‫האובייקט מהזיכרון באמצעות ‪( Nothing‬כפי שתראה בהמשך) ותנסה לגשת אליו שוב מבלי לקרוא ל‪-‬‬
‫‪ New‬שוב‪ Visual Basic ,‬תיצור את האובייקט עבורך‪ .‬כך אתה נמנע משגיאות‪ .‬לעומת זאת‪ ,‬אם המהרת‬
‫על אובייקט כמו בדוגמה ‪ 2‬ולא יצרת אותו בפועל באמצעות המילה ‪ New‬או ששחררת אותו‪ ,‬ותנסה‬
‫לגשת אליו תקבל ‪Runtime Error‬‬
‫‪ o‬מההבדל הקודם נובע כי אובייקט המוצהר כמו בדוגמה ‪ 1‬ירוץ לאט יותר כיוון ש‪ Visual Basic-‬מוודאת‬
‫עבורך שהאובייקט קיים בכל פעם שאתה מנסה לגשת לפרוצדורה של האובייקט‬
‫‪Dim WithEvents obj as CCalendar‬‬
‫‪‬‬
‫‪‬‬
‫בדוגמה זו מוצהר אובייקט מסוג ‪ .CCalendar‬האירועים שהמחלקה ‪ CCalendar‬חושפת יהיו זמינים עבור יישום‬
‫הלקוח‬
‫לא ניתן להשתמש במילה ‪ WithEvents‬יחד עם המילה ‪ New‬בהצהרה‪ .‬כלומר‪ ,‬המילה ‪ WithEvents‬זמינה רק‬
‫עבור הצהרות כמו בדוגמה ‪1‬‬
‫‪Dim rc1 As CRect, rc2 As CRect‬‬
‫‪Set rc1 = New CRect‬‬
‫‪Set rc2 = rc1‬‬
‫‪‬‬
‫בדוגמה זו הוצהרו שני משתני ייחוס מסוג ‪ .CRect‬הראשון שבהם אותחל לאובייקט חדש מסוג ‪ ,CRect‬ואילו‬
‫השני אותחל כך שיתייחס לאותו אובייקט ‪ CRect‬ש‪ rc1-‬מתייחס אליו‬
‫‪Set prs = Nothing‬‬
‫‪‬‬
‫פעולה זו מטרתה לשחרר את האובייקט ש‪ prs-‬מתייחס אליו מהזיכרון (בסעיף הבא תראה שאין זה מדויק)‬
‫‪( Reference Counting‬ספירת התיי חסו יות)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫כל ה‪-Class-‬ים של ‪ Visual Basic‬הם למעשי אובייקטים של ‪COM‬‬
‫לכל אובייקט ‪ COM‬יש משתנה פנימי הסופר את מספר ההתייחסויות (‪ )Reference Count‬אליו‪ .‬בכל עת‬
‫שמשתנה ייחוס נוסף מצביע לאובייקט‪ ,‬מונה זה גדל ב‪ ,1-‬ואילו כאשר משתנה מפסיק להתייחס לאובייקט (על ידי‬
‫קריאה ל‪ )Set...Nothing-‬מונה ההתייחסויות קטן ב‪1-‬‬
‫אובייקט משתחרר מהזיכרון ברגע שה‪ Reference Count-‬שלו מגיע ל‪0-‬‬
‫ב‪ COM-‬כל אובייקט ממש את ה‪ Interface-‬ששמו ‪ .IUnknown‬זהו הממשק הבסיסי ביותר ב‪COM-‬‬
‫‪ IUnknown‬כולל שלוש מתודות‪:‬‬
‫‪ – QueryInterface o‬מתודה זו מאפשרת קבלת מצביע ל‪ Interface-‬שהאובייקט ממש‬
‫‪ – AddRef o‬מתודה זו גורמת ל‪ Reference Count-‬לגדול ב‪( 1-‬מתודה זו נקראת אוטומטית עבורך כאשר‬
‫אתה מבצע השמה למשתנה ייחוס)‬
‫‪ – Release o‬מתודה זו מפחיתה את ה‪ Reference Count-‬ב‪( 1-‬מתודה זו נקראת עבורך אוטומטית כאשר‬
‫אתה מבטל התייחסות של משתנה לאובייקט מסוים)‬
‫‪Dim rc1 As CRect, rc2 As CRect‬‬
‫‪‬‬
‫בשורה זו הצהרנו על שני משתני ייחוס לאובייקט מסוג ‪CRect‬‬
‫‪‬‬
‫‪‬‬
‫בשורה זו יוצרים אובייקט מסוג ‪ CRect‬בזיכרון וגורמים ל‪ rc1-‬להתייחס אליו‬
‫ה‪ Reference Count-‬של האובייקט יהיה בשלב זה ‪1‬‬
‫‪‬‬
‫בשורה זו גם משתנה הייחוס ‪ rc2‬מצביע לאותו אובייקט בזיכרון שנוצר בשורת הקוד הקודמת‪ .‬לפיכך‬
‫ה‪ Reference Count-‬של האובייקט יגדל ב‪1-‬‬
‫‪Set rc1 = New CRect‬‬
‫‪Set rc2 = rc1‬‬
‫‪Set rc1 = Nothing‬‬
‫‪‬‬
‫בשורת קוד זו מבטלים את התייחסות המשתנה ‪ rc1‬לאובייקט בזיכרון‪ ,‬לפיכך ה‪ Reference Count-‬יקטן ב‪1-‬‬
‫ויהיה שוב ‪ .1‬כיוון שה‪ Reference Count-‬עדיין אינו ‪ 0‬האובייקט לא ישתחרר מהזיכרון‬
‫‪Set rc2 = Nothing‬‬
‫‪‬‬
‫בשורת קוד זו מבטלים את התייחסות המשתנה ‪ rc1‬לאובייקט בזכרון‪ ,‬לפיכך קטן ה‪ Reference Count-‬ב‪.1-‬‬
‫בשלב זה ה‪ reference Count-‬מגיע ל‪ 0-‬והאובייקט ‪ CRect‬שנותר בשורת הקוד השניה משוחרר מהזיכרון ומסיים‬
‫את חייו‪.‬‬
‫תרגיל ‪ – 1‬התוכנ ית ‪ClassDemo‬‬
‫‪ ‬בדוגמה זו ניצור מחלקה פשוטה באמצעותה נוכל לעקוב אחר אופן יצירת האובייקטים ושחרורם‬
‫‪ .1‬צור פרוייקט חדש מסוג ‪ Standard EXE‬ושמור אותו‪:‬‬
‫‪ ‬הקצה לפרוייקט את השם ‪ ClassDemo‬ולטופס את השם ‪frmClassDemo‬‬
‫‪ .1‬הוסף ‪ Class Module‬לפרוייקט ושמור אותו‪:‬‬
‫‪ ‬הוסף לפרוייקט ‪ Class Module‬תוך שימוש בתפריט ‪Project‬‬
‫‪ ‬הקצה ל‪ Class-‬את השם ‪ CDemo‬על ידי שינוי המאפיין ‪ Name‬של ה‪Class-‬‬
‫‪ .3‬הוסף קוד ל‪:CDemo-‬‬
‫‪Public val As Integer‬‬
‫‪‬‬
‫‪‬‬
‫בחלון הקוד של ‪ CDemo‬בחר ב‪ Class-‬מתוך התיבה ‪( Object‬ה‪ Combo Box-‬השמאלי המופיע בראש חלון‬
‫הקוד) ומתוך התיבה הימנית בחר ב‪Initialize-‬‬
‫הוסף את הקוד הבא‪:‬‬
‫)(‪Private Sub Class_Initialize‬‬
‫‪val = 0‬‬
‫"‪MsgBox "Object is now loaded into the memory‬‬
‫‪End Sub‬‬
‫‪‬‬
‫‪‬‬
‫קטע קוד זה מאתחל את המשתנה ‪ val‬ברגע שנוצר אובייקט חדש‪ ,‬וכמו כן מציג הודעה באמצעות ‪Message‬‬
‫‪Box‬‬
‫בחר ב‪ Terminate-‬והוסף את הקוד הבא‪:‬‬
‫)(‪Private Sub Class_Terminate‬‬
‫_ & "!‪MsgBox "Object is now unloaded from the memory‬‬
‫_ & ‪vbCrLf‬‬
‫)‪"val = " & Str(val‬‬
‫‪End Sub‬‬
‫ קטע קוד זה מציג הודעה בעת שהאובייקט נהרס‬
:‫ים לטופס והגדר את המאפיינים הבאים‬-CommandButton ‫ הוסף אחד עשר‬.1
‫ערך‬
Class Demo
3- Fixed Dialog
2-CenterScreen
cmdSetValOfD1
Set val of d1
cmdGetValOfD1
Get val of d1
cmdReleaseD1
Release d1
cmdInitializeD2
Initialize d2
cmdSetValOfD2
Set val of d2
cmdGetValOfD2
Get val of d2
cmdReleaseD2
Release d2
cmdInitializeD3
Initialize d3
cmdSetValOfD3
Set val of d3
cmdGetValOfD3
Get val of d3
cmdReleaseD3
Release d3
‫מאפיין‬
Caption
BorderStyle
StartUpPosition
Name
Caption
Name
Caption
Name
Caption
Name
Caption
Name
Caption
Name
Caption
Name
Caption
Name
Caption
Name
Caption
Name
Caption
Name
Caption
frmClassDemo
Command1
Command2
Command3
Command4
Command5
Command6
Command7
Command8
Command9
Command10
Command11
:‫הטופס צריך להיראות כמו זה שבציור הבא‬
www.kita.co.il

Visual Basic-‫ תכנות מונחה עצמים ב‬:1 ‫שיעור‬
:‫ הוסף את קוד לטופס‬.1
Option Explicit
Dim d1 As New CDemo
Dim d2 As CDemo
Dim d3 As CDemo
CDemo ‫בשורות הקוד הללו מוצהרים שלושה משתני ייחוס לאובייקטים מסוג‬
‫ההצהרות מתבצעות בשתי הצורות שהוסברו קודם‬
‫בהמשך (לאחר שנפעיל את התוכנית) תבין כיצד צורת ההצהרה משפיעה על אופן הפעולה של האובייקט‬
Private Sub cmdGetValOfD1_Click()
MsgBox "d1.val = " & Str(d1.val)
End Sub
End Sub
End Sub
Private Sub cmdInitializeD2_Click()
Set d2 = New CDemo
End Sub
Private Sub cmdInitializeD3_Click()
Set d3 = d2
End Sub
Private Sub cmdReleaseD1_Click()
Set d1 = Nothing
End Sub
Set d2 = Nothing
End Sub
Set d3 = Nothing
End Sub
Private Sub cmdSetValOfD1_Click()
d1.val = 100
End Sub
www.kita.co.il



‫)(‪Private Sub cmdSetValOfD2_Click‬‬
‫‪d2.val = 200‬‬
‫‪End Sub‬‬
‫)(‪Private Sub cmdSetValOfD3_Click‬‬
‫‪d3.val = 300‬‬
‫‪End Sub‬‬
‫‪ .1‬בחינת התוכנית‪:‬‬
‫‪ ‬כעת לאחר שהתוכנית מוכנה נריץ אותה יחד שלב אחר שלב ונבחן את מה שמתרחש וגם את מה שלא מתרחש‬
‫‪ ‬לחץ על הכפתור ‪ Start‬או ‪F5‬‬
‫‪ ‬שים לב‪ ,‬הצהרנו על ‪ d1‬באמצעות ‪ ,New‬ולמרות זאת‪ ,‬האירוע ‪ Initialize‬של ‪ CDemo‬לא התרחש עדיין‬
‫‪ ‬לחץ על ‪ Set val of d1‬או ‪ ,Get val of d1‬שים לב שהאירוע ‪Initialize‬התרחש כעת כיוון שניסית לגשת‬
‫לאובייקט‬
‫‪ ‬כעת לחץ על ‪ Release d1‬פעם אחת‬
‫‪ ‬שים לב כי האובייקט התפרק ואתה מקבל ‪ Message Box‬מהאירוע ‪ Terminate‬של ‪CDemo‬‬
‫‪ ‬נסה ללחוץ שוב על ‪ ,Release d1‬שום דבר לא מתרחש‬
‫‪ ‬כעת לחץ שוב על ‪ Set val of d1‬או ‪ ,Get val of d1‬שוב ‪ Visual Basic‬יוצרת עבורך אובייקט והאירוע‬
‫‪ Initialize‬מתעורר שוב‬
‫‪ ‬מסקנה‪ :‬הקוד הניגש ל‪ d1-‬בטוח כיוון שמובטח שאם לא קיים אובייקט בזיכרון‪ ,‬ייווצר אחד כזה‪ .‬אך‬
‫בתמורה לכך משלמים בביצועים מהירים פחות‬
‫‪ ‬כעת נסה ללחוץ על ‪ .Set val of d2‬אתה אמור לקבל שגיאה כיוון שאין אובייקט שעליו מצביע ‪d2‬‬
‫‪ ‬עצור את התוכנית והפעל אותה שוב‬
‫‪ ‬לחץ על ‪ Initialize d2‬כעת נוצר אובייקט עבור ‪ d2‬והאירוע ‪ Initialize‬שלו מתרחש‬
‫‪ ‬שים לב‪ :‬למרות שעדיין לא ניגשת למאפייני האובייקט הוא נוצר‬
‫‪ ‬הפעל את ‪ Set val of d2‬ולאחר מכן את ‪ ,Get val of d2‬אתה אמור לקבל את הערך ‪200‬‬
‫‪ ‬הפעל את ‪ .Initialize d3‬אם תעיין בקוד תבחין ש‪ d3-‬מושווה ל‪ ,d2-‬כלומר שניהם מצביעים כעת על אותו‬
‫‪ ‬לחץ על ‪ Get val of d3‬אתה אמור לקבל ‪ .200‬אכן זהו אותו אובייקט‬
‫‪ ‬לחץ על ‪ Set val of d3‬ולאחר מכן ‪ ,Get val of d2‬תבחין בוודאי שהשתנה הערך ל‪ ,300-‬וניתן לקבל אותו הן‬
‫מ‪ d2-‬והן מ‪d3-‬‬
‫‪ ‬כעת לחץ על ‪ ,Release d2‬שים לב שאירוע ‪Terminate‬עדיין לא התרחש‪ ,‬לראייה תוכל ללחוץ על ‪Get val of‬‬
‫‪ d3‬ותראה כי האובייקט עדיין קיים בזיכרון‪ .‬כלומר כעת ה‪ Reference Count-‬של האובייקט הוא ‪1‬‬
‫‪ ‬לחץ על ‪ .Release d3‬ה‪ Reference Count-‬של האובייקט יורד ל‪ 0-‬וכתוצאה מכך האובייקט משתחרר‬
‫מהזיכרון והאירוע ‪ Terminate‬שאתה מבחין בו מתרחש‬
‫‪ ‬אם תנסה כעת לגשת לערך של האובייקט באמצעות ‪ d2‬או ‪ d3‬תקבל שגיאה כיוון שאן אובייקט בזיכרון‬
‫‪ ‬כעת נבצע בדיקה אחרונה‪ ,‬הפסק את פעולת התוכנית והרץ אותה שוב‬
‫‪ ‬לחץ על ‪ ,Initialize d2‬הודעה בדבר האירוע ‪ Initialize‬צריכה להופיע‪ .‬לחץ ‪OK‬‬
‫‪ ‬אנו יודעים כי כעת קיים בזכרון אובייקט ש‪ d2-‬מתייחס אליו‬
‫‪ ‬כעת לחץ שוב על ‪ ,Initialize d2‬שים לב ששוב ייוצר אובייקט אשר ‪ d2‬יהיה אמור להצביע עליו‪ .‬לראיה אתה‬
‫מקבל הודעה מאירוע ‪ Initialize‬של ‪ CDemo‬אך השאלה היא מה קורה עם האובייקט ש‪ d2-‬התייחס אליו‬
‫קודם‪ .‬לאובייקט זה הרי כבר אין מי שמתייחס‪ ,‬כלומר ה‪ Reference Count-‬שלו יורד ל‪ ,0-‬לפיכך אתה מקבל‬
‫הודעה בדבר פירוקו של האובייקט מהזיכרון‬
‫‪‬‬
‫‪‬‬
‫אני ממליץ בפניך לבצע עוד מספר ניסויים כדי להבין כיצד נוצרים אובייקטים וכיצד הם מתפרקים‪ .‬תוכל‬
‫להשתמש גם בהרצה במצב ‪ Break Mode‬כדי לבחון את התוכנית ‪Step By Step‬‬
‫מסקנה‪ :‬הקוד הניגש ל‪ d2-‬ו‪ d3-‬מהיר יותר‪ ,‬כיוון שאין בדיקה לגבי קיומו של אובייקט בזכרון‪ ,‬אך קוד זה‬
‫פחות בטוח‬
‫תרגיל ‪ – 2‬התוכנ ית ‪Rect Demo‬‬
‫‪ ‬בדוגמה זו ניצור ‪ Class‬בשם ‪CRect‬‬
‫‪ Class ‬זה יאחסן נתונים אודות אורך ורוחב של מלבן‬
‫‪ ‬נוסיף ל‪ Class-‬שגרות מאפיינים ומתודות לאתחול נתוני המלבן‪ ,‬חישוב היקף המלבן ושטחו‬
‫‪ ‬הקצה לפרוייקט את השם ‪ RectDemo‬ולטופס את השם ‪frmRectDemo‬‬
‫‪ ‬הקצה ל‪ Class-‬את השם ‪ CRect‬על ידי שינוי המאפיין ‪ Name‬של ה‪Class-‬‬
‫‪ .3‬הוסף קוד ל‪:CRect-‬‬
‫‪Option Explicit‬‬
‫‪Private m_dLength As Double‬‬
‫‪Private m_dWidth As Double‬‬
‫‪‬‬
‫‪‬‬
‫בשורות הקוד הללו אנו מצהירים על שני משתנים‪ ,‬האחד לאחסון אורך המלבן והשני לאחסון רוחב המלבן‬
‫משתנים אלו מוצהרים כ‪ Private‬ולפיכך לא תוכל להתבצע גישה ישירה אליהם‬
‫‪m_dLength = 0#‬‬
‫‪m_dWidth = 0#‬‬
‫‪End Sub‬‬
‫‪‬‬
‫באירוע ‪ Initialize‬נהוג לבצע אתחולים של משתנים ואובייקטים השייכים ל‪Class-‬‬
‫)‪Public Property Let Length(ByVal dLength As Double‬‬
‫"‪Debug.Print "Inside Property Let Length‬‬
‫‪If dLength >= 0# Then‬‬
‫‪m_dLength = dLength‬‬
‫‪End If‬‬
‫‪End Property‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫המאפיין ‪ Length‬מאפשר הכנסת ערך למשתנה ‪m_dLength‬‬
‫נעשית בדיקה כדי לוודא שלא מוכנס ערך לא חוקי (מספר שלילי)‬
‫במקרה שמוכנס ערך חוקי‪ ,‬מעודכן ערכו של ‪ m_dLength‬בהתאם‬
‫כמו כן הוספתי שורת קוד המדפיסה לחלון ה‪ Immediate‬כאשר הביצוע של התוכנית עובר לפרוצדורה זו‬
‫‪Public Property Get Length() As Double‬‬
‫"‪Debug.Print "Inside Property Get Length‬‬
‫‪Length = m_dLength‬‬
‫‪‬‬
‫‪‬‬
‫‪ Property Get‬מאפשר ללקוח לקרוא את הערך שב‪Length-‬‬
‫גם באירוע זה נכתוב לחלון ה‪ Immediate-‬כדי לבחון את התרחשות התוכנית‬
Public Property Let Width(dWidth As Double)
Debug.Print "Inside Property Let Width"
If dWidth >= 0# Then
m_dWidth = dWidth
End If
End Property
Public Property Get Width() As Double
Debug.Print "Inside Property Get Width"
Width = m_dWidth
End Property
Width ‫באופן דומה יוצרים מאפיינים עבור‬

Public Function Perimeter() As Double
Perimeter = 2# * (m_dLength + m_dWidth)
End Function
Public Function Surface() As Double
Surface = m_dLength * m_dWidth
End Function
‫ (שטח) מחשבות את היקף ושטח המלבן בהתאמה‬Surface-‫ (היקף) ו‬Perimeter ‫ שתי הפונקציות‬
:‫ים לטופס והגדר את המאפיינים הבאים‬-CommandButton ‫הוסף חמישה‬
‫ערך‬
Rectangle Demo
3- Fixed Dialog
2-CenterScreen
cmdSetNew
Set New
cmdSetLength
Set length
cmdGetLength
Get length
cmdSetWidth
Set width
cmdGetWidth
Get width
‫מאפיין‬
Caption
BorderStyle
StartUpPosition
Name
Caption
Name
Caption
Name
Caption
Name
Caption
Name
Caption
www.kita.co.il
fmRectDemo
Command1
Command2
Command3
Command4
Command5
‫‪‬‬
‫הטופס צריך להיראות כמו בציור הבא‪:‬‬
‫‪Dim rc As CRect‬‬
‫)(‪Private Sub cmdSetNew_Click‬‬
‫‪Set rc = New CRect‬‬
‫‪End Sub‬‬
‫‪‬‬
‫בשורת קוד זו יוצרים את האובייקט בזיכרון‬
‫)(‪Private Sub cmdGetLength_Click‬‬
‫)‪MsgBox "Length = " & Str(rc.Length‬‬
‫‪End Sub‬‬
‫)(‪Private Sub cmdGetWidth_Click‬‬
‫)‪MsgBox "Width = " & Str(rc.Width‬‬
‫‪End Sub‬‬
‫)(‪Private Sub cmdSetLength_Click‬‬
‫))"‪rc.Length = Val(InputBox("Enter the length:‬‬
‫‪End Sub‬‬
‫)(‪Private Sub cmdSetWidth_Click‬‬
‫))"‪rc.Width = Val(InputBox("Enter the width:‬‬
‫‪End Sub‬‬
‫‪ ‬ארבעה הפרוצדורות הנ"ל מאתחלות את האובייקט ‪ rc‬ומציגות את הערכים‬
‫‪ ‬שים לב לנוחות שבשימוש במאפיינים‪ ,‬אתה יכול להשתמש בסימן = כדי לבצע השמה‪ ,‬ופרוצדורת המאפיין‬
‫תופעל עבורך‪ ,‬כך שאפשר לרשום ‪ rc.Length = 90‬במקום לרשום )‪rc.Length(90‬‬
‫‪ ‬התוכנית הנ"ל מציגה מידע בחלון ה‪ Immediate-‬כך שאם חלון זה איו מוצג‪ ,‬בצג אותו על ידי בחירתו‬
‫מהתפריט ‪View‬‬
‫‪ ‬הרץ את התוכנית‬
‫‪ ‬לחץ על ‪ Set New‬כדי ליצור אובייקט מסוג ‪CRect‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫לחץ על ‪ Set length‬והכנס ערך כלשהו‪ .‬שים לב שבחלון ה‪ Immediate-‬מוצגת הודעה מתוך‬
‫הפרוצדורה‪Property Let Length‬‬
‫באותו אופן נסה את שאר הלחצנים והבחן בפלט שבחלון ה‪Immediate-‬‬
‫אני ממליץ בפניך להריץ את התוכנית ‪ Step By Step‬במצב ‪( Break Mode‬השתמש ב‪ F8-‬לשם כך)‪ ,‬ולעקוב‬
‫אחר ביצוע התוכנית‬
‫תרגיל ‪ – 1‬התוכנ ית ‪EventDemo‬‬
‫‪ ‬בדוגמה זו ניצור ‪ Class‬שיכלול גם ‪ Events‬ונשתמש ב‪ Events-‬הללו מתוך תוכנית הלקוח‬
‫‪ ‬תוכנית זו אינה קשה‪ ,‬אם כי ייתכן שזרימת התוכנית תהיה מוזרה לך מעט‪ .‬אני ממליץ בפנינך להריץ את התוכנית‬
‫‪ Step By Step‬כדי לעקוב מקרוב אחר אופן ההתנהלות שלה‬
‫‪ ‬הקצה לפרוייקט את השם ‪ EventDemo‬ולטופס את השם ‪frmEventDemo‬‬
‫‪ ‬הקצה ל‪ Class-‬את השם ‪ CPerson‬על ידי שינוי המאפיין ‪ Name‬של ה‪Class-‬‬
‫‪ .3‬הוסף קוד ל‪:CPerson-‬‬
‫‪Private m_strName As String‬‬
‫‪Private m_nAge As Integer‬‬
‫‪‬‬
‫בשורות קוד אלו מוצהרים שני משתנים שאובייקט מסוג ‪ CPerson‬יכיל בתוכו‬
‫)(‪Public Event Changed‬‬
‫)‪Public Event WillReset(ByRef bCancel As Boolean‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫שתי השורות הנ"ל מצהירות על שני ‪ Events‬שאובייקט מסוג ‪ CPerson‬יכול לעורר‬
‫את האירוע ‪ Changed‬נעורר בכל פעם שערכו של אחד מהמשתנים הפנימיים (‪ m_strName‬או ‪)m_nAge‬‬
‫ישונה‬
‫האירוע ‪ WillReset‬יתעורר בכל פעם שנקראת השגרה ‪( Reset‬רשמה בהמשך)‬
‫תפקיד השגרה ‪ Reset‬הוא לאפס את המשתנים ‪ m_strName‬ו‪m_nAge-‬‬
‫באירוע ‪ WillReset‬אנו מעבירים משתנה ‪ bCancel‬באמצעות ייחוס (‪ )ByRef‬לפיכך אם המשתמש באובייקט‬
‫החליט לבטל את פעולת ה‪ Reset-‬הוא יוכל פשוט לשנות את ערכו של ‪ bCancel‬ל‪( True-‬בהמשך כשנכתוב‬
‫תוכנית המשתמשת ב‪ CPerson-‬דבר זה יובהר)‬
‫"" = ‪m_strName‬‬
‫‪m_nAge = 0‬‬
‫‪End Sub‬‬
‫‪‬‬
‫באירוע ‪ Initialize‬אנו מאפסים את ‪ m_nAge‬ומאתחלים את ‪ m_strName‬למחרוזת ריקה‬
‫)‪Public Property Let Name(strName As String‬‬
‫‪m_strName = strName‬‬
‫‪RaiseEvent Changed‬‬
‫ על ידי שימוש במילת המפתח‬Change ‫ ומיד מעורר את האירוע‬m_strName ‫מאפיין זה משנה את תוכן‬
RaiseEvent

Public Property Get Name() As String
Name = m_strName
End Property
Public Property Let Age(ByVal nAge As Integer)
If nAge >= 0 Then
m_nAge = nAge
RaiseEvent Changed
End If
End Property
‫שלילי‬-‫ בתנאי שהמספר המועבר הוא אי‬m_nAge ‫מאפיין זה משנה את ערכו של‬
Changed ‫ מעוררים את האירוע‬,‫לאחר שינוי הערך‬


Public Property Get Age() As Integer
Age = m_nAge
End Property
Public Sub Reset()
Dim bCnl As Boolean
bCnl = False
RaiseEvent WillReset(bCnl)
If bCnl = False Then
m_strName = ""
m_nAge = 0
RaiseEvent Changed
End If
End Sub
m_nAge-‫ ו‬m_strName ‫ הוא לאפס את המשתנים‬Reset ‫ תפקיד המתודה‬
)False-‫ (המאותחל ל‬bCnl ‫ ומעבירה את הפרמטר‬WillReset ‫ מעוררת את האירוע‬Reset ‫ תחילה המתודה‬
‫ כל שעליו לעשות הוא לשנות את ערכו של‬,Reset-‫ אם המשתמש שלוכד את האירוע החליט לבטל את פעולת ה‬
True-‫ ל‬bCnl
‫ אזי מאפסים את‬,False ‫ אם הוא עדיין‬.bCnl ‫ נבחן ערכו של‬,‫ לאחר שלוכד האירוע סיים את הטיפול באירוע‬
‫ לא‬True-‫ אם ערכו שונה ל‬.Changed ‫ ומעוררים את האירוע‬m_nAge-‫ ו‬m_strName ‫ערכי המשתנים‬
‫מבצעים מאומה‬
:‫ים לטופס והגדר את המאפיינים הבאים‬-CommandButton ‫ הוסף שלושה‬.1
‫ערך‬
Event Demo
3- Fixed Dialog
2-CenterScreen
cmdSetAge
Set Age
cmdSetName
‫מאפיין‬
Caption
BorderStyle
StartUpPosition
Name
Caption
Name
fmEventDemo
www.kita.co.il
Command1
Command2
Set Name
cmdReset
Reset
cmdSetWidth
Set width
Caption
Name
Caption
Name
Caption
Command3
Command4
:‫הטופס צריך להיראות כמו בציור שלפניך‬

Option Explicit
Dim WithEvents prs As CPerson
CPerson ‫שורת קוד זו מצהירה על משתנה ייחוס לאובייקט מסוג‬
‫ כדי שהאירועים של האובייקט יילכדו בתוך הטופס‬WithEvents ‫נעשה שימוש במילה‬


Set prs = New CPerson
End Sub
‫ברגע שהטופס נוצר יוצרים את האובייקט‬

‫ משחררים את האובייקט מהזיכרון‬Unload ‫באירוע‬

prs ‫ של‬Reset ‫ קוראים למתודה‬Reset ‫בעת לחיצה על‬

Private Sub Form_Unload(Cancel As Integer)
Set prs = Nothing
End Sub
Private Sub cmdReset_Click()
prs.Reset
End Sub
Private Sub cmdSetAge_Click()
prs.Age = Val(InputBox("Enter the age"))
End Sub
InputBox-‫ לפי הערך המוזן על ידי המשתמש ב‬Age ‫ מאתחלים את‬Set Age ‫בתגובה ללחיצה על‬

Private Sub cmdSetName_Click()
prs.Name = InputBox("Enter the name")
End Sub
InputBox-‫ לפי המחרוזת המוזנת על ידי המשתמש ב‬Name ‫ מאתחלים את‬SetName ‫בתגובה ללחיצה על‬
Private Sub prs_Changed()
MsgBox "prs has changed. The new values are:" & vbCrLf & _
"Name = " & prs.Name & vbCrLf & _
"Age = " & Trim(Str(prs.Age))
End Sub
www.kita.co.il

‫‪‬‬
‫אירוע זה מתעורר (‪ )Fired‬על‪-‬ידי ‪ prs‬בכל פעם שערך מסוים בתוך האובייקט שונה‪ .‬בנקודה זו אנו מציגים‬
‫באמצעות ‪ Message Box‬את הערכים העדכניים את ‪prs‬‬
‫)‪Private Sub prs_WillReset(bCancel As Boolean‬‬
‫‪If MsgBox("Do you want to cancel the reset?", vbYesNo) = vbYes Then‬‬
‫‪bCancel = True‬‬
‫‪End If‬‬
‫‪End Sub‬‬
‫‪ ‬אירוע זה מתעורר על ידי ‪ prs‬בכל פעם שמנסים לאפס את ‪ .prs‬בנקודה זו אנו מציגים הודעה המאפשרת‬
‫למשתמש להחליט האם לבטל את פעולת האיפוס או לא‬
‫‪ ‬הרץ את התוכנית ובחן את פעולתה‬
‫‪ ‬כאמור‪ ,‬אני ממליץ בפניך להריץ את התוכנית ‪ Step By Step‬באמצעות ‪ F8‬כדי לבצע מעקב מדויק אחר‬
‫זרימת התוכנית‬
‫מימוש ‪Interface‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ Interface‬הוא החלק הציבורי (‪ )Public‬של ‪ Class‬מסוים – כלומר החלק הנגיש של המחלקה‬
‫ב‪ COM-‬נהוג לכתוב ממשקים באמצעות שפת ‪ )Interface Definition Language( IDL‬ולקמפל את הקוד‬
‫באמצעות הקומפיילר ‪MIDL‬‬
‫אם אתה מכיר את שפת ‪ IDL‬תוכל להשתמש בה כדי ליצור ממשקים ולממש אותם בכל שפה שתרצה (בתנאי‬
‫ששפה זו תומכת ‪ COM‬כמובן)‬
‫ב‪ Visual Basic-‬נוכל ליצור ‪-Interface‬ים פשוט על ידי יצירת ‪ Class‬ללא משתנים וללא מימושים כלשהם‬
‫לפונקציות‪ .‬למעשה לכל ‪ Class‬ב‪ Visual Basic-‬יש ממשק משלו‬
‫‪ Class‬המעונין לממש ‪ Interface‬צריך להשתמש במילה ‪Implements‬‬
‫מימוש ‪Class‬ים הנו מימוש ה‪-Interface-‬ים של אותם ‪-Class‬ים‬
‫‪ Class‬המממש ‪ Interface‬חייב לממש את כל המתודות והמאפיינים שלו‬
‫אם לא תממש פרוצדורה מסוימת של ‪ Interface‬תקבל שגיאת קומפילציה‬
‫אם הצהרת על משתנים ‪ Public‬ב‪ Class-‬שאת ה‪ Interface-‬שלו אתה מממש ב‪ Class-‬אחר‪ ,‬תקבל עבור כל‬
‫משתנה כזה פרוצדורות ‪ Property Get‬ו‪Property Let-‬‬
‫באמצעות מימוש ‪-Interface‬ים ניתן ליצור היררכיה של ‪-Class‬ים וכן ליצור רכיבי תוכנה שיתאימו לתוכנה מוכנה‬
‫מצד שלישי‬
‫כאשר אובייקט מממש מספר ‪-Interface‬ים‪ ,‬ניתן להשתמש במשתני ייחוס מכל סוגי ה‪-Interface-‬ים הממומשים‬
‫כדי להתייחס לאובייקט‬
‫בשיעור הבא תלמד כיצד ליצור ‪ Add-In‬ל‪ Visual Basic-‬על ידי מימוש ממשק מתאים‬
‫אבחון תכו נות אובייקט בזמן ריצה‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫ניתן לבדוק אם אובייקט תומך ב‪ Interface-‬מסוים ע"י שימוש במילה ‪:TypeOf...Is‬‬
‫ניתן לבדוק מהו סוג האובייקט המוצבע בפועל על ידי שימוש בפונקציה ‪ .TypeName‬פונקציה זו מחזירה מחרוזת‬
‫הזהה לשם ה‪ Class-‬שאליו שייך האובייקט (הכוונה כאן היא לאובייקט המוצבע בפועל ולא לסוג המצביע)‬
‫ניתן לבדוק האם אובייקט אותחל או שהוא שווה ל‪ Nothing-‬ע"י שימוש במילים ‪....Is Nothing...‬‬
‫‪If TypeOf shape is IArchive Then‬‬
‫‪...‬‬
‫‪End If‬‬
‫‪‬‬
‫בשורות קוד אלו נבדק האם ‪ obj‬מממש את ה‪ Interface-‬ששמו ‪ ,IArchive‬אם כן נכנסים לתוך בלוק הביצוע של‬
‫ה‪If-‬‬
‫)‪MsgBox TypeName(obj‬‬
‫‪‬‬
‫שורת קוד זו מציגה את שם המחלקה אליה שייך האובייקט המוצבע ע"י ‪obj‬‬
‫‪If obj Is Nothing Then Exit Sub‬‬
‫‪‬‬
‫‪‬‬
‫שורת קוד זו גורמת ליציאה מרוטינה אם ‪ obj‬אינו מאותחל (כלומר הוא ‪)Nothing‬‬
‫שים לב שכדי לשלול את התנאי עליך לרשום ‪ Not‬בתחילת התנאי‪ .‬כלומר‪:‬‬
‫‪If Not TypeOf shape is IArchive Then...‬‬
‫וכן‪:‬‬
‫‪If Not obj Is Nothing Then Exit Sub‬‬
‫תרגיל ‪ – 4‬התוכנ ית ‪ImplementsDemo‬‬
‫‪ ‬בדוגמה זו ניצור ‪ Class‬עם מספר פרוצדורות בעלות מימוש ריק כלומר ‪ ,Interface‬ונממש אותו ב‪ Class-‬אחר‬
‫‪ .1‬צו פרוייקט חדש מסוג ‪ Standard EXE‬ושמור אותו‪:‬‬
‫‪ ‬הקצה לפרוייקט את השם ‪ ImplementsDemo‬ולטופס את השם ‪frmImplementsDemo‬‬
‫‪ .1‬הוסף שלושה ‪-Class Module‬ים לפרוייקט ושמור אותם‪:‬‬
‫‪ ‬הקצה ל‪-Class-‬ים את השמות‪ CCircle ,IShape :‬ו‪CRect-‬‬
‫‪ ‬שמור את ה‪-Class Module-‬ים‬
‫‪ .3‬הוסף קוד ל‪:IShape-‬‬
‫‪Public Function Perimeter() As Double‬‬
‫‪' Empty inside interface‬‬
‫‪Public Function Surface() As Double‬‬
‫‪' Empty inside interface‬‬
‫‪ ‬בשורות קוד אלו מוצהרות שתי פונקציות‪ Perimeter ,‬ו‪Surface-‬‬
‫‪ ‬שים לב כי אין מימוש לפונקציות (בתוך כל פונקציה רשומה הערה!)‬
‫‪ .1‬הוסף קוד ל‪:CCircle-‬‬
‫‪Implements IShape‬‬
‫‪‬‬
‫‪‬‬
‫בשורת הקוד הזו אנו מבקשים לממש את ה‪ Interface-‬של ‪IShape‬‬
‫תשים לב כי ב‪ Combo Box-‬השמאלי שבחלון הקוד (‪ )Object‬מופיע כעת ‪IShape‬‬
‫‪Public m_dRadius As Double‬‬
‫בשורת קוד זו מצהירים על משתנה שיאחסן את רדיוס המעגל‬
‫ וליצור‬Private-‫ אך ברור לך שכדאי להצהיר עליו כ‬Public-‫שים לב כי לצורך ההדגמה המשתנה מוצהר כ‬
‫ מתאימות‬Property Let-‫ ו‬Property Get ‫עבורו פרוצדורות‬


Private Function IShape_Perimeter() As Double
IShape_Perimeter = 2 * 3.14 * m_dRadius
End Function
P  2r ‫הוא כמובן‬Circle ‫ עבור‬Perimeter ‫המימוש של‬

Private Function IShape_Surface() As Double
IShape_Surface = 3.14 * m_dRadius * m_dRadius
End Function
S  r 2 ‫ הוא‬Circle ‫ עבור‬Surface ‫ המימוש של‬
:CRect-‫ הוסף קוד ל‬.1
Option Explicit
Implements IShape
Public m_dLength As Double
Public m_dWidth As Double
IShape_Perimeter = 2 * (m_dLength + m_dWidth)
End Function
IShape_Surface = m_dLength * m_dWidth
End Function
‫ תוך ביצוע החישובים המתאימים למלבן‬,IShape ‫ של‬Interface-‫ ממומש ה‬CRect-‫ גם ב‬CCircle-‫ כמו ב‬
:‫ והגדר את המאפיינים הבאים‬,‫ אחד‬TextBox‫ים ו‬-CommandButton ‫הוסף לטופס חמישה‬
‫ערך‬
Implements Demo
3- Fixed Dialog
2-CenterScreen
cmdSetCircle
Set Circle Radius...
cmdSetShapeIsCircle
Set shape = c
cmdSetRectangleValues
Set Rectangle Values...
cmdSetShapeIsRect
Set shape = r
cmdDisplayInfo
Display Info...
txtInfo
‫מאפיין‬
Caption
BorderStyle
StartUpPosition
Name
Caption
Name
Caption
Name
Caption
Name
Caption
Name
Caption
Name
frmImplementsDemo
www.kita.co.il
Command1
Command2
Command3
Command4
Command5
Text1
]‫[ריק‬
True
Text
MultiLine
:‫הטופס אמור להיראות כמו בציור שלפניך‬

Option Explicit
Dim c As New CCircle
Dim r As New CRect
Dim shape As IShape
IShape-‫ ומשתנה ייחוס ל‬CCircle ‫ אובייקט מסוג‬,CRect ‫השורות הנ"ל מצהירות על אובייקט מסוג‬

Private Sub cmdSetCircle_Click()
c.m_dRadius = Val(InputBox("Enter the radius of the circle:"))
End Sub
Private Sub cmdSetRectangleValues_Click()
r.m_dLength = Val(InputBox("Enter the length of the recangle:"))
r.m_dWidth = Val(InputBox("Enter the width of the rectangle:"))
End Sub
r ‫ והמלבן‬c ‫שורות הקוד הנ"ל מאפשרות אתחול של המעגל‬
Private Sub cmdSetShapeIsCircle_Click()
Set shape = c
End Sub
Private Sub cmdSetShapeIsRect_Click()
www.kita.co.il

‫‪Set shape = r‬‬
‫‪End Sub‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫בשורות הקוד הללו קובעים לאיזה מבין הצורות (‪ c‬או ‪ )r‬יצביע המשתנה ‪shape‬‬
‫שים לב כי אין כל בעיה ש‪ shape-‬יצביע על אובייקט מסוג ‪ CCircle‬או מסוג ‪ CRect‬כיוון שאובייקטים אלו‬
‫ממשים את ‪IShape‬‬
‫עם זאת – ‪ shape‬לא יוכל להפעיל פונקציות שאינן שייכות ל‪( IShape-‬נדון בכך בסעיף הבא "‪Early Binding‬‬
‫לעומת ‪)"Late Binding‬‬
‫)(‪Private Sub cmdDisplayInfo_Click‬‬
‫‪If shape Is Nothing Then Exit Sub‬‬
‫‪txtInfo.Text = TypeName(shape) & "..." & vbCrLf‬‬
‫_ & )" " ‪txtInfo.Text = txtInfo.Text & String(8,‬‬
‫‪"Perimeter = " & Str(shape.Perimeter()) & vbCrLf‬‬
‫_ & )" " ‪txtInfo.Text = txtInfo.Text & String(8,‬‬
‫‪"Surface = " & Str(shape.Surface()) & vbCrLf‬‬
‫‪End Sub‬‬
‫‪ ‬בתגובה ללחיצה על ‪ Display Info...‬מתבצעות שורות הקוד הנ"ל‬
‫‪ ‬תחילה נבדק שהמשתנה ‪ shape‬מאותחל‪ .‬אם ‪ shape‬אינו מאותחל יוצאים מהרוטינה‬
‫‪ ‬לאחר מכן מציגים את שם סוג האובייקט המוצבע ע"י ‪ .shape‬עושים זאת באמצעות הפונקציה ‪TypeName‬‬
‫‪ ‬מוסיפים קריאות ל‪ Perimeter-‬ו‪ Surface-‬כדי להציג את היקף ושטח הצורה‬
‫‪ ‬הרץ את התוכנית ובדוק את אופן פעולתה‬
‫‪ Early Binding‬לעומת ‪Late Binding‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ Early Binding‬פירושו קישור הקריאות למתודות ומאפיינים של אובייקט עוד בזמן הקימפול‪ .‬כלומר ב‪Early -‬‬
‫‪ Binding‬עוד במן הקימפול ידוע לקומפיילר מהן הכתובות הפיסיות של המתודות הנקראות‬
‫קישור מסוג זה קרוי ‪ VTBL Binding‬והוא המהיר ביותר ב‪COM-‬‬
‫בדרך כלל אתה משתמש בסוג זה של קישור בתוכניות ‪Visual Basic‬‬
‫‪ Late Binding‬היא האפשרות לגשת למאפיין או מתודה של אובייקט שאין וודאות בזמן הפיתוח שהם נתמכים‬
‫ע"י האובייקט‪ .‬משמעות הדבר היא שבזמן ריצת התוכנית יהיה על התוכנית לגלות אם באותו אובייקט קיימת‬
‫המתודה או קיים המאפיין שאליו רוצים לגשת‬
‫פונקציונליות זו אפשרית על ידי שימוש בממשק ‪ IDispatch‬מ‪ COM-‬או ע"י שימוש ב‪ Type Library-‬וזיהויו בזמן‬
‫ריצה‬
‫ב‪ Visual Basic-‬כל האובייקטים מממשים את ה‪ Interface‬ששמו ‪Object‬‬
‫‪ Object‬הוא למעשה הממשק ‪ IDispatch‬המאפשר ‪ Late Binding‬ב‪Visual Basic-‬‬
‫‪ Late Binding‬הרבה יותר גמיש מבחינת אפשרויות התכנות מאשר ‪ .Early Binding‬עם זאת‪Late Binding ,‬‬
‫איטי ביותר ביחס ל‪Early Binding-‬‬
‫בעת קריאה למתודה או מאפיין בזמן ריצה תוך שימוש ב‪ Object-‬מתבצעות מספר הכנות לפני שהפונקציה‬
‫מופעלת‪ .‬פעולות אלה בודקות את קיומה של המתודה או קיומו של המאפיין הנקרא‪ .‬ניקח לדוגמה את המשפטים‪:‬‬
‫‪Dim obj As Object‬‬
‫‪...‬‬
‫‪...‬‬
‫)‪obj.SetValues("Today is your day", 57‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫שלבי הביצוע הם‪:‬‬
‫‪ o‬הכנת כל המחרוזות הטקסטואליות שיש לזהות‪ :‬במקרה זה המחרוזת שיש לזהות היא ‪– SetValues‬‬
‫כלומר יש לבדוק האם האובייקט שאליו מצביע ‪ obj‬אכן כולל פונקציה כזו‬
‫‪ o‬קריאה ל‪ .IDispatch::GetIDsOfNames()-‬קריאה זו מטרתה לאחזר את מספרי הזיהוי (‪ )DISPIDs‬של‬
‫שם המתודה והפרמטרים שיש להעביר לה‪ :‬במקרה שלנו יוחזרו מספרי זיהוי עבור השם ‪SetValues‬‬
‫ועבור הפרמטרים שיש להעביר לה‬
‫‪ o‬כל מספרי הזיהוי (‪ )DISPIDs‬יוחזרו‬
‫‪ o‬קריאה ל‪ .IDispatch::Invoke()-‬קריאה זו מטרתה להפעיל (סוף סוף) את המתודה לאחר שזיהינו שאכן‬
‫היא נתמכת‪ ,‬וכל הפרמטרים שלה הוכנו‪.‬‬
‫‪ o‬הערך המוחזר של הפונקציה (‪ )HRESULT‬מוחזר מ‪ IDispatch::Invoke()-‬לקוד הקורא‬
‫תחשוב על כך שהפעולות הללו מתבצעות עבור כל קריאה למתודה‪ ,‬כאשר היא מתבצעת באמצעות ‪.IDispatch‬‬
‫ללא ספק זוהי תקורה (‪ )Overhead‬גבוהה למדי עבור קריאה בודדת‪ .‬תחשוב מה כמה זמן היית ממתין לתשובה לו‬
‫הקטע הנ"ל היה מתבצע בין שני ‪-Process‬ים נפרדים או בין שני מחשבים ברחבי הרשת‬
‫בדוגמה הבאה תבחן במושגים של זמן את ההבדלים בין ‪ Late Binding‬ל‪Early Binding-‬‬
‫תרגיל ‪ – 3‬התוכנ ית ‪Analyzer‬‬
‫‪ ‬הקצה לפרוייקט את השם ‪ Analyzer‬ולטופס את השם ‪frmAnalyzer‬‬
‫‪ .1‬הוסף ‪ Class Module‬לפרוייקט‪:‬‬
‫‪ ‬הקצה את השם ‪ CTest‬ל‪Class Module-‬‬
‫‪ ‬שמור את הפרוייקט שוב‬
‫הוסף קוד ל‪:CTest-‬‬
‫‪Private m_lVal As Long‬‬
‫)‪Public Property Let Val(lVal As Long‬‬
‫‪m_lVal = lVal‬‬
‫‪ ‬זוהי מחלקה פשוטה עם מאפיין אחד המאפשר להזין ערך למשתנה ‪Val‬‬
‫‪ .3‬הוסף לטופס שלושה ‪-CommandButton‬ים ו‪ TextBox-‬אחד והגדר את המאפיינים הבאים‪:‬‬
‫‪frmAnalyzer‬‬
‫‪Command1‬‬
‫‪Text1‬‬
‫מאפיין‬
‫‪Caption‬‬
‫‪Name‬‬
‫‪Caption‬‬
‫‪Name‬‬
‫‪Caption‬‬
‫‪Name‬‬
‫‪Caption‬‬
‫‪Name‬‬
‫ערך‬
‫‪Late Binding VS. Early Binding‬‬
‫‪3- Fixed Dialog‬‬
‫‪2-CenterScreen‬‬
‫‪cmdSetNew‬‬
‫‪Set ... = New‬‬
‫‪cmdUseObject‬‬
‫‪Dim ... As Object‬‬
‫‪cmdStop‬‬
‫!‪I got it - STOP‬‬
‫‪txtTimer‬‬
‫‪Background‬‬
‫‪Locked‬‬
‫‪Text‬‬
‫‪MultiLine‬‬
‫‪‬‬
‫‪Button Face‬‬
‫‪True‬‬
‫[ריק]‬
‫‪True‬‬
‫הטופס אמור להיראות כמו בציור שלפניך‪:‬‬
‫הוסף קוד לטופס‪:‬‬
‫)(‪Private Sub cmdSetNew_Click‬‬
‫‪Dim cls As CTest‬‬
‫‪Dim lVal As Long, i As Integer‬‬
‫‪Dim sTime As Single‬‬
‫‪Set cls = New CTest‬‬
‫‪sTime = Timer‬‬
‫‪For i = 1 To 1000‬‬
‫_ & ‪txtTimer.Text = "As CTest... " & vbCrLf‬‬
‫_ & ‪"i = " & Str(i) & vbCrLf‬‬
‫"‪"Time elapsed:" & Str(Timer - sTime) & " sec‬‬
‫‪DoEvents‬‬
‫‪For lVal = 1 To 10000‬‬
‫‪cls.Val = lVal‬‬
‫‪Next‬‬
‫‪Next‬‬
‫‪End Sub‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫בקטע קוד זה מריצים שתי לולאות מקוננות‬
‫בתוך הלולאה הפנימית ניגשים למאפיין של האובייקט ‪cls‬‬
‫לפני הכניסה ללולאה החיצונית נמדד הזמן ולפני כל איטרציה של הלולאה הפנימית מוצג ההפרש בשניות מאז‬
‫הכניסה ללולאה החיצונית‬
‫בפעולת ההדפסה מציגים את שם האובייקט באמצעות ‪TypeName‬‬
‫)(‪Private Sub cmdUseObject_Click‬‬
‫‪Dim cls As Object‬‬
‫‪Dim lVal As Long, i As Integer‬‬
‫‪Dim sTime As Single‬‬
‫‪Set cls = New CTest‬‬
‫‪sTime = Timer‬‬
‫‪For i = 1 To 1000‬‬
‫_ & ‪txtTimer.Text = "As Object..." & vbCrLf‬‬
‫_ & ‪"i = " & Str(i) & vbCrLf‬‬
‫"‪"Time elapsed:" & Str(Timer - sTime) & " sec‬‬
‫‪DoEvents‬‬
‫‪For lVal = 1 To 10000‬‬
‫‪cls.Val = lVal‬‬
‫‪Next‬‬
‫‪Next‬‬
‫‪End Sub‬‬
‫‪‬‬
‫‪‬‬
‫קטע קוד זה זהה לקודם‪ ,‬אלא שכאן מוצהר האובייקט כ‪Object-‬‬
‫במקרה זה מופעלת הגישה למאפיין ‪ Val‬באמצעות ‪Late Binding‬‬
‫)(‪Private Sub cmdStop_Click‬‬
‫‪Unload Me‬‬
‫‪End Sub‬‬
‫)‪Private Sub Form_Unload(Cancel As Integer‬‬
‫‪End‬‬
‫‪End Sub‬‬
‫‪ ‬הרץ את התוכנית ןהשווה את הביצועים של ‪ Early Binding‬לעומת ‪Late Binding‬‬
‫‪ ‬תסכים איתי שהתוצאות מרשימות‪ .‬אצלי במחשב (‪ )Pentium III 733MHrz‬השימוש ב‪Early Binding-‬‬
‫(שימוש במשתנה ייחוס מסוג ‪ )CTest‬הסתכם ב‪ 4.41-‬שניות‪ ,‬ואילו הפעלה באמצעות ‪( Late Binding‬שימוש‬
‫במשתנה ייחוס מסוג ‪ )Object‬הסתכם ב‪ 77.21-‬שניות‪.‬‬
‫הגדרת תכונות של פרוצדורות‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫ב‪INTREFCAE-‬‬
‫בעת יצירת ‪ Class‬ב‪ Visual Basic-‬נוצר עבורו באופן אוטומטי ‪Interface‬‬
‫לפרוצדורות ב‪ Interface-‬ישנן הגדרות ותכונות נוספות‬
‫הגדרה מותאמת אישית של תכונות אובייקטים ב‪ Visual Basic-‬מהווה לעתים תכופות מטלה שחובה לבצע אותה‬
‫על מנת לגרום לאובייקט לפעול בצורה תקינה‬
‫בסעיף זה תלמד כיצד ניתן לצפות בתכונות ה‪ ,Interface-‬וכיצד ניתן להגדיר את התכונות הללו ב‪Visual Basic-‬‬
‫חלק מהתכונות יילמדו בשיעורים הבאים‬
‫צפייה בתכו נות באמצעות ‪Object Browser‬‬
‫‪‬‬
‫כדי לצפות בפרוצדורות והתכונות שלהן ניתן להשתמש ב‪Object Browser-‬‬
‫תרגיל ‪ – 6‬צפי יה באובייקטים באמצעות ה ‪Object Browser -‬‬
‫‪ ‬תרגיל זה נטול קוד‪ .‬מטרת התרגיל היא להכיר לך את חלון ה‪Object Browser-‬‬
‫‪ .1‬פתח את ה‪:Object Browser-‬‬
‫‪ ‬מתוך התפריט ‪ View‬בחר ב‪ ,Object Browser-‬לחילופין לחץ על ‪F2‬‬
‫‪ .1‬בחר אובייקט לבחינה‪:‬‬
‫‪ ‬לצורך התרגול (וגם בגלל שהנושא הבא הוא ‪ )Collections‬נבחר לצפות באובייקט ‪Collection‬‬
‫‪ ‬מתוך הרשימה ‪ Classes‬בחר ב‪( Collection-‬אם אינך מוצא את ‪ ,Collection‬וודא שב‪ Combo Box-‬העליון‬
‫בחרת ב‪ <All Libraries>-‬או ב‪VBA-‬‬
‫‪ .3‬בחן את ‪:Collection‬‬
‫‪ ‬כפי שאתה רוצה‪ ,‬בפנל הימני מוצגים המאפיינים והמתודות של ‪Collection‬‬
‫‪ ‬סמן את אחת הפרוצדורות‪ ,‬תבחין מיד כי בתחתית החלון מוצגת אינפורמציה אודות הפרוצדורה הנבחרת‪.‬‬
‫אינפורמציה זו כוללת את סוג הפרוצדורה (‪ Property ,Function ,Sub‬או ‪ )Event‬הסבר קצר‪ ,‬ולינק ל‪Class-‬‬
‫המכיל (במקרה זה ‪)VBA.Collection‬‬
‫‪ .1‬זהה את פרוצדורת ברירת המחדל‪:‬‬
‫‪ ‬תשים לב כי ליד ‪ Item‬ישנו עיגול כחול‪ .‬זהו סימן לכך שהפונקציה ‪ Item‬היא פרוצדורת ברירת המחדל עבור‬
‫‪Collection‬‬
‫‪ ‬פרוצדורת ברירת מחדל מופעלת באופן אוטומטי אם לא ציינת במפורש שום פרוצדורה להפעלה‬
‫הצג פרוצדורות נסתרות‪:‬‬
‫‪ ‬לחץ לחיצה ימנית במקום כלשהו ובחר ב‪Show Hidden Members-‬‬
‫‪ ‬תבחין כי לרשימת הפרוצדורות של ‪ Collection‬נוסף חבר חדש ושמו ‪_NewEnum‬‬
‫‪ ‬על משמעות ‪ _NewEnum‬תלמד בסעיף ‪Collections‬‬
‫צפייה באמצעות היישום ‪OLE VIEW‬‬
‫‪‬‬
‫‪‬‬
‫לא כל התכונות של פרוצדורה מוצגות ב‪Object Browser-‬‬
‫כדי לצפות בכל הפרטים אודות ‪ Interface‬מסוים‪ ,‬אפשר להשתמש ביישום ‪ .OLE View‬יישום זה מותקן יחד עם‬
‫חבילת ‪ .Visual Studio‬תוכל לפתוח אותו מתוך תת התפריט ‪ Microsoft Visual Studio 6.0 Tools‬תחת‬
‫‪Microsoft Visual Studio6.0‬‬
‫תרגיל ‪ OLE View – 7‬לבעלי לב ח זק בלבד‬
‫‪ ‬אם אתה בעל לב חזק‪ ,‬בטח תרצה לבחון את ‪ Collection‬גם מתוך ‪OLE View‬‬
‫‪ .1‬פתח את ‪:OLE View‬‬
‫‪ OLE View ‬נמצא במסלול הבא (אלא אם התקנת את ‪ Visual Studio‬במסלול שונה מאשר ברירת המחדל)‪:‬‬
‫‪OLE View >--Microsoft Visual Studio 6.0 Tools >--Microsoft Visual Studio 6.0 >--Programs>--Start‬‬
‫‪ .1‬פתח את ה‪:Type Library-‬‬
‫‪ ‬מהתפריט ‪ File‬בחר ב‪View TypeLib...-‬‬
‫‪ ‬עבור לספריית ‪ VB98‬תחת ספריית ההתקנה של ‪( Visual Studio‬בררך כלל זהו המסלול‪:‬‬
‫\‪)C:\Program Files\Microsoft Visual Studio\VB98‬‬
‫‪ ‬בחר בקובץ ‪ .VBA6.DLL‬האובייקט ‪ Collection‬נמצא בספריית ‪.VBA‬‬
‫‪ OLE View ‬ישתהה מעט בזמן שהוא קורא את נתוני הספרייה‬
‫‪ .3‬בחר ב‪ Interface-‬של האובייקט ‪:Collection‬‬
‫‪ ‬בתחתית הפנל השמאלי לחץ על לחצן הפלוס (‪ )+‬שליד הפריט ‪interface _Collection‬‬
‫‪ ‬תוכל להבחין שהמתודות ‪ Remove ,Count ,Add ,Item‬ו‪ _NewItem-‬מופיעות‬
‫‪ ‬מעיון בפרוצדורות תבחין כי לכל פרוצדורה יש מספר זיהוי (‪ )id‬הרשום בהגדרת ה‪Interface-‬‬
‫‪ ‬אם תעיין במתודה ‪ _NewEnum‬תבחין בכך שמספר הזיהוי שלה הוא ‪ -4( 0xfffffffc‬בהקצהדצימלית) פרט‬
‫זה ישמש אותנו כשניצור ‪ Collection‬מותאם אישית‬
‫‪ .1‬עיין ב‪-Interface-‬ים ממומשים על‪-‬ידי ‪:Collection‬‬
‫‪ ‬כפי שזכור לך מהדיון על ‪ Reference Counting‬ועל ‪ ,Late Binding‬אמרתי אז ש‪ IUnknown-‬הוא‬
‫ה‪ Interface-‬הבסיסי ביותר ב‪ COM-‬ואילו ‪ IDispatch‬מאפשר ‪ Late Binding‬עבור רכיבי ‪ActiveX‬‬
‫‪ ‬אם תלחץ על ‪ Inherited Interfaces‬תחת הענף הנוכחי‪ ,‬תגלה את ‪ IDispatch‬חבוי עם המתודות המוכרות לנו‬
‫מהדיון אודות ‪ Invoke ,GetIdsOfNames( Late Binding‬ועוד‪).‬‬
‫‪ ‬אם תלחץ שוב על ‪ Inherited Interfaces‬שתחת ‪ IDispatch‬תגלה את ‪ IUnknown‬עם שלוש המתודות שלו‬
‫(‪ AddRef ,Query Interface‬ו‪ .)Release-‬ואכן זהו ה‪ Interface-‬הבסיסי ביותר‪ IUnknown .‬אינו נורש מאף‬
‫‪ Interface‬אחר‬
‫‪ .1‬אם אתה מרגיש שאתה צריך קפה – זה הזמן!‬
‫הגדרת תכונות‬
‫‪‬‬
‫‪‬‬
‫עד כה ראינו איפה צופים בתכונות של ‪Interface‬‬
‫תכונות פרוצדורה של מחלקה נקבעים בשני מקומות חשובים‪:‬‬
‫‪ o‬הגדרת הפרוצדורה כפי שמופיעה בקוד קובעת‪:‬‬
‫‪‬‬
‫‪ ‬מהו סוג הפרוצדורה (‪ Property Let ,Property Get ,Function ,Sub‬או ‪)Event‬‬
‫‪ ‬מהם הפרמטרים המועברים לפרוצדורה (אם בכלל)‬
‫‪ ‬מהו הערך המוחזר מהפונקציה‬
‫‪ o‬תיבת הדו שיח ה‪:Procedure Attributes-‬‬
‫‪ ‬תיבת הדו שיח ה‪ Procedure Attributes-‬נמצאת תחת התפריט ‪Tools‬‬
‫‪ ‬תיבת דו שיח זו מאפשרת לשלוט במאפיינים רבים שאת חלקם נסקור רק בשיעורים הבאים‬
‫‪o‬‬
‫‪o‬‬
‫‪ :Name ‬שם הפרוצדורה‬
‫‪ :Description ‬תיאור קצר של הפרוצדורה‬
‫‪ :Project Help ‬שם קובץ העזרה של הפרוייקט (ניתן להגדרה מתוך חלון ה‪Project -‬‬
‫‪)Properties‬‬
‫‪ :Help Context ID ‬מגדיר את מספר הקשר העזרה בתוך קובץ העזרה‬
‫‪( :Procedure ID ‬מזהה שגרה)‪ :‬לכל שגרה ב‪ Interface-‬יש מספר זיהוי‪ .‬מספר זה משפיע על‬
‫אופן התנהגות השגרה‬
‫‪ :Use This Page In Property Browser ‬מגדיר את הדף שייפתח מבין דפי המאפיינים עבור‬
‫מאפיין זה‬
‫‪ :Property Category ‬הקטגוריה אליה שייכת הפרוצדורה (שים לב כי בחלון המאפיינים יש‬
‫אפשרות להציג מאפיינים לפי קטגוריות)‬
‫‪ :Hide This Member ‬מסתיר את הפרוצדורה ממשתמשי המחלקה‬
‫‪ :Don't Show In Property Browser ‬לא מציג את המאפיין בחלון המאפיינים‬
‫‪ :User Interface Default ‬האם הפרוצדורה תהיה פרוצדורת ברירת המחדל בחלון המאפיינים‬
‫‪ :Data Binding ‬האם הפרוצדורה יכולה להיות קשורה לנתונים חיצוניים‪ .‬נושא זה יידון‬
‫בהמשך הקורס‬
‫בהמשך שיעור זה תשתמש בתיבת דו שיח זו כדי להגדיר ‪( Procedure ID‬מזהה שגרה) עבור פרוצדורה‬
‫שתכתוב‬
‫ביתר ההגדרות שצויינו נשתמש בשיעורים הבאים‬
‫‪( COLLECTIONS‬אוספים)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ Collection‬הוא מבנה נתונים דינמי‬
‫‪ Collection‬הוא ‪ Class‬מוכן של ‪ ,Visual Basic‬כלומר‪ ,‬מבנה שניתן להוסיף ולהסיר ממנו פריטים במהלך ריצת‬
‫התוכנית‬
‫לפריטים באוסף יש אינדקסים הרצים מ‪ 1-‬עד ‪( Count‬כאשר ‪ Count‬הוא גודל ה‪)Collection-‬‬
‫פריטים הנוספים ל‪ Collection-‬הם מסוג ‪ ,Object‬לפיכך ניתן להוסיף ל‪ Collection-‬את כל סוגי האובייקטים‪,‬‬
‫כיוון שכולם נגזרים מ‪Object-‬‬
‫אם אתה מוסיף אובייקטים מסוגים שונים ל‪ Collection-‬תוכל להשתמש בזיהוי סוג האובייקט בזמן ריצה כדי‬
‫לבצע פעולות האופייניות רק לסוג מסוים‬
‫ניתן לבצע סריקה על אובייקטים ב‪ Collection-‬בשתי צורות‪:‬‬
‫‪ o‬לולאת ‪ For‬רגילה הרצה מ‪ 1-‬עד ‪Count‬‬
‫‪ o‬לולאת ‪ .For Each...In...Next‬סוג זה של לולאה נוסף לשפה כדי להקל את העבודה עם אוספים‬
‫תחביר‬
‫‪‬‬
‫תחביר ההצהרה על ‪ Collection‬הוא‪:‬‬
‫‪Dim coll As New Collection‬‬
‫‪‬‬
‫‪ o‬אפשר להצהיר ללא המילה ‪ New‬ואז ליצור את ה‪ Collection-‬מאוחר יותר‬
‫ל‪ Collection-‬יש את המאפיינים והמתודות הבאות‪:‬‬
‫‪ :Add o‬מוסיף פריט ל‪.Collection-‬‬
‫‪ ‬תחביר‪:‬‬
‫)]‪coll.Add (Item, [Key], [Before], [After‬‬
‫‪‬‬
‫‪ :Item‬זהו הפריט שיש להוסיף ל‪Collection-‬‬
‫‪o‬‬
‫‪ :Key ‬מחרוזת ייחודית שניתן להצמיד לפריט‪ .‬מאוחר יותר ניתן יהיה לאתר את הפריט‬
‫באמצעות מחרוזת זו‬
‫‪ :Before ‬מוסיף את הפריט לפני הפריט שהאינדקס שלו או המפתח (‪ )Key‬שלו מצוין ב‪.Before-‬‬
‫לא ניתן לציין ‪Before‬יחד עם ‪After‬‬
‫‪ :After ‬מוסיף את הפריט אחרי הפריט שהאינדקס שלו אן המפתח (‪ )Key‬שלו מצוין ב‪.After-‬‬
‫לא ניתן להשתמש ב‪ After-‬יחד עם ‪Before‬‬
‫‪ :Remove‬מסיר פריט מה‪:Collection-‬‬
‫‪ ‬תחביר‪:‬‬
‫)‪coll.Remove (Index‬‬
‫‪ :Index ‬מציין את האינדקס או המפתח (‪ )Key‬של הפריט שיש להסיר‬
‫‪ :Item‬מחזיר מצביע לפריט מסויים ב‪Collection-‬‬
‫‪ ‬תחביר‪:‬‬
‫)‪coll.Item (Index‬‬
‫‪‬‬
‫‪‬‬
‫‪ :Index‬מציין את האינדקס או המפתח (‪ )Key‬של הפריט שיש להחזיר‬
‫‪ Item‬הוא מאפיין ברירת המחדל‪ .‬לפיכך ניתן לפנות לפריט גם באופן הבא‪:‬‬
‫)‪coll(Index‬‬
‫‪o‬‬
‫‪ :Count‬מחזיר את מספר הפריטים ב‪Collection-‬‬
‫‪ ‬תחביר‪:‬‬
‫‪coll.Count‬‬
‫הלולאה ‪For each ..In .. Next‬‬
‫‪‬‬
‫‪‬‬
‫לולאה זו מיועדת לסריקת אובייקטים מתוך אוסף‬
‫תחביר הלולאה הוא כדלקמן‪:‬‬
‫‪‬‬
‫בכל איטרציה של הלולאה ‪ obj‬מתייחס לאובייקט הנוכחי ב‪Coll-‬‬
‫‪For Each obj In Coll‬‬
‫‪obj.Method1...‬‬
‫‪obj.Method2...‬‬
‫‪Next‬‬
‫תרגיל ‪ – 1‬התוכנ ית ‪ShapeColl1‬‬
‫‪ ‬התוכנית ‪ ShapeColl1‬תאפשר למשתמש להוסחף מלבנים או עיגולים‬
‫‪ ‬האובייקטים שייוצרו יצורפו ל‪ Collection-‬שיוצהר לשם כך‬
‫‪ ‬לחיצה על ‪ List Items‬תציג את כל הפריטים הנמצאים באוסף‬
‫‪ ‬סריקת האוסף נעשית באמצעות הלולאה ‪For Each ... In ... Next‬‬
‫‪ ‬הקצה לפרוייקט את השם ‪ ShapeColl1‬ולטופס את השם ‪frmTest‬‬
‫‪ .1‬הוסף שני ‪-Class Module‬ים לפרוייקט‪:‬‬
‫‪ ‬הקצה את השמות ‪ CCircle‬ו‪ CRect-‬למחלקות‬
‫‪ ‬שמור את הפרוייקט שוב‬
:CCircle-‫ הוסף את הקוד הבא ל‬.3
Option Explicit
Private Const PI As Double = 3.14
Private m_dRadius As Double
Public Property Get Radius() As Double
Radius = m_dRadius
End Property
Public Property Let Radius(dRad As Double)
If dRad >= 0 Then m_dRadius = dRad
End Property
Surface = PI * m_dRadius * m_dRadius
End Function
Perimeter = 2 * PI * m_dRadius
End Function
:CRect-‫ הוסף את הקוד הבא ל‬.1
Option Explicit
Private m_dLength As Double
Private m_dWidth As Double
Public Property Get Length() As Double
Length = m_dLength
End Property
Public Property Let Length(dLen As Double)
If dLen >= 0 Then m_dLength = dLen
End Property
Width = m_dWidth
End Property
Public Property Let Width(dWid As Double)
If dWid >= 0 Then m_dWidth = dWid
End Property
www.kita.co.il
Surface = m_dLength * m_dWidth
End Function
Perimeter = 2 * (m_dLength + m_dWidth)
End Function
:‫ אחד והגדר את המאפיינים הבאים‬TextBox-‫ים ו‬-CommandButon ‫הוסף ארבעה‬
‫ערך‬
Shape Collection Demo 1
3- Fixed Dialog
2-CenterScreen
cmdAddRect
Add Rectangle
cmdAddCircle
Add Circle
cmdListItemsMethod1
List items - Method 1
cmdListItemsMethod2
List items - Method 2
txtColl
ButtonFace
True
]‫[ריק‬
True
‫מאפיין‬
Caption
BorderStyle
StartUpPosition
Name
Caption
Name
Caption
Name
Caption
Name
Caption
Name
Background
Locked
Text
MultiLine
frmTest
Command1
Command2
Command3
Command4
Text1
:‫ הוסף את הקוד הבא לטופס‬.1
Option Explicit
Public shpColl As Collection
shpColl ‫ בשם‬Collection-‫בשורת קוד זו מוצהר מצביע ל‬

Set shpColl = New Collection
End Sub
Set shpColl = Nothing
End Sub
‫ עם‬Collection-‫ ומשחרר את ההתיחסות ל‬, ‫ חדש עם טעינת הטופס‬Collection ‫הקוד הנ"ל יוצר אובייקט‬
‫התפרקות הטופס‬
www.kita.co.il

Private Sub cmdAddCircle_Click()
Dim cr As CCircle
Set cr = New CCircle
cr.Radius = Val(InputBox("Enter the radius for the circle:"))
shpColl.Add cr
Set cr = Nothing
End Sub
Private Sub cmdAddRect_Click()
Dim rc As CRect
Set rc = New CRect
rc.Length = Val(InputBox("Enter the length of the rectangle:"))
rc.Width = Val(InputBox("Enter the width of the rectangle:"))
shpColl.Add rc
Set rc = Nothing
End Sub
‫ בהתאם ללחיצה של המשתמש‬,‫בשורות הקוד הנ"ל יוצרים עיגול או מלבן‬
InputBox ‫מאתחלים את האובייקט שנוצר על ידי שימוש בפונקציה‬
shpColl-‫מוסיפים את האובייקט ל‬



Private Sub cmdListItemsMethod1_Click()
Dim obj As Object
txtColl.Text = ""
On Error Resume Next
For Each obj In shpColl
txtColl.Text = txtColl.Text & TypeName(obj) & vbCrLf
txtColl.Text = txtColl.Text & String(8, " ") & _
"Length = " & obj.Length & vbCrLf
"Width = " & obj.Width & vbCrLf
"Radius = " & obj.Radius & vbCrLf
"Surface = " & obj.Surface & vbCrLf
"Perimeter = " & obj.Perimeter & vbCrLf
Next
End Sub
shpColl-‫בשורות קוד אלו מבצעים סריקה של האובייקטים ב‬
Surface ,Radius ,Width ,Length ‫עבור כל אובייקט מציגים (יותר מדוייק להגיד "מנסים להציג") את‬
Perimeter-‫ו‬
‫ אין את המאפיינים‬CCircle ‫ ולאובייקטים מסוג‬,Radius ‫ אין את המאפיין‬CRect ‫כיוון שלאובייקטים מסוג‬
‫ כדי להעביר את הביצוע לשורה הבאה אם מתרחשת‬On Error Resume Next-‫ קוראים ל‬,Width-‫ ו‬Length
‫שגיאה‬
www.kita.co.il



Late Binding ‫ ביצועי‬,‫ וכפי שראית בתרגיל הקודם‬,‫ כדי להציג פרטים‬Late Binding-‫שיטה זו משתמשת ב‬
!‫ צורות‬10000 ‫ חשוב כמה זמן היתה נמשכת פעולת הצגת הפרטים אם נניח שהאוסף מכיל‬.‫הם גרועים‬

Private Sub cmdListItemsMethod2_Click()
Dim obj As Object
Dim rc As CRect
Dim cr As CCircle
txtColl.Text = ""
On Error Resume Next
For Each obj In shpColl
If TypeOf obj Is CRect Then
Set rc = obj
txtColl.Text = txtColl.Text & "CRect" & vbCrLf
"Length = " & rc.Length & vbCrLf
"Width = " & rc.Width & vbCrLf
"Surface = " & rc.Surface & vbCrLf
"Perimeter = " & rc.Perimeter & vbCrLf
Else
Set cr = obj
txtColl.Text = txtColl.Text & "CCircle" & vbCrLf
"Radius = " & cr.Radius & vbCrLf
"Surface = " & rc.Surface & vbCrLf
"Perimeter = " & rc.Perimeter & vbCrLf
End If
Next
End Sub
shpColl-‫ גם כאן מבצעים סריקה על האובייקטים ב‬
‫ או מסוג‬CRect ‫ כאן נבחן סוג האובייקט ולאחר מכן הוא מושם למשתנה מסוג‬,‫ לעומת השיטה הקודמת‬
‫ שלהם וכתוצאה מקבלים ביצועים‬Type Library-‫ הגישה לאובייקטים נעשית דרך ה‬,‫ כיוון שכך‬.CCircle
.‫הרבה יותר טובים‬
:‫ בחינת התוכנית‬.1
‫ הרץ את התוכנית ובדוק את פעולתה‬
www.kita.co.il
‫מחלקות ‪ Collection‬מותאמות אישית‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫כפי שראית‪ Collection ,‬מקבל את הסוג ‪Object‬‬
‫ניתן ליצור מחלקות אוסף מותאמות‪ ,‬כך שמחלקות אלו יקבלו נתונים מסוג מסוים או מנגזרותיו‬
‫היתרון ב‪ Collection-‬מותאם אישית הוא בכך שהאובייקטים המוחזרים ממנו הם מסוג מסוים‪ ,‬לפיכך ניתן‬
‫להשתמש ב‪Early Binding-‬‬
‫משתמשים ב‪-Collection-‬ים גם כדי ליצור היררכית עצמים‬
‫היררכית ‪( ADO‬שתכיר בהמשך הקורס) היא דוגמה לצירוף של ‪-Class‬ים ו‪-Collection-‬ים היוצרים היררכיה‬
‫אחת‬
‫בתרגיל הבא תיצור ‪ .Collection‬משלך‪ ,‬בכל מקרה דע שתוכל להשתמש ב‪( VB Class Builder-‬אתה מציג אותו‬
‫ע"י בחירת ‪ Add Class Module‬מתפריט ‪ )Project‬כדי ליצור היררכת עצמים ואוספים‬
‫שים לב שבאוספים הנוצרים ע"י ‪ VB Class Builder‬המתודה ‪ Add‬יוצרת את האובייקטים‪ .‬בתרגיל שלפנינו‬
‫המתודה ‪ Add‬מקבלת את האובייקט בדיוק כמו ב‪ Collection-‬רגיל‬
‫הוללאה ‪ For Each...In...Next‬המוכרת לך‪ ,‬פועלת על ‪ Collection‬כיוון שהם ממשים פונקציה בשם ‪_NewEnum‬‬
‫(כפי שראית כשצפינו ב‪ Collection-‬ב‪)Object Browser-‬‬
‫המתודה ‪ NewEnum‬מאפשרת ללולאה לאתר רשומות ב‪ .Collection-‬למעשה ‪ Enumerator‬עוקב אחר המיקום‬
‫של הלולאה ב‪Collection-‬‬
‫כדי שהלולאה ‪ For Each...In...Next‬תפעל ב‪ Collection-‬שלך‪ ,‬עליך להוסיף פונקציה דומה‬
‫כפי שראינו ב‪ ,OLE View-‬ה‪ id-‬של המתודה ‪ _NewEnum‬הוא ‪ .  4‬לפיכך‪ ,‬גם למתודה שאתה תכתוב ה‪id-‬‬
‫חייב להיות ‪ .  4‬תוכל להגדיר זאת באמצעות תיבת הדו‪-‬שיח ‪( Procedure Attributes‬תוכל להבין מכך שהשם‬
‫שתיתן לפונקציה שלך הוא לא חשוב‪ ,‬מה שחשוב הוא שמספר הזיהוי שלה יהיה ‪)  4‬‬
‫כיוון שלא ניתן לכתוב ‪ Collection‬יעילים ב‪ ,Visual Bsic-‬משתמשים בטכניקה הנקראת ‪Object Containment‬‬
‫‪ and Delegation‬כדי ליצור ‪ Collections‬משלנו‪:‬‬
‫‪ :Containment o‬פירושה הכלה‪ .‬ובאופן יותר מעשי‪ ,‬האובייקט שאנו יוצרים מכיל אובייקט אחר‬
‫‪ :Delegation o‬פירושה האצלה‪ .‬כלומר‪ ,‬בעת קריאה לפונקציה של האובייקט שאנו יוצרים‪ ,‬אנו מעבירים‬
‫את הביצוע (העבודה השחורה) לאובייקט הפנימי‬
‫בתרגיל הבא נשתמש בעקרון הנ"ל כדי ליצור ‪ Collection‬משלנו לפי השלבים הבאים‪:‬‬
‫‪ o‬צור מחלקה והצהר על משתנה ‪ Collection‬פרטי למחלקה‬
‫‪ o‬הוסף למחלקה פרוצדורות ‪ Count ,Item ,Remove ,Add‬ו‪NewEnum-‬‬
‫‪ o‬כדי לאפשר ללולאה ‪ For Each ... In ... Next‬עליך להוסיף מתודה בשם ‪( NewEnum‬תוכל לתת לה גם‬
‫שם אחר‪ ,‬אך עדיף לתת לה שם זה)‬
‫‪ o‬ממש את הפרוצדורות של המחלקה שלך‪ ,‬ע"י קריאה לפרוצדורה המקבילה ב‪ Collection-‬שבתוך‬
‫המחלקה‬
‫‪ o‬מימוש ‪ NewEnum‬יפעיל את הפונקציה ‪ _NewEnum‬ב‪ Collection-‬הפנימי במחלקה‬
‫‪ o‬מתוך תיבת הדו שיח ‪ Procedure Attributes‬הגדר את מספר הזיהוי של המתודה ‪ NewEnum‬למספר –‪4‬‬
‫והגדר את הפונקציה ‪ Item‬כ‪Default-‬‬
‫תרגיל ‪ – 1‬התוכנ ית ‪ShapeColl2‬‬
‫‪ ‬בתוכנית הבאה תיצור היררכיה שלושה ‪-Class‬ים רגילים‪ CRect ,IShape :‬ו‪ ,CCircle-‬כאשר ‪ CRect‬ו‪CCircle-‬‬
‫ממשים את הממשק של ‪IShape‬‬
‫‪ ‬תיצור גם ‪ Collection‬המקבל את הסוג ‪ IShape‬ולפיכך גם תומך ב‪ CRect-‬ו‪CCircle-‬‬
‫‪ ‬הקצה לפרוייקט את השם ‪ SahpeColl2‬ולטופס את השם ‪frmTest‬‬
:‫ים‬-Class Module ‫ הוסף לפרוייקט ארבעה‬.1
Shapes-‫ ו‬CCircle ,CRect ,IShape ‫ים את השמות‬-Class-‫ הקצה ל‬
‫ שמור את הפרוייקט שוב‬
:IShape-‫ הוסף קוד ל‬.3
‫ לפיכך הפונקציות שלו רישות ממימוש‬,‫ מגדיר ממשק בלבד‬IShape 
Option Explicit
' Empty inside interface
End Function
‫ מחזירה את שטח הצורה‬Surface ‫הפונקציה‬

‫ מחזירה את היקף הצורה‬Perimeter ‫הפונקציה‬

End Function
Public Function FormatDetails() As String
End Function
:‫ מחזירה מחרוזת עם נתונים אודות‬FormatDetails ‫ הפונקציה‬
‫ סוג הצורה‬o
‫ פרמטרים שונים של הצורה‬o
‫ היקף הצורה‬o
‫ שטח צורה‬o
‫ כך שהמשמעות שתינתן לכל אחת מהפונקציות הנ"ל‬,CCircle-‫ וב‬CRect-‫ הממשק הנ"ל ממומש ב‬:‫ זכור‬
‫תהיה שונה בכל אחת מהמחלקות הללו‬
:CCircle ‫ הוסף קוד למחלקה‬.1
Option Explicit
Private Const PI As Double = 3.14
Implements IShape
Private m_dRadius As Double
Public Property Get Radius() As Double
Radius = m_dRadius
End Property
Public Property Let Radius(dRad As Double)
If dRad >= 0 Then m_dRadius = dRad
End Property
www.kita.co.il
IShape_Perimeter = 2 * PI * m_dRadius
End Function
P  2r ‫ בתוך המעגל‬IShape_Perimeter ‫מימוש הפונקציה‬

IShape_Surface = PI * m_dRadius * m_dRadius
End Function
S  r 2 ‫ בתוך המעגל‬IShape_Surface ‫מימוש הפונקציה‬

Private Function IShape_FormatDetails() As String
Dim strRes As String
strRes = "CCircle" & vbCrLf
strRes = strRes & String(8, " ") & "Radius = " & _
Trim(Str(Me.Radius)) & vbCrLf
strRes = strRes & String(8, " ") & "Perimeter = " & _
Trim(Str(IShape_Perimeter())) & vbCrLf
strRes = strRes & String(8, " ") & "Surface = " & _
Trim(Str(IShape_Surface())) & vbCrLf
IShape_FormatDetails = strRes
End Function
:‫ במעגל מחזיר מחרוזת המכילה‬FormatDetails ‫ המימוש שלם‬
)CCircle( ‫ שם המחלקה‬o
‫ רדיוס המעגל‬o
‫ היקף המעגל‬o
‫ שטח המעגל‬o
:CRect ‫ הוסף קוד למחלקה‬.1
Option Explicit
Implements IShape
Private m_dLength As Double
Private m_dWidth As Double
Public Property Get Length() As Double
Length = m_dLength
End Property
Public Property Let Length(dLen As Double)
If dLen >= 0 Then m_dLength = dLen
End Property
Width = m_dWidth
End Property
www.kita.co.il
Public Property Let Width(dWid As Double)
If dWid >= 0 Then m_dWidth = dWid
End Property
IShape_Perimeter = 2 * (m_dLength + m_dWidth)
End Function
IShape_Surface = m_dLength * m_dWidth
End Function
Private Function IShape_FormatDetails() As String
Dim strRes As String
strRes = "CRect" & vbCrLf
strRes = strRes & String(8, " ") & "Length = " & _
Trim(Str(Me.Length)) & vbCrLf
strRes = strRes & String(8, " ") & "Width = " & _
Trim(Str(Me.Width)) & vbCrLf
strRes = strRes & String(8, " ") & "Perimeter = " & _
Trim(Str(IShape_Perimeter())) & vbCrLf
strRes = strRes & String(8, " ") & "Surface = " & _
Trim(Str(IShape_Surface())) & vbCrLf
IShape_FormatDetails = strRes
End Function
:‫ במלבן מחזיר מחרוזת המכילה‬FormatDetails ‫ המימוש שלם‬
)CRect( ‫ שם המחלקה‬o
‫ אורך המלבן‬o
‫ רוחב המלבן‬o
‫ היקף המלבן‬o
‫ שטח המלבן‬o
:Shapes-‫ הוסף קוד ל‬.1
Option Explicit
Private m_coll As Collection
Private Sub Class_Initialize()
Set m_coll = New Collection
End Sub
Private Sub Class_Terminate()
Set m_coll = Nothing
End Sub
www.kita.co.il
‫בשורות הקוד הנ"ל מוצהר אובייקט ‪ Collection‬שיכיל בפועל את האובייקטים‬
‫‪ ‬בעת אתחול האובייקט (‪ )Initialize‬יוצרים ‪ Collection‬חדש‬
‫‪ ‬בעת שחרור האובייקט (‪ )Terminate‬משחררים את ה‪ Collection-‬שהוצהר‬
‫‪ ‬זהו למעשה קטע ה‪ Containment-‬במחלקה‪ .‬כלומר‪ ,‬במחלקה שלנו (‪ )Shapes‬מכילה אובייקט מסוג‬
‫‪Collection‬‬
‫)"" = ‪Public Sub Add(Item As IShape, Optional Key As String‬‬
‫‪If Len(Key) > 0 Then‬‬
‫‪m_coll.Add Item, Key‬‬
‫‪Else‬‬
‫‪m_coll.Add Item‬‬
‫‪End If‬‬
‫‪End Sub‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫הפונקציה ‪ Add‬מוסיפה אובייקט ל‪Collection-‬‬
‫הפעולה מתבצעת ע"י הפעלת ‪ Add‬מתוך ה‪ Collection-‬שהוצהר במחלקה‬
‫העברת הפעולה מהמחלקה שלנו לאובייקט שפנימי ‪ ,m_coll‬היא למעשה ‪( Delegation‬האצלה)‬
‫באופן דומה ננהג בפרוצדורות הבאות‬
‫)‪Public Sub Remove(Index As Variant‬‬
‫‪m_coll.Remove Index‬‬
‫‪End Sub‬‬
‫‪Public Function Item(Index As Variant) As IShape‬‬
‫)‪Set Item = m_coll.Item(Index‬‬
‫‪Public Function Count() As Long‬‬
‫‪Count = m_coll.Count‬‬
‫‪Public Property Get NewEnum() As IUnknown‬‬
‫]‪Set NewEnum = m_coll.[_NewEnum‬‬
‫‪ ‬בפונקציה ‪ NewEnum‬העברנו את הפעולה ל‪ _NewEnum-‬של האובייקט ‪m_coll‬‬
‫‪ ‬כיוון שאסור להשתמש בקו תחתון בתחילת שם פרוצדורה או משתנה ב‪ Visual Basic-‬אנו עוטפים את‬
‫המילה בסוגריים מרובעים‬
‫‪ .1‬הגדר את תכונות הפרוצדורות במחלקה ‪:Shapes‬‬
‫‪ ‬הישאר בחלון הקוד של ‪Shapes‬‬
‫‪ ‬מתוך התפריט ‪ Tools‬בחר ב‪Procedure Attributes...-‬‬
‫‪ ‬מתוך הרשימה ‪ Name‬בחר ב‪Item-‬‬
‫‪ ‬לחץ על הלחצן ‪ – Advanced‬תיבת הדו שיח תתרחב ותכלול אפשרויות נוספות‬
‫‪ ‬מתוך הרשימה ‪ Procedure ID‬בחר ב‪Default-‬‬
‫‪ ‬כך הגדרת את הפרוצדורה ‪ Item‬כפרוצדורת ברירת המחדל של ‪Shapes‬‬
‫‪ ‬בשדה ‪ Name‬בחר ב‪New Enum-‬‬
‫‪ ‬בתיבה ‪ Procedure ID‬רשום ‪ 4‬‬
‫‪ ‬ב‪ Attributes-‬סמן ‪ V‬ליד ‪Hide This Member‬‬
‫ אבל מומלץ להסתיר ממשתמש‬,‫ כמתודה נסתרת (לא היית חייב‬NewEnum ‫ באופן זה הגדרת את המתודה‬
‫ שלו מצפה‬ 4 ‫ את מזהה השגרה‬NewEnum-‫ כמו כן נתת ל‬.)‫המחלקה את מה שהוא לא אמור להשתמש בו‬
For Each...In...Next ‫הלולאה‬
Shapes ‫ לכל אחת מהפרוצדורות של‬Description ‫ כעת הוסף תיאור בשדה‬
:‫ והגדר את המאפיינים הבאים‬,‫ אחד לטופס‬TextBox-‫ים ו‬-CommandButton ‫ הוסף שלושה‬.1
‫ערך‬
Shapes Collection Demo 2
3- Fixed Dialog
2-CenterScreen
cmdAddRect
Add Rectangle
cmdAddCircle
Add Circle
cmdListItems
List items
txtColl
Button Face
True
2 - Vertical
]‫[ריק‬
True
‫מאפיין‬
Caption
BorderStyle
StartUpPosition
Name
Caption
Name
Caption
Name
Caption
Name
Background
Locked
ScrollBars
Text
MultiLine
frmTest
Command1
Command2
Command3
Text1
:‫הטופס אמור להיראות דומה לזה שבציור‬

Option Explicit
Public shpColl As Shapes
www.kita.co.il
Set shpColl = New Shapes
End Sub
Set shpColl = Nothing
End Sub
Shapes ‫ מסוג‬Collection ‫בשורות הנ"ל מוצהר אובייקט‬
‫אובייקט זה נוצר בעת טעינת הטופס ומשוחרר עם פריקת הטופס‬


Private Sub cmdAddCircle_Click()
Dim cr As CCircle
Set cr = New CCircle
cr.Radius = Val(InputBox("Enter the radius for the circle:"))
shpColl.Add cr
Set cr = Nothing
End Sub
Private Sub cmdAddRect_Click()
Dim rc As CRect
Set rc = New CRect
rc.Length = Val(InputBox("Enter the length of the rectangle:"))
rc.Width = Val(InputBox("Enter the width of the rectangle:"))
shpColl.Add rc
Set rc = Nothing
End Sub
‫ נוסף מלבן או מעגל בהתאם לבחירת המשתמש‬,‫בדומה לתרגיל הקודם‬

Private Sub cmdListItems_Click()
Dim shp As IShape
txtColl.Text = ""
For Each shp In shpColl
txtColl.Text = txtColl.Text & shp.FormatDetails
Next
End Sub
‫ נקראת כדי להציג‬FormatDetails ‫ והפונקציה‬Collection-‫ בקטע קוד זה מתבצעת סריקה של האובייקטים ב‬
‫את נתוני הצורה‬
‫ ולפיכך אנו קוראים‬,IShape ‫ כאן אנו יודעים מראש שאנו ניגשים לאובייקטים מסוג‬,‫ בשונה מהתרגיל הקודם‬
Early Binding-‫ אנו מרוויחים מהירות גבוהה המתאימה ל‬.FormatDetails ‫מיד לפונקציה‬
‫ הקוד כאן הרבה יותר קריא‬,‫ בנוסף לרווחים הביצועיים‬
:‫ בחינה ראשונה של התוכנית – הרצה‬.12
‫ הרץ את התוכנית ובחן את פעולה‬
1 ‫ בדוק אם הגדרת את תכונות הפרוצדורה בשלב‬,For Each...In...Next ‫ אם התקבלו שגיאות בלולאה‬
:Object Browser ‫ צפייה המחלקות באמצעות‬- ‫ בחינה שניה של התוכנית‬.11
View ‫ מתוך התפריט‬Object Browser-‫ פתח את חלון ה‬
www.kita.co.il
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫מתוך רשימת ה‪ Classes-‬מצא את המחלקה ‪( Shapes‬אם אינך רואה אותה‪ ,‬וודא שב‪ ComboBox-‬העליון‬
‫בחרת >‪ <All Libraries‬או ‪)ShapeColl2‬‬
‫בפנל הימני אתה אמור לראות את הפרוצדורות של ‪Shapes‬‬
‫שים לב שפרוצדורות מוסתרות גם מוצגות בפנל הימני‪ .‬כשתיצור ‪( DLL‬בשיעור הבא) פרוצדורות אלו יוסתרו‪.‬‬
‫שיעור ‪ActiveX DLL :11‬‬
‫‪ ‬תבין יותר את המושגים ‪ Thread ,Address Space ,Process‬ו‪Component-‬‬
‫‪ ‬תלמד ליצור רכיבי ‪ ActiveX‬מסוג ‪ActiveX DLL‬‬
‫‪ ‬תלמד כיצד להשתמש ברכיבים שנכתבו כ‪ ActiveX DLL-‬מתוך תוכנית אחרת‬
‫‪ ‬תכיר את המושג ‪Instancing‬‬
‫‪ ‬תבין כיצד ‪ Windows‬טוענת קובץ ‪ DLL‬לתוך תוכנית‬
‫‪ ‬תלמד לטפל בשגיאות בתוך רכיבים שתכתוב‬
‫מושגים‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫בסעיף זה תכיר מספר מושגים שיוכלו לסייע לך לנצל טוב יותר את מערכת ‪ ,Windows‬להבין מהו ‪,Component‬‬
‫ולהכיר טוב יותר את ההבדל בין סוגי ה‪-Component-‬ות שניתן לפתח ב‪Visual Basic-‬‬
‫‪( Inctance‬מופע) של תוכנית‪ :‬ניתן להריץ תוכנית מספר פעמים‪ .‬כל הרצה נפרדת של תוכנית נקראת ‪ Instance‬של‬
‫התוכנית‪ .‬כך למשל‪ ,‬אם הרצת את ‪ Microsoft Word‬שלוש פעמים‪ ,‬כל הרצה כזו מהווה ‪ Instance‬של ‪Microsoft‬‬
‫‪Word‬‬
‫‪( Process‬תהליך)‪ :‬אוסף המשאבים הדרושים להרצת ‪ Instance‬של תוכנית נקרא ‪ .Process‬ה‪ Process-‬מנהל את‬
‫המשאבים הקשורים בתוכנית שרצה‪ .‬משאבים לדוגמה הם‪ :‬הקצאת זיכרון לתוכנית‪ ,‬יצירת ‪-Thread‬ים (יוסבר‬
‫בהמשך)‪ ,‬טעינת רכיבי ‪ DLL‬וכו'‪ .‬ברגע שתוכנית מסתיימת‪ ,‬מערכת ההפעלה פורקת את ה‪ Process-‬וכל‬
‫המשאבים הקשורים אליו‪.‬‬
‫‪( Thread‬מטלת ביצוע)‪ Thread :‬הינו רצף של פקודות שעל המחשב לבצע‪ Thread .‬הינו משאב הצורך בפועל זמן‬
‫מעבד‪ .‬ב‪ Process-‬אחד יכולים להיות מספר ‪-Thread‬ים שרצים בו זמנית‪ .‬כך למשל‪ ,‬התוכנית ‪Microsoft Word‬‬
‫מאפשרת לך לערוך ולהדפיס בו זמנית על ידי הרצת ‪ Thread‬נפרד עבור פעולת ההדפסה‪ .‬בעת טעינת ‪Process‬‬
‫מערכת ההפעלה יוצרת באופן אוטומטי ‪ Thread‬עבור ה‪ Process-‬שהורץ‪ Thread .‬זה נקרה ה‪ Thread-‬הראשי של‬
‫התוכנית‪.‬‬
‫‪( Address Space‬מרחב כתובות)‪ Address Space :‬הוא מרחב כתובות של ‪ 4( 4G‬ג'יגה)‪ .‬לכל ‪ Process‬ישנו מרחב‬
‫זכרון משלו‪ .‬תוכל להסיק מכך שאם תוכנית מנסה לגשת לכתובת מסוימת ותוכנית אחרת מנסה לגשת לאותה‬
‫הכתובת‪ ,‬כל תוכנית תיגש בפפועל לנתונים ייחודיים משלה – כלומר יש הגנה על מרחב הכתובות מפני ‪-Process‬ים‬
‫אחרים‪ .‬תשאל את עצמך‪ ,‬בוודאי‪ ,‬איך ייתכן שלכל ‪ Process‬ישנם ‪ 4G‬כתובות זכרון‪ ,‬והרי זיכרון ה‪ RAM-‬הוא‬
‫מצומצם מאוד (בדרך כלל בין ‪ 32M‬ל‪ 256M-‬ברוב המחשבים)‪ .‬יתרה מזאת‪ ,‬אם נניח שישנם ‪-Process 50‬ים‬
‫שרצים במקביל במערכת‪ ,‬כי אז אנו מדברים על ‪ 200G‬זיכרון ( ‪ .) 50  4G  200G‬תפתור את עצמך מטרדה זו‪,‬‬
‫בכך שתדע (מבלי שניכנס לפרטים טכניים) כי מערכת ההפעלה עושה שימוש חסכוני בכתובות על ידי שימוש‬
‫במספר טריקים‪ ,‬כגון שימוש ב‪-Page-‬ים (דפי זכרון)‪( Page Tables ,‬טבלאות דפים) ועוד‪ .‬היבט נוסף שחשוב לשים‬
‫לב אליו‪ ,‬בעוד שלכל ‪ Process‬יש ‪ Address Space‬משלו‪-Thread ,‬ים הרצים באותו ה‪ Process-‬משתתפים באותו‬
‫‪ .Address Space‬תוכל להסיק מכך ש‪-Thread-‬ים הרצים תחת אותו ‪ Process‬יכולים לשתף בניהם מידע גלובלי‪.‬‬
‫‪ – Executable File( EXE‬קובץ ריצה)‪ :‬קובץ ‪ EXE‬הוא קובץ תוכנית שעם הרצתו נוצר עבורו ‪ Instance‬חדש‪,‬‬
‫וכתוצאה מכך נוצר ‪ Process‬במערכת‪ .‬ל‪ Process-‬שנוצר מוקצים מיד ‪ Main Thread ,Address Space‬ועוד‪.‬‬
‫‪ – Dynamic Link Library( DLL‬ספריית קישור דינמי)‪ :‬קובץ ‪ DLL‬הוא קובץ שיכול ליצא משאבים (למשל‬
‫‪-Icon‬ים‪ ,‬מחרוזות ועוד)‪ ,‬כמו גם פונקציות‪ .‬משמעות המושג ליצא היא‪ ,‬שמשאבים אלו נועדו לשימושן של‬
‫תוכניות אחרות‪ ,‬כלומר‪ ,‬תוכניות שייבאו ת המשאבים הללו‪.‬כיוון ש‪ DLL -‬אינו רץ בפני עצמו‪ ,‬אלא משמש‬
‫תוכניות ‪ .EXE‬קובץ ‪ DLL‬הנטען על ידי תוכנית‪ ,‬נטען לתוך ה‪ Address Space-‬של ה‪.Process-‬‬
‫‪‬‬
‫‪( Component‬רכיב)‪( Component :‬כפי שהוסבר בפרק ‪ )8‬הוא רכיב בינרי‪ Component .‬יכול להיות מאוחסן‬
‫בקובץ ‪ DLL ,EXE‬ועוד‪ .‬נבדיל בין מספר מושגים הקשורים ב‪-Component -‬ות‪:‬‬
‫‪( Server Component o‬רכיב שרת)‪ :‬זהו ‪ Component‬המספק שירותים‪ .‬כך למשל ניתן לכתוב‬
‫‪ Component‬מיוחד‪ ,‬המספק שירותי חישובים מתמטיים ועוד‪.‬‬
‫‪( Client Component o‬רכיב לקוח)‪ :‬זהו רכיב המנצל שירותים של רכיב אחר‪.‬‬
‫שים לב‪ Client Component :‬יכול להיות גם ‪ .Server Component‬כך למשל ייתכן ש‪Component-‬‬
‫מסוים מספק שירותים מסוימים ומבחינה זו הוא ‪ ,Server‬אך במקביל מנצל שירותים של ‪Component‬‬
‫אחר כדי להשלים את המשימה‪ ,‬ובחינה זו הוא ‪.Client‬‬
‫‪( In Process Component o‬רכיב תוך תהליכי)‪ :‬זו ‪ Component‬הנטען אל תוך ‪ Address Space‬של‬
‫‪ Process‬קיים‪ .‬חשוב למשל על ‪ Control‬מיוחד המציג לוח שנה‪ ,‬וממוקם על טופס בתוכנית שלך‪ .‬רכיב זה‬
‫הינו חלק מהתוכנית והוא נטען לתוך התוכנית‪.‬‬
‫‪( Out Of Process Component o‬רכיב חוץ תהליכי)‪ :‬זהו רכיב הרץ כתוכנית עצמאית ומספק שירותים‬
‫לתוכניות אחרות‪ .‬חשוב למשל על התוכנית שלך המריצה את ‪ Microsoft Word‬כדי לננצל את שירותי‬
‫האיות (‪ )Spelling‬של ‪ .Microsoft Word‬במקרה זה ה‪ Server Component-‬הנו התוכנית ‪ Word‬הרצה‬
‫ב‪ Process-‬נפרד (‪ Word‬היא תוכנית ‪ EXE‬ולכן היא רצה כתוכנית עצמאית)‬
‫יצירת‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ACTIVEX DLL‬‬
‫יש לבחור את הפרוייקט ‪ActiveX DLL‬‬
‫יש להבחין בין ‪-DLL‬ים שנוצרים ב‪ Visual Basic-‬לבין ‪-DLL‬ים רגילים‪-DLL .‬ים הנוצרים ב‪ Visual Basic-‬הם‬
‫מסוג ‪ ActiveX‬ולפיכך מהווים ספריות של רכיבים‪ .‬ב‪ DLL-‬מסוס זה אין גישה ישירה לפונקציה מסוימת‪ ,‬אלא‬
‫קיימת אפשרות ליצור רכיב‪ .‬לאחר שהרכיב נוצר ניתן לפנות למתודות שלו‪ .‬כלומר ‪-DLL‬ים של ‪ActiveX‬‬
‫מייצאים רכיבים ולא פונקציות‪-DLL .‬ים רגילים של ‪ Win32‬מייצאים פונקציות‪.‬‬
‫כל רכיב ב‪ DLL-‬נכתב ב‪ Class Module-‬נפרד‬
‫יצירת אובייקטים‬
‫יישום לקוח יכול המעוניין להשתמש ברכיבים מספרייה חיצונית יכול לבצע זאת במספר דרכים‪:‬‬
‫‪ ‬הוספת הפניה ב‪ ,Project References-‬ולאחר מכן יצירת אובייקט באמצעות המילה ‪.New‬‬
‫‪ ‬יצירת אובייקט והמתו למשתנה מסוג ‪ Object‬באמצעות הפונקציה ‪( CreateObject‬במקרה כזה יהי שימוש‬
‫ב‪ .Late Binding-‬כדי להמנע מכך‪ ,‬ניתו ליצור משתנה מסוג האובייקט‪ ,‬ולהוסחף את ההפניה המתאימה‬
‫ב‪)Project References-‬‬
‫‪ ‬באמצעות הפונקציה ‪ CreateObject‬ניתן ליצור אובייקטים גם במחשבים מרוחקים‪ .‬פשוט יש להעביר את שם‬
‫המחשב ברשת כפרמטר שני לפונקציה לפי התחביר הבא‪:‬‬
‫)‪CreateObject(component_name, computer_name‬‬
‫הצגת ממשק משתמש‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫רכיב ‪ DLL‬יכול ליצור ממשק משתמש למשל על ידי קריאה לפונקציה ‪MsgBox‬‬
‫ניתן למנוע הצגת ממשק משתמש על ידי הרכיב אם מסמנים ‪ V‬ליד האפשרות ‪Unattended Execution‬‬
‫בכרטיסיית ‪ General‬בחלון ה‪Project Properties-‬‬
‫אם רכיב שהוגדר עבור ‪ Unattended Execution‬מנסה להציג ממשק משתמש‪ ,‬תירשם הודעה בקובץ ה‪ Log-‬של‬
‫המערכת (ב‪ Windows 2000-‬ניתן לצפות בהודעה מתוך חלון ה‪ Event Viewer-‬תחת הקטגוריה ‪Application‬‬
‫‪ .Log‬היישום ‪ Application Viewer‬נמצא תחת ‪)Administrative Tools‬‬
‫ניהול קבוצת פרוייקטים במקביל‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫בעת פיתוח רכיב יש לבחון אותו במקביל לפיתוח‬
‫ניתן ליצור קבוצת פרוייקטים ב‪ Visual Basic-‬ולנהל אותם במקביל‬
‫‪ Visual Basic‬יוצרת קובץ פרוייקט (‪ )*.vbg‬השוקב אחר מיקום הפרוייקטים ומנהל אותם‬
‫אני ממליץ בפניך ליצור ספרייה עבור קבוצת הפרוייקטים‪ .‬תחת ספרייה זו צור תתי ספריות עבור כל פרוייקט‬
‫בקבוצת הפרוייקטים‪ .‬את הקבצים של כל פרוייקט שמור בספרייה השייכת לפרוייקט‪ ,‬ואת קובץ הפרוייקט שמור‬
‫תחת ספריית הקבוצה‬
‫תרגיל ‪ – 1‬ספריית הרכיבים ‪SecurityLib‬‬
‫‪ ‬בתרגיל זה ניצור רכיב ‪ DLL‬המאפשר הצגת מסך ‪ ,Login‬ובדיקת וסיסמה‬
‫‪ ‬הפונקציה ‪ Login‬תציג את מסך ה‪ .Login-‬אם הסיסמה שהוכנסה תקינה‪ ,‬הפונקציה תחזיר ‪ ,True‬אחרת יוחזר‬
‫‪Flase‬‬
‫‪ ‬בדוגמה זו אנו מניחים שהמשתמש היחד הוא "‪ "superuser‬ושסיסמתו היא "‪ ,"1234‬ברור עם זאת שביישום‬
‫אמיתי תכתוב משהו קצת פחות טיפשי‬
‫‪ .1‬צור קבוצת פרוייקטים ‪ ActiveX DLL‬ו‪:Standard EXE-‬‬
‫‪ ‬פתח את ‪ Visual Basic‬יחד עם פרוייקט מסוג ‪ActiveX DLL‬‬
‫‪ ‬שנה את שם הפרוייקט ל‪SecurityLib-‬‬
‫‪ ‬בתוך הפרוייקט ישנו ‪ .Class Module‬שנה את שמו ל‪CLogin-‬‬
‫‪ ‬הוסף פרוייקט ‪ Standard EXE‬על ידי בחירת האפשרות ‪ Add Project‬מהתפריט ‪File‬‬
‫‪ ‬שנה את שם הפרוייקט ל‪ TestLib-‬ואת שם הטופס שבו ל‪frmTestLib-‬‬
‫‪ .1‬שמור את קבוצת הפרוייקטים‪:‬‬
‫‪ ‬בעת לחיצה על ‪ Save‬ייפתח חלון השמירה‪ .‬צור ספרייה בשם ‪ Security‬ותחת ספרייה זו צור שתי ספריות‬
‫בשם ‪ SecurityLib‬ו‪TestLib-‬‬
‫‪ ‬את קבצי פרוייקט ה‪ ActiveX DLL-‬שמור תחת הספרייה ‪ SecurityLib‬ואת קובצי פרוייקט ה‪Standard -‬‬
‫‪ EXE‬שמור תחת הספרייה ‪TestLib‬‬
‫‪ ‬לאחר שתשמור את הפרוייקטים ‪ Visual Basic‬תבקש ממשך לשמור את קובץ קבוצת הפרוייקטים‪ .‬שנה את‬
‫שם הקובץ ל‪ grpSecurity.vbg-‬ושמור אותו תחת הספרייה ‪Security‬‬
‫‪ .3‬הוסף טופס לספריית הרכיבים‪:‬‬
‫‪ ‬בחלון ה‪ Project Explorer-‬בחר בפרוייקט ‪( SecurityLib‬אם אינך רואה את חלון ה‪ Project Explorer-‬תוכל‬
‫לבחור אותו מתוך התפריט ‪ View‬או על ידי הצירוף ‪)Ctrl+R‬‬
‫‪ ‬הוסף טופס על ידי בחירת האפשרות ‪ Add Form‬מתוך התפריט ‪Project‬‬
‫‪ ‬שנה את שם הטופס ל‪frmLogin-‬‬
‫‪ ‬שמור את הטופס תחת הספרייה השייכת לפרוייקט ‪)\Security\SecurityLib\( SecurityLib‬‬
‫עצב את הטופס ‪:frmLogin‬‬
‫‪ ‬הוסף שני ‪-TextBox‬ים‪ ,‬שני ‪-CommandButton‬ים ושני ‪-Label‬ים לטופס‪ ,‬והגדר את המאפיינים הבאים‪:‬‬
‫‪frmLogin‬‬
‫‪Label1‬‬
‫‪Label2‬‬
‫מאפיין‬
‫‪Caption‬‬
‫‪Name‬‬
‫‪Caption‬‬
‫‪TabIndex‬‬
‫‪Name‬‬
‫ערך‬
‫‪Login‬‬
‫‪3- Fixed Dialog‬‬
‫‪1-CenterOwner‬‬
‫‪lblUsername‬‬
‫‪&Username‬‬
‫‪0‬‬
‫‪lblPassword‬‬
ActiveX DLL :11 ‫שיעור‬
&Password
2
txtUsername
]‫[ריק‬
1
txtPassword
8
*
]‫[ריק‬
3
cmdOK
&OK
True
cmdCancel
&Cancel
True
Caption
TabIndex
Name
Text
TabIndex
Name
MaxLength
PasswordChar
Text
TabIndex
Name
Caption
Default
Name
Caption
Cancel
Text1
Text2
Command1
Command2
:‫הטופס אמור להיראות בדומה לציור שלפניך‬

:frmLogin ‫ הוסף קוד לטופס‬.1
Option Explicit
Private m_strUsername As String
Private m_strPassword As String
‫שני המשתנים הללו יכילו את שם המשתמש והסיסמה לאחר שהטופס יוסר‬

Private Sub cmdOK_Click()
m_strUsername = txtUsername.Text
m_strPassword = txtPassword.Text
Unload Me
End Sub
‫ והטופס מפורק‬m_strPassword-‫ ו‬m_strUsername ‫ מועברים מעוגכנים ערכי המשתנים‬OK ‫בעת לחיצה על‬
Unload ‫על ידי המתודה‬
‫ ברגע‬.‫ עדיין קיימים בזכרון‬m_strPassword-‫ ו‬m_strUsername ‫ למרות שהטופס מפורק המשתנים‬:‫שים לב‬
.‫ יפורקו גם המשתנים הללו‬Set...= Nothing ‫ידי‬-‫שהטופס ישוחרר מהזכרון על‬
www.kita.co.il


Private Sub cmdCancel_Click()
Unload Me
End Sub
m_strPassword-‫ ו‬m_strUsername ‫ הטופס מפורק מבלי לעדכן את‬Cancel ‫בעת לחיצה על‬

Public Property Get Username() As String
Username = m_strUsername
End Property
Public Property Get Password() As String
Password = m_strPassword
End Property
m_strPassword-‫ ו‬m_strUsername ‫ שני פרוצדורות המאפיינים הללו מאפשרים לאחזר את ערכם של‬
:CLogin ‫ הוסף קוד למחלקה‬.1
Option Explicit
Public Function ShowLogin() As Boolean
Dim loginForm As New frmLogin
loginForm.Show vbModal
If LCase(loginForm.Username) = "superuser" And _
loginForm.Password = "1234" Then
ShowLogin = True
Else
ShowLogin = False
End If
Set loginForm = Nothing
End Function
‫ ומציגה אותו למשתמש במצב מודאלי‬frmLogin ‫ של הטופס‬Instance ‫ יוצרת‬ShowLogin ‫ הפונקציה‬
‫ אם‬.loginForm ‫ של‬Password-‫ ו‬Username ‫ נבדקים המאפיינים‬Cancel ‫ או‬OK ‫ לאחר שהמשתמש לחץ על‬
False ‫ אחרת יוחזר‬,True ‫ אזי מוחזר מהפונקציה הערך‬,‫" בהתאמה‬1234"–‫" ו‬superuser"-‫הם שווים ל‬
:TestLib ‫ עבור לפרוייקט‬.1
Project Explorer-‫ בחלון ה‬TestLib ‫ לחץ על שם הפרוייקט‬
:frmTestLib ‫עצב את הטופס‬
:‫ים והגדר את המאפיינים הבאים‬-CommandButton ‫ שני‬frmTestLib ‫ הוסף לטופס‬
‫ערך‬
Test Login
3- Fixed Dialog
2-CenterScreen
cmdUseNew
Use "Set ...New"
cmdUseCreate
Use "CreateObject (...)"
‫מאפיין‬
Caption
BorderStyle
StartUpPosition
Name
Caption
Name
Caption
www.kita.co.il
frmTestLib
Command1
Command2
‫‪‬‬
‫הטופס אמור להיראות דומה לזה שבציור שלפניך‪:‬‬
‫‪ .1‬הוסף ‪ Reference‬לפרוייקט ‪:SecurityLib‬‬
‫‪ ‬מתוך התפריט ‪ Project‬בחר באפשרות ‪References‬‬
‫‪ ‬סמן ‪ V‬ליד הספרייה ‪SecurityLib‬‬
‫‪ ‬שים לב‪ :‬ללא הפניה זו לא תוכל ליצור אובייקטים או משתנים מהסוג ‪ CLogin‬בתוך יישום הלקוח (במקרה‬
‫הזה התוכנית ‪ )TestLib‬תוך שימוש במילה ‪ .New‬עם זאת‪ ,‬תוכל ליצור אובייקטים באמצעות הפונקציה‬
‫‪ CreateObject‬תוך ציון שם הספרייה ושם הרכיב בספרייה‪ ,‬כלומר )"‪CreateObject("SecurityLib.CLogin‬‬
‫‪ .1‬הוסף קוד לטופס ‪:frmTestLib‬‬
‫)(‪Private Sub cmdUseNew_Click‬‬
‫‪Dim sec As New SecurityLib.CLogin‬‬
‫‪If sec.ShowLogin() Then‬‬
‫"!‪MsgBox "You are succesfull logged in‬‬
‫‪Else‬‬
‫"!‪MsgBox "Login Failed‬‬
‫‪End If‬‬
‫‪Set sec = Nothing‬‬
‫‪End Sub‬‬
‫‪‬‬
‫‪‬‬
‫בתגובה לליחצה על ‪ cmdUseNew‬יוצרים מופע של המחלקה ‪ CLogin‬מתוך הספרייה ‪SecurityLib‬‬
‫לאחר מכן מפעילים את הפונקציה ‪ ShowLogin‬ומציגים הודעה למשתמש באמצעות ‪ Message Box‬על פי‬
‫התוצאה המוחזרת מ‪ShoLogin-‬‬
‫)(‪Private Sub cmdUseCreate_Click‬‬
‫‪Dim sec As Object‬‬
‫)"‪Set sec = CreateObject("SecurityLib.CLogin‬‬
‫‪If sec.ShowLogin() Then‬‬
‫‪Else‬‬
‫‪End If‬‬
‫‪Set sec = Nothing‬‬
‫‪End Sub‬‬
‫‪‬‬
‫פונקציה זו זהה לקודמת אלא שהפעם האובייקט נוצר באמצעות ‪ CreateObject‬ומושם לתוך משתנה מסוג‬
‫‪Object‬‬
‫‪.1‬‬
‫‪.12‬‬
‫‪.11‬‬
‫‪.11‬‬
‫קבע את ה‪:Start Up Project-‬‬
‫‪ ‬לפני שתנסה להריץ את הפרוייקט עליך לקבוע איזה פרוייקט יופעל על ידי ‪Visual Basic‬‬
‫‪ ‬בחלון ה‪ Project Explorer-‬לחץ לחיצה ימנית על הפרוייקט ‪ .TestLib‬בתגובה יוצג תפריט מוקפץ שהאפשרות‬
‫הראשונה בו היא ‪ .Set As Start Up‬בחר באפשרות זו‪.‬‬
‫‪ ‬שים לב ש‪ Visual Basic-‬הדגישה את שם הפרוייקט‬
‫בחינה ראשונה של הפרוייקט‪:‬‬
‫‪ ‬הרץ את התוכנית באמצעות ‪ F5‬ובחן את פעולתה‬
‫בחינה שניה של הפרוייקט‪:‬‬
‫‪ ‬בטל את ה‪ Reference-‬לספרייה ‪ SecurityLib‬על ידי הסרת סימן ה‪ V-‬מתיבת הדו שיח ‪.References‬‬
‫(לפתיחת תיבת דו שיח זו בחר ב‪ References-‬מתוך התפריט ‪)Project‬‬
‫‪ ‬נסה להריץ את הפרוייקט‪ .‬שים לב כי לחיצה על הלחצן "‪ Use "Set...New‬תגרום לשגיאה‪ ,‬ואילו שימוש‬
‫ב‪ Use "CreateObject (...)"-‬ימשיך לפעול‬
‫שמור את הפרוייקטים‪:‬‬
‫‪ ‬החזר את ה‪ Reference-‬שביטלת‬
‫‪ ‬שמור את הפרוייקטים‬
‫‪ ‬אם אתה לא הולך לישון‪ ,‬השאר את הפרוייקטים פתוחים‪ .‬בתרגיל הבא נעשה שימוש בקובוצת פרוייקטים זו‬
‫‪( Instancing‬יצירת מופעים)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫לכל ‪ Class Module‬ישנו מאפיין ‪ Instancing‬המגדיר כיצד ניתן ליצור אובייקטים מסוג המחלקה‬
‫המאפיין ‪ Instancing‬משפיע על אופן יצירת האובייקטים על ידי תוכנית חיצונית המשתמשת בספריית הרכיבים‪.‬‬
‫מאפיין זה אינו משפיע על אופן יצירת הרכיבים מתוך הפרוייקט עצמו‪.‬‬
‫‪ Instancing‬עבור ‪ Class‬בפרוייקט מסוג ‪ ActiveX DLL‬מאפשר את הערכים הבאים‪:‬‬
‫‪ :Private‬ה‪ Class-‬הוא פרטי של הפרוייקט‪ .‬יישומים חיצוניים אינם יכולים ליצור אובייקטים מסוג המחלקה‪.‬‬
‫יתרה מכך‪ ,‬יישומים חיצוניים אינם יכולים להצהיר אפילו על משתנים מסוג המחלקה‪ .‬כלומר‪ ,‬ה‪-Class-‬ים הללו‬
‫פרטיים באופן מוחלט בפרוייקט ואינם מוכרים כלל מיישומים חיצוניים‪.‬‬
‫‪ :PublicNoCreatable‬ה‪ Class-‬יהיה מוכר ביישומים חיצוניים באופן כזה שניתן להצהיר על משתני ייחוס מסוג‬
‫האובייקט הזה‪ .‬עם זאת‪ ,‬יישומים חיצוניים אינם יכולים ליצור בעצמם אובייקטים מסוג המחלקה‪.‬‬
‫‪ :MultiUse‬כל האובייקטים הנוצרים על ידי יישום חיצוני משתתפים בעותק אחד של ה‪ .Class-‬ברור שעבור‬
‫המשתנים הפנימיים של ה‪ Class-‬נוצרים העתקים עבור כל יצירת אובייקט על ידי יישום לקוח‪ ,‬עם זאת‪ ,‬הקוד‬
‫מופיע פעם אחת‪.‬‬
‫‪ :GlobalMultiUse‬זהה ל‪ MultiUse-‬אלא שהיישום החיצוני אינו חייב‪.‬ליצור עותק של האובייקט‪ .‬כלומר באופן‬
‫אוטומטי נוצר אובייקט כזה על ידי ספריית הרכיבים‪ .‬כמו כן‪ ,‬היישום יכול לפנות לפונקציות של המחלקה ללא‬
‫הקדמת שם אובייקט‪ .‬אם לדוגמה קיימת מחלקה בשם ‪ CStatistics‬הכוללת את הפונקציה ‪ ,StdDev‬אפשר‬
‫להשתמש בפונקציה פשוט על ידי רישום )‪ StdDev(...‬כאילו היה מדובר בפונקציה גלובלית‪.‬‬
‫שים לב‪ :‬בכל פרוייקט ‪ ActiveX‬חייב להיות לפחות ‪ Class‬אחד הניתן ליצירה‬
‫תרגיל ‪ – 2‬שינוי המאפיין ‪ Instancing‬במחלקה ‪CLogin‬‬
‫‪ ‬בתרגיל זה ננסה את האפשרות ‪ GlobalMultiUse‬במקום ‪MultiUse‬‬
‫‪ .1‬פתח את קבוצת הפרוייקטים ‪:grpSecurity.vbg‬‬
‫‪ ‬אם סגרת את קבוצת הפרוייקטים ‪ grpSecurity‬תוכל לפתוח אותה מתוך הסייר על ידי לחיצה כפולה על שם‬
‫הקובץ ‪grpSecurity.vbg‬‬
‫‪ .1‬שנה את המאפיינן ‪:Instancing‬‬
‫‪ ‬שנה את המאפיין ‪ Instancing‬של המחלקה ‪ CLogin‬ל‪GlobalMultiUse-‬‬
‫‪ .3‬בחינה ראשונה‪:‬‬
‫‪ ‬הרץ את הפרוייקט‬
‫‪ ‬שים לב שהכל פועל כרגיל‬
‫‪ .1‬בחינה שניה‪:‬‬
‫‪ ‬הוסף ‪ CommandButton‬נוסף לטופס שנה את שמו ל‪ cmdUseGlobal-‬ואת הכותרת שלו ל‪"Use Global"-‬‬
‫‪ ‬הוסף את הקוד הבא בתגובה ללחיצה על ‪:cmdUseGlobal‬‬
‫)(‪Private Sub cmdUsetGlobal_Click‬‬
‫‪If ShowLogin() Then‬‬
‫‪Else‬‬
‫‪End If‬‬
‫‪End Sub‬‬
‫‪ ‬שים לב כי הפונקציה ‪ ShowLogin‬מופעלת כאילו הייתה פונקציה גלובלית‪ .‬דבר זה מתאפשר הודות להגדרת‬
‫‪ CLogin‬כ‪ .GlobalMultiUse-‬במקרה זה נוצר עבורנו אובייקט מסוג ‪ CLogin‬בעת שהתוכנית מופעלת‬
‫והפונקציות שלה נחשפות באופן אוטומטי‪ .‬כמו כן שים לב שאתה יכול לרשום ‪SecurityLib.ShowLogin‬‬
‫כאילו מדובר בפונקציה גלובלית של הספרייה‬
‫‪ .1‬שמור את קבוצת הפרוייקטים‪:‬‬
‫‪ ‬מתוך התפריט ‪ File‬בחר ב‪Save-‬‬
‫‪ ‬אם עדיין לא נרדמת אז תיאר ער עוד קצת‪ .‬בתרגיל הבא נסיים את העבודה על קבוצת הפרוייקטים הזו‪.‬‬
‫הגדרת כתובות בסיס לרכיבי ‪DLL‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫רכיב ‪( DLL‬כפי שהוסבר בתחילת השיעור) נטען לתוך ה‪ Address Space-‬של תוכנית הלקוח‬
‫בעת קימפול הרכיב‪ ,‬קריאות לפונקציות מתפרשות לפי כתובות הפונקציות‪ .‬לדוגמה‪ ,‬אם נניח שפונקציה מסוימת‬
‫נמצאת במרחק (‪ &H00000100 )Offset‬מתחילת ה‪ DLL-‬ואותו ‪ DLL‬קומפל מתוך הנחה שייטען לכתובת‬
‫‪ &H11000000‬בתוכנית הלקוח (זוהי כתובת הבסיס)‪ ,‬אזי כתובת הפונקציה לאחר הקימפול תהיה‬
‫‪( &H11000100‬כתובת בסיס ‪ +‬כתובת היסט)‬
‫כאשר תוכנית משתמשת במספר ‪-DLL‬ים סביר מאוד ששני ‪-DLL‬ים או יותר ינסו להיטען לאותה כתובת בסיס‬
‫אם ‪ DLL‬מנסה להיטען לכתובת בסיס שנתפסה כבר על ידי ‪ DLL‬אחר‪ ,‬מערכת ההפעלה ‪ Windows‬מקצה כתובת‬
‫בסיס ייחודית עבור הרכיב כדי למנוע התנגשויות‪ .‬בנוסף‪ ,‬מערכת ההפעלה משנה את הכתובות כך שיתאימו‬
‫לכתובת הבסיס החדשה‪ .‬פעולה זו נקראת ‪ .Rebasing‬שינוי כתובות הבסיס כרוך בזמן טעינה ארוך יותר‪.‬‬
‫ניתן להגדיר את כתובת הבסיס שלפיה יתבצע קימפול הרכיב מתוך הכרטיסייה ‪ Compile‬בתיבת הדו שיח‬
‫‪Project Properties‬‬
‫כתובת ברירת המחדל היא ‪ &H11000000‬ומומלץ לשנות אותה‪ ,‬כיוון שסביר להניח שישנם לא מעט רכיבים‬
‫שכתובת זו מוקצת עבורם‬
‫‪‬‬
‫בעת הגדרת כתובת בסיס זכור את הכללים הבאים‪:‬‬
‫‪ o‬על כתובת הבסיס להיות כפולה של ‪( 64K‬בהקצהדצימלית ‪ ,)&H10000‬כלומר ארבע הספרות האחרונות‬
‫של כתובת הבסיס יהיו ‪.0000‬‬
‫‪ Address Space o‬של ‪ Process‬כולל ‪ 4G‬כתובות‪ .‬עם זאת‪ ,‬הכתובות הבאות שמורות עבור מרכיבים שונים‬
‫של ‪:Windows‬‬
‫‪ ‬ב‪ Windows NT/2000-‬וכן ב‪ ,Windows 98-‬רצץ הכתובות בין ‪( 2G‬הכתובת ‪)&H80000000‬‬
‫לבין ‪( 4G‬הכתובת ‪ )&HFFFFFFFF‬שמורות עבור ‪Windows‬‬
‫‪ ‬ב‪ Windows98-‬רצף הכתובות המתחילות ב‪ &H00000000-‬לבין ‪( &H0040000‬כלומר ‪4M‬‬
‫הזיכרון התחתון) שמור גם הוא ל‪Windows-‬‬
‫‪ ‬ב‪ 64k WindowsNT/2000-‬הזיכרון התחתון (כלומר הרצף ‪)&H00000000-&H00010000‬‬
‫שמור למערכת ההפעלה‪ ,‬וכן ‪ 64K‬מתחילים ברצף ‪ &H7FFF0000‬עד ‪)&H80000000‬‬
‫‪ o‬אני ממליץ לשנות את כתובת הבסיס כך שתהיה כפולה של ‪ 64K‬בין הכתובת ‪ &H40000000‬לבין‬
‫‪( &H80000000‬כלומר בין ‪ 1G‬ל‪)2G-‬‬
‫תרגיל ‪ – 1‬שינוי כתובת הבסיס לספרייה ‪Securi tyLib‬‬
‫‪ ‬בתרגיל זה נשנה את כתובת הבסיס לטעינת ה‪DLL‬‬
‫‪ .1‬פתח את קבוצת הפרוייקטים שכתבנו בתרגילים הקודמים‬
‫‪ .1‬בחר בפרוייקט ‪:SecurityLib‬‬
‫‪ ‬מתוך קבוצת הפרוייקטים המוצגים בחלון ה‪ Project Explorer-‬בחר ב‪SecurityLib-‬‬
‫‪ .3‬שנה את כתובת הבסיס‪:‬‬
‫‪ ‬בחר באפשרות ‪ SecurityLib Properties...‬מתוך התפריט ‪Project‬‬
‫‪ ‬עבור לכרטיסייה ‪Compile‬‬
‫‪ ‬בשדה ‪ DLL Base Address‬המופיע בתחתית תיבת הדו שיח שנה את הכתובת לערך ‪ &H80000000‬ולחץ‬
‫‪ .OK‬אתה אמור לקבל הודעה כי כתובת זו אינה חוקית‪ .‬נסה את הכתובות הבאות‪:‬‬
‫כתובת ‪ 0‬אינה חוקית‬
‫‪&H00000000 o‬‬
‫כתובת שאינה כפולה של ‪ 6kK‬אינה חוקית (בכתובות שהן כפולה של ‪64K‬‬
‫‪&H40001000 o‬‬
‫ארבע הספרות הימניות הן ‪)0‬‬
‫כתובת חוקית‬
‫‪&H4001000 o‬‬
‫שמור את הפרוייקט‪:‬‬
‫‪ ‬שמור את הפרוייקט וסגור אותו‬
‫טיפול בשגיאות ברכיב‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫בעת יצירת רכיב שים לב שעל הרכיב שלך לטפל בכל השגיאות העלולות להתרחש במהלך החיים שלו‬
‫שגיאה המתרחשת ברכיב ואינה זוכה לטיפול תגרום לקריסת תוכנית הלקוח (חשוב איך יגיבו המשתמשים של‬
‫הרכיב שלך ברגע שהם יגלו שאתה הוא הבאג שלהם!!!)‬
‫תוכל לטפל בשגיאות הן ע"י פתרון הבעיה בתוך הרכיב או ע"י שיגור שגיאה (מותאמת אישית או המקורית) החוצה‬
‫אל תוכנית הלקוח‬
‫כדי להקצות מספר לשגיאה מותאמת אישית עליך להוסיף מספר בין ‪ 512‬ל‪ 65535-‬לקבוע ‪vbObjectError‬‬
‫תוכל לעורר את השגיאה באמצעות המתודה ‪ Raise‬של האובייקט ‪Err‬‬
‫שים לב‪ ,‬אם בתוך הרכיב שלך מתבצע טיפול בשגיאות ואתה רוצה לעורר שגיאה ללקוח‪ ,‬קרא תחילה ל‪On Error -‬‬
‫‪ ,GoTo 0‬כדי לבטל את מטפל השגיאות הפעיל‬
‫שים לב‪ :‬אל תנסה לעורר שגיא ללקוח מתוך אירוע השייך לאובייקט‪ .‬לשגיאה כזו אין מקום לכידה בתוך תוכנית‬
‫הלקוח‪ ,‬ולפיכך היא תקרוס‪.‬‬
‫תרגיל ‪ : 4‬ספריית הרכיב ים ‪DynamicArray‬‬
‫‪ ‬בדוגמה זו ניצור ספריית רכיבים בשם ‪ DynamicArray‬שתכיל רכיב אחד בשם ‪CDynamicArray‬‬
‫‪ ‬בשונה מהתרגיל הקודם‪ ,‬בתרגיל זה נקמפל את ה‪ DLL-‬ונטען אותו לתוכנית שניה‪.‬‬
‫‪ ‬רכיב זה ישמש כמערך דינמי המשנה את גודלו באופן אוטומטי כאשר מכניסים איבר באינדקס מסוים שאינו‬
‫מוקצה באותו שלב במערך‬
‫‪ ‬האינדקסים במערך רצים מ‪ 2-‬עד ‪( n  1‬כאשר ‪ n‬הוא גודל המערך)‬
‫‪ ‬ניסיון לגשת לאינדקס שלילי יגרום לשגיאה‬
‫‪ ‬ניסיון לקריאה (‪ )Property Get‬של איבר באיננקס שעדיין לא הוקצה גורם לשגיאה‬
‫‪ ‬שים לב כי הרכיב מטפל בכל השגיאות‪ ,‬ע"י פתרון שלהם (כמו שינוי ממדי המערך) או העברה שלהם החוצה‪ ,‬אל‬
‫רכיב הלקוח‬
‫‪ ‬בשיעור הקודם הכרנו את אפשרות הגדרת התכונות עבור פרוצדורות של מחלקה‪ .‬בתרגיל זה נשתמש באפשרות זו‪.‬‬
‫‪ .1‬צור פרוייקט חדש מסוג ‪ ,ActiveX DLL‬ושמור אותו‪:‬‬
‫‪ ‬הקצה לפרוייקט את השם ‪ DynamicArray‬ולמחלקה ‪CDynamicArray‬‬
‫‪ .2‬הוסף משתנים למחלקה‪:‬‬
‫‪ ‬המחלקה תכיל מערך דינמי פנימי‬
‫‪Private m_anValues() As Integer‬‬
‫‪ .3‬הוסף את המאפיין ‪:Count‬‬
‫‪ ‬המאפיין ‪ Count‬מחזיר את גודל המערך (אחד מעל האינדקס האחרון במערך) תוך שימוש בפונקציות‬
‫‪ LBound‬ו‪UBound-‬‬
‫‪ ‬אם לא הוקצו איברים למערך תתרחש שגיאה‪ .‬לוכדים שגיאה זו כדי להחזיר גודל מערך ‪0‬‬
‫‪Public Property Get Count() As Integer‬‬
‫‪Count = UBound(m_anValues) - LBound(m_anValues) + 1‬‬
‫‪Exit Property‬‬
‫‪Count = 0‬‬
‫‪ .1‬הוסף את השגרה ‪:Clear‬‬
‫‪ ‬השגרה ‪ Clear‬משחררת את הזיכרון שהוקצה עבור המערך תוך שימוש במילה השמורה ‪Erase‬‬
‫)(‪Public Sub Clear‬‬
‫‪Erase m_anValues‬‬
‫‪End Sub‬‬
‫‪ .1‬הוסף את המאפיין ‪:Item‬‬
‫‪ ‬המאפיין ‪ Item‬מקבל אינדקס במערך ומאפשר לאחזר או לקבוע את ערכו‬
‫‪ ‬כאשר מעבירים מספר פרמטרים ל‪ Property Let-‬הפרמטר האחרון יהווה את סוג המאפיין‬
‫‪ ‬יש להקפיד שכל הפרמטרים (מלבד האחרון ב‪ )Property Let-‬שב‪ Property Get-‬וב‪ Property Let-‬יהיו זהים‬
‫בסוגם ובשמם)‬
‫‪Public Property Get Item(ByVal n As Integer) As Integer‬‬
‫)‪Item = m_anValues(n‬‬
‫‪Err.Raise Err.Number‬‬
‫)‪Public Property Let Item(ByVal n As Integer, ByVal value As Integer‬‬
‫‪m_anValues(n) = value‬‬
‫‪If n > 0 Then‬‬
‫)‪ReDim Preserve m_anValues(n‬‬
‫‪Resume‬‬
‫‪Else‬‬
‫‪Err.Raise Err.Number‬‬
‫‪End If‬‬
‫‪ .1‬הוסף תיאורים לממשק המחלקה‪:‬‬
‫‪ ‬בעת שימוש באובייקטים ניתן לבחון את מאפייניהם תוך שימוש ב‪( Object Browser-‬ניתן לפתוח את‬
‫ה‪ Object Browser-‬באמצעות ‪ F2‬או מתוך תפריט ‪)View‬‬
‫‪ ‬מתוך התפריט ‪ Tools‬בחר ב‪Procedure Attributes-‬‬
‫‪ ‬מתוך התיבה ‪ Name‬בחר ב‪ Clear-‬והקלד את התיאור הבא בשדה ‪:Description‬‬
‫‪Free the memory occupied by the array.‬‬
‫‪‬‬
‫באופן דומה הוסף את התיאור הבא למאפיין ‪:Count‬‬
‫‪Returns the number of items in the array.‬‬
‫‪‬‬
‫ואת התיאור הבא למאפיין ‪:Item‬‬
‫‪Sets/Returns the value of an item in the array.‬‬
‫‪ ‬אל תסגור את חלון ה‪ Procedure Attributes-‬אתה צריך אותו לשלב הבא‬
‫הגדר את ‪ Item‬כמאפיין ברירת מחדל‪:‬‬
‫‪ ‬להזכירך‪ ,‬מאפיין ברירת מחדל הוא המאפיין שיופעל במקרה שלא צוין במפורש שם מאפיין (לדוגמה‪ ,‬המאפיין‬
‫‪ Text‬הוא מאפיין ברירת המחדל של ‪)TextBox‬‬
‫‪ ‬בחר במאפיין ‪ Item‬בתיבה ‪ Name‬ולחץ על הלחצן ‪Advanced‬‬
‫‪ ‬כעת‪ ,‬כדי להפוך את ‪ Item‬למאפיין ברירת מחדל‪ ,‬ב‪ Procedure ID-‬בחר ב‪)Default(-‬‬
‫‪ .1‬בצע קומפילציה לספריית הרכיבים‪:‬‬
‫‪ ‬מתוך התפריט ‪ File‬בחר ב‪...Make DynamicArray.dll-‬‬
‫‪ ‬התוכנית תקומפל ו‪ Visual Basic-‬תרשום את הרכיב באופן אוטומטי במערכת‬
‫‪ ‬אם התגלו שגיאות‪ ,‬תקן אותן וקמפל מחדש את הפרוייקט‬
‫‪.1‬‬
‫‪.1‬‬
‫‪.12‬‬
‫‪.11‬‬
‫צור תוכנית לקוח לבחינת ספריית הרכיבים‪:‬‬
‫‪ ‬הפעל את ‪ Visual Basic‬מחדש ופתח פרוייקט ‪Standard EXE‬‬
‫‪ ‬הקצה לפרוייקט את השם ‪ TestDArray‬ולטופס שבו את השם ‪frmTestDArray‬‬
‫הוסף הפנייה לספריית הרכיבים‪:‬‬
‫‪ ‬מתוך התפריט ‪ Project‬בחר בפריט ‪References‬‬
‫‪ ‬סמן ‪ V‬ליד הספרייה ‪( DynamicArray‬שים לב שלא היית צריך לבצע רישום של הרכיב‪ ,‬כי ‪Visual Basic‬‬
‫ביצעה זאת עבורך בעת קימפול הספרייה בשלב ‪)1‬‬
‫שים לב‪ :‬אם תרצה לערוך ולאחר מכן לקמפל את ה‪ DLL-‬כאשר יש הפניה אליו מתוך הפרוייקט ‪,TestDArray‬‬
‫יהיה עליך להסיר את ההפניה כדי שהקמפול יצליח‪.‬‬
‫בחינה ראשונה‪ :‬ה‪:Object Browser-‬‬
‫‪ ‬פתח את ה‪ Object Browser-‬מתוך התפריט ‪ View‬או ע"י שימוש בקיצור ‪F2‬‬
‫‪ ‬בחר ב‪ CDynamicArray-‬ועיין במאפיינים והמתודות המוצגים בפנל הימני של החלון‬
‫‪ ‬שים לב שתיאור המאפיינים והמתודות מופיע בתחתית החלון של ה‪Object Browser-‬‬
‫‪ ‬שים לב כי ליד סמל המאפיין ‪ Item‬מופיע עיגול כחול קטן המעיד כי זהו מאפיין ברירת המחדל‬
‫‪ ‬סגור את חלון ה‪Object Browser-‬‬
‫הוסף ‪ Controls‬לטופס‪:‬‬
‫‪ ‬הוסף ‪ Controls‬לטופס כפי שמוצג בציור הבא‪:‬‬
‫‪ ‬הקוד הבא מצהיר על אובייקט מסוג ‪CDynamicArray‬‬
‫‪Private m_DArray As DynamicArray.CDynamicArray‬‬
‫הוסף קוד לטופס‪:‬‬
‫‪ ‬הקוד הבא מאתחל את ממשק המשתמש ויוצר ‪ Instance‬של ‪:CDynamicArray‬‬
‫)(‪Private Sub Form_Load‬‬
‫‪' Initializations:‬‬
‫"‪Me.Caption = "Test Dynamic Array‬‬
‫"" = ‪txtIndex.Text‬‬
‫"" = ‪txtValue.Text‬‬
‫"‪cmdGet.Caption = "&Get‬‬
‫"‪cmdLet.Caption = "&Let‬‬
‫"‪cmdCount.Caption = "&Count‬‬
‫"‪cmdClear.Caption = "Clea&r‬‬
‫‪' Create the dynamic-array class‬‬
‫‪Set m_DArray = New CDynamicArray‬‬
‫‪End Sub‬‬
‫‪ ‬הקוד הבא פועל בתגובה ללחיצה על אחד הלחצנים‬
‫‪ ‬שים לב שאין חובה לציין במפורש את המאפיין ‪ Item‬בעת השימוש בו‪ ,‬כיוון שזהו מאפיין ברירת המחדל‪.‬‬
‫כלומר הרישום ‪ m_DArray(1) = 100‬כמוהו כרישום ‪m_DArray.Item(1) = 100‬‬
‫)(‪Private Sub cmdClear_Click‬‬
‫‪m_DArray.Clear‬‬
‫‪End Sub‬‬
‫)(‪Private Sub cmdCount_Click‬‬
‫"‪MsgBox "The array contains " & Str(m_DArray.Count) & " items‬‬
‫‪End Sub‬‬
‫)(‪Private Sub cmdGet_Click‬‬
‫)))‪txtValue.Text = Str(m_DArray(Val(txtIndex.Text‬‬
‫‪End Sub‬‬
‫)(‪Private Sub cmdLet_Click‬‬
‫)‪m_DArray(Val(txtIndex.Text)) = Val(txtValue.Text‬‬
‫‪End Sub‬‬
‫בחינה שניה‪ :‬הרצת הפרוייקט‪:‬‬
‫‪ ‬הרץ את התוכנית ובצע את הפעולות הבאות (לפי הסדר)‬
‫‪ ‬לחץ על ‪ :Count‬אתה צריך לקבל ‪0‬‬
‫‪ ‬לחץ על ‪ :Get‬אתה אמור לקבל שגיאה‪ .‬זוהי השגיאה שהרכיב מעורר כשמנסים לקרוא פריט שאינו קיים (עיין‬
‫בקוד הרכיב לפרטים נוספים)‬
‫‪ ‬הרץ שוב את הפרוייקט והזן ערך למערך‪ .‬בשדה ‪ Index‬בחר באינדקס המתאים ובשדה ‪ Value‬בחר בערך עבור‬
‫אותו פריט לאחר מכן לחץ ‪ .Let‬באופן זה הזן מספר ערכים‬
‫‪ ‬השתמש ב‪ Get-‬כדי לאחזר את הערכים הללו‬
‫‪ ‬השתמש ב‪ Count-‬כדי לקבל את מספר האיברים החדש במערך‬
‫‪ ‬השתמש ב‪ Clear-‬כדי לרוקן את המערך‬
‫‪ ‬נסה להזין ערך למערך באינדקס שלילי כלשהו‪ ,‬אתה אמור לקבל שגיאה שהרכיב מעורר (עיין בקוד הרכיב‬
‫לפרטים נוספים)‬
‫שיעור ‪ :11‬כתיבת ‪ Stored Procedures‬ב‪SQL Server-‬‬
‫‪ ‬תבין מהם ‪ Stored Procedures‬ותלמד כיצד להוסיף ‪ Stored Procedure‬ל‪ Database-‬של ‪SQL Server‬‬
‫‪ ‬תלמד לכתוב ‪ Stored Procedure‬המקבלים פרמטים‬
‫‪ ‬תכיר מבני בקרה שונים ב‪Transact SQL-‬‬
‫‪STORED PROCEDURES‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ Stored Procedure‬היא פרוצדורה המאוחסנת בתוך ה‪Database-‬‬
‫‪ Stored Procedure‬יכול לקבל פרמטרים ולפיכך יכול לשמש לבקשות שונות‬
‫‪ Stored Procedure‬מקומפל בתוך ה‪ Database-‬ולפיכך כל תהליך ה‪( Parsing-‬ניתוח המשפט)בניית ה‪Execution -‬‬
‫‪( Plan‬מסלול הביצוע) נחסכים‬
‫כדי להבין את היתרון שבהפעלת ‪ Stored Procedure‬מתוך תוכנית לקוח לעומת בניית משפט ‪ SQL‬ושליחתו‬
‫לביצוע ל‪ Database-‬על ידי תוכנית לקוח‪ ,‬נבחן את תהליך הביצוע בשני המקרים על ידי ה‪:Database-‬‬
‫תהליך הביצוע של משפט ‪ SQL‬הנשלח על ידי לקוח‬
‫‪‬‬
‫נניח כי תוכנית לקוח יוצרת את משפט ה‪ SQL-‬הבא ושולחת אותו לביצוע ב‪:Database-‬‬
‫* ‪SELECT‬‬
‫‪FROM Employees‬‬
‫‪WHERE EmployeeID = 10‬‬
‫‪‬‬
‫‪.1‬‬
‫‪.1‬‬
‫בתוך ה‪:Database-‬‬
‫מתבצע ניתוח סינטקטי (תחבירי) של המשפט‬
‫קיום הטבלה ‪ Employees‬נבדק‪ ,‬כמו כן נבדקות הרשאות הגישה לטבלה זו על ידי המשתמש המפעיל את משפט‬
‫ה‪SQL-‬‬
‫נוצר ‪ Execution Plan‬עבור משפט ה‪SQL-‬‬
‫(‪ Execution Plan‬היא תוכנית הביצוע של משפט ה‪ SQL-‬הכוללת הנחיות כיצד יש לסרוק טבלאות כדי לאתר את‬
‫הרשומות‪ ,‬האם יש להשתמש באינדקסים‪ ,‬בצירוף טבלאות‪ ,‬כיצד יש למזג את הטבלאות וכו')‬
‫משפט ה‪ SQL-‬מופעל והתוצאות מוחזרות למשתמש‬
‫‪‬‬
‫‪‬‬
‫נניח שאותו משפט ‪ SQL‬נשלח שוב על ידי תוכנית הלקוח‬
‫ב‪ Database-‬ישנו אזור זיכרון הכולל את משפטי ה‪ SQL-‬האחרונים שהורצו וכן אזור נוסף הכולל את הרשומות‬
‫האחרונות שהתקבלו כתוצאהמהפעלת משפטי ‪ . SQL‬אם התמזל מזלך‪ ,‬משפט ה‪ SQL-‬יימצאו בתוצאות עבור‬
‫שאילתה זו‪ ,‬או לפחות המשפט עצמו‪ .‬במקרה כזה‪ ,‬חלק מהשלבים שצוינו קודם יחסכו‬
‫אם המשפט אינו נמצא בין המשפטים האחרונים שבוצעו (זה יקרה אם עבר זמן רב מאז הרצת המשפט‪ ,‬כי אז‬
‫אזורי הזכרון הללו פינו את מקומם למשפטים חדשים‪ .‬ככה זה בשיטת ‪ )LRU‬כל השלבים שתוארו קודם יבוצעו‬
‫שוב‬
‫‪‬‬
‫נניח שהמשפט הבא נשלח על ידי תוכנית הלקוח‪:‬‬
‫‪‬‬
‫לכאורה נראה כי שני משפטי ה‪ SQL-‬זהים רק התנאי שונה‪ ,‬ובכל זאת אלו הם שני משפטי ‪ SQL‬שונים לגמרי וכל‬
‫התהליך שבוצע קודם יבוצע שוב עד להחזרת הרשומות לתוכנית הלקוח‪ .‬מדוע? כיוון שלכל משפט ‪ SQL‬הרץ‬
‫‪.3‬‬
‫‪.1‬‬
‫‪‬‬
‫* ‪SELECT‬‬
‫‪WHERE EmployeeID = 18‬‬
‫תהליך הביצוע של בקשה ל הפעלת ‪ Stored Procedure‬מתוך תוכנית לקוח‬
‫‪ ‬נניח כי ב‪ Database-‬מאוחסנת פרוצדורה בשם ‪ GetEmployee‬המקבלת כפרמטר מספר המזהה את מספר העובד‬
‫(‪)EmployeeID‬‬
‫‪ ‬תוכנית הלקוח שולחת בקשה לקבל את פרטי העובד שמספרו ‪10‬‬
‫‪ ‬בתוך ה‪:Database-‬‬
‫‪ .1‬נבדק כי הפרמטר שהועבר תקין‬
‫‪ .1‬מופעלת הפרוצדורה (שים לב כי הפרוצדורה כבר מקומפלת ואין צורך לקמפל אותה מחדש‪ ,‬לפיכך כל השלבים‬
‫שתוארו במקרה הקודם נחסכים)‬
‫‪‬‬
‫כעת נניח כי תוכנית הלקוח מבקשת את פרטי העובד שמספרו ‪ .18‬בקשה כזו לא תיחשב כבקשה שונה מהקודמת‬
‫כיוון שמספר העובד מועבר כפרמטר לפרוצדורה‬
‫כתיבת‬
‫‪‬‬
‫‪‬‬
‫‪ STORED PROCEDURES‬ב‪SQL SERVER-‬‬
‫פרוצדורות ב‪ SQL Server-‬נכתבות ב‪Transact SQL-‬‬
‫‪ Transact SQL‬זוהי ההרחבה של שפת ‪ SQL‬הסטנדרטית במערכת ‪( SQL Server‬בדיוק כפי ש‪ PL SQL-‬היא‬
‫ההרחבה של שפת ‪ SQL‬במערכת ‪)Oracle‬‬
‫פרוצדורה פשוטה ללא פרמטרים‬
‫‪CREATE PROCEDURE proc_name‬‬
‫‪AS‬‬
‫‪statements...‬‬
‫‪GO‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫הוספת ‪ Stored Procedure‬ל‪Northwind-‬‬
‫(לקוח מתוך ‪)Microsoft SQL Server 7 Administrator Companion‬‬
‫הפרוצדורה ‪ LateShipments‬מחזירה את תאריך המבוקש למשלוח (‪ ,)RequiredDate‬תאריך המשלוח בפועל‬
‫(‪ )ShippedDate‬ושם חברת המשלוחים (‪ CompanyName‬מהטבלה ‪ )Shippers‬עבור כל אותן הזמנות שהמשלוח‬
‫הגיע באיחור‬
‫דוגמה זו לקוחה מהספר ‪Microsoft SQL Server 7.0 Administator Companion‬‬
‫‪CREATE PROCEDURE LateShipments‬‬
‫‪AS‬‬
‫‪SELECT RequiredDate, ShippedDate, Shippers.CompanyName‬‬
‫‪FROM Orders, Shippers‬‬
‫=‬
‫‪WHERE ShippedDate > RequiredDate AND Orders.ShipVia‬‬
‫‪Shippers.ShipperID‬‬
‫‪GO‬‬
‫‪‬‬
‫הפעלת הפרוצדורה ב‪:Query Analyzer-‬‬
‫‪ o‬אם זהו המשפט הראשון שמופעל מתוך סדרת משפטים‪ ,‬ניתן לרשום‪:‬‬
‫‪LateShpments‬‬
:‫אם זהו אינו המשפט הראשון יש לרשום‬

EXECUTE LateShipments
‫או‬
EXEC LateShipments
‫פרוצדורה המקבלת פרמטרי ם‬
CREATE PROCEDURE proce_name @parameter1 type, @parameter2 type...
AS
statements...
GO
2 ‫דוגמה‬
‫ אלא שכאן מועבר שם חברת המשלוח כפרמטר ומוצגות רק השורות של חברה זו‬,‫דוגמה זו זהה לדוגמה הקודמת‬
Microsoft SQL Server 7.0 Administator Companion ‫דוגמה זו לקוחה מהספר‬


CREATE PROCEDURE LateShippmentsByShipperName @shipperName char(40)
AS
SELECT RequiredDate, ShippedDate, Shippers.CompanyName
FROM Orders, Shippers
WHERE ShippedDate > RequiredDate
AND Orders.ShipVia = Shippers.ShipperID
AND Shippers.CompanyName = @shipperName
GO
:Query Analyzer ‫הפעלת הפרוצדורה מתוך‬

EXECUTE LateShipmentsByShipperName "Speedy Express"
‫הג ד רת ערך ברירת מחדל לפרמטרים‬
CREATE PROCEDURE proce_name @parameter1 type [= deft_val], @parameter2
type [= def_val]...
AS
statements...
GO
1 ‫דוגמה‬
‫דוגמה זו מציבה בפרוצדורה הקודמת ערך ברירת מחדל עבור שם חברת המשלוחים‬
Microsoft SQL Server 7.0 Administator Companion ‫דוגמה זו לקוחה מהספר‬
CREATE PROCEDURE LateShippmentsByShipperName @shipperName char(40) =
"United Package"
AS
SELECT RequiredDate, ShippedDate, Shippers.CompanyName
FROM Orders, Shippers
WHERE ShippedDate > RequiredDate
AND Orders.ShipVia = Shippers.ShipperID
www.kita.co.il


‫‪AND Shippers.CompanyName = @shipperName‬‬
‫‪GO‬‬
‫‪‬‬
‫הפעלת הפרוצדורה מתוך ‪:Query Analyzer‬‬
‫‪EXECUTE LateShipmentsByShipperName‬‬
‫"‪EXECUTE LateShipmentsByShipperName "Speedy Express‬‬
‫החזרת ערך מפרוצדורה באמצעות משת נה‬
‫‪CREATE PROCEDURE proce_name @parameter1 type [= deft_val] OUTPUT,...‬‬
‫‪AS‬‬
‫‪statements...‬‬
‫‪GO‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫בדומה הבאה ניצור פרוצדורה בשם ‪GetUnitPrice‬‬
‫פרוצדורה זו מחזירה באמצעות המשתנה ‪ unit_price‬את המחיר ליחידה של מוצר שמספר הזיהוי שלו נתון‬
‫ב‪prod_id-‬‬
‫דוגמה זו לקוחה מהספר ‪Microsoft SQL Server 7.0 Administator Companion‬‬
‫‪CREATE PROCEDURE GetUnitPrice @prod_id INT, @unit_price MONEY OUTPUT‬‬
‫‪AS‬‬
‫‪SELECT @unit_price = UnitPrice‬‬
‫‪FROM Products‬‬
‫‪WHERE ProductID = @prod_id‬‬
‫‪GO‬‬
‫‪‬‬
‫הפעלת הפרוצדורה מתוך ‪:Query Analyzer‬‬
‫‪ o‬יש להצהיר (באמצעות ‪ )DECLARE‬על משתנה שיאוחסן בו הערך המוחזר מהפרוצדורה‬
‫‪ o‬את הפרמטר יש להעביר תוך שימוש במילה ‪OUTPUT‬‬
‫‪ o‬ניתן להדפיס ערך באמצעות הפונקציה ‪PRINT‬‬
‫‪ o‬אם רוצים להמיר סוג נתונים לסוג אחר‪ ,‬ניתן להשתמש בפונקציה ‪CONVERT‬‬
‫‪DECLARE @price MONEY‬‬
‫‪EXEC GetUnitPrice 77, @price output‬‬
‫)‪PRINT CONVERT(VARCHAR(8), @price‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫ניתן להשתמש במשתנה הן כדי להעביר ערך לפרוצדורה והן כדי לקבל ערך מוחזר מהפרוצדורה‬
‫בדוגמה זו ניצור פרוצדורה בשם ‪ GetBoss‬המחזירה באמצעות ‪ emp_id‬את מספר הזיהוי של המנהל של עובד‬
‫שמספר הזיהוי שלו מועבר באמצעות ‪emp_id‬‬
‫בטבלת ‪( Employees‬ב‪ )Northwind-‬שינו שדה בשם ‪ ReportsTo‬המזהה את מספר המנהל‬
‫אם מדובר במנהל הראשי‪ ,‬מוחזר המספר ‪0‬‬
‫שים לב שניתן להשתמש במשפט תנאי ‪IF...BEGIN...END‬‬
‫כדי להשים ערך למשתנה יש להשתמש במילה ‪ SET‬לפני ההשמה‬
‫‪CREATE PROCEDURE GetBoss @emp_id INT OUTPUT‬‬
‫‪AS‬‬
‫‪SELECT @emp_id = ReportsTo‬‬
WHERE EmployeeID = @emp_id
IF @emp_id IS NULL
BEGIN
SET @emp_id = 0
END
GO
:Query Analyzer‫הפעלת הפרוצדורה מתוך ה‬

DECLARE @emp INT
SET @emp = 8
EXEC GetBoss @emp OUTPUT
PRINT CONVERT(VARCHAR(4), @emp)
‫שימוש במשתנים מקומי ים‬
DECLARE ‫ניתן להצהיר על משתנים מקומיים בפרוצדורה באמצעות‬

6 ‫דוגמה‬
)‫ (שניצור בהמשך‬PupilsTBL ‫ שורות חדשות לטבלת‬5 ‫הפרוצדורה הבאה מכניסה‬
pupil_name-‫ ו‬pupil_id :‫בטבלה זו שני שדות‬
WHILE...BEGIN...END ‫בפרוצדורה נעשה שימוש בלולאה‬



CREATE PROCEDURE Insert5Rows @low_val NUMERIC
AS
DECLARE @loop_counter NUMERIC
SET @loop_counter = 5
WHILE @loop_counter > 0
BEGIN
INSERT INTO PupilsTBL VALUES (@low_val, "new_pupil")
SET @low_val = @low_val + 1
SET @loop_counter = @loop_counter - 1
END
GO
:Query Analyzer ‫הרצה מתוך‬
CREATE TABLE... ‫ תחילה ניצור את הטבלה באמצעות המשפט‬o
‫ לאחר מכן נריץ את הפרוצדורה‬o
SELECT ‫ לבסוף נציג את התוצאות באמצעות המשפט‬o

CREATE TABLE PupilsTBL (pupil_id NUMERIC(4), pupil_name NVARCHAR(20))
EXEC Insert5Rows 8
SELECT * FROM PupilsTBL
RETURN ‫יציאה מפרוצדורה באמצעות‬
RETURN ‫ניתן לצאת מפרוצדורה באופן מיידי על ידי שימוש במילה‬
‫) לתוכנית הקוראת‬INT( ‫ ערך מסוג שלם‬RETURN ‫ניתן להחזיר באמצעות‬
www.kita.co.il


SQL Server-‫ ב‬Stored Procedures ‫ כתיבת‬:11 ‫שיעור‬
7 ‫דוגמה‬
:‫ המקבלת מספר מוצר ומחזירה את הערכים הבאים‬GetPriceCategory ‫בדוגמה זו ניצור פרוצדורה בשם‬
)‫ לפרוצדורה (זהו יהיה גם ערך ברירת המחדל‬NULL ‫ אם הועבר‬-1 o
Products ‫ אם המוצר אינו קיים בטבלה‬0 o
‫ דולר‬20-‫ אם מחירו של המוצר קטן מ‬1 o
‫ בכל מקרה אחר‬99 o
CASE...WHEN...THEN...END ‫לצורך הדוגמה נשתמש במשפט‬


CREATE PROCEDURE GetPriceCategory @prod_id INT = NULL
AS
DECLARE @price INT
IF @prod_id IS NULL
RETURN -1
SELECT
@price = UnitPrice FROM Products WHERE ProductID = @prod_id
RETURN
CASE
WHEN
@price IS NULL THEN 0
WHEN @price < 20 THEN 1
ELSE 99
END
GO
:Query Analyzer ‫הרצה באמצעות‬
DECLARE @cat_id INT
EXEC @cat_id = GetPriceCategory 38
PRINT @cat_id
www.kita.co.il

‫שיעור ‪ActiveX Data Objects :12‬‬
‫‪ ‬אסקור בפניך את אפשרויות החיבור השונות מהיישום שלך ב‪ Visual Basic-‬למקורות נתונים‬
‫‪ ‬תכיר את מודל האובייקטים של הספרייה ‪ADODB‬‬
‫‪ ‬תכיר את המאפינים‪ ,‬השיטות והאירועים של האובייקטים השונים של ‪ADO‬‬
‫סקירה של טכנולוגיות הגישה לנתונים‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫קיימות שיטות רבות לגישה לנתונים‪ ,‬החל מטכנולוגיות מבוססות ממשקי קריאות ‪ ,API‬וכלה באובייקטים‬
‫וויזואליים נוחים המתממשקים למסדי נתונים‬
‫‪ Visual Basic‬תומכת באפשרויות רבות המאפשרות גישה לנתונים‬
‫בסעיף זה נסקור אוסף הרכיבים הללו‪ ,‬ונראה את אפשרויות החיבור השונות‬
‫הגרף הבא מתאר את היררכית האובייקטים‪ ,‬הספריות ורכיבי הקוד השונים המפרידים בין יישום ‪Visual Basic‬‬
‫לבין שכבת ה‪Data-‬‬
‫‪Visual Basic Application‬‬
‫‪ADO Data‬‬
‫‪Control‬‬
‫‪Data‬‬
‫‪Control‬‬
‫‪Remote Data‬‬
‫‪Control‬‬
‫‪DAO‬‬
‫‪RDO‬‬
‫‪ADO‬‬
‫‪Jet Engine‬‬
‫‪ODBC Driver Manager‬‬
‫‪MSDASQL‬‬
‫‪OLE DB‬‬
‫‪Provider‬‬
‫‪Specific ODBC Driver‬‬
‫‪Database‬‬
‫‪) Open Database Connectivity ( ODBC‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ ODBC‬מספק ממשק ‪ API‬לקישור עם ‪Databases‬‬
‫‪ ODBC‬מהיר מאוד כיוון שהוא מבוסס ‪ ,)Call Level Interface( CLI‬משתמש המפעיל פונקציות ‪ODBC API‬‬
‫מנצל תקורת (‪ )Overhead‬משאבים נמוכה יחסית‪ ,‬לעומת תקורת קוד גבוהה‬
‫‪ ,ODBC‬החל מגרסה ‪ ,3‬תומך ב‪ .Connection Pooling-‬כיוון שהתחברות לשרת ‪Database‬הא פעולה ארוכה‪,‬‬
‫‪ ODBC‬מנהל חיבורים פתוחים‪ ,‬כך שייתכן שבקוד שלך מתבצעת פתיחה וסגירה של חיבורים ל‪ Databases-‬אך‬
‫בפועל אותו חיבור ב‪ ODBC-‬משרת את כל החיבורים שלך‬
‫בעת התחברות‪ ,‬נבחר ה‪ Driver-‬הספציפי המותאם לעבודה עם ה‪ Database-‬הספציפי‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫המידע אודות ה‪ ,Database-‬מיקומו‪ ,‬אופן ההתחברות אליו‪ ,‬שם המשתמש והסיסמה המשמשים בהתחברות אליו‪,‬‬
‫שם ה‪ Driver-‬המשמש לתקשורת עמו ועוד נשמרים ב‪)Data Source Name( DSN-‬‬
‫ניתן ליצור ‪ DSN‬מתוך ה‪ ,Control Panel-‬או מתוך הקוד של התוכנית‬
‫קיימים שלושה סוגים של ‪:DSN‬‬
‫‪ DSN :User DSN o‬הזמין לאותו משתמש בלבד‬
‫‪ DSN :System DSN o‬הזמין לכל המשתמשים במערכת‪ ,‬כולל שירותי ‪ IIS( NT‬ממומש כשירות ‪NT‬‬
‫ולפיכך יש לשתף ‪ Databases‬שאמורים להשתמש בשירות זה)‬
‫‪ DSN :File DSN o‬המאפשר לשמור את ההגדרות בקובץ (עם הסיומת ‪ ,)*.dsn‬כך שמשתמשים ברחבי‬
‫הרשת יכולים לשתף אותו בניהם‪ ,‬בתנאי שיש להם ‪ Drivers‬מתאימים‬
‫הערה‪ :‬בשני הסוגים הראשונים המידע מאוחסן ב‪Registry-‬‬
‫כרטיסיות ‪ ODBC‬ב‪Control Panel-‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫הערה‪ :‬ב‪ Win2k-‬יש להיכנס ל‪ Administration Tools-‬ומשם לפתוח )‪Data Sources (ODBC‬‬
‫‪ :User DSN‬כרטיסייה ליצירת ‪ DSN‬של משתמש ספציפי‬
‫‪ :System DSN‬הכרטיסייה ליצרית ‪ DSN‬של מערכת‬
‫‪ :File DSN‬הכרטיסייה ליצירת ‪ DSN‬הנשמר בקובץ‬
‫‪ :Drivers‬מציג את רשימת ה‪ Drivers-‬המותקנים ומידע נוסף לגביהם‬
‫‪ :Tracing‬מאפשר לבצע מעקב אחר פעולות ה‪ ,ODBC-‬כולל הפעלה משולבת יחד עם ‪Visual Studio Analyzer‬‬
‫המאפשר ביצוע אבחון ברשת של פעולות היישום‬
‫‪ :Connection Pooling‬מאפשר לקבוע את הגדרות ה‪ Connection Pooling-‬עבור ה‪ Drivers-‬הספציפיים‬
‫השונים של ‪ODBC‬‬
‫‪) Data Access Object ( DAO‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ DAO‬הוא ממשק תכנות מונחה עצמים הפועל על גבי מנוע ‪( Jet‬מנוע ‪ Jet‬הוא מנוע ה‪ Databases-‬היוצר ומנהל‬
‫קובצי ‪ *.mdb‬המוכרים מ‪)Access-‬‬
‫‪ DAO‬עוצב והותאם המיוחד לעבודה מול ‪ Databases‬של ‪Access‬‬
‫ניתן לגשת לטבלאות מכל ‪ Database‬שקיים עבורו ‪ ,ODBC Driver‬באמצעות שיטת הטבלאות המקושרות של‬
‫‪Access‬‬
‫חסרון השימוש במנוע ‪ Jet‬הוא בכך שכולו נטען לזכרון‪ ,‬גם אם עובדים עם ‪ Database‬מסוג שונה מ‪*.mdb-‬‬
‫‪ DAO‬אינו חושף את כל היכולות של ‪ODBC API‬‬
‫‪ DAO‬לא פותחה רבות מאז גרסת ‪ ,3.5‬וככל הנראה ‪ Microsoft‬רואה את העתיד כשייך ל‪ADO-‬‬
‫‪) Data Control ( DC‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ Data Control‬הוא פקד סטנדרטי של ‪Visual Basic‬‬
‫זהו ממשק וויזואלי המאפשר חיבור ל‪Database-‬‬
‫‪ Data Control‬מהווה ממשק וויזואלי (לא כ"כ מתוחכם) ל‪DAO-‬‬
‫ניתן לכרוך פקדים (‪ )to bind‬למקורות מידע המסופקים ע"י ה‪Data Control-‬‬
‫כריכת פקדים היא פעולה שהופכת את היישום לדו שכבתי (שכבת תוכנית המשתמש ושכבת ה‪ ,)Database-‬ולפיכך‬
‫קיימים בכך חסרונות עיצוב רבים‬
‫‪) Remote Data Object ( RDO‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ RDO‬משלב את הפשטות של ‪ DAO‬עם הכוח של ‪ODBC‬‬
‫‪ RDO‬מדלג על מנוע ‪ Jet‬מה שמשפר את הביצועים באופן ניכר‬
‫‪ RDO‬עוצב המיוחד לעבודה מול ‪ODBC API‬‬
‫‪‬‬
‫הגרסה האחרונה של ‪ RDO‬היא ‪( 2.0‬והיא דיי ישנה)‪ ,‬כך שניתן להסיק ש‪ Microsoft-‬דוחפת אותנו "בגסות"‬
‫לכיוון ה‪ADO-‬‬
‫‪) Remote Data Control ( RDC‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ Remote Data Control‬הוא פקד וויזואלי הדומה בתפקודו ל‪ Data Control-‬הסטנדרטי של ‪Visual Basic‬‬
‫כל היתרונות והחסרונות של הפקד ‪ Data Control‬קיימים גם ב‪Remote Data Control-‬‬
‫ההבדל בין ‪ Data Control‬ל‪ Remote Data Control-‬הוא בשכבת הביניים‪ .‬עבור ‪ DC‬זהו אובייקט ‪ DAO‬ואילו‬
‫עבור ‪ RDC‬זהו אובייקט ‪RDO‬‬
‫‪‬‬
‫‪‬‬
‫‪ ODBCDirect‬הוא מצב פעולה של ‪ DAO‬הטוען את רכיב ‪ RDO‬במקום מנוע ‪Jet‬‬
‫כדי להפעיל אובייקט ‪ DAO‬במצב ‪ ODBCDircet‬יש לרשום‪:‬‬
‫‪DBEngine.DefaultType = dbUseODBC‬‬
‫‪‬‬
‫במקרה של מצב פעולה של ‪ ,ODBCDirect‬ניתן לנצל את יתרונות ‪ ODBC‬ואת פשטות הקוד של ‪DAO‬‬
‫‪OLE DB‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ OLE DB‬מגדיר ממשקי ‪ COM‬סטנדרטיים שעל כל ‪ OLE DB Provider‬לתמוך בהם‪ ,‬כדי שצרכני (‪)Consumers‬‬
‫מידע יוכלו להתקשר אליו באמצעות ממשקים אלו‬
‫התחברות ישירה יכולה להתבצע דרך קוד הכתוב בשפת ‪ C‬מבוסס על קריאות ‪ ,COM API‬התחברות באופן כזה‬
‫מתוך קוד ‪ Visual Basic‬היא כמעט בלתי אפשרית לשם כך קיימים רכיבי ‪ ADO‬שנכיר ונתמקד בהם בפרק זה‬
‫יתרונה הגדול של טכנולוגיה זו הוא בתמיכה בסוגי מידע שונים ולאו דווקאב‪-Database-‬ים רגילים‬
‫באמצעות ‪ OLE DB‬ניתן לגשת למידע שבכל קובץ נתונים‪ ,‬מסוג כלשהו‪ ,‬כולל מסמך ‪ ,Excel‬הודעת דואר ועוד‪,‬‬
‫ובתנאי שקיים עבורו ‪ OLE DB Provider‬מתאים‬
‫השכבה היחידה שחוצצת בין ה‪ Database-‬לבין היישום‪ ,‬הוא ‪ .OLE DB Provider‬כיוון שברכיב זה קיימת‬
‫תמיכה בממשקי ‪ COM‬הדרושים‪ ,‬אין צורך בשכבה מפרידה כמו ב‪ODBC-‬‬
‫הנתונים שאליהם ניתן לגשת ב‪ OLE DB-‬הם כל הנתונים תומכי ‪ COM‬ולא רק נתונים סטנדרטיים של ‪SQL‬‬
‫‪) ActiveX Data Objects ( ADO‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ ADO‬הוא ממשק עילי ל‪OLE DB-‬‬
‫כיאה לממשקי ‪ ADO ,COM‬תומך ב‪ OLE DB Provider-‬המציעים ממשקים נוספים המרחיבים את יכולת‬
‫פעילותו של ‪ADO‬‬
‫הפונקציונליות של ‪ ADO‬אינה ממוקמת ב‪ DLL-‬יחיד‪ ,‬אלה במספר ‪-DLL‬ים‪ .‬לכן אין צורך להפיץ את כל‬
‫ה‪-DLL-‬ים למשתמש הקצה אם אין שימוש בפונקציונליות של כולם‬
‫ניתן להשתמש ב‪ ADO-‬מתוך קוד ‪ HTML‬ו‪ASP-‬‬
‫תת מערכת של ‪ ADO‬בשם ‪ Remote Data Services‬מאפשר שליחת רשומות ל‪ Client-‬ברחבי הרשת‪ ,‬ואפילו‬
‫הפעלת ‪ COM Components‬אצל ה‪Client-‬‬
‫‪MSDASQL‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ MSDASQL‬הוא אחד מה‪-Proveder-‬ים של ‪OLE DB‬‬
‫הייחוד ב‪ MSDASQL-‬הוא בכך שהוא מהווה ‪ Provider‬מתאם בין ‪ OLE DB‬ל‪ODBC-‬‬
‫הצורך ב‪ MSDASQL-‬קיים‪ ,‬כיוון שישנם ‪-DBMS‬ים שעדיין לא פותח עבורם ‪ OLE DB Provider‬מתאים‬
‫‪) ADO Data Control ( ADODC‬‬
‫‪‬‬
‫‪‬‬
‫‪ ADODC‬הינו אובייקט וויזואלי הדומה בעיקרו ל‪ DC-‬ול‪ ,RDC-‬אם כי ‪ ADODC‬מציג מספר שיפורים לעומת‬
‫‪ DC‬ו‪RDC-‬‬
‫‪ ADODC‬משתמש ב‪ )OLE DB( ADO-‬כשכבת הביניים להתקשרות מול מקור הנתונים‬
‫תרגיל ‪Nwi ndDSN – 1‬‬
‫‪ ‬בדוגמה זו ניצור ‪ DSN‬באמצעות לוח הבקרה של ‪Windows‬‬
‫‪ .1‬פתח את חלון ‪:ODBC Data Source Administrator‬‬
‫‪ ‬פתח את ה‪Control Panel-‬‬
‫‪ ‬ב‪Windows 2000-‬מתוך ה‪ Control Panel-‬בחר ב‪Administrative Tools-‬‬
‫‪ ‬בחר ב‪ ( ODBC-‬או )‪ Data Sources (ODBC‬ב‪)Windows 2000-‬‬
‫‪ .1‬הכר את הכרטיסיות השונות ביישום ‪:ODBC Data Source Admiistrator‬‬
‫‪ ‬לפני שניגש להגדרת ה‪ DSN-‬בתרגיל זה‪ ,‬נכיר את הכרטיסיות השונות‬
‫‪ ‬הכרטיסיה ‪:User DSN‬‬
‫‪‬‬
‫בכרטיסייה ‪ User DSN‬אתה יכול להוסיף (‪ DSN )Add...‬חדש השייך למשתמש בנוכחי בלבד במערכת ( ‪User‬‬
‫‪ ,)DSN‬ולהגדיר (‪ )Configure...‬את המאפיינים שלו‪ ,‬או להסיר ‪ User DSN‬קיים‬
‫‪‬‬
‫הכרטיסיה ‪:System DSN‬‬
‫‪‬‬
‫בכרטיסייה ‪ System DSN‬ניתן לבצע את אותם הפעולות כמו ב‪ ,User DSN-‬אלא שה‪-DSN-‬ים הנוצרים‬
‫ומוגדרים בכרטיסייה זו יהיהו זמינים לכל משתמשי המערכת (‪)System DSN‬‬
‫הכרטיסיה ‪:File DSN‬‬
‫‪‬‬
‫‪‬‬
‫בכרטיסייה ‪ File DSN‬תוכל ליצור ‪-DSN‬ים חדשים ולהגדירם‪ ,‬כמו גם להסיר ‪-DSN‬ים קיימים‪ .‬ה‪-DSN-‬ים‬
‫הנוצרים בכרטיסיה זו נשמרים בקבצים (‪)File DSN‬‬
‫‪ File DSN‬נשמרים בדרך כלל בספרייה ‪ .C:\Program Files\Common Files\ODBC\Data Sources‬אם‬
‫תרצה לשנות את מיקום קובץ ה‪ DSN-‬שאתה יוצר יהיה עליך ללחוץ על ‪ Set Directory‬לאחר המעבר‬
‫לספרייה המתאימה‬
‫הכרטיסיה ‪:Drivers‬‬
‫‪‬‬
‫בכרטיסיה ‪ Drivers‬מוצגים ה‪-Driver-‬ים השונים של ‪ ODBC‬המותקנים במערכת והפרטים הבאים עבור כל‬
‫‪:Driver‬‬
‫‪ :Version o‬מספר הגירסה של ה‪Driver-‬‬
‫‪ :Company o‬שם החברה המייצרת‬
‫‪ :File o‬שם קובץ ה‪ DLL-‬של ה‪Driver-‬‬
‫‪ :Date o‬התאריך האחרון בו שונה הקובץ‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫הכרטיסיה ‪:Tracing‬‬
‫‪‬‬
‫בכרטיסיה ‪ Tracing‬תוכל להפעיל מעקב אחר פעולות ‪ ODBC‬שיירשמו בקובץ ששמו נתון בשדה ‪Log file‬‬
‫‪ .Path‬אפשרות זו יכולה לסייע כשעובדים באופן ישיר או עקיף (באמצעות ‪ ADO‬למשל) יחד עם ‪.ODBC‬‬
‫תוכל גם להפעיל את ‪ Visual Studio Analyzer‬כדי לאבחן פעולות של היישום שלך ברחבי הרשת‪ .‬בשדה‬
‫‪ Custom Trace DLL‬תוכל לבחור ‪ DLL‬אחר שינהל את פעולות המעקב‪ ,‬אן קיים אחד כזה ברשותך‬
‫‪‬‬
‫הכרטיסיה ‪:Connetion Pooling‬‬
‫‪‬‬
‫בכרטיסייה ‪ Connection Pooling‬תוכל להגדיר את ההגדרות הבאות‪:‬‬
‫‪ :Connetion Pooling Timeout o‬בשדה זה אתה מגדיר את משך הזמן שבו יישארו‬
‫‪-Connection‬ים בזיכרון לאחר סגירתם‪ .‬המטרה בהשארת ‪-Connection‬ים בזכרון ה‪ Pooling-‬היא‬
‫לחסוך את זמן ההתחברות בעת יצירת חיבורים חדשים על ידי אותה תוכנית אם קיימים חיבורים‬
‫פנויים המתאימים לדרישות החיבור החדש של התוכנית‪ .‬כדי לשנות הגדרה זו עבור ‪ Driver‬מסוים‪,‬‬
‫עליך להקליק על שמו ולהתאים את ההגדרות בתיבת הדו שיח המתקבלת (מוצגת להלן)‪:‬‬
‫‪‬‬
‫‪ :)Performance Monitoring( PerfMon o‬סימון אפשרות זו מאפשר מעקב אחר ביצועי‬
‫ה‪ Connection Pooling-‬של כל ה‪-Driver-‬ים‬
‫‪ :Retry Wait Time o‬כאשר ניסיון התחברות למערכת ניהול ‪-Database‬ים נכשלת‪ ,‬מתבצע ניסיון‬
‫נוסף‪ .‬משך הזמן בשניות בין ניסיון אחד למשנהו מוגדר בשדה זה‬
‫מומלץ שלא לשנות ההגדרות של ה‪ Connection Pooling-‬אלא אם אתה מודע למשמעות השינויים שאתה‬
‫מבצע‬
‫‪‬‬
‫‪.3‬‬
‫‪.1‬‬
‫‪.1‬‬
‫‪.1‬‬
‫‪.1‬‬
‫‪.1‬‬
‫הכרטיסיה ‪:About‬‬
‫‪ ‬בכרטיסייה ‪ About‬תוכל לצפות במידע אודות קובצי הליבה (‪ )Core‬המנהלים את תת המערכת ‪ ODBC‬תחת‬
‫מערכת ההפעלה‬
‫הוסף ‪:DSN‬‬
‫‪ ‬וודא שהכרטיסייה ‪ UserDSN‬נבחרה‬
‫‪ ‬לחץ על ‪Add‬‬
‫בחר ב‪ Driver-‬המתאים‪:‬‬
‫‪ ‬מתוך רשימת ה‪-Driver-‬ים המוצעים בחר ב‪SQL Server-‬‬
‫‪ ‬לחץ על ‪Finish‬‬
‫הקצה שם ל‪:DSN-‬‬
‫‪ ‬בשדה ‪ Name‬הקצה את השם ‪NwindDSN‬‬
‫הקצה תיאור ל‪:DSN-‬‬
‫‪ ‬בשדה ‪ Description‬רשום ‪ DSN‬אם ‪Northwind Database‬‬
‫קבע את מיקום ה‪ Server-‬ברשת‪:‬‬
‫‪ ‬בשדה ‪ Server‬בחר מהרשימה הנפתחת או הקלד ידנית את שם המחשב ברשת שבו נמצאת מערכת ה‪SQL -‬‬
‫‪ Server‬שאליה תרצה להתחבר באמצעות ‪ DSN‬זה (אם מערכת ה‪ SQL Server-‬מותקנת במחשב המקומי‬
‫ושמו אינו מוצג ברשימה הנפתחת‪ ,‬תוכל להשתמש גם בכתובת ה‪)127.0.0.1 :IP-‬‬
‫בחר את שם המשתמש והסיסמה באמצעותם תתחבר ל‪:SQL Server-‬‬
‫‪ ‬אם שם מערכת ה‪ SQL Server-‬אליה אתה מתחבר מאפשרת כניסה באמצעות שם המשתמש והסיסמה של‬
‫‪ ,Windows NT/2000‬אזי תוכל לבחור באפשרות‪With Windows NT Authentication...‬‬
‫‪ ‬תוכל לבחור באפשרות ‪ With SQL Server Authentication...‬ובתחתית החלוןהקלד את שם המשתמש‬
‫והסיסמה באופן מפורש‬
‫‪ ‬בדוגמה זו הקלד ‪ sa‬עבור שם המשתמש והשאר את הסיסמה ריקה (בעת התקנת ‪ SQL Server‬נוסף באופן‬
‫אוטומטי מנהל מערכת בשם ‪ sa‬ללא סיסמה‪ ,‬אם שינית את הסיסמה התאם את השדה ‪ Password‬בהתאם)‬
‫‪ ‬לחץ על ‪Next‬‬
‫‪ .1‬בחר ב‪ Database-‬אליו תרצה להתחבר‪:‬‬
‫‪ ‬סמן ‪ V‬ב‪ Change the default database to:-‬ומתוך הרשימה הנפתחת בחר ‪Northwind‬‬
‫‪ ‬לחץ על ‪Next‬‬
‫‪ .12‬סיים את הגדרת ה‪:DSN‬‬
‫‪ ‬השאר את ההגדרות במסך האחרון ללא שינו ולחץ על ‪Finish‬‬
‫‪)ACTIVEX DATA OBJECTS( ADO‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫כאמור‪ ADO ,‬הוא ממשק עילי ל‪OLE DB-‬‬
‫בסעיף זה נסקור את מודל העצמים של ‪ ADO‬ונלמד להשתמש בכל אחד מהאובייקטים הללו‬
‫כדי לכלול את ספריית ‪ ADO‬בפרוייקט ‪ Visual Basic‬בצע את השלבים הבאים‪:‬‬
‫‪ .1‬פתח את החלון ‪ References‬על ידי בחירת האפשרות ‪ References‬מהתפריט ‪Project‬‬
‫‪ .1‬הוסף הפנייה לספרייה ‪ .Microsoft ActiveX Data Objects 2.7‬ייתכן שבמחשב שלך הגרסה ‪ 2.7‬לא תופיעה‪,‬‬
‫או שתופיעה גרסה מתקדמת יותר‪ .‬בכל מקרה מומלץ לבחור בגרסה המעודכת היותר של הספרייה‪.‬‬
‫התרשים הבא מציג את היררכית ה‪-Object-‬ים וה‪-Collection-‬ים שבספרייה ‪( ADODB‬הספרייה ‪ ADODB‬היא‬
‫הספרייה המכילה את האובייקטים של ‪:)ADO‬‬
‫‪ADODB‬‬
‫‪Connection‬‬
‫‪Error‬‬
‫‪Errors‬‬
‫‪Property‬‬
‫‪Properties‬‬
‫‪Command‬‬
‫‪Parameter‬‬
‫‪Parameters‬‬
‫‪Recordset‬‬
‫‪Field‬‬
‫‪Fields‬‬
‫מקרא‪:‬‬
‫‪ ( Library‬ספרייה)‬
‫‪‬‬
‫‪( Collection‬אוסף)‬
‫‪ ( Object‬אובייקט)‬
‫בהמשך השיעור נתעכב על כל אחד מהאובייקטים והאוספים הללו‬
‫‪Data Link‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫בדומה ל‪ Data Link ,DSN-‬מהווה את אוסף הפרטים הנחוצים לשם פניה למקור נתונים על ידי אובייקט ‪ADO‬‬
‫‪ Data Link‬הוא קובץ טקסט הכולל פרטי מידע אודות שם ה‪ Provider-‬באמצעותו ניגשים למקור הנתונים‪ ,‬שם‬
‫מקור הנתונים ומיקומו ועוד‪.‬‬
‫בעת בחירת ‪ Provider‬משתנים הפרטים הנוספים הנדרשים לפי סוג ה‪ .Provider-‬כך למשל אם בחרת‬
‫ב‪( MSDASQL-‬זהו ה‪ Provider-‬עבור מקור נתונים של ‪ )ODBC‬תידרש להזין את שם ה‪ DSN-‬ולא יהיה צורך‬
‫בציון מקור הנתונים כיוון שהוא כלול כבר בתוך ה‪ .DSN-‬אם‪ ,‬לעומת זאת‪ ,‬בחרת ב‪( SQLOLEDB-‬זהו ‪Provider‬‬
‫עבור ‪ )SQLServer‬תידרש להזין את שם המחשב עליו מצוי ה‪ SQL Server-‬ושם ה‪ Database-‬אליו ברצונך לגשת‪.‬‬
‫יצירת קובץ ‪Data Link‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫תחת ‪ Windows 98‬או ‪:Windows NT‬‬
‫‪ .1‬פתח את הסייר ועבור לספרייה שברצונך ליצור בה את הקובץ‬
‫‪ .1‬לחץ לחיצה ימנית על העכבר במקום ריק בספריה ובחר באפשרות ‪New‬‬
‫‪ .3‬בחר ‪Microsoft Data Link‬‬
‫‪ .1‬הקצה שם לקובץ‬
‫תחת ‪( Windows 2000‬פועל גם ב‪ Windows 98-‬ו‪:)Windows NT-‬‬
‫‪ .1‬פתח את הסייר ועבור לספרייה שברצונך ליצור בה את הקובץ‬
‫‪ .1‬לחץ לחיצה ימנית על העכבר במקום ריק בספריה ובחר ב‪New-‬‬
‫‪ .3‬בחר באפשרות ‪Text Document‬‬
‫‪ .1‬הקצה לקובץ שם כרצונך‪ ,‬ושנה את הסיומת שלו ל‪( .udl-‬אם אינך רואה את סיומת הקובץ בחר באפשרות‬
‫‪ Folder Options‬מתוך התפריט ‪ Tools‬ובכרטיסייה ‪ View‬נקה את הסימון ליד ‪Hide file Extensions for‬‬
‫‪ known file types‬ולחץ על ‪)OK‬‬
‫‪ .1‬אל תתייחס לאזהרה שתתקבל כתוצאה משינוי הסיומת‬
‫לאחר שיצרת את הקובץ הקלק עליו והתאם את ההגדרות בתיבת הדו שיח ‪Data Link Properties‬‬
‫בתרגילים הבאים ובסעיף העוסק באובייקט ‪ ,Connection‬תכיר היטב את פרטי המידע הנחוצים לשם הגדרת‬
‫‪ Data Link‬ואת משמעותם‬
‫תרגיל ‪NWind.udl : 2‬‬
‫‪ ‬בתרגיל זה ניצור קובץ ‪ Data Link‬שיכיל את הנתונים הדרושים לשם פניה ל‪Nwind.mdb-‬‬
‫‪ .1‬צור קובץ ‪ Data Link‬ריק‪:‬‬
‫‪ ‬צור קובץ עם הסיומת ‪ .udl‬כפי שהוסבר בסעיף הקודם‬
‫‪ ‬הקצה לקובץ את השם ‪NWind.udl‬‬
‫‪ .1‬פתח את תיבת הדו שיח ‪ Data Link Properties‬והכר את הכרטיסיות שבו‪:‬‬
‫‪ ‬הקלק על הקובץ‪ ,‬תיבת הדו שיח ‪ Data Link Properties‬אמורה להיפתח‬
‫‪ ‬לפני שנתאים את ההגדרות‪ ,‬נבחן את הכרטיסיות השונות של תיבת הדו שיח ‪Data Link‬‬
‫‪‬‬
‫הכרטיסיה ‪:Provider‬‬
‫‪‬‬
‫בכרטיסייה ‪ Provider‬אתה בוחר את ה‪ OLE DB Provider-‬לפי סוג מקור הנתונים שאליו אתה מתכוון‬
‫לגשת‪:‬‬
‫‪ o‬עבור ‪-Database‬ים של ‪ Access‬בחר ב‪ Microsoft Jet 3.51 OLE DB Provider-‬או גירסה ‪4.0‬‬
‫שהיא מעודכנת יותר‬
‫‪ o‬עבור ‪-Database‬ים של ‪ SQL Server‬בחר ב‪Microsoft OLE DB Provider for SQL Server-‬‬
‫‪ o‬עבור ‪-Database‬ים של ‪ Oracle‬בחר ב‪ Microsoft OLE DB Provider for Oracle-‬או ב‪Provider-‬‬
‫אחר המתאים ל‪ Oracle-‬אם קיים כזה במחשב שלך‬
‫‪ o‬עבור גישה ל‪ Database-‬שלא קיים עבורו ‪ OLE DB Provider‬אך קיים עבורו ‪ Driver‬של ‪,ODBC‬‬
‫בחר ב‪ .Microsoft OLE DB Provider for ODBC Drivers-‬שים לב ש‪ Provider-‬זה מסומן‬
‫כברירת מחדל אם לא בחרת ‪ Provider‬אחר‬
‫‪‬‬
‫הכרטיסייה ‪:Connection‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫הכרטיסייה ‪ Connection‬מאפשרת להגדיר את מיקום ה‪ ,Database-‬שם המשתמש והסיסמה וכו'‪.‬‬
‫הפרטים בתוך כרטיסייה זו משתנים בהתאם ל‪ Provider-‬שנבחר בכרטיסייה הראשונה‬
‫את פרטי הכרטיסייה הזו תכיר בהמשך תרגיל זה ובשני התרגילים הבאים‬
‫‪‬‬
‫הכרטיסייה ‪:Advanced‬‬
‫‪‬‬
‫‪ Connect Timeout‬מגדיר את משך הזמן בשניות בהן יתבצע ניסיון התחברות למקור הנתונים‪ .‬אם החיבור‬
‫לא התליח בפרק זמן זה תתרחש שגיאה‬
‫‪ Access Permissions‬מגדיר את הרשאות הגישה ל‪ Database-‬בסעיף העוסק במאפיין ‪ Mode‬של האובייקט‬
‫‪( Connection‬בהמשך) תמצא הסבר אודות האפשרויות השונות‬
‫‪ Impersonation Level‬ו‪ Protection Level-‬מאפשרים הגדרות שונות עבור חיבור למקורות נתונים ברחבי‬
‫הרשת המבוססים על שיטות קריאה שונות מאשר ‪ ,)Remote Procedure Call( RPC‬ברוב המקרים הגדרות‬
‫אלו אינן רלוונטיות‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫הכרטיסייה ‪:All‬‬
‫‪ ‬בכרטיסייה ‪ All‬מוצגים כל המאפיינים של ה‪ Provider-‬שבחרת בכרטיסייה הראשונה‪ ,‬בין שהגדרת להם‬
‫ערכים ובין שלא הגדרת להם ערכים‬
‫‪ ‬המאפיינים המוצגים בכרטיסייה זו שונים עבור ‪-Provider‬ים שונים‬
‫‪ ‬תוכל לסמן מאפיין מסויים ולהגדיר את ערכו באמצעות לחיצה על הכפתור ‪Edit Value...‬‬
‫‪ ‬בדרך כלל לא תצטרך להגדיר מאפיינים שאינם סטנדרטיים‪ ,‬אך אם בכל זאת תרצה להבין את משמעותו של‬
‫מאפיין מסויים‪ ,‬יהיה עליך לעיין בתיעור של ה‪ Provider-‬המתאים‬
‫‪ .3‬הגדר את מאפייני ה‪:Data Link-‬‬
‫‪ ‬בכרטיסייה ‪:Provider‬‬
‫‪ o‬בחר ב‪( Microsoft Jet 4.0 OLE DB Provider-‬אם ברשותך גרסה מעודכנת יותר מ‪ 4.0-‬בחר בה)‬
‫‪ ‬בכרטיסייה ‪:Connection‬‬
‫‪ o‬בסעיף ‪ )Select or enter a database name( 1‬הזן את המסלול של ‪( NWIND.MDB‬קובץ זה נמצא‬
‫תחת ספריית ההתקנה של ‪ , Visual Basic‬במחשב שלי המסלול הוא ‪:‬‬
‫‪ ,C:\Program Files\Microsoft Visual Studio\VB98\NWIND.MDB‬אם בחרת בספריית‬
‫התקנה שונה בעת התקנת ‪ Visual Studio‬התאם את המסלול בהתאם)‬
‫‪ o‬לחץ על ‪ Test Connection‬כדי לוודא שההתחברות ל‪ Database-‬מצליחה‬
‫‪ ‬בכרטיסייה ‪:Advanced‬‬
‫‪ o‬השאר את הגדרת ה‪ Access permissions-‬כמו שהיא‬
‫‪ ‬בכרטיסייה ‪:All‬‬
‫‪ o‬תוכל לעיין בכרטיסייה ‪ All‬כדי לצפות בהגדרות שקבעת עד כה‪ .‬תוכל גם לשנות הגדרות בכרטיסיה‬
‫זו‪ ,‬או להגדיר ערכי מאפיינים שאינם מופיעים בכרטיסיות הקודמות‬
‫‪ .1‬אשר את ההגדרות‪:‬‬
‫‪ ‬לחץ על ‪ OK‬וסגור את תיבת הדו שיח‬
‫‪ .1‬עיין בקובץ ‪:NWind.udl‬‬
‫‪ ‬פתח את הקובץ ‪ NWind.udl‬באמצעות ה‪ Notepad-‬ועיין במבנה הקובץ ובאופן שבו נשמרו ההגדרות השונות‬
‫כפי שקבעת בכרטיסיות השונות‬
‫תרגיל ‪Pubs.udl : 1‬‬
‫‪ ‬בתרגיל זה ניצור קובץ ‪ Data Link‬שיכיל את פרטי המידע הדרושים לשם פניה ל‪ Database-‬בשם ‪ Pubs‬הנמצא‬
‫ב‪SQL Server-‬‬
‫‪ .1‬צור קובץ ‪ Data Link‬ריק‪:‬‬
‫‪ ‬צור קובץ ‪ Data Link‬ריק כפי שביצעת בתרגיל הקודם והקצה לו את השם ‪Pubs.udl‬‬
‫‪ .1‬הגדר את מאפייני ה‪:Data Link-‬‬
‫‪ o‬בחר ב‪Microsoft OLE DB Provider for SQL Server-‬‬
‫‪ o‬בסעיף ‪ )Select or enter a server name( 1‬בחר בשם המחשב בו נמצאת תוכנת ה‪SQL Server-‬‬
‫שלך (אם התוכנה מותקנת על אותו המחשב בו ממוקם קובץ ה‪ Data Link-‬ואינך יודע מה שמו של‬
‫המחשב ברשת‪ ,‬תוכל להזין בשדה זה את כתובת ה‪ .127.0.0.1 IP-‬כתובת זו היא כתובת‬
‫ה‪ loopback-‬אשר מצביעה חזרה על המחשב המקומי)‬
‫‪ o‬בסעיף ‪ )Enter information to log on to the server( 2‬קיימות שתי אפשרויות‪:‬‬
‫‪ :Use Windows NT Integrated security ‬אפשרות זו מתאימה אם התקנת ה‪SQL -‬‬
‫‪ Server‬אליה אתה מתחבר מאפשרת התחברות אוטומטית באמצעות שם המשתמש‬
‫והסיסמה של מערכת ההפעלה ‪ Windows NT‬שעליה היא מותקנת‬
‫‪ :Use a spesific username and password ‬באפשרות זו אתה מזין את שם המשתמש‬
‫והסיסמה ידנית‪ .‬בעת התקנת ‪ SQL Server‬נוצר באופן אוטומטי ‪ username‬ששמו הוא ‪sa‬‬
‫בעל סיסמה ריקה‪ .‬אם לא שינית את ההגדרות ב‪ SQL Server-‬הזן ‪ sa‬לשדה ‪username‬‬
‫והשאר את הסיסמה ריקה‪ .‬אם הסיסמה ריקה הוסף סימן ‪ V‬ליד האפשרות ‪Blank‬‬
‫‪ .password‬אם אתה מזין סיסמה שאתה מעוניין שתישמר בקובץ ה‪ Data Link-‬עליך לסמן‬
‫‪ V‬ליד האפשרות ‪Allow Saving Password‬‬
‫‪ o‬בסעיף ‪ 3‬עליך לבחור את ה‪ Database-‬אליו תרצה להתחבר‪ .‬באפשרותך לציין את ה‪Database-‬‬
‫בשתי צורות‪:‬‬
‫‪ ‬לסמן ‪ V‬ליד האפשרות ‪ ,Select the database on the server‬ולבחור ב‪ Pubs-‬מתוך רשימת‬
‫ה‪-Database-‬ים‬
‫‪ ‬לסמן ‪ V‬ליד האפשרות ‪ ,Attach a database file as a database name‬ולבחור את השם‬
‫‪ Pubs‬בשדה הראשון‪ ,‬ולהזין את מיקום הקובץ ‪ pubs.mdf‬בשדה השני (‪SQL Server‬‬
‫ממקם קובץ זה תחת תת הספרייה ‪ Data‬שתחת ספריית ההתקנה של ‪ ,SQL Server‬בדרך‬
‫כלל זהו ‪)C:\Program Files\Microsoft SQL Server\Data\Pubs.MDF‬‬
‫הערה‪ :‬בשונה מ‪ Access-‬יישומים רציניים לניהול ‪-Database‬ים‪ ,‬למשל ‪,SQL Server‬‬
‫‪ DB2 ,Oracle‬ועוד‪ ,‬שומרים את הנתונים ופרטי המידע הדרושים עבור ניהולו השוטף של‬
‫‪ Database‬במספר קבצים‪ .‬במקרה של ‪ SQL Server‬קיימים שלושה סוגי קבצים‪:‬‬
‫‪ ‬קובץ עם הסיומת ‪ :.MDF‬זהו קובץ הנתונים הראשי של ה‪Database-‬‬
‫‪ ‬קבצים עם הסיומת‪ :.NDF‬אלו הם קובצי נתונים משניים של ה‪Database-‬‬
‫‪ ‬קבצים עם הסיומת ‪ :.LDF‬אלו הם קובצי רישום (‪ )Log Files‬המשמשים‬
‫לפיעילותו השוטפת של ה‪Database-‬‬
‫‪ o‬תוכל לבדוק אם ההתחברות ל‪ Database-‬מצליחה על ידי לחיצה על ‪Test Connection‬‬
‫‪ ‬בכרטיסיה ‪:Advanced‬‬
‫‪ o‬בשדה ‪ Connect timeout‬הקצה ‪ 30‬שניות לניסיון ההתחברות‬
‫‪ o‬שים לב שה‪ Provider-‬עבור ‪ SQL Server‬אינו תומך באפשרות ‪Access permissions‬‬
‫‪ ‬בכרטיסיה ‪:All‬‬
‫‪ o‬תוכל לעיין בערכי המאפיינים שהזנת‬
‫‪ o‬תוכל גם לשנות את ערכי המאפיינים‪ ,‬או להזין ערכים למאפיינים שאינם מופיעים בכרטיסיות‬
‫‪ Connection‬ו‪( Advanced-‬אני ממליץ בפניך לא לשנות ערכי מאפיינים שאינך יודע את משמעותם)‬
‫‪ .3‬אשר את ההגדרות‪:‬‬
‫‪ ‬לחץ על ‪ OK‬וסגור את תיבת הדו שיח‬
‫‪ .1‬עיין בקובץ ‪:Pubs.udl‬‬
‫‪ ‬פתח את הקובץ ‪ ,Pubs.udl‬שזה עתה יצרת‪ ,‬באמצעות היישום ‪ ,Notepad‬ובחן את תוכנו ואת מבנהו‬
‫תר גיל ‪NWindDSN.udl : 4‬‬
‫‪‬‬
‫‪.1‬‬
‫‪.1‬‬
‫‪.3‬‬
‫‪.1‬‬
‫בתרגיל זה ניצור קובץ ‪ Data Link‬שיכיל את פרטי המידע הדרושים לשם פניה ל‪ Database-‬בשם ‪Northwind‬‬
‫המצוי ב‪ SQL Server-‬תוך שימוש ב‪ DSN-‬שיצרנו בתרגיל ‪ 1‬בשם ‪NWindDSN‬‬
‫צור קובץ ‪ Data Link‬ריק‪:‬‬
‫‪ ‬צור קובץ ‪ Data Link‬ריק והקצה לו את השם ‪ NWindDSN.udl‬כפי שביצעת בשני התרגילים הקודמים‬
‫הגדר את מאפייני ה‪:Data Link-‬‬
‫‪ o‬בחר ב‪( Microsoft OLE DB Provider for ODBC Drivers-‬זוהי אפשרות ברירת המחדל)‬
‫‪ o‬בסעיף ‪ )Use data source name( 1‬בלר מהרשימה הנפתחת ב‪( NwindDSN-‬זהו ה‪User DSN-‬‬
‫שיצרנו בתרגיל ‪ .)1‬תוכל גם ליצור ‪ ConnectionString‬אך נושא זה יילמד בהמשך השיעור‪.‬‬
‫‪ o‬בסעיף ‪ )Enter information to log on to the server( 2‬הקצה שם משתמש וסיסמה מתאימים‬
‫לשם התחברות ל‪Database-‬‬
‫‪ o‬לחץ על ‪ Test Connection‬על מנת לוודא שההתחברות מצליחה‬
‫‪ ‬בכרטיסייה ‪:Advanced‬‬
‫‪ o‬תוכל לשנות את הגדרות ה‪ Connect timeout-‬והגדרות ה‪( Access permissions-‬האפשרויות‬
‫השונות של ה‪ Access permissions-‬יילמדו בהמשך‪ ,‬כאשר תכיר את המאפיין ‪ Mode‬של האובייקט‬
‫‪ .)Connection‬לצורך תרגיל זה אני ממליץ בפניך להשאיר את ההגדרות כמו שהן‬
‫אשר את ההגדרות‪:‬‬
‫‪ ‬אשר את ההגדרות על ידי לחיצה על ‪OK‬‬
‫עיין בקובץ ‪:NWindDSN.udl‬‬
‫‪ ‬באמצעות ה‪ Notepad-‬פתח את הקובץ ‪ NWindDSN.udl‬כדי לעיין במבנהו ותוכנו של הקובץ‬
‫‪‬‬
‫‪‬‬
‫אובייקט ‪ Connection‬שולט על התקשרות אחת למקור נתונים‬
‫אובייקט ‪ Connection‬משמש כמכולה לטרנזקציות מול מקור הנתונים‬
‫מאפיינים‪ ,‬מתודות ואירועים להכנה וביצוע התחברות למקור נתונים‬
‫הערה‪ :‬לא כל המאפיינים נתמכים על ידי כל ה‪-Provider-‬ים השונים‪ .‬למשל המאפיין ‪ Mode‬נתמך על ידי ה‪Provider-‬‬
‫של ‪ )Microsoft.Jet.OLEDB( Access‬אך אינו נתמך על ידי ה‪ Provider-‬של ‪ .)SQLOLEDB( SQL Server‬אינך צריך‬
‫לזכור את כל המאפיינים הנתמכים על ידי ‪ Provider‬מסויים כיוון שיצירת ה‪ ConnectionString-‬הכוללת את‬
‫המאפיינים נעשית בדרך כלל על ידי ‪.Wizard‬‬
‫‪ :Provider ‬מגדיר את שם ה‪ OLE DB Provider-‬המשמש לביצוע ההתחברות‪ .‬ברירת המחדל היא ‪MSDASQL‬‬
‫המאפשר התחברות באמצעות ‪ Driver‬של ‪ .ODBC‬ניתן להגדיר מאפיין זה כחלק מהמאפיינים בתוך‬
‫ה‪ ConnectionString-‬כפי שיוסבר להלן‪ ,‬או כאובייקט ‪ .Property‬לדוגמה כדי להגדיר את ה‪Proveider‬‬
‫כ‪ Provider( SQLOLEDB.1-‬עבור ‪ )SQL Server‬ניתן להשתמש בכל אחת מהצורות הבאות‪:‬‬
‫‪Dim conn As New ADODB.Connection‬‬
‫‪...‬‬
‫‪...‬‬
‫"‪conn.Provider = "SQLOLEDB.1‬‬
‫או‬
‫"‪conn.Properties("Provider") = "SQLOLEDB.1‬‬
‫או‬
‫"‪conn.ConnectionString = "Provider=SQLOLEDB.1;...‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ :ConnectionString‬מחרוזת המכילה את מאפיני החיבור השונים‪ .‬המחרוזת היא במבנה של‬
‫"‪ "PropertyName1=Value; PropertyName2=Value;...‬כאשר ‪ PropertyName‬הוא שם של מאפיין ו‪Value-‬‬
‫הוא הערך המושם לאותו מאפיין‪ .‬ניתן להגדיר את מאפייני החיבור גם באמצעות האוסף ‪ Properties‬כפי שהודגם‬
‫קודם‪ .‬קיימים מאפיינים רבים עבור חיבור והם משתנים בין ‪-Provider‬ים שונים‪ .‬נציין מספר מאפיינים נפוצים‪:‬‬
‫‪ :Data Source o‬שם מקור הנתונים או שם של ‪ DSN‬הקיים במערכת במקרה של התחברות למקור נתוני‬
‫‪ODBC‬‬
‫‪ :DSN o‬שם של ‪ DSN‬הקיים במערכת‪ .‬מאפיין זה יכול להחליף את ‪ Data Source‬במקרה של התחברות‬
‫למקור נתונים של ‪ODBC‬‬
‫‪ :File Name o‬שם של קובץ המכיל את נתוני ההתחברות‪ .‬קובץ זה יכול להיות מסוג ‪ DSN‬עבור חיבור‬
‫למקור נתונים של ‪ ODBC‬או שם של קובץ מסוג ‪UDL‬‬
‫‪ :Initial Catalog o‬השם של ה‪Default Database-‬‬
‫‪ :Database o‬שם ה‪ .Database-‬ניתן להשתמש במאפיין זה בעת התחברות למקור נתונים של ‪ODBC‬‬
‫‪ :Password o‬סיסמת המשתמש באמצעותו מתבצע החיבור‬
‫‪ :PWD o‬סיסמת המשתמש באמצעותו מתבצע החיבור‪ .‬ניתן להשתמש במאפיין זה בעת התחברות למקור‬
‫נתונים של ‪ODBC‬‬
‫‪ :Persist Security Info o‬קובע האם ‪ ADO‬ישמור (‪ )Persist‬את שם המשתמש והסיסמה‬
‫(‪ )Security Info‬בקובץ ה‪Data Link-‬‬
‫‪ :Provider o‬כפי שהוסבר קודם‪ ,‬זהו שם ה‪ OLE DB Provider-‬באמצעותו מתבצעת ההתחברות‬
‫‪ :User ID o‬שם המשתמש באמצעותו מתבצעת ההתחברות‬
‫‪ :UID o‬שם המשתמש באמצעותו מתבצעת הנתחברות‪ .‬ניתן להשתמש במאפיין זה בעת התחברות למקור‬
‫נתונים של ‪ODBC‬‬
‫‪ :Default Database‬מחזיר את שם ה‪ .Default Database-‬מאפיין זה זמין רק לאחר שההתחברות בוצעה‪ ,‬ואז‬
‫הוא לקריאה בלבד‬
‫‪ :ConnectionTimeout‬מגדיר את משך הזמן (בשניות) המקסימלי שאובייקט ה‪ Connection-‬ימתין עד להשלמת‬
‫ההתחברות למקור הנתונים‪ .‬אם ההתחברות לא הסתיימה תוך פרק הזמן המוגדר‪ ,‬תתעורר שגיאה מתאימה‪ .‬ערך‬
‫ברירת המחדל למאפיין זה הוא ‪ 15‬שניות‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ :CommandTimeout‬מגדיר את משך הזמן (בשניות) המקסימלי שאובייקט ה‪ Connection-‬ימתין עד להשלמת‬
‫פקודה מול מקור הנתונים‪ .‬אם הפקודה לא הושלמה תוך פרק הזמן המוגדר תתעורר שגיאה מתאימה‪ .‬ערך ברירת‬
‫המחדל למאפיין זה הוא ‪ 30‬שניות‪ .‬מאפיין זה משפיע על הפקודות המורצות באופן ישיר באמצעות ‪Connection‬‬
‫זה‪ ,‬ואינו משפיע על פקודות המורצות מאובייקט ‪ Command‬המשתמש באובייקט זה‪ .‬לאובייקט ‪ Command‬ישנו‬
‫מאפיין ‪ CommandTimeout‬משלו‬
‫‪ :CursorLocation‬קובע את מיקום ה‪ .Cursor-‬מאפיין זה יכול לקבל אחד מהערכים הבאים‪:‬‬
‫הערה‪ Cursor :‬הינו אובייקטהמכיל רשומה אחת או בלוק של רשומות מתוך אוסף הרשומות המוחזר על ידי‬
‫שאילתה ממקור הנתונים‬
‫‪ :adUseServer o‬ה‪ Cursor-‬נוצר במחשב ה‪Server-‬‬
‫‪ :adUseClient o‬ה‪ Cursor-‬נוצרבמחשב ה‪Client-‬‬
‫שים לב‪ :‬ניתן ליצור את כל סוגי ה‪-Cursor-‬ים ב‪ ,Server-‬ואילובמחשב ה‪ Client-‬ניתן ליצור ‪Cursor‬‬
‫מסוג ‪ adOpenStatic‬בלבד‪ .‬הסבר אודות סוגי ה‪-Cursor-‬ים תמצא בהמשך השיעור‬
‫‪ :Mode‬מאפיין זה מגדיר את הרשאות ה‪ .Connection-‬מאפיין זה יכול לקבל אחד או יותר מהערכים הבאים‪:‬‬
‫‪ :adModeRead o‬מאפשר קריאה ממקור הנתונים‬
‫‪ :adModeWrite o‬מאפשר כתיבה למקור הנתונים‬
‫‪ :adModeReadWrite o‬מאפשר קריאה ממקור הנתונים כמו גם כתיבה למקור הנתונים‬
‫‪ :adModeShareDenyRead o‬מונע מלקוחות אחרים להתחבר לאותו מקור נתונים לשם קריאה‬
‫‪ :adModeShareDenyWrite o‬מונע מלקוחות אחרים להתחבר לאותו מקור נתונים לשם כתיבה‬
‫‪ :adModeShareExclusive o‬מונע מלקוחות אחרים התחברות לאותו מקור נתונים בהרשאה כלשהי‬
‫‪ :adModeShareDenyNone o‬מאפשר ללקוחות אחרים להתחבר למקור הנתונים עם הרשאות כלשהן‬
‫יצירת ‪Connection String‬‬
‫‪‬‬
‫תוכל להגדיר את ה‪ ConnectionString-‬במספר דרכים‪:‬‬
‫‪ .1‬לקודד בעצמך מאפיין זה – הגדרה באופן כזה קשה למדי כיוון שקשה לזכור את רשימת המאפיינים הרבה‬
‫הקיימים עבור מאפיין זה‪ .‬תוכל להשתמש בטריק קטן‪ :‬צור קובץ ‪ Data Link‬ולאחר מכן העתק את ההגדרות‬
‫שבתוך הקובץ (תוכל לצפות בהן באמצעות ה‪ ,Notepad-‬כפי שביצעת בתרגילים הקודמים) למאפיין‬
‫‪ ConnectionString‬שבקוד התוכנית שלך‬
‫‪ .1‬ליצור קובץ ‪ Data Link‬ולהגדיר אותו באמצעות המאפיין ‪ File Name‬ב‪ .Connection String-‬כך למשל‪ ,‬כדי‬
‫להתחבר למקור הנתונים שהוגדר באמצעות קובץ ה‪ Data Link-‬מתרגיל ‪ ,)Pubs.udl( 1‬ניתן להגדיר את‬
‫ה‪ Connection String-‬באופן הבא‪:‬‬
‫‪Dim conn As New ADODB.Connection‬‬
‫‪...‬‬
‫‪...‬‬
‫"‪conn.ConnectionString = "File Name=...\Pubs.udl‬‬
‫כאשר יש לציין כמובן את המסלול המלא של הקובץ‬
‫שיטה זו מומלצת מאוד‪ ,‬כיוון שתוכל לשנות את הגדרת מקור הנתונים בקובץ ה‪ Data Link-‬מבלי לשנות‬
‫את קוד המקור של התוכנית או לקמפל את התוכנית מחדש‬
‫‪ .3‬תוכל לבנות את המאפיין ‪ ConnectionString‬באמצעות האשפים השונים‪ .‬בתיבות הדו שיח המגדירה את‬
‫מקור הנתונים עבור פקד ‪ ADODC‬קיים כפתור ‪ Build‬ליד השדה ‪ .Connection String‬לחיצה על כפתור זה‬
‫מפעילה אשף המאפשר לך להגדיר את מקור הנתונים‪ .‬לאחר סיום פעולת האשף‪ ,‬נוצר עבורך ‪Connection‬‬
‫‪ .String‬תוכל להעתיק ‪ Connection String‬זה לתוך הקוד שלך‪ .‬באחת הדוגמאות הבאות תשתמש בטכניקה‬
‫זו‪.‬‬
ActiveX Data Objects :12 ‫שיעור‬
SimpleConnection ‫ – התוכנ ית‬3 ‫תרגיל‬
‫ מוכן‬DSN-‫ תוך שימוש ב‬ADO ‫ לבין מקור נתונים באמצעות‬Visual Basic ‫ בתרגיל זה ניצור חיבור בין תוכנית‬
:‫ ושמור אותו‬Standard EXE ‫ צור פרוייקט‬.1
frmTestConnection ‫ ולטופס את השם‬SimpleConnection ‫ הקצה לפרוייקט את השם‬
:‫ לטופס והגדר את המאפיינים הבאים‬CommandButtons ‫ הוסף שני‬.1
‫ערך‬
Test Connection
3- Fixed Dialog
2-CenterScreen
cmdConnect
Connect
True
cmdDisconnect
Disconnect
False
‫מאפיין‬
Caption
BorderStyle
StartUpPosition
Name
Caption
Enabled
Name
Caption
Enabled
frmTestConnection
Command1
Command2
:‫הטופס צריך להיראות דומה לזה שבציור‬

:ADO ‫ הוסף הפנייה לספריית‬.3
References ‫ בחר באפשרות‬Project ‫ מתוך תפריט‬
‫ (ייתכן‬Microsoft ActiveX Data Objects 2.7 Library ‫ מתוך רשימת ספריות הרכיבים בחר בספרייה‬
)‫ בחר בגירסה הכי מתקדמת‬.‫שבמחשב שלך מותקנת גירסה מוקדמת יותר או מאוחרת יותר של הספריה‬
Option Explicit
Dim conn As ADODB.Connection
ADO ‫ של‬Connection ‫בחלק הגלובלי של הטופס הוצהר אובייקט‬

Set conn = New ADODB.Connection
End Sub
New ‫בעת טעינת הטופס נוצר אובייט באמצעות המילה‬
Private Sub cmdConnect_Click()
conn.ConnectionString = "DSN=NwindDSN;User ID=sa"
conn.Open
If conn.State = adStateOpen Then
MsgBox "Connection successful"
cmdConnect.Enabled = False
cmdDisconnect.Enabled = True
www.kita.co.il

‫‪Else‬‬
‫"‪MsgBox "Connection Failed‬‬
‫‪End If‬‬
‫‪End Sub‬‬
‫‪‬‬
‫‪‬‬
‫בעת לחיצה על ‪ Connect‬יוצרים ‪ Connection String‬עם הפניה ל‪ DSN-‬שיצרנו בתרגיל הקודם וכפרמטר‬
‫נוסף מעבירים את שם המשתמש‬
‫לאחר קריאה לפרוצדורה ‪ Open‬בודקים את מצב החיבור‪ adStateOpen .‬מצביע על חיבור מוצלח‬
‫)(‪Private Sub cmdDisconnect_Click‬‬
‫‪conn.Close‬‬
‫‪If conn.State = adStateClosed Then‬‬
‫"‪MsgBox "Disconnected‬‬
‫‪cmdConnect.Enabled = True‬‬
‫‪cmdDisconnect.Enabled = False‬‬
‫‪End If‬‬
‫‪End Sub‬‬
‫‪‬‬
‫בעת ליחצה על ‪ Disconnect‬קוראים לשיטה ‪ Close‬כדי לנתק את החיבור ל‪Database-‬‬
‫‪If conn.State = adStateOpen Then‬‬
‫‪conn.Close‬‬
‫‪End If‬‬
‫‪Set conn = Nothing‬‬
‫‪End Sub‬‬
‫‪ ‬בעת הסרת הטופס מנתקים את החיבור (אם הוא עדיין לא נותק) ומשחררים את אובייקט ה‪ADO-‬‬
‫‪ ‬אם לא קוראים באופן מפורש ל‪ ,Close-‬פעולה זו תתבצע באופן אוטומטי על ידי האובייקט ‪ ADO‬בעת‬
‫שיחרורו מהזיכרון‬
‫‪ .1‬בחינת הפרוייקט‪:‬‬
‫‪ ‬הרץ את התוכנית ובדוק את פעולתה‬
‫‪ - Event‬ים של אובייקט ‪Connection‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫האובייקטים השונים של ‪ ADO‬חושפים ‪-Event‬ים שונים‪ .‬לחלק מבין ה‪-Event-‬ים ישנו מבנה קבוע‪:‬‬
‫‪ :Willxxxx o‬אירוע זה מתרחש לפני שהפעולה ‪ xxxx‬מתרחשת‬
‫‪ :xxxxComplete o‬אירוע זה מתרחש לאחר השלמת הפעולה ‪xxxx‬‬
‫דוגמאות לצמדים כאלה של אירועים הם ‪ WillConnect‬ו‪WillExecute ,ConnectComplete-‬‬
‫ו‪ ExecuteComplete-‬וכו'‬
‫בעת כניסה לאירוע ‪ Willxxxx‬מועבר פרמטר ‪ adStatus‬שיכול להכיל את הערכים הבאים‪:‬‬
‫‪ :adStatusOK o‬אין שום שגיאות‬
‫‪ :adStatusErrorsOccured o‬התרחשה שגיאה כלשהי‬
‫‪ :adStatusCantDeny o‬לא התרחשה שגיאה‪ ,‬אך לא ניתן לבטל את הפעולה‬
‫בעת כניסה לאירוע ‪ Willxxxx‬תוכל לשנות את ערכו של ‪ adStatus‬לאחד הערכים הבאים‪:‬‬
‫‪ :adStatusCancel o‬מורה ל‪ ADO-‬לבטל את הפעולה (כאמור‪ ,‬לא ניתן לבצע זאת אם הערך הקודם של‬
‫‪ adStatus‬היה ‪)adStatusCantDeny‬‬
‫‪ :adStatusUnwantedEvent o‬מורה ל‪ ADO-‬לחדול משליחת האירוע‬
‫תרגיל ‪ – 6‬התוכנ ית ‪ConnectWithEvents‬‬
‫‪ ‬בתרגיל זה ניצור חיבור בין תוכנית ‪ Visual Basic‬לבין מקור נצונים באמצעות ‪ ADO‬תוך שימוש ב ‪OLE‬‬
‫‪ Provider‬עבור ‪ ,SQL Server‬כמו כן נשתמש ב‪-Event-‬ים של האובייקט ‪ Connection‬בתרגיל זה‬
‫‪ .1‬שלבים ‪ 1-1‬בתרגיל זה‪ ,‬זהים לתרגיל הקודם (לתוכנית זו הקצה את השם ‪)ConnectWithEvents‬‬
‫‪ .1‬צור ‪:Connection String‬‬
‫‪ ‬בתרגיל זה ניצור ‪ Connection String‬שישתמש ב‪Microsoft OLEDB Provider for SQL Server-‬‬
‫‪ ‬שליטה בתחביר של ה‪ Connection String-‬ויצירת ה‪ Connection String-‬היא‪ ,‬כאמור‪ ,‬משימה מפרכת‪,‬‬
‫לפיכך נשתמש באובייקט ‪ ADODC‬באופן זמני כדי ליצור את ה‪ ConnectionString-‬באמצעות ‪:Wizard‬‬
‫‪ o‬מהתפריט ‪ Project‬בחר ב‪ Components-‬והוסף את הרכיב ‪Microsoft ADO Data Control 6.0‬‬
‫)‪ (OLEDB‬לפרוייקט‬
‫‪ o‬הוסף אובייקט ‪ ADODC‬לטופס‬
‫‪ o‬לחץ לחיצה ימנית על הפקד שהוספת ובחר ב‪ ,Properties-‬חלון המאפיינים של ‪ ADODC‬אמור‬
‫להפתח‬
‫‪ o‬בכרטיסייה ‪ General‬בחר ב‪ Use Connection String-‬ולאחר מכן לחץ על הלחצן ‪ Build...‬הממוקם‬
‫מימין לתיבת הטקסט‪ ,‬ייפתח חלון שכותרתו ‪Data Link Properties‬‬
‫‪ o‬מתוך רשימת ה‪ OLEDB Providers-‬בחר ב‪Microsoft OLEDB Provider for SQL Server-‬‬
‫ולאחר מכן לחץ על ‪Next‬‬
‫‪ o‬בסעיף ‪ 1‬בכרטיסייה ‪ Connection‬בחר ב‪ Server-‬שבו ממוקמת מערכת ‪ SQL Server‬שאליה אתה‬
‫מתחבר‬
‫‪ o‬בסעיף ‪ 2‬הזן שם משתמש וסיסמה או שתבחר ב‪ Use Windows NT Integrated Security-‬אם‬
‫מערכת ה‪ SQL-‬שאליה אתה מתחבר מאפשרת זאת‪ .‬תוכל להזין את שם המשתמש ‪ sa‬בצירוף‬
‫סיסמה ריקה אם במערכת ה‪ SQL Server-‬לא שונו ההגדרות‬
‫‪ o‬בסעיף ‪ 3‬בחר מתוך רשימת ה‪-Database-‬ים את ‪Northwind‬‬
‫‪ o‬תוכל ללחוץ על ‪ Test Connection‬כדי לבחון האם ה‪ Connection-‬שהגדרת פועל‬
‫‪ o‬לחץ על ‪ ,OK‬כעת חזרת לכרטיסייה ‪General‬‬
‫‪ o‬שים לב שבתיבת הטקסט מופיעה מחרוזת‪ ,‬העתק מחרוזת זו ע"י סימונה ולחיצה על ‪Ctrl+C‬‬
‫‪ o‬סגור את חלון ה‪ Property Pages-‬והסר את אובייקט ה‪ ADODC-‬מהטופס‪ ,‬תוכל להסיר גם את‬
‫ההתיחסות ל‪ Microsoft ADO Data Control 6.0 (OLEDB)-‬שהוספת קודם‬
‫‪ .3‬הוסף את הקוד הבא לטופס‪:‬‬
‫‪Dim WithEvents conn As ADODB.Connection‬‬
‫‪‬‬
‫בשורה זו מוצהר אובייקט ‪ Connection‬תוך שימוש במילה ‪ WithEvents‬כדי שגם האירועים שלו יילכדו‬
‫)(‪Private Sub Form_Load‬‬
‫‪Set conn = New ADODB.Connection‬‬
‫‪End Sub‬‬
‫‪‬‬
‫בעת טעינת הטופס יוצרים את האובייקט‬
‫)(‪Private Sub cmdConnect_Click‬‬
‫_ & ";‪conn.ConnectionString = "Provider=SQLOLEDB.1‬‬
‫_ & ";‪"Persist Security Info=False‬‬
‫_ & ";‪"User ID=sa;Initial Catalog=Northwind‬‬
‫"‪"Data Source=WIN2K‬‬
conn.Open
If Err.Number <> 0 Then
MsgBox "Error No. " & Trim(Str(Err.Number)) & ":" & vbCrLf & _
Err.Description
Err.Clear
conn.Errors.Clear
End If
End Sub
1 ‫ זוהי המחרוזת שהעתקת בשלב‬:‫ (שים לב‬Connection String-‫ מגדירים את ה‬Connect ‫בעת לחיצה על‬
)‫ שהוספת באופן זמני לטופס‬ADODC ‫ של האובייקט‬Property Pages-‫מחלון ה‬
‫ בוטלה או נכשלה‬,‫ כדי לבחון האם ההתחברות הצליחה‬Err ‫ נבדק האובייקט‬Open ‫לאחר הפעלת הפרוצדורה‬
‫מסיבה כלשהי‬


Private Sub conn_WillConnect(ConnectionString As String, _
UserID As String, _
Password As String, _
Options As Long, _
adStatus As ADODB.EventStatusEnum, _
ByVal pConnection As ADODB.Connection)
If adStatus = adStatusOK Then
If MsgBox("Do you want to cancel the operation?", _
vbYesNo Or vbQuestion Or vbDefaultButton2) = vbYes Then
adStatus = adStatusCancel
End If
End If
End Sub
‫ מציגים למשתמש שאלה המאפשרת לו לבטל את פעולת ההתחברות‬WillConnect ‫באירוע‬
‫ משמעותו היא שלא‬adStatusOK .adStatusOK-‫ שווה ל‬adStatus ‫ שאלה זו מוצגת רק אם ערך‬:‫שים לב‬
‫התרחשו שגיאות וכן ניתן לבטל את הפעולה‬


Private Sub conn_ConnectComplete(ByVal pError As ADODB.Error, _
adStatus As ADODB.EventStatusEnum, _
ByVal pConnection As
ADODB.Connection)
MsgBox "Connection successful"
cmdConnect.Enabled = False
cmdDisconnect.Enabled = True
End If
End Sub
‫ אם כן מציגים הודעה למשתמש‬,‫ בודקים אם ההתחברות הצליחה‬ConnectComplete-‫ב‬
‫ אירוע זה יטופל שם‬,cmdConnect_Click ‫אם ההתחברות נכשלה אזי תיווצר שגיאה שתילכד באירוע‬
‫ כיוון שבשלב זה‬ConnectComplete ‫ לא תוכל לבדוק אם התרחשה שגיאה בהתחברות בתוך האירוע‬:‫שים לב‬
conn.Open ‫ שגיאה תתעורר רק בסיום נסיון ההתחברות לאחר בשורה שבה כתוב‬,0 ‫ יהיה‬Err.Number ‫ערך‬
www.kita.co.il



Private Sub cmdDisconnect_Click()
conn.Close
End Sub
Close ‫ נסגר החיבור על ידי‬Disconnect ‫בעת לחיצה על‬

Private Sub conn_Disconnect(adStatus As ADODB.EventStatusEnum, _
ByVal pConnection As ADODB.Connection)
If conn.State = adStateClosed Then
MsgBox "Disconnected"
cmdConnect.Enabled = True
cmdDisconnect.Enabled = False
End If
End Sub
‫ מציגים הודעה מתאימה למשתמש‬adStateClosed-‫ שווה ל‬conn.State ‫אם פעולת הניתוק הצליחה וערכו של‬

conn.Close
End If
Set conn = Nothing
End Sub
‫ בעת הסרת הטופס מנתקים את החיבור אם לא נותק עד כה‬
:‫ בחינת הפרוייקט‬.1
‫ הרץ את הפרוייקט ובחן את פעולתו‬
‫ כדי לבחון אותה מקרוב‬F8 ‫ באמצעות‬Step By Step ‫ אני ממליץ בפניך להריץ את התוכנית‬
RECORDSET
‫האובייקט‬
DisplayEmployees ‫ – התוכנ ית‬7 ‫תרגיל‬
Employees ‫ ונציג את תוכן הטבלה‬Northwind-‫ בתרגיל זה ניצור חיבור ל‬
:‫ ושמור אותו‬Standard EXE ‫ צור פרוייקט‬.1
frmDisplayEmployees ‫ ולטופס את השם‬DisplayEmployees ‫ הקצה לפרוייקט את השם‬
‫ שמור את הפרוייקט‬
:ADO ‫ לספריית‬Reference ‫ הוסף לפרוייקט‬.1
Project ‫ מתוך התפריט‬References ‫ בחר באפשרות‬
‫ (אם יש לך גירסה מוקדמת יותר או‬Microsoft ActiveX Data Objects 2.7 Library ‫ ליד הספרייה‬V ‫ סמן‬
)‫ ליד הספרייה המעודכנת ביותר‬V ‫ סמן‬,‫מאוחרת יותר‬
:‫ והגדר את המאפיינים הבאים‬,‫ אחד לטופס‬TextBox-‫ים ו‬-CommandButton ‫ הוסף שני‬.3
‫ערך‬
Test Connection
3- Fixed Dialog
2-CenterScreen
cmdUseTableName
Use table name
cmdUseSQLStatement
‫מאפיין‬
Caption frmDisplayEmployees
BorderStyle
StartUpPosition
Name
Command1
Caption
Name
Command2
www.kita.co.il
Use SQL statment
txtDisplay
True
3 - Both
Caption
Name
Multiline
ScrollBars
Text1
:‫הטופס צריך להיראות דומה לזה שבציור‬

Option Explicit
Dim conn As ADODB.Connection
Dim rcs As ADODB.Recordset
‫ עבור אחזור של‬rcs-‫ ו‬Northwind-‫ עבור התחברות ל‬conn ,‫בשתי השורות הנ"ל מצהירים עלש ני אובייקטים‬
)Recordset( ‫אוסף רשומות‬

Set conn = New ADODB.Connection
conn.Open "Provider=SQLOLEDB.1;" & _
"Persist Security Info=False;" & _
"User ID=sa;" & _
"Initial Catalog=Northwind;" & _
"Data Source=WIN2K"
If conn.State = adStateClosed Then
MsgBox "Error: Fail to connect"
Unload Me
End If
Set rcs = New ADODB.Recordset
Set rcs.ActiveConnection = conn
End Sub
Open ‫ באמצעות הפרוצדורה‬Northwind-‫ פותחים חיבור ל‬Form_Load ‫ באירוע‬
:‫שים לב‬
www.kita.co.il
‫ בדוגמאות‬.Open-‫ או כפרמטר ל‬Open ‫ לפני הפעלת‬Conn-‫ ל‬Connection String-‫ ניתן להעביר את ה‬.1
Open ‫ לפני הפעלת‬Connection String-‫הקודמות העברנו את ה‬
‫ כפי שעשית בתרגיל הקודם‬ADODC ‫ צור באמצעות פקד‬Connection String-‫ את ה‬.1
‫ לחיבור‬conn ‫ והופכים את החיבור‬,New ‫ חדש באמצעות המילה‬Recordset ‫ יוצרים‬,‫ לאחר יצירת החיבור‬
rcs ‫) עבור האובייקט‬ActiveConnection( ‫הפעיל‬
Private Sub cmdUseTableName_Click()
If rcs.State = adStateOpen Then
rcs.Close
End If
rcs.Source = "Employees"
rcs.Open , , , , adCmdTable
txtDisplay.Text = ""
DisplayRecordset rcs
End Sub
‫ כדי לאחזר את רשומות הטבלה‬rcs ‫ של‬Open ‫ מפעילים את הפרוצדורה‬Use table name ‫ בעת לחיצה על‬
Employees
:‫שים לב‬
)‫ (כפי שתראה בשגרה הבאה‬Open ‫ בעת הפעלת המתודה‬rcs-‫ ל‬Sourec String-‫ניתן להעביר את ה‬
.1
.‫ וכו') אין חובה להעביר‬,adCmdText – SQL ‫ משפט‬,adCmdTable – ‫את סוג הפקודה (בקשת טבלה‬
.1
‫ יהיהחייב להחליט באיזה סוג פקודה‬OLE Provider-‫ יהיה הפסד ביצועי קל כיוון שה‬,‫במקרה כזה‬
‫מדובר‬
‫ באמצעות‬rcs ‫ ולהשימו לתוך‬ADODB.Command ‫ניתן להגדיר פקודה באמצעות אובייקט מסוג‬
.3
rcs.ActiveCommand ‫המאפיין‬
‫ שנכתוב בהמשך‬DisplayRecordset ‫ מוצגות הרשומות באמצעות הפרוצדורה‬,‫ לאחר שהמשפט בוצע‬
Private Sub cmdUseSQLStatement_Click()
If rcs.State = adStateOpen Then
rcs.Close
End If
rcs.Open "SELECT * FROM Employees", , , , adCmdText
txtDisplay.Text = ""
DisplayRecordset rcs
End Sub
‫ אלא שנשתמש‬,Employees ‫ נציג את תוכן הטבלה‬Use SQL Statement-‫ גם ב‬,Use table name-‫בדומה ל‬
‫ במקום שם טבלה‬SQL ‫במשפט‬
SQL ‫ המציין כי מדובר במשפט‬adCmdText ‫שים לב שסוג הפקודה שצויין הוא‬
Private Sub DisplayRecordset(rs As ADODB.Recordset)
rs.MoveFirst
Do Until rs.EOF
DisplaySingleRecord rs.Fields
txtDisplay.Text = txtDisplay.Text & vbCrLf
rs.MoveNext
Loop
End Sub
www.kita.co.il


‫‪‬‬
‫‪‬‬
‫‪‬‬
‫ברוטינה ‪ DisplayRecordset‬מציגים את תוכן הטבלה באמצעות לולאה הסורקת את אוסף הרשומות עד‬
‫שמגיעים ל‪ EOF-‬המציין את סיום אוסף הרשומות‬
‫השימוש במתודה ‪ MoveFirst‬נועד לאתחל את ה‪ Recordset-‬כך שימוקם ברשומה הראשונה ברוסף‬
‫עבור כל רשומה מעבירים את אוסף השדות שלה למתודה ‪( DisplaySingleRecord‬מוגדרת בהמשך)‬
‫באמצעותה מציגים את הרשומה הנוכחית באוסף הרשומות‬
‫)‪Private Sub DisplaySingleRecord(flds As ADODB.Fields‬‬
‫‪Dim fld As ADODB.Field‬‬
‫‪For Each fld In flds‬‬
‫_ & ‪txtDisplay.Text = txtDisplay.Text‬‬
‫_ & " = " & ‪fld.Name‬‬
‫_ & )‪IIf(IsNull(fld.Value), "<Null>", fld.Value‬‬
‫)" " ‪String(8,‬‬
‫‪Next‬‬
‫‪End Sub‬‬
‫‪‬‬
‫‪‬‬
‫עבור כל רשומה‪ ,‬סורקים את אוסף השדות שבה‪ ,‬תוך הצגת שמות השדות ותוכנם‬
‫אם ערך שדה מסוים הוא ‪ Null‬מציגים את המחרוזת >‪<Null‬‬
‫‪Set rcs = Nothing‬‬
‫‪Set conn = Nothing‬‬
‫‪End Sub‬‬
‫‪ ‬באירוע ‪ Form_Unload‬משחריים את ה‪ Connection-‬ואת ה‪Recordset-‬‬
‫‪ .1‬בחינה והרצת הפרוייקט‪:‬‬
‫‪ ‬הרץ את התוכנית ובדוק את פעולתה‬
‫המאפי ין ‪CursorType‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ :adOpenForwardOnly‬יוצר ‪ Cursor‬הנע קדימה בלבד‪ .‬ב‪ Cursor-‬מסוג זה תוכל להשתמש במתודות‬
‫‪ MoveFirst , MoveNext‬או ‪ Move‬עם פרמטר חיובי‪ .‬לא תוכל לדלג לרשומה האחרונה באמצעות ‪ MoveLast‬או‬
‫לחזור לרשומותקודמות באמצעות ‪ MovePrevious‬או ‪ Move‬עם פרמטר שלילי‪ Cursor .‬מסוג ‪Forward Only‬‬
‫יכול להיות בצד ה‪ Server-‬בלבד‪ .‬ל‪ Cursor-‬זה הביצועים הטובים ביותר‪.‬‬
‫‪ :adOpenDynamic‬יוצר ‪ Cursor‬המאפשר תנועה חופשית ב‪ Cursor .Recordset-‬מסוג זה מעודכן תמיד‬
‫בנתונים העדכניים ביותר מה‪ .Database-‬בעת מעבר לרשומה מסוימת‪ ,‬מובאת הרשומה המעודכנת‬
‫מה‪ Cursor .Database-‬מסוג זה יכול להיות ממוקם בצד ה‪ Server-‬בלבד‪ .‬ל‪ Cursor-‬זה הביצועים הגרועים‬
‫ביותר‪.‬‬
‫‪ :adOpenKeyset‬בדומה ל‪ Cursor ,adOpenDynamic-‬מסוג זה מציג גם הוא את הנתונים העדכניים ביותר‪ .‬עם‬
‫זאת‪ Cursor ,‬מסוג ‪ Keyset‬אינו מציג רשומות חדשות שנוספו על‪-‬ידי משתמשים אחרים‪ Cursor .‬מסוג ‪Keyset‬‬
‫יכול להיות במחשב ה‪ Server-‬בלבד‪.‬‬
‫‪ Cursor :adOpenStatic‬מסוג זה יוצר העתק של הנתונים המאוחזרים מה‪ .Database-‬ניתן לנוע בחופשיות בין‬
‫הרשומות שב‪ Cursor-‬סטטי‪ .‬שינויים הנעשים על ידי משתמשים אחרים ברשומות לא יעודכנו ב‪ Cursor-‬מסוג זה‪.‬‬
‫ביצועיו של ‪ Cursor‬סטטי הם טובים למרות שמשך הטעינה הראשון הוא ממושך יחסית‪ .‬מומלץ לעבוד עם ‪Cursor‬‬
‫כזה כאשר מספר הרשומות המאוחזרות קטן יחסית‪ Cursor .‬סטטי הוא ה‪ Cursor-‬היחיד הניתן ליצירה בצד‬
‫ה‪Client-‬‬
‫תנועה ב ‪Recordset -‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ :MoveFirst‬הופך את הרשומה הראשונה ב‪ Recordset-‬לרשומה הנוכחית‬
‫‪ :MoveLast‬הופך את הרשומה האחרונה ב‪ Recordset-‬לרשומה הנוכחית‬
‫‪ :MoveNext‬הופך את הרשומה הבאה לרשומה הנוכחית‬
‫‪ :MovePrevious‬הופך את הרשומה הקודמת לרשומה הנוכחית‬
‫)‪ :Move(n‬הופך את הרשומה הנמצאת המרחק ‪ n‬מהרשומה הנוכחית‪ ,‬לרשומה הנוחכית‪ n( .‬יכול להיות גם מספר‬
‫שלילי)‬
‫‪( CURSORS‬סמנים)‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ Cursor‬הוא מערך רשומות המתקבל כתוצאה משליחת בקשה ל‪Database-‬‬
‫ניתן לשלוט על שלושה מאפיינים של ‪:Cursor‬‬
‫‪( CursorLocation o‬מיקום ה‪)Cursor-‬‬
‫‪( CursorType o‬סוג ה‪)Cursor-‬‬
‫‪( LockType o‬סוג הנעילה)‬
‫ניתן להגדיר מאפיינים אלו‪ ,‬כל עוד לא נפתח ה‪ Recordset-‬באמצעות הפרוצדורה ‪Open‬‬
‫בשלושת הסעיפים הבאים יפורטו מאפיינים אלו‬
‫המאפי ין ‪LockType‬‬
‫‪‬‬
‫‪:adLockReadOnly‬‬
‫מאפיינים נוספים‬
‫‪‬‬
‫‪‬‬
‫‪ :MaxRecords‬קובע את מספר הרשומות המקסימלי שיאוחזר מה‪Database-‬‬
‫‪:CashSize‬‬
‫תרגיל ‪ – 3‬התוכנ ית ‪Nevi gateRecords‬‬
‫‪ ‬בתוכנית זו תנווט בין רשומות באמצעות המתודות ‪ MoveFirst ,MovePrev ,MoveNext‬ו‪ .MoveLast-‬כמו כן‬
‫תשתמש באירועים ‪MoveCo‬‬
‫‪ .1‬לסיים‬
‫‪ .1‬לסיים‬
‫‪.3‬‬
‫‪.1‬‬
‫‪.1‬‬
‫‪CONTROL‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ADO DATA‬‬
‫‪ ADODC‬הוא ‪ Control‬המבוסס על אובייקט מסוג ‪ADO‬‬
‫‪ ADODC‬ניתן לקשר לאוסף רשומות מ‪ Database-‬בדרכים שונות‬
‫ניתן להגדיר את ‪ ADODC‬כספק נתונים עבור פקד שהוא צרכן נתונים‬
‫רוב הפקדים הסטנדרטיים תומכים ב‪ ,Data Binding-‬כלומר יכולים לשמש כצרכני נתונים‬
‫כדי שניתן יהיה להשתמש ב‪ADODC -‬יש להגדיר אליו הפניה ב‪Project Components-‬‬
‫האובייקט ‪Recordset‬‬
‫‪‬‬
‫הוספת רשומה חדשה‬
‫‪‬‬
‫מחיקת רשומה‬
‫‪‬‬
‫התחלת טרנזקציה (באמצעות גישה ל‪ ActiveConnection-‬מתוך ה‪)Recordset-‬‬
‫‪myadodc.Recordset.AddNew‬‬
‫‪myadodc.Recordset.Delete‬‬
‫‪myadodc.Recordset.ActiveConnection.BeginTrans‬‬
‫‪‬‬
‫סיום תוך שמירה של הטרנזקציה‬
‫‪‬‬
‫סיום ואי שמירה של הטרנזקציה‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫לפי בדיקה שלי אין תמיכה ב‪Transaction Nested-‬‬
‫‪ ADODC‬מבצע ‪ Commit‬אוטומטית בסוף‪ ,‬אלא אם קראת ל‪BeginTrans-‬‬
‫‪myadodc.Recordset.ActiveConnection.CommitTrans‬‬
‫‪myadodc.Recordset.ActiveConnection.RollbackTrans‬‬
‫‪ Properties‬של ‪ADODC‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪ :Align‬מגדיר כיצד ייושר הפקד על פני הטופס‬
‫‪ :BOFAction‬מגדיר מה יבוצע בעת ניסיון לחרוג מתחילת אוסף הרשומות (‪:)Beginning Of File -BOF‬‬
‫‪ :adDoMoveFirst o‬גורם להחזרה לרשומה הרשואנה‬
‫‪ :adStayBOF o‬נשאר ב‪BOF-‬‬
‫‪ :EOFAction‬מגדיר מה יבוצע ה‪ ADODC-‬בעת ניסיון לחרוג מתחום אוסף הרשומות(‪)End Of File - EOF‬‬
‫‪ :adDoMoveLast o‬מחזיר לרשומה האחרונה‬
‫‪ :adStayEOF o‬נשאר ב‪EOF-‬‬
‫‪ :adDoAddNew o‬גורם להוספת רשומה חדשה‬
‫‪ :ConnectionStrin‬מחרוזת המכילה את כל הפרטים הדרושים לשם התחברות ל‪Database-‬‬
‫‪ Username‬ו‪ :Password-‬כוללים את שם המשתמש והסיסמה‪ ,‬שבאמצעותם מתחברים ל‪Database-‬‬
‫‪ :ConnectionTimeout‬מגדיר את משך זמן שלאחריו ייפסק הניסיון להתחבר אל ה‪Database-‬‬
‫‪ :Mode‬מגדיר את אוסף הפעולות המותר מול ה‪Database-‬‬
‫‪ :RecordSourec‬מגדיר את מקור הרשומות עבור ה‪ .ADODC-‬קיימות ארבע אפשרויות‪:‬‬
‫‪ :Table o‬טבלה או שאילתה‬
‫‪ :StoreProcedure o‬שגרה מאוחסנת ב‪Database-‬‬
‫‪ :Text o‬משפט ‪SQL‬‬
‫‪ :CommandType‬מגדיר את סוג ה‪RecordSource-‬‬
‫‪ :CommandTimeout‬מגדיר את משך הזמן שלאחריו ייפסק ניסיון להפעיל פקודה מול ה‪Database-‬‬
‫‪ :Caption‬כותרת הפקד‬
‫‪ Methods‬של ‪ADODC‬‬
‫‪‬‬
‫‪ :Refresh‬מרענן את התצוגה (חשוב לאחר ביצוע שינויים כגון ‪ Delete‬או ‪ CommitTrans‬או ביטול שינויים‬
‫באמצעות ‪)RollbakTrans‬‬
‫‪ Events‬של ‪ADODC‬‬
‫‪‬‬
‫‪‬‬
‫‪ :WillChangeRecord‬מתרחש רגע לפני שרשומה מעודכנת‪ .‬זהו המקום לבצע בדיקת ערכים ולאשר או לבטל‬
‫את השינוי‬
‫‪ :Error‬מתרחש כאשר מתרחשת שגיאה כלשהי‪ .‬ניתן לבטל את ההודעה המוצגת ע"י שינוי ערכו של‬
‫‪ fCancelDisplay‬המועבר להודה – לערך ‪True‬‬
‫עיצוב הנתונים‬
‫‪‬‬
‫ניתן להשתמש במספר דרכים‪:‬‬
‫‪ o‬המאפיין ‪ DataFormat‬של ‪ Bound Controls‬אך לא תמיד מאפיין זה פועל כמו שצריך‬
‫‪ o‬קוד בדיקה מותאם אישית – כרוך בעבודה רבה‬
‫‪ o‬שימוש ב‪StdDataFormat Objects-‬‬
‫‪StdDataFormats Obj ects‬‬
‫‪‬‬
‫לסיים‬
‫יש להוסיף ‪ Reference‬אליו מתוך ‪( Project References‬‬
‫הערות לגבי ‪Data Bound Controls‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫כאשר משתמשים ב‪ Data Bound Label Control-‬יש להגדיר את המאפיין ‪ UseMnemonics‬לערך ‪ False‬כדי‬
‫שתוי אמפרסנד לא יוצגו כקו תחתי‪.‬‬
‫‪ CheckBox‬מקבל ערך ‪ vbChecked‬עבור ערך שונה מ‪ 2-‬ב‪ vbUnchecked ,Database-‬לערך ‪ ,0‬ו‪vbGrayed‬‬
‫ל‪Null-‬‬
‫יש לקשר ‪ CheckBox‬אך ורק לערך בוליאני‪ ,‬כיוון שיש לו שני מצבים שהמשתמש שולט בהם ‪ True -‬או ‪False‬‬
‫תמונות מ‪ Access-‬יש לקשר ל‪control OLE-‬‬
‫תמונות מ‪ SQL Server-‬ניתן לקשר ל‪Picture Box-‬‬
‫‪ OptionBox‬אינו ‪ ,Data Bound Control‬ולפיכך כדי להשתמש בו בצמוד לשדה מה‪ .Database-‬בכל אופן‪ ,‬ניתן‬
‫לבצע טריקים כדי לפתור את הבעיה בדרך עקיפה‪ ,‬וגם כמובן ליצור ‪ ActiveX‬מתאים‬
‫ניתן לשנות בזמן ריצה את ה‪ DataSource-‬ל‪ ADODC-‬אחר‪( .‬לא קיימת אפשרות כזו ב‪ Data-‬וב‪RDO Data -‬‬
‫‪)Control‬‬
‫‪‬‬
‫‪ ‬תכיר את המודל ‪ N Tiers‬ותשווה אותו ל‪Tiers 1-‬‬
‫‪ ‬תכיר את ‪( MTS - Microsoft Transaction Server‬זהו ‪ COM+‬ב‪ ,)Windows 2000-‬תבין את פעולתו ביחס‬
‫לניהול טרנזקציות‪ ,‬ותכיר בחשיבותו‬
‫‪ ‬תלמד להפוך את רכיבי הקוד שאתה מפתח ב‪ Visual Basic-‬ל‪ Business Objects-‬הפועלים תחת ‪COM+‬‬
‫‪‬‬
‫תרגיל ‪COM+Demo : 1‬‬
‫‪ ‬בתרגיל זה ניצור אפליקצית ‪ COM+‬ריקה (כלומר ללא רכיבים)‬
‫‪ ‬בתרגילים הבאים תיצור רכיבי ‪ COM+‬באמצעות ‪ Visual Basic‬ותוסיף אותם לאפליקציה זו‬
‫‪ .1‬פתח את החלון ‪:Component Services‬‬
‫‪ ‬פתח את ה‪ Control Panel-‬ומשם עבור ל‪Administrative Tools-‬‬
‫‪ ‬בחר ב‪ Component Services-‬החלון הבא אמור להיפתח‪:‬‬
‫‪ .1‬הוסף אפליקצית ‪ COM+‬ריקה‪:‬‬
‫‪ ‬בפנל השמאלי הרחב את הענף ‪Component Services‬‬
‫‪ ‬עבור ל‪ My Computer-‬ומשם ל‪( COM+ Applications-‬לחץ על ‪ COM+ Applications‬באמצעות הלחצן‬
‫השמאלי של העכבר כך שהאפליקציות המותקנות יוצגו בפנל הימני)‬
‫‪ ‬לחץ לחיצה ימנית על ‪ COM+ Applications‬ובחר ב‪ New-‬ואחר כך ב‪Application-‬‬
‫‪‬‬
‫‪ Wizard‬המשמש להתקנת אפליקציית ‪ COM‬ייפתח‪:‬‬
‫‪ o‬במסך הראשון של ה‪ Wizard-‬לחץ על ‪Next‬‬
‫‪ o‬במסך השני של ה‪ Wizard-‬קימות שתי אפשרויות‪ .‬האפשרות הראשונה‪ ,‬להתקין אפליקציה מוכנה‬
‫על ידי בחירת קובץ התקנה‪ ,‬והאפשרות השניה‪ ,‬ליצור אפליקציה חדשה‪ .‬בחר באפשרות השניה‬
‫‪Create an empty application‬‬
‫‪ o‬במסך השלישי של ה‪ Wizard-‬עליך להקצות שם לאפליקציה ולבחור את אופן ההפעלה של‬
‫האפליקציה‪ .‬קיימים שני סוגי הפעלה לאפליקצית ‪ Library Application :COM+‬ו‪Server -‬‬
‫‪ Library Application .Application‬מציין כי האפליקציה תרוץ כמו ‪ DLL‬בתוך ה‪ Process-‬שיצר‬
‫את רכיב מהאפליקציה‪ Server Application .‬מציין כי האפליקציה תרוץ בתוך ‪ Process‬משל‬
‫עצמה‪ .‬הגדר את המאפיינים כפי שמתואר בציור שלפניך‪:‬‬
‫‪ o‬במסך הרביעי של ה‪ Wizard-‬עליך לקבוע תחת איזה משתמש ‪ NT‬האפליקציה תרוץ בעת טעינתה‪.‬‬
‫תוכל לבחור שם משתמש מסוים ולהזין את הסיסמה‪ ,‬או לבחור ‪ Interactive user‬שמשמעותו היא‬
‫כי האפליקציה רצה תחת חשבון המשתמש המחובר למערכת‬
‫‪ o‬במסך האחרון של ה‪ Wizard-‬לחץ על ‪Finish‬‬
‫‪ .3‬עיין במאפייני האפליקציה‪:‬‬
‫‪ ‬בפנל הימני של חלון ה‪ Component Services-‬יוצג סמל האפליקציה ‪ COM+Demo‬שזה עתה יצרת‬
‫‪ ‬לחץ לחיצה ימנית על סמל האפליקציה ובחר באפשרות ‪ .Properties‬החלון ‪ COM+Demo Properties‬אמור‬
‫להיפתח כפי שמוצג בציור הבא‪:‬‬
‫‪‬‬
‫‪‬‬
‫בחלון זה מוצגות שש כרטיסיות‪:‬‬
‫‪ o‬בכרטיסייה ‪ General‬תוכל להוסיף שדה תיאור (‪ )Description‬לאפליקציה‬
‫‪ o‬בכרטיסייה ‪ Security‬תוכל להגדיר נושאי אבטחה שונים הקשורים להפעלת האפליקציה‬
‫‪ o‬בכרטיסיה ‪ Identity‬זהה לזה שפגשת ב‪ Wizard-‬בעת יצירת האפליקציה‬
‫‪ o‬הכרטיסיה ‪ Activation‬זהה לאפשרות ‪ Activation type‬שפגשת ב‪ Wizard-‬בתחילת התרגיל‬
‫‪ o‬שים לב‪ :‬אם אתה משנה את אופן ההפעלה של האפליקציה‪ ,‬האפשרויות בשאר הכרטיסיות ישתנו‬
‫בהתאם‬
‫‪ o‬הכרטיסייה ‪ Queuing‬מגדירה את אופן הפעולה ההדי יחד עם ‪MSMQ‬‬
‫‪ o‬בכרטיסיה ‪ Advanced‬תוכל להגדיר הגדרות שונות‪ ,‬כגון משך הזמן בו ‪ Process‬של אפליקציה ישאר‬
‫מופעל‪ ,‬למרות שהאפליקציה אינה פעילה באותו השלב‪ ,‬הגנות מסוימות על האפליקציה ועוד‬
‫בתרגיל שלנו השאר את ההגדרות ללא שינוי‪ ,‬וסגור את חלון ה‪COM+Demo Properties-‬‬
‫יצירת רכיבים המותאמים לפעולה תחת‬
‫‪COM+‬‬
‫המאפי ין ‪MTSTransact ionMode‬‬
‫‪‬‬
‫‪‬‬
‫‪ COM+‬משתמש במאפיין ‪ MTSTransactionMode‬כדי לקבוע האם יש להפעיל את האובייקט בתוך טרנזקציה‪,‬‬
‫והאם טרנזקציה נדרשת או אופציונלית‬
‫מאפיין זה משפיע רק על האובייקטים הנוצרים תחת ‪ .COM+‬אובייקטים שאינם נוצרים תחת ‪ COM+‬אינם‬
‫מושפעים ממאפיין זה‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫מאפיין זה יכול לקבל אחד מהערכים הבאים‪:‬‬
‫‪ :NotAnMTSObject o‬האובייקט אינו תומך ב‪COM+-‬‬
‫‪ :NoTransactions o‬האובייקט אינו תומך בטרנזקציות‪ .‬מאפיין זה מציין שהאובייקט אינו רץ במסגרת‬
‫טרנזקציות‪ .‬כאשר נוצר אובייקט חדש‪ ,‬ל‪ ObjectContext-‬המוצמד לאובייקט לא נוצרת טרנזקציה‪.‬‬
‫‪ :RequiresTransaction o‬מאפיין זה מציין כי האובייקט חייב לרוץ במסגרת טרנזקציה‪ .‬כאשר אובייקט‬
‫חדש נוצר‪ ,‬ה‪ ObjectContext-‬שלו יורש את הטרנזקציה מה‪ ObjectContext-‬של ה‪ .Client-‬אם אין‬
‫טרנזקציה ב‪ ObjectContext-‬של ה‪ Client-‬תיווצר טרנזקציה חדשה עבור האובייקט‪.‬‬
‫‪ :UsesTransaction o‬ערך זה מציין כי האובייקט משתמש בטרנזקציה של האובייקט המשתמש בו‬
‫(ה‪ .)Client-‬כאשר נוצר אובייקט חדש הוא יורש את הטרנזקציה מאובייקט ה‪ .Client-‬אם לאובייקט‬
‫ה‪ Client-‬אין טרנזקציה‪ ,‬אזי גם ל‪ ObjectContext-‬של האובייקט הנוצר לא תיווצר טרנזקציה‪.‬‬
‫‪ :RequiresNewTransaction o‬ערך זה מציין שלאובייקט הנוצר חייבת להיווצר טרנזקציה חדשה‬
‫בתוכה הוא ירוץ‪ .‬כאשר נוצר אובייקט חדש ‪ COM+‬יוצר עבורו טרנזקציה חדשה ללא קשר לקיום או‬
‫היעדר טרנזקציה באובייקט ה‪.Client-‬‬
‫לרוב תקצה לאובייקטים שלך את המאפיינים ‪ UsesTransaction‬או ‪ .RquiresTransaction‬ההבדל בין שני‬
‫הערכים הללו הוא במקרה שטרנזקציה אינה קיימת באוביקט היוצר אותם‪ ,‬שאז עבור אובייקטים בהם מוגדר‬
‫המאפיין כ‪ RquiresTransaction-‬נוצרת טרנזקציה חדשה‪ ,‬ואילו עבור אובייקטים בהם מוגדר המאפיין‬
‫כ‪ UsesTransaction-‬לא תיווצר טרנזקציה‬
‫הגדרת מאפיין כ‪ RequiresNewTransaction-‬כמו ‪ RequiresTransaction‬מבטיחה כי האובייקט יפעל במסגרת‬
‫טרנזקציה‪ .‬עם זאת הערך ‪ RequiresNewTransaction‬יוצר טרנזקציה חדשה שאינה תלויה בטרנזקציה של‬
‫האובייקט המכיל (אובייקט ה‪ .)Client-‬מאפיין זה שימושי כאשר רוצים לבצע רישום פעילות של אובייקט‬
‫ה‪ Client-‬ללא קשר להצלחה או כישלון של הטרנזקציה שלו‪.‬‬
‫האובייקט ‪ObjectContext‬‬
‫להוסיף הסבר אודות ‪Objetct Context‬‬
‫תרגיל ‪MTSSample.dll : 2‬‬
‫‪ ‬בתרגיל זה ניצור רכיב ‪ DLL‬אשר יתמוך ב‪COM+-‬‬
‫‪ ‬לרכיב שניצור נוסיף פונקציה בשם ‪ ExecuteTransaction‬המקבלת שני פרמטרים‪:‬‬
‫‪ o‬מערך של ‪-String‬ים המייצגים ‪-ConnectionString‬ים למקורות מידע שונים‬
‫‪ o‬מערך של ‪-String‬ים של משפטי ‪ SQL‬שיש להריץ מול מקורות המידע הללו‬
‫‪ ‬הרעיון שבבסיסו של רכיב זה‪ :‬אם אחד ממשפטי ה‪ SQL-‬המבוצע מול אחד ממקורות הנתונים נכשל‪ ,‬יתבצע‬
‫‪ Rollback‬לכל משפטי ה‪ SQL-‬שבוצעו עד כה‬
‫‪ .1‬צור תוכנית ‪ ActiveX DLL‬ריק‪:‬‬
‫‪ ‬הקצה לפרוייקט את השם ‪MTSSampleDLL‬‬
‫‪ ‬הקצה ל‪ Class-‬בפרוייקט את השם ‪MTSObj‬‬
‫‪ .1‬התאם את הגדרות הפרוייקט‪:‬‬
‫‪ ‬מתוך התפריט ‪ Project‬בחר ב‪ ,MTSSampleDLL Properties...-‬כך שיוצג חלון המאפיינים של הפרוייקט‬
‫‪ ‬בכרטיסיה ‪ General‬סמן ‪ V‬ליד האפשרות ‪ .Unattended Execution‬אפשרות זו מבטיחה כי הרכיב לא יציג‬
‫ממשק משתמש (למשל על ידי שימוש בפונקציה ‪ .)MsgBox‬אם הרכיב ינסה להציג ממשק‪ ,‬תירשם שגיאה‬
‫מתאימה בקובץ ה‪ Log-‬של המערכת‬
‫‪ ‬בכרטיסיה ‪ General‬וודא כי ב‪ Threading Model-‬נבחרה האפשרות ‪Apartment Threaded‬‬
‫‪ .3‬הוסף הפניות לספריות רכיבים בפרוייקט‪:‬‬
‫‪ ‬כיוון שהפרוייקט משתמש ברכיבי ‪ ADO‬וברכיבי ‪ COM+‬כדי לגשת למקורות הנתונים יש להוסיף הפניות‬
‫מתאימות בחלון ה‪References-‬‬
‫‪ ‬בחר באפשרות ‪ References...‬מתוך התפריט ‪Project‬‬
‫‪ ‬סמן ‪ V‬ליד הספריה ‪ Microsoft ActiveX Data Objects 2.7‬או גירסה אחרת (בחר את הגירסה המעודכנת‬
‫ביותר במחשב שלך)‬
‫‪ ‬סמן ‪ V‬ליד הפריט ‪COM+ Services Type Library‬‬
‫‪ .1‬הגדר את המאפיין ‪:MTSTransactionMode‬‬
‫‪ ‬האפשרויות השונות של המאפיין ‪ MTSTransactionMode‬הוסברו קודם‬
‫‪ ‬בחר באפשרות ‪2 - RequiresTransaction‬‬
‫‪ ‬כך אנו מבטיחים שהאובייקט שלנו ירוץ בתוך טרנזקציה‪ .‬אם האובייקט נקרא על ידי אובייקט אחר שיש לו‬
‫טרנזקציה‪ ,‬האובייקט שניצור ישתתף בטרנזקציה של אובייקט האב‪ .‬אם אין לאובייקט האב טרנזקציה‬
‫משלו‪ ,‬תיווצר טרנזקציה חדשה עבור האובייקט‬
‫‪ .1‬הוסף קוד למחלקה‪:‬‬
‫‪ ‬במודול המחלקה ‪ MTSObj‬הוסף את הקוד הבא‪:‬‬
‫_ ‪Public Sub ExecuteTransaction(strSQLStatements() As String,‬‬
‫)‪strConnectionStrings() As String‬‬
‫‪Dim l As Long‬‬
‫‪Dim u As Long‬‬
‫‪‬‬
‫בעת התרחשות שגיאה תתבצע קפיצה ל‪ Err_Handler-‬שם תיקרא השגרה ‪ SetAbort‬ותוחזר שגיאה‬
‫מתאימה לפונקציה הקוראת‬
‫)‪l = LBound(strSQLStatements‬‬
‫)‪u = UBound(strSQLStatements‬‬
‫)‪adoExecute strSQLStatements(l), strConnectionStrings(l‬‬
‫‪l = l + 1‬‬
‫‪Loop‬‬
‫‪‬‬
‫בלולאה זו מפעילים את הפונקציה ‪( adoExecute‬מוגדרת בהמשך) אשר מריצה כל משפט ‪ SQL‬יחד עם‬
‫ה‪ ConnectionString-‬המתאים לו‬
‫‪GetObjectContext.SetComplete‬‬
‫‪‬‬
‫בשורת קוד זו‪ ,‬לאחר שכל הקריאות לפרוצדורה ‪ adoExecute‬שבלולאה לא נתקלו בשום שגיאה‪ ,‬קוראים‬
‫ל‪ SetComplete-‬כדי להשלים את הטרנזקציה‬
‫‪Exit Sub‬‬
‫‪GetObjectContext.SetAbort‬‬
‫"‪Err.Raise vbObjectError + 1024, , "Transaction Failed‬‬
‫‪‬‬
‫אם התרחשה שגיאה כלשהי‪ ,‬קוראים ל‪ SetAbort-‬כדי לבטל את הטרנזקציה‪ .‬בנוסף‪ ,‬מעוררים שגיאה החוצה‬
‫כדי לסמן לאובייקט חיצוני המריץ טרנזקציה חיצונית (אם קיים אחד כזה) כי הטרנזקציה של האובייקט‬
‫נכשלה‪ .‬באופן כזה מאפשרים לאובייקט החיצוני להגיב בהתאם‬
‫‪End Sub‬‬
‫_ ‪Private Sub adoExecute(ByVal strSQL As String, ByVal‬‬
‫)‪strConnectionString As String‬‬
‫‪Dim oConn As ADODB.Connection‬‬
‫‪Set oConn = New ADODB.Connection‬‬
‫‪oConn.Open strConnectionString‬‬
‫‪oConn.Execute strSQL‬‬
‫‪oConn.Close‬‬
‫‪End Sub‬‬
‫‪ ‬הפונקציה ‪ adoExecute‬פשוט למדי‪ .‬בפונקציה זו‪ ,‬מתבצע חיבור למקור נתונים באמצעות אובייקט‬
‫‪ Connection‬של ‪ .ADODB‬ומתוך אובייקט זה מורצת פקודת ה‪ SQL-‬תוך שימוש בפרוצדורה ‪ Execute‬של‬
‫‪ .1‬קמפל את הרכיב‪:‬‬
‫‪ ‬מתוך התפריט ‪ File‬בחר ב‪Make MTSSampleDLL.dll...-‬‬
‫‪ ‬תקן שגיאות במידת הצורך‬
‫‪ .1‬הגדר רמת תאימות בינרית לרכיב שיצרת‪:‬‬
‫‪ ‬מתוך התפריט ‪ Project‬בחר באפשרות ‪MTSSampleDLL Properties...‬‬
‫‪ ‬בכרטיסיה ‪ Component‬בחר ב‪Binary Compatibility-‬‬
‫‪ ‬אפשרות זו תבטיח שאם תנסה לשנות את ממשק הרכיב שיצרת‪ ,‬תקבל הודעת אזהרה מתאימה‬
‫תרגיל ‪ : 1‬הוספת ‪ MTSSampleDLL.dll‬ל ‪COM+ -‬‬
‫לסיים‬
‫תרגיל ‪ : 4‬בחינת פעולת ‪ MTSSample.dll‬תחת ‪COM+‬‬
‫לסיים‬
‫תרגיל ‪ : 3‬הוספת ‪ Roles‬לאפליקצית ‪COM+‬‬
‫לסיים‬
‫תרגיל ‪ : 6‬בדיקת הרשאות מתוך רכיב‬
‫לסיים‬
‫יש להשתמש במתודה ‪ IsCallerInRole‬של ה‪ObjectContext-‬‬
‫תרגיל ‪ : 7‬העברת ‪ ConstructString‬לרכיב‬
‫לסיים‬
‫תרגיל ‪ : 1‬קליטת ‪ ConstructString‬מרכיב‬
‫לסיים‬
COM+ :11 ‫שיעור‬
Implements COMSVCSLib.IObjectConstruct
‫ להעביר מחרוזת אתחול‬COM+-‫ המאפשר ל‬IObjectConstruct ‫בשורת קוד זו מממשים את הממשק‬
‫לאובייקט‬

Dim strConstruct As String
Private Sub IObjectConstruct_Construct(ByVal pCtorObj As Object)
strConstruct = pCtorObj.ConstructString
‫ מעביר לאובייקט את מחרוזת האתחול‬COM+ ‫ מתרחש כאשר‬IObjectConstruct_Construct ‫האירוע‬
ConstructString-‫ מחזיר את ה‬,‫ המועבר באירוע‬pCtorObj ‫ של האובייקט‬ConstructString ‫המאפיין‬
End Sub
Public Property Get Constructor() As String
Constructor = strConstruct
End Property
www.kita.co.il


‫כתיבה עריכה‪ :‬אילן אמויאל‬
‫מותר להפיץ את הספר חינם וללא ביצוע כל שינוי בתוכנו‪ ,‬אך שלא למטרות מסחריות‬

Visual Basic 6.0 for Programmers

Transcription

Similar documents

דף נוסחאות 2012 pdf | 493763.00 KB

באקסל מבוא לפקודות מאקרו VBA ביצוע למה צריך את זה? הקלה על ביצוע

פרוגרמה לתוכנית אב ליער

הגרלות מעודכנות ולוח זמנים

Effective Visual Communication Branding | Design

מצגת חברה - שחר אנרגיה

Individual and Community : : חובה: Bossel, H., (1999), Indicators for

נספח א - משרד התקשורת

5/2011 הוראת ביצוע מס הכנסה מספר